carbon-language/carbon-lang
1
0
Fork 0
mirror of https://github.com/carbon-language/carbon-lang.git synced 2026-10-04 22:02:52 +01:00
Code Issues Packages Projects Releases 10 Wiki Activity

Refactor output to be more streaming-focused. (#666)

Browse Source 
- Switch code to llvm::raw_ostream as part of standardizing output forms.
    - Preferring llvm::raw_ostream over std::ostream because other tooling code should be expected to rely on llvm more closely, and an overall preference towards library consistency.
    - There are a couple spots in syntax/ that still use std streams, but I'd prefer to take a separate PR to see how best to address those.
    - std::boolalpha doesn't work with llvm, so I've implemented equivalent in a couple places (not enough that it felt like worth making a helper function).
- Implement Print(ostream) as consistently as we can, as an instance member.
    - This facilitates the use of the common/ostream.h template to provide operators.
    - Preferring this approach so that Print is easily accessible via gdb, per suggestion on #executable-semantics.
- Switch code currently calling `type->Print(ostream)` to instead do `ostream << *type`.
- Remove the unused `PrintTypeEnv`, nothing used it and the declaration didn't match the definition.
This commit is contained in:
Jon Meow
2021-07-20 13:16:48 -07:00
committed by GitHub
parent 368fc0063c
commit 8fccecadeb
31 changed files with 391 additions and 458 deletions
Download Patch File Download Diff File Expand all files Collapse all files
executable_semantics/ast/BUILD
+14 -3
View File
@@ -17,6 +17,7 @@ cc_library(
":function_definition",
":member",
":struct_definition",
"//common:ostream",
"//executable_semantics/interpreter:address",
"//executable_semantics/interpreter:containers",
],
@@ -26,7 +27,10 @@ cc_library(
name = "expression",
srcs = ["expression.cpp"],
hdrs = ["expression.h"],
deps = ["//common:indirect_value"],
deps = [
"//common:indirect_value",
"//common:ostream",
],
)
cc_library(
@@ -43,7 +47,10 @@ cc_library(
name = "member",
srcs = ["member.cpp"],
hdrs = ["member.h"],
deps = [":expression"],
deps = [
":expression",
"//common:ostream",
],
)
cc_library(
@@ -53,11 +60,15 @@ cc_library(
deps = [
":expression",
"//common:check",
"//common:ostream",
],
)
cc_library(
name = "struct_definition",
hdrs = ["struct_definition.h"],
deps = [":member"],
deps = [
":member",
"//common:ostream",
],
)
executable_semantics/ast/declaration.cpp
+10 -17
View File
@@ -4,8 +4,6 @@
#include "executable_semantics/ast/declaration.h"
#include <iostream>
namespace Carbon {
auto Declaration::MakeFunctionDeclaration(FunctionDefinition definition)
@@ -65,41 +63,36 @@ auto Declaration::GetVariableDeclaration() const -> const VariableDeclaration& {
return std::get<VariableDeclaration>(value);
}
void Declaration::Print() const {
void Declaration::Print(llvm::raw_ostream& out) const {
switch (tag()) {
case DeclarationKind::FunctionDeclaration:
GetFunctionDeclaration().definition.Print();
out << GetFunctionDeclaration().definition;
break;
case DeclarationKind::StructDeclaration: {
const StructDefinition& struct_def = GetStructDeclaration().definition;
std::cout << "struct " << struct_def.name << " {" << std::endl;
out << "struct " << struct_def.name << " {\n";
for (Member* m : struct_def.members) {
m->Print();
out << *m;
}
std::cout << "}" << std::endl;
out << "}\n";
break;
}
case DeclarationKind::ChoiceDeclaration: {
const auto& choice = GetChoiceDeclaration();
std::cout << "choice " << choice.name << " {" << std::endl;
out << "choice " << choice.name << " {\n";
for (const auto& [name, signature] : choice.alternatives) {
std::cout << "alt " << name << " ";
PrintExp(signature);
std::cout << ";" << std::endl;
out << "alt " << name << " " << *signature << ";\n";
}
std::cout << "}" << std::endl;
out << "}\n";
break;
}
case DeclarationKind::VariableDeclaration: {
const auto& var = GetVariableDeclaration();
std::cout << "var ";
PrintExp(var.type);
std::cout << " : " << var.name << " = ";
PrintExp(var.initializer);
std::cout << std::endl;
out << "var " << *var.type << " : " << var.name << " = "
<< *var.initializer << "\n";
break;
}
}
executable_semantics/ast/declaration.h
+2 -1
View File
@@ -8,6 +8,7 @@
#include <list>
#include <string>
#include "common/ostream.h"
#include "executable_semantics/ast/function_definition.h"
#include "executable_semantics/ast/member.h"
#include "executable_semantics/ast/struct_definition.h"
@@ -82,7 +83,7 @@ class Declaration {
auto GetChoiceDeclaration() const -> const ChoiceDeclaration&;
auto GetVariableDeclaration() const -> const VariableDeclaration&;
void Print() const;
void Print(llvm::raw_ostream& out) const;
inline auto tag() const -> DeclarationKind {
return std::visit([](const auto& t) { return t.Kind; }, value);
executable_semantics/ast/expression.cpp
+50 -69
View File
@@ -4,8 +4,6 @@
#include "executable_semantics/ast/expression.h"
#include <iostream>
namespace Carbon {
auto Expression::GetIdentifierExpression() const
@@ -168,9 +166,8 @@ auto Expression::MakeTupleLiteral(int line_num,
for (auto& arg : args) {
if (arg.name == "") {
if (seen_named_member) {
std::cerr << line_num
<< ": positional members must come before named members"
<< std::endl;
llvm::errs() << line_num
<< ": positional members must come before named members\n";
exit(-1);
}
arg.name = std::to_string(i);
@@ -191,138 +188,122 @@ auto Expression::MakeIndexExpression(int line_num, const Expression* exp,
return e;
}
static void PrintOp(Operator op) {
static void PrintOp(llvm::raw_ostream& out, Operator op) {
switch (op) {
case Operator::Add:
std::cout << "+";
out << "+";
break;
case Operator::Neg:
case Operator::Sub:
std::cout << "-";
out << "-";
break;
case Operator::Mul:
case Operator::Deref:
case Operator::Ptr:
std::cout << "*";
out << "*";
break;
case Operator::Not:
std::cout << "not";
out << "not";
break;
case Operator::And:
std::cout << "and";
out << "and";
break;
case Operator::Or:
std::cout << "or";
out << "or";
break;
case Operator::Eq:
std::cout << "==";
out << "==";
break;
}
}
static void PrintFields(const std::vector<FieldInitializer>& fields) {
static void PrintFields(llvm::raw_ostream& out,
const std::vector<FieldInitializer>& fields) {
int i = 0;
for (auto iter = fields.begin(); iter != fields.end(); ++iter, ++i) {
if (i != 0) {
std::cout << ", ";
out << ", ";
}
std::cout << iter->name << " = ";
PrintExp(iter->expression);
out << iter->name << " = " << *iter->expression;
}
}
void PrintExp(const Expression* e) {
switch (e->tag()) {
void Expression::Print(llvm::raw_ostream& out) const {
switch (tag()) {
case ExpressionKind::IndexExpression:
PrintExp(e->GetIndexExpression().aggregate);
std::cout << "[";
PrintExp(e->GetIndexExpression().offset);
std::cout << "]";
out << *GetIndexExpression().aggregate << "["
<< *GetIndexExpression().offset << "]";
break;
case ExpressionKind::FieldAccessExpression:
PrintExp(e->GetFieldAccessExpression().aggregate);
std::cout << ".";
std::cout << e->GetFieldAccessExpression().field;
out << *GetFieldAccessExpression().aggregate << "."
<< GetFieldAccessExpression().field;
break;
case ExpressionKind::TupleLiteral:
std::cout << "(";
PrintFields(e->GetTupleLiteral().fields);
std::cout << ")";
out << "(";
PrintFields(out, GetTupleLiteral().fields);
out << ")";
break;
case ExpressionKind::IntLiteral:
std::cout << e->GetIntLiteral();
out << GetIntLiteral();
break;
case ExpressionKind::BoolLiteral:
std::cout << std::boolalpha;
std::cout << e->GetBoolLiteral();
out << (GetBoolLiteral() ? "true" : "false");
break;
case ExpressionKind::PrimitiveOperatorExpression: {
std::cout << "(";
PrimitiveOperatorExpression op = e->GetPrimitiveOperatorExpression();
out << "(";
PrimitiveOperatorExpression op = GetPrimitiveOperatorExpression();
if (op.arguments.size() == 0) {
PrintOp(op.op);
PrintOp(out, op.op);
} else if (op.arguments.size() == 1) {
PrintOp(op.op);
std::cout << " ";
auto iter = op.arguments.begin();
PrintExp(*iter);
PrintOp(out, op.op);
out << " " << *op.arguments[0];
} else if (op.arguments.size() == 2) {
auto iter = op.arguments.begin();
PrintExp(*iter);
std::cout << " ";
PrintOp(op.op);
std::cout << " ";
++iter;
PrintExp(*iter);
out << *op.arguments[0] << " ";
PrintOp(out, op.op);
out << " " << *op.arguments[1];
}
std::cout << ")";
out << ")";
break;
}
case ExpressionKind::IdentifierExpression:
std::cout << e->GetIdentifierExpression().name;
out << GetIdentifierExpression().name;
break;
case ExpressionKind::BindingExpression: {
const BindingExpression& binding = e->GetBindingExpression();
const BindingExpression& binding = GetBindingExpression();
if (binding.name.has_value()) {
std::cout << *binding.name;
out << *binding.name;
} else {
std::cout << "_";
out << "_";
}
std::cout << ": ";
PrintExp(e->GetBindingExpression().type);
out << ": " << *binding.type;
break;
}
case ExpressionKind::CallExpression:
PrintExp(e->GetCallExpression().function);
if (e->GetCallExpression().argument->tag() ==
ExpressionKind::TupleLiteral) {
PrintExp(e->GetCallExpression().argument);
out << *GetCallExpression().function;
if (GetCallExpression().argument->tag() == ExpressionKind::TupleLiteral) {
out << *GetCallExpression().argument;
} else {
std::cout << "(";
PrintExp(e->GetCallExpression().argument);
std::cout << ")";
out << "(" << *GetCallExpression().argument << ")";
}
break;
case ExpressionKind::BoolTypeLiteral:
std::cout << "Bool";
out << "Bool";
break;
case ExpressionKind::IntTypeLiteral:
std::cout << "Int";
out << "Int";
break;
case ExpressionKind::TypeTypeLiteral:
std::cout << "Type";
out << "Type";
break;
case ExpressionKind::AutoTypeLiteral:
std::cout << "auto";
out << "auto";
break;
case ExpressionKind::ContinuationTypeLiteral:
std::cout << "Continuation";
out << "Continuation";
break;
case ExpressionKind::FunctionTypeLiteral:
std::cout << "fn ";
PrintExp(e->GetFunctionTypeLiteral().parameter);
std::cout << " -> ";
PrintExp(e->GetFunctionTypeLiteral().return_type);
out << "fn " << *GetFunctionTypeLiteral().parameter << " -> "
<< *GetFunctionTypeLiteral().return_type;
break;
}
}
executable_semantics/ast/expression.h
+4 -2
View File
@@ -10,6 +10,8 @@
#include <variant>
#include <vector>
#include "common/ostream.h"
namespace Carbon {
struct Expression;
@@ -176,6 +178,8 @@ struct Expression {
auto GetCallExpression() const -> const CallExpression&;
auto GetFunctionTypeLiteral() const -> const FunctionTypeLiteral&;
void Print(llvm::raw_ostream& out) const;
inline auto tag() const -> ExpressionKind {
return std::visit([](const auto& t) { return t.Kind; }, value);
}
@@ -191,8 +195,6 @@ struct Expression {
value;
};
void PrintExp(const Expression* exp);
} // namespace Carbon
#endif // EXECUTABLE_SEMANTICS_AST_EXPRESSION_H_
executable_semantics/ast/function_definition.cpp
+6 -11
View File
@@ -4,21 +4,16 @@
#include "executable_semantics/ast/function_definition.h"
#include <iostream>
namespace Carbon {
void FunctionDefinition::PrintDepth(int depth) const {
std::cout << "fn " << name << " ";
PrintExp(param_pattern);
std::cout << " -> ";
PrintExp(return_type);
void FunctionDefinition::PrintDepth(int depth, llvm::raw_ostream& out) const {
out << "fn " << name << " " << *param_pattern << " -> " << *return_type;
if (body) {
std::cout << " {" << std::endl;
PrintStatement(body, depth);
std::cout << std::endl << "}" << std::endl;
out << " {\n";
body->PrintDepth(depth, out);
out << "\n}\n";
} else {
std::cout << ";" << std::endl;
out << ";\n";
}
}
executable_semantics/ast/function_definition.h
+3 -2
View File
@@ -5,6 +5,7 @@
#ifndef EXECUTABLE_SEMANTICS_AST_FUNCTION_DEFINITION_H_
#define EXECUTABLE_SEMANTICS_AST_FUNCTION_DEFINITION_H_
#include "common/ostream.h"
#include "executable_semantics/ast/expression.h"
#include "executable_semantics/ast/statement.h"
@@ -21,8 +22,8 @@ struct FunctionDefinition {
return_type(return_type),
body(body) {}
void Print() const { PrintDepth(-1); }
void PrintDepth(int depth) const;
void Print(llvm::raw_ostream& out) const { PrintDepth(-1, out); }
void PrintDepth(int depth, llvm::raw_ostream& out) const;
int line_num;
std::string name;
executable_semantics/ast/member.cpp
+2 -6
View File
@@ -4,8 +4,6 @@
#include "executable_semantics/ast/member.h"
#include <iostream>
namespace Carbon {
auto Member::MakeFieldMember(int line_num, std::string name,
@@ -20,13 +18,11 @@ auto Member::GetFieldMember() const -> const FieldMember& {
return std::get<FieldMember>(value);
}
void Member::Print() {
void Member::Print(llvm::raw_ostream& out) const {
switch (tag()) {
case MemberKind::FieldMember:
const auto& field = GetFieldMember();
std::cout << "var " << field.name << " : ";
PrintExp(field.type);
std::cout << ";" << std::endl;
out << "var " << field.name << " : " << *field.type << ";\n";
break;
}
}
executable_semantics/ast/member.h
+2 -1
View File
@@ -7,6 +7,7 @@
#include <string>
#include "common/ostream.h"
#include "executable_semantics/ast/expression.h"
namespace Carbon {
@@ -25,7 +26,7 @@ struct Member {
auto GetFieldMember() const -> const FieldMember&;
void Print();
void Print(llvm::raw_ostream& out) const;
inline auto tag() const -> MemberKind {
return std::visit([](const auto& t) { return t.Kind; }, value);
executable_semantics/ast/statement.cpp
+48 -66
View File
@@ -4,8 +4,6 @@
#include "executable_semantics/ast/statement.h"
#include <iostream>
#include "common/check.h"
namespace Carbon {
@@ -182,117 +180,101 @@ auto Statement::MakeAwait(int line_num) -> const Statement* {
return s;
}
void PrintStatement(const Statement* s, int depth) {
if (!s) {
return;
}
void Statement::PrintDepth(int depth, llvm::raw_ostream& out) const {
if (depth == 0) {
std::cout << " ... ";
out << " ... ";
return;
}
switch (s->tag()) {
switch (tag()) {
case StatementKind::Match:
std::cout << "match (";
PrintExp(s->GetMatch().exp);
std::cout << ") {";
out << "match (" << *GetMatch().exp << ") {";
if (depth < 0 || depth > 1) {
std::cout << std::endl;
for (auto& clause : *s->GetMatch().clauses) {
std::cout << "case ";
PrintExp(clause.first);
std::cout << " =>" << std::endl;
PrintStatement(clause.second, depth - 1);
std::cout << std::endl;
out << "\n";
for (auto& clause : *GetMatch().clauses) {
out << "case " << *clause.first << " =>\n";
clause.second->PrintDepth(depth - 1, out);
out << "\n";
}
} else {
std::cout << "...";
out << "...";
}
std::cout << "}";
out << "}";
break;
case StatementKind::While:
std::cout << "while (";
PrintExp(s->GetWhile().cond);
std::cout << ")" << std::endl;
PrintStatement(s->GetWhile().body, depth - 1);
out << "while (" << *GetWhile().cond << ")\n";
GetWhile().body->PrintDepth(depth - 1, out);
break;
case StatementKind::Break:
std::cout << "break;";
out << "break;";
break;
case StatementKind::Continue:
std::cout << "continue;";
out << "continue;";
break;
case StatementKind::VariableDefinition:
std::cout << "var ";
PrintExp(s->GetVariableDefinition().pat);
std::cout << " = ";
PrintExp(s->GetVariableDefinition().init);
std::cout << ";";
out << "var " << *GetVariableDefinition().pat << " = "
<< *GetVariableDefinition().init << ";";
break;
case StatementKind::ExpressionStatement:
PrintExp(s->GetExpressionStatement().exp);
std::cout << ";";
out << *GetExpressionStatement().exp << ";";
break;
case StatementKind::Assign:
PrintExp(s->GetAssign().lhs);
std::cout << " = ";
PrintExp(s->GetAssign().rhs);
std::cout << ";";
out << *GetAssign().lhs << " = " << *GetAssign().rhs << ";";
break;
case StatementKind::If:
std::cout << "if (";
PrintExp(s->GetIf().cond);
std::cout << ")" << std::endl;
PrintStatement(s->GetIf().then_stmt, depth - 1);
std::cout << std::endl << "else" << std::endl;
PrintStatement(s->GetIf().else_stmt, depth - 1);
out << "if (" << *GetIf().cond << ")\n";
GetIf().then_stmt->PrintDepth(depth - 1, out);
if (GetIf().else_stmt) {
out << "\nelse\n";
GetIf().else_stmt->PrintDepth(depth - 1, out);
}
break;
case StatementKind::Return:
std::cout << "return ";
PrintExp(s->GetReturn().exp);
std::cout << ";";
out << "return " << *GetReturn().exp << ";";
break;
case StatementKind::Sequence:
PrintStatement(s->GetSequence().stmt, depth);
GetSequence().stmt->PrintDepth(depth, out);
if (depth < 0 || depth > 1) {
std::cout << std::endl;
out << "\n";
} else {
std::cout << " ";
out << " ";
}
if (GetSequence().next) {
GetSequence().next->PrintDepth(depth - 1, out);
}
PrintStatement(s->GetSequence().next, depth - 1);
break;
case StatementKind::Block:
std::cout << "{";
out << "{";
if (depth < 0 || depth > 1) {
std::cout << std::endl;
out << "\n";
}
PrintStatement(s->GetBlock().stmt, depth);
if (depth < 0 || depth > 1) {
std::cout << std::endl;
if (GetBlock().stmt) {
GetBlock().stmt->PrintDepth(depth, out);
if (depth < 0 || depth > 1) {
out << "\n";
}
}
std::cout << "}";
out << "}";
if (depth < 0 || depth > 1) {
std::cout << std::endl;
out << "\n";
}
break;
case StatementKind::Continuation:
std::cout << "continuation " << s->GetContinuation().continuation_variable
<< " ";
out << "continuation " << GetContinuation().continuation_variable << " ";
if (depth < 0 || depth > 1) {
std::cout << std::endl;
out << "\n";
}
PrintStatement(s->GetContinuation().body, depth - 1);
GetContinuation().body->PrintDepth(depth - 1, out);
if (depth < 0 || depth > 1) {
std::cout << std::endl;
out << "\n";
}
break;
case StatementKind::Run:
std::cout << "run ";
PrintExp(s->GetRun().argument);
std::cout << ";";
out << "run " << *GetRun().argument << ";";
break;
case StatementKind::Await:
std::cout << "await;";
out << "await;";
break;
}
}
} // namespace Carbon
executable_semantics/ast/statement.h
+3 -2
View File
@@ -7,6 +7,7 @@
#include <list>
#include "common/ostream.h"
#include "executable_semantics/ast/expression.h"
namespace Carbon {
@@ -162,6 +163,8 @@ struct Statement {
auto GetRun() const -> const Run&;
auto GetAwait() const -> const Await&;
void PrintDepth(int depth, llvm::raw_ostream& out) const;
inline auto tag() const -> StatementKind {
return std::visit([](const auto& t) { return t.Kind; }, value);
}
@@ -175,8 +178,6 @@ struct Statement {
value;
};
void PrintStatement(const Statement*, int);
} // namespace Carbon
#endif // EXECUTABLE_SEMANTICS_AST_STATEMENT_H_
executable_semantics/interpreter/BUILD
+8
View File
@@ -13,6 +13,7 @@ cc_library(
deps = [
":containers",
":value",
"//common:ostream",
"//executable_semantics/ast:expression",
"//executable_semantics/ast:function_definition",
"//executable_semantics/ast:statement",
@@ -24,6 +25,7 @@ cc_library(
hdrs = ["address.h"],
deps = [
":field_path",
"//common:ostream",
],
)
@@ -42,6 +44,7 @@ cc_library(
cc_library(
name = "field_path",
hdrs = ["field_path.h"],
deps = ["//common:ostream"],
)
cc_library(
@@ -52,6 +55,7 @@ cc_library(
":action",
":address",
":containers",
"//common:ostream",
],
)
@@ -62,6 +66,7 @@ cc_library(
deps = [
":address",
":value",
"//common:ostream",
],
)
@@ -81,6 +86,7 @@ cc_library(
":heap",
":value",
"//common:check",
"//common:ostream",
"//executable_semantics:tracing_flag",
"//executable_semantics/ast:declaration",
"//executable_semantics/ast:expression",
@@ -95,6 +101,7 @@ cc_library(
deps = [
":containers",
":interpreter",
"//common:ostream",
"//executable_semantics:tracing_flag",
"//executable_semantics/ast:expression",
"//executable_semantics/ast:function_definition",
@@ -110,6 +117,7 @@ cc_library(
":address",
":containers",
":field_path",
"//common:ostream",
"//executable_semantics/ast:statement",
],
)
executable_semantics/interpreter/action.cpp
+8 -9
View File
@@ -4,7 +4,6 @@
#include "executable_semantics/interpreter/action.h"
#include <iostream>
#include <iterator>
#include <map>
#include <optional>
@@ -57,19 +56,19 @@ auto Action::GetValAction() const -> const ValAction& {
return std::get<ValAction>(value);
}
void Action::Print(std::ostream& out) {
void Action::Print(llvm::raw_ostream& out) const {
switch (tag()) {
case ActionKind::LValAction:
PrintExp(GetLValAction().exp);
out << *GetLValAction().exp;
break;
case ActionKind::ExpressionAction:
PrintExp(GetExpressionAction().exp);
out << *GetExpressionAction().exp;
break;
case ActionKind::StatementAction:
PrintStatement(GetStatementAction().stmt, 1);
GetStatementAction().stmt->PrintDepth(1, out);
break;
case ActionKind::ValAction:
PrintValue(GetValAction().val, out);
out << *GetValAction().val;
break;
}
out << "<" << pos << ">";
@@ -77,7 +76,7 @@ void Action::Print(std::ostream& out) {
out << "(";
for (auto& result : results) {
if (result) {
PrintValue(result, out);
out << *result;
}
out << ",";
}
@@ -85,9 +84,9 @@ void Action::Print(std::ostream& out) {
}
}
void Action::PrintList(Stack<Action*> ls, std::ostream& out) {
void Action::PrintList(Stack<Action*> ls, llvm::raw_ostream& out) {
if (!ls.IsEmpty()) {
ls.Pop()->Print(out);
out << *ls.Pop();
if (!ls.IsEmpty()) {
out << " :: ";
PrintList(ls, out);
executable_semantics/interpreter/action.h
+3 -3
View File
@@ -5,9 +5,9 @@
#ifndef EXECUTABLE_SEMANTICS_INTERPRETER_ACTION_H_
#define EXECUTABLE_SEMANTICS_INTERPRETER_ACTION_H_
#include <iostream>
#include <vector>
#include "common/ostream.h"
#include "executable_semantics/ast/expression.h"
#include "executable_semantics/ast/statement.h"
#include "executable_semantics/interpreter/stack.h"
@@ -48,14 +48,14 @@ struct Action {
static auto MakeStatementAction(const Statement* s) -> Action*;
static auto MakeValAction(const Value* v) -> Action*;
static void PrintList(Stack<Action*> ls, std::ostream& out);
static void PrintList(Stack<Action*> ls, llvm::raw_ostream& out);
auto GetLValAction() const -> const LValAction&;
auto GetExpressionAction() const -> const ExpressionAction&;
auto GetStatementAction() const -> const StatementAction&;
auto GetValAction() const -> const ValAction&;
void Print(std::ostream& out);
void Print(llvm::raw_ostream& out) const;
inline auto tag() const -> ActionKind {
return std::visit([](const auto& t) { return t.Kind; }, value);
executable_semantics/interpreter/address.h
+3 -4
View File
@@ -6,10 +6,10 @@
#define EXECUTABLE_SEMANTICS_INTERPRETER_ADDRESS_H_
#include <cstdint>
#include <iostream>
#include <string>
#include <vector>
#include "common/ostream.h"
#include "executable_semantics/interpreter/field_path.h"
namespace Carbon {
@@ -38,9 +38,8 @@ class Address {
// Currently, that representation consists of an integer index identifying
// the whole memory allocation, and an optional FieldPath specifying a
// particular field within that allocation.
friend auto operator<<(std::ostream& out, const Address& a) -> std::ostream& {
out << "Address(" << a.index << ")" << a.field_path;
return out;
void Print(llvm::raw_ostream& out) const {
out << "Address(" << index << ")" << field_path;
}
// If *this represents the address of an object with a field named
executable_semantics/interpreter/field_path.h
+4 -5
View File
@@ -5,10 +5,11 @@
#ifndef EXECUTABLE_SEMANTICS_INTERPRETER_FIELD_PATH_H_
#define EXECUTABLE_SEMANTICS_INTERPRETER_FIELD_PATH_H_
#include <ostream>
#include <string>
#include <vector>
#include "common/ostream.h"
namespace Carbon {
// Given some initial Value, a FieldPath identifies a sub-Value within it,
@@ -43,12 +44,10 @@ class FieldPath {
components.push_back(std::move(name));
}
friend auto operator<<(std::ostream& out, const FieldPath& path)
-> std::ostream& {
for (const std::string& component : path.components) {
void Print(llvm::raw_ostream& out) const {
for (const std::string& component : components) {
out << "." << component;
}
return out;
}
private:
executable_semantics/interpreter/frame.cpp
+3 -4
View File
@@ -10,10 +10,9 @@
namespace Carbon {
void PrintFrame(Frame* frame, std::ostream& out) {
out << frame->name;
out << "{";
Action::PrintList(frame->todo, out);
void Frame::Print(llvm::raw_ostream& out) const {
out << name << "{";
Action::PrintList(todo, out);
out << "}";
}
executable_semantics/interpreter/frame.h
+3 -2
View File
@@ -8,6 +8,7 @@
#include <list>
#include <string>
#include "common/ostream.h"
#include "executable_semantics/interpreter/action.h"
#include "executable_semantics/interpreter/address.h"
#include "executable_semantics/interpreter/dictionary.h"
@@ -45,9 +46,9 @@ struct Frame {
Frame(std::string n, Stack<Scope*> s, Stack<Action*> c)
: name(std::move(std::move(n))), scopes(s), todo(c), continuation() {}
};
void PrintFrame(Frame* frame, std::ostream& out);
void Print(llvm::raw_ostream& out) const;
};
} // namespace Carbon
executable_semantics/interpreter/heap.cpp
+7 -9
View File
@@ -23,7 +23,7 @@ auto Heap::Read(const Address& a, int line_num) -> const Value* {
return values_[a.index]->GetField(a.field_path, line_num);
}
auto Heap::Write(const Address& a, const Value* v, int line_num) -> void {
void Heap::Write(const Address& a, const Value* v, int line_num) {
CHECK(v != nullptr);
this->CheckAlive(a, line_num);
values_[a.index] = values_[a.index]->SetField(a.field_path, v, line_num);
@@ -31,9 +31,8 @@ auto Heap::Write(const Address& a, const Value* v, int line_num) -> void {
void Heap::CheckAlive(const Address& address, int line_num) {
if (!alive_[address.index]) {
std::cerr << line_num << ": undefined behavior: access to dead value ";
PrintValue(values_[address.index], std::cerr);
std::cerr << std::endl;
llvm::errs() << line_num << ": undefined behavior: access to dead value "
<< *values_[address.index] << "\n";
exit(-1);
}
}
@@ -43,24 +42,23 @@ void Heap::Deallocate(const Address& address) {
if (alive_[address.index]) {
alive_[address.index] = false;
} else {
std::cerr << "runtime error, deallocating an already dead value"
<< std::endl;
llvm::errs() << "runtime error, deallocating an already dead value\n";
exit(-1);
}
}
void Heap::PrintHeap(std::ostream& out) {
void Heap::Print(llvm::raw_ostream& out) const {
for (size_t i = 0; i < values_.size(); ++i) {
PrintAddress(Address(i), out);
out << ", ";
}
}
auto Heap::PrintAddress(const Address& a, std::ostream& out) -> void {
void Heap::PrintAddress(const Address& a, llvm::raw_ostream& out) const {
if (!alive_[a.index]) {
out << "!!";
}
PrintValue(values_[a.index], out);
out << *values_[a.index];
}
} // namespace Carbon
executable_semantics/interpreter/heap.h
+5 -5
View File
@@ -5,9 +5,9 @@
#ifndef EXECUTABLE_SEMANTICS_INTERPRETER_MEMORY_H_
#define EXECUTABLE_SEMANTICS_INTERPRETER_MEMORY_H_
#include <ostream>
#include <vector>
#include "common/ostream.h"
#include "executable_semantics/interpreter/address.h"
#include "executable_semantics/interpreter/value.h"
@@ -28,19 +28,19 @@ class Heap {
// Writes the given value at the address in the heap after
// checking that the address is alive.
auto Write(const Address& a, const Value* v, int line_num) -> void;
void Write(const Address& a, const Value* v, int line_num);
// Put the given value on the heap and mark it as alive.
auto AllocateValue(const Value* v) -> Address;
// Marks the object at this address, and all of its sub-objects, as dead.
auto Deallocate(const Address& address) -> void;
void Deallocate(const Address& address);
// Print the value at the given address to the stream `out`.
auto PrintAddress(const Address& a, std::ostream& out) -> void;
void PrintAddress(const Address& a, llvm::raw_ostream& out) const;
// Print all the values on the heap to the stream `out`.
auto PrintHeap(std::ostream& out) -> void;
void Print(llvm::raw_ostream& out) const;
private:
// Signal an error if the address is no longer alive.
executable_semantics/interpreter/interpreter.cpp
+62 -81
View File
@@ -4,7 +4,6 @@
#include "executable_semantics/interpreter/interpreter.h"
#include <iostream>
#include <iterator>
#include <list>
#include <map>
@@ -26,12 +25,12 @@ State* state = nullptr;
auto PatternMatch(const Value* pat, const Value* val, Env,
std::list<std::string>*, int) -> std::optional<Env>;
auto Step() -> void;
void Step();
//
// Auxiliary Functions
//
void PrintEnv(Env values, std::ostream& out) {
void PrintEnv(Env values, llvm::raw_ostream& out) {
for (const auto& [name, address] : values) {
out << name << ": ";
state->heap.PrintAddress(address, out);
@@ -43,9 +42,9 @@ void PrintEnv(Env values, std::ostream& out) {
// State Operations
//
void PrintStack(Stack<Frame*> ls, std::ostream& out) {
void PrintStack(Stack<Frame*> ls, llvm::raw_ostream& out) {
if (!ls.IsEmpty()) {
PrintFrame(ls.Pop(), out);
out << *ls.Pop();
if (!ls.IsEmpty()) {
out << " :: ";
PrintStack(ls, out);
@@ -58,17 +57,15 @@ auto CurrentEnv(State* state) -> Env {
return frame->scopes.Top()->values;
}
void PrintState(std::ostream& out) {
out << "{" << std::endl;
out << "stack: ";
void PrintState(llvm::raw_ostream& out) {
out << "{\nstack: ";
PrintStack(state->stack, out);
out << std::endl << "heap: ";
state->heap.PrintHeap(out);
out << "\nheap: " << state->heap;
if (!state->stack.IsEmpty() && !state->stack.Top()->scopes.IsEmpty()) {
out << std::endl << "values: ";
out << "\nvalues: ";
PrintEnv(CurrentEnv(state), out);
}
out << std::endl << "}" << std::endl;
out << "\n}\n";
}
auto EvalPrim(Operator op, const std::vector<const Value*>& args, int line_num)
@@ -98,7 +95,7 @@ auto EvalPrim(Operator op, const std::vector<const Value*>& args, int line_num)
case Operator::Ptr:
return Value::MakePointerType(args[0]);
case Operator::Deref:
std::cerr << line_num << ": dereference not implemented yet\n";
llvm::errs() << line_num << ": dereference not implemented yet\n";
exit(-1);
}
}
@@ -184,8 +181,8 @@ void CallFunction(int line_num, std::vector<const Value*> operas,
PatternMatch(operas[0]->GetFunctionValue().param, operas[1], globals,
&params, line_num);
if (!matches) {
std::cerr << "internal error in call_function, pattern match failed"
<< std::endl;
llvm::errs()
<< "internal error in call_function, pattern match failed\n";
exit(-1);
}
// Create the new frame and push it on the stack
@@ -213,9 +210,8 @@ void CallFunction(int line_num, std::vector<const Value*> operas,
break;
}
default:
std::cerr << line_num << ": in call, expected a function, not ";
PrintValue(operas[0], std::cerr);
std::cerr << std::endl;
llvm::errs() << line_num << ": in call, expected a function, not "
<< *operas[0] << "\n";
exit(-1);
}
}
@@ -224,7 +220,7 @@ void DeallocateScope(int line_num, Scope* scope) {
for (const auto& l : scope->locals) {
std::optional<Address> a = scope->values.Get(l);
if (!a) {
std::cerr << "internal error in DeallocateScope" << std::endl;
llvm::errs() << "internal error in DeallocateScope\n";
exit(-1);
}
state->heap.Deallocate(*a);
@@ -275,8 +271,8 @@ auto PatternMatch(const Value* p, const Value* v, Env values,
case ValKind::TupleValue: {
if (p->GetTupleValue().elements.size() !=
v->GetTupleValue().elements.size()) {
std::cerr << "runtime error: arity mismatch in tuple pattern match"
<< std::endl;
llvm::errs()
<< "runtime error: arity mismatch in tuple pattern match\n";
exit(-1);
}
for (const TupleElement& pattern_element :
@@ -284,10 +280,8 @@ auto PatternMatch(const Value* p, const Value* v, Env values,
const Value* value_field =
v->GetTupleValue().FindField(pattern_element.name);
if (value_field == nullptr) {
std::cerr << "runtime error: field " << pattern_element.name
<< "not in ";
PrintValue(v, std::cerr);
std::cerr << std::endl;
llvm::errs() << "runtime error: field " << pattern_element.name
<< "not in " << *v << "\n";
exit(-1);
}
std::optional<Env> matches = PatternMatch(
@@ -300,10 +294,9 @@ auto PatternMatch(const Value* p, const Value* v, Env values,
return values;
}
default:
std::cerr
<< "internal error, expected a tuple value in pattern, not ";
PrintValue(v, std::cerr);
std::cerr << std::endl;
llvm::errs()
<< "internal error, expected a tuple value in pattern, not " << *v
<< "\n";
exit(-1);
}
case ValKind::AlternativeValue:
@@ -324,11 +317,10 @@ auto PatternMatch(const Value* p, const Value* v, Env values,
return *matches;
}
default:
std::cerr
llvm::errs()
<< "internal error, expected a choice alternative in pattern, "
"not ";
PrintValue(v, std::cerr);
std::cerr << std::endl;
"not "
<< *v << "\n";
exit(-1);
}
case ValKind::FunctionType:
@@ -367,8 +359,8 @@ void PatternAssignment(const Value* pat, const Value* val, int line_num) {
case ValKind::TupleValue: {
if (pat->GetTupleValue().elements.size() !=
val->GetTupleValue().elements.size()) {
std::cerr << "runtime error: arity mismatch in tuple pattern match"
<< std::endl;
llvm::errs()
<< "runtime error: arity mismatch in tuple pattern match\n";
exit(-1);
}
for (const TupleElement& pattern_element :
@@ -376,10 +368,8 @@ void PatternAssignment(const Value* pat, const Value* val, int line_num) {
const Value* value_field =
val->GetTupleValue().FindField(pattern_element.name);
if (value_field == nullptr) {
std::cerr << "runtime error: field " << pattern_element.name
<< "not in ";
PrintValue(val, std::cerr);
std::cerr << std::endl;
llvm::errs() << "runtime error: field " << pattern_element.name
<< "not in " << *val << "\n";
exit(-1);
}
PatternAssignment(pattern_element.value, value_field, line_num);
@@ -387,11 +377,10 @@ void PatternAssignment(const Value* pat, const Value* val, int line_num) {
break;
}
default:
std::cerr
llvm::errs()
<< "internal error, expected a tuple value on right-hand-side, "
"not ";
PrintValue(val, std::cerr);
std::cerr << std::endl;
"not "
<< *val << "\n";
exit(-1);
}
break;
@@ -403,7 +392,7 @@ void PatternAssignment(const Value* pat, const Value* val, int line_num) {
val->GetAlternativeValue().choice_name ||
pat->GetAlternativeValue().alt_name !=
val->GetAlternativeValue().alt_name) {
std::cerr << "internal error in pattern assignment" << std::endl;
llvm::errs() << "internal error in pattern assignment\n";
exit(-1);
}
PatternAssignment(pat->GetAlternativeValue().argument,
@@ -411,18 +400,17 @@ void PatternAssignment(const Value* pat, const Value* val, int line_num) {
break;
}
default:
std::cerr
llvm::errs()
<< "internal error, expected an alternative in left-hand-side, "
"not ";
PrintValue(val, std::cerr);
std::cerr << std::endl;
"not "
<< *val << "\n";
exit(-1);
}
break;
}
default:
if (!ValueEqual(pat, val, line_num)) {
std::cerr << "internal error in pattern assignment" << std::endl;
llvm::errs() << "internal error in pattern assignment\n";
exit(-1);
}
}
@@ -435,9 +423,7 @@ void StepLvalue() {
Action* act = frame->todo.Top();
const Expression* exp = act->GetLValAction().exp;
if (tracing_output) {
std::cout << "--- step lvalue ";
PrintExp(exp);
std::cout << " --->" << std::endl;
llvm::outs() << "--- step lvalue " << *exp << " --->\n";
}
switch (exp->tag()) {
case ExpressionKind::IdentifierExpression: {
@@ -446,8 +432,8 @@ void StepLvalue() {
std::optional<Address> pointer =
CurrentEnv(state).Get(exp->GetIdentifierExpression().name);
if (!pointer) {
std::cerr << exp->line_num << ": could not find `"
<< exp->GetIdentifierExpression().name << "`" << std::endl;
llvm::errs() << exp->line_num << ": could not find `"
<< exp->GetIdentifierExpression().name << "`\n";
exit(-1);
}
const Value* v = Value::MakePointerValue(*pointer);
@@ -528,9 +514,7 @@ void StepLvalue() {
case ExpressionKind::AutoTypeLiteral:
case ExpressionKind::ContinuationTypeLiteral:
case ExpressionKind::BindingExpression: {
std::cerr << "Can't treat expression as lvalue: ";
PrintExp(exp);
std::cerr << std::endl;
llvm::errs() << "Can't treat expression as lvalue: " << *exp << "\n";
exit(-1);
}
}
@@ -543,9 +527,7 @@ void StepExp() {
Action* act = frame->todo.Top();
const Expression* exp = act->GetExpressionAction().exp;
if (tracing_output) {
std::cout << "--- step exp ";
PrintExp(exp);
std::cout << " --->" << std::endl;
llvm::outs() << "--- step exp " << *exp << " --->\n";
}
switch (exp->tag()) {
case ExpressionKind::BindingExpression: {
@@ -581,9 +563,8 @@ void StepExp() {
std::string f = std::to_string(act->results[1]->GetIntValue());
const Value* field = tuple->GetTupleValue().FindField(f);
if (field == nullptr) {
std::cerr << "runtime error, field " << f << " not in ";
PrintValue(tuple, std::cerr);
std::cerr << std::endl;
llvm::errs() << "runtime error, field " << f << " not in "
<< *tuple << "\n";
exit(-1);
}
frame->todo.Pop(1);
@@ -591,10 +572,10 @@ void StepExp() {
break;
}
default:
std::cerr
llvm::errs()
<< "runtime type error, expected a tuple in field access, "
"not ";
PrintValue(tuple, std::cerr);
"not "
<< *tuple << "\n";
exit(-1);
}
}
@@ -649,8 +630,8 @@ void StepExp() {
std::optional<Address> pointer =
CurrentEnv(state).Get(exp->GetIdentifierExpression().name);
if (!pointer) {
std::cerr << exp->line_num << ": could not find `"
<< exp->GetIdentifierExpression().name << "`" << std::endl;
llvm::errs() << exp->line_num << ": could not find `"
<< exp->GetIdentifierExpression().name << "`\n";
exit(-1);
}
const Value* pointee = state->heap.Read(*pointer, exp->line_num);
@@ -710,7 +691,7 @@ void StepExp() {
frame->todo.Pop(1);
CallFunction(exp->line_num, act->results, state);
} else {
std::cerr << "internal error in handle_value with Call" << std::endl;
llvm::errs() << "internal error in handle_value with Call\n";
exit(-1);
}
break;
@@ -809,9 +790,9 @@ void StepStmt() {
const Statement* stmt = act->GetStatementAction().stmt;
CHECK(stmt != nullptr) << "null statement!";
if (tracing_output) {
std::cout << "--- step stmt ";
PrintStatement(stmt, 1);
std::cout << " --->" << std::endl;
llvm::outs() << "--- step stmt ";
stmt->PrintDepth(1, llvm::outs());
llvm::outs() << " --->\n";
}
switch (stmt->tag()) {
case StatementKind::Match:
@@ -960,9 +941,9 @@ void StepStmt() {
PatternMatch(p, v, frame->scopes.Top()->values,
&frame->scopes.Top()->locals, stmt->line_num);
if (!matches) {
std::cerr << stmt->line_num
<< ": internal error in variable definition, match failed"
<< std::endl;
llvm::errs()
<< stmt->line_num
<< ": internal error in variable definition, match failed\n";
exit(-1);
}
frame->scopes.Top()->values = *matches;
@@ -1114,8 +1095,8 @@ void StepStmt() {
void Step() {
Frame* frame = state->stack.Top();
if (frame->todo.IsEmpty()) {
std::cerr << "runtime error: fell off end of function " << frame->name
<< " without `return`" << std::endl;
llvm::errs() << "runtime error: fell off end of function " << frame->name
<< " without `return`\n";
exit(-1);
}
@@ -1143,7 +1124,7 @@ void Step() {
auto InterpProgram(std::list<Declaration>* fs) -> int {
state = new State(); // Runtime state.
if (tracing_output) {
std::cout << "********** initializing globals **********" << std::endl;
llvm::outs() << "********** initializing globals **********\n";
}
InitGlobals(fs);
@@ -1156,8 +1137,8 @@ auto InterpProgram(std::list<Declaration>* fs) -> int {
state->stack = Stack(frame);
if (tracing_output) {
std::cout << "********** calling main function **********" << std::endl;
PrintState(std::cout);
llvm::outs() << "********** calling main function **********\n";
PrintState(llvm::outs());
}
while (state->stack.CountExceeds(1) ||
@@ -1165,7 +1146,7 @@ auto InterpProgram(std::list<Declaration>* fs) -> int {
state->stack.Top()->todo.Top()->tag() != ActionKind::ValAction) {
Step();
if (tracing_output) {
PrintState(std::cout);
PrintState(llvm::outs());
}
}
const Value* v = state->stack.Top()->todo.Top()->GetValAction().val;
executable_semantics/interpreter/interpreter.h
+2 -1
View File
@@ -9,6 +9,7 @@
#include <utility>
#include <vector>
#include "common/ostream.h"
#include "executable_semantics/ast/declaration.h"
#include "executable_semantics/interpreter/frame.h"
#include "executable_semantics/interpreter/heap.h"
@@ -27,7 +28,7 @@ struct State {
extern State* state;
void InitEnv(const Declaration& d, Env* env);
void PrintStack(Stack<Frame*> ls, std::ostream& out);
void PrintStack(Stack<Frame*> ls, llvm::raw_ostream& out);
void PrintEnv(Env values);
/***** Interpreters *****/
executable_semantics/interpreter/typecheck.cpp
+57 -86
View File
@@ -5,7 +5,6 @@
#include "executable_semantics/interpreter/typecheck.h"
#include <algorithm>
#include <iostream>
#include <iterator>
#include <map>
#include <set>
@@ -20,12 +19,9 @@ namespace Carbon {
void ExpectType(int line_num, const std::string& context, const Value* expected,
const Value* actual) {
if (!TypeEqual(expected, actual)) {
std::cerr << line_num << ": type error in " << context << std::endl;
std::cerr << "expected: ";
PrintValue(expected, std::cerr);
std::cerr << std::endl << "actual: ";
PrintValue(actual, std::cerr);
std::cerr << std::endl;
llvm::errs() << line_num << ": type error in " << context << "\n"
<< "expected: " << *expected << "\n"
<< "actual: " << *actual << "\n";
exit(-1);
}
}
@@ -33,25 +29,13 @@ void ExpectType(int line_num, const std::string& context, const Value* expected,
void ExpectPointerType(int line_num, const std::string& context,
const Value* actual) {
if (actual->tag() != ValKind::PointerType) {
std::cerr << line_num << ": type error in " << context << std::endl;
std::cerr << "expected a pointer type\n";
std::cerr << "actual: ";
PrintValue(actual, std::cerr);
std::cerr << std::endl;
llvm::errs() << line_num << ": type error in " << context << "\n"
<< "expected a pointer type\n"
<< "actual: " << *actual << "\n";
exit(-1);
}
}
void PrintErrorString(const std::string& s) { std::cerr << s; }
void PrintTypeEnv(TypeEnv types, std::ostream& out) {
for (const auto& [name, value] : types) {
out << name << ": ";
PrintValue(value, out);
out << ", ";
}
}
// Reify type to type expression.
auto ReifyType(const Value* t, int line_num) -> const Expression* {
switch (t->tag()) {
@@ -83,9 +67,7 @@ auto ReifyType(const Value* t, int line_num) -> const Expression* {
return Expression::MakePrimitiveOperatorExpression(
0, Operator::Ptr, {ReifyType(t->GetPointerType().type, line_num)});
default:
std::cerr << line_num << ": expected a type, not ";
PrintValue(t, std::cerr);
std::cerr << std::endl;
llvm::errs() << line_num << ": expected a type, not " << *t << "\n";
exit(-1);
}
}
@@ -113,39 +95,37 @@ auto TypeCheckExp(const Expression* e, TypeEnv types, Env values,
if (tracing_output) {
switch (context) {
case TCContext::ValueContext:
std::cout << "checking expression ";
llvm::outs() << "checking expression ";
break;
case TCContext::PatternContext:
std::cout << "checking pattern, ";
llvm::outs() << "checking pattern, ";
if (expected) {
std::cout << "expecting ";
PrintValue(expected, std::cerr);
llvm::outs() << "expecting " << *expected;
}
std::cout << ", ";
llvm::outs() << ", ";
break;
case TCContext::TypeContext:
std::cout << "checking type ";
llvm::outs() << "checking type ";
break;
}
PrintExp(e);
std::cout << std::endl;
llvm::outs() << *e << "\n";
}
switch (e->tag()) {
case ExpressionKind::BindingExpression: {
if (context != TCContext::PatternContext) {
std::cerr
llvm::errs()
<< e->line_num
<< ": compilation error, pattern variables are only allowed in "
"pattern context"
<< std::endl;
<< "\n";
exit(-1);
}
auto t = InterpExp(values, e->GetBindingExpression().type);
if (t->tag() == ValKind::AutoType) {
if (expected == nullptr) {
std::cerr << e->line_num
<< ": compilation error, auto not allowed here"
<< std::endl;
llvm::errs() << e->line_num
<< ": compilation error, auto not allowed here"
<< "\n";
exit(-1);
} else {
t = expected;
@@ -172,10 +152,8 @@ auto TypeCheckExp(const Expression* e, TypeEnv types, Env values,
std::string f = std::to_string(i);
const Value* field_t = t->GetTupleValue().FindField(f);
if (field_t == nullptr) {
std::cerr << e->line_num << ": compilation error, field " << f
<< " is not in the tuple ";
PrintValue(t, std::cerr);
std::cerr << std::endl;
llvm::errs() << e->line_num << ": compilation error, field " << f
<< " is not in the tuple " << *t << "\n";
exit(-1);
}
auto new_e = Expression::MakeIndexExpression(
@@ -183,8 +161,8 @@ auto TypeCheckExp(const Expression* e, TypeEnv types, Env values,
return TCResult(new_e, field_t, res.types);
}
default:
std::cerr << e->line_num << ": compilation error, expected a tuple"
<< std::endl;
llvm::errs() << e->line_num
<< ": compilation error, expected a tuple\n";
exit(-1);
}
}
@@ -193,15 +171,14 @@ auto TypeCheckExp(const Expression* e, TypeEnv types, Env values,
std::vector<TupleElement> arg_types;
auto new_types = types;
if (expected && expected->tag() != ValKind::TupleValue) {
std::cerr << e->line_num << ": compilation error, didn't expect a tuple"
<< std::endl;
llvm::errs() << e->line_num
<< ": compilation error, didn't expect a tuple\n";
exit(-1);
}
if (expected && e->GetTupleLiteral().fields.size() !=
expected->GetTupleValue().elements.size()) {
std::cerr << e->line_num
<< ": compilation error, tuples of different length"
<< std::endl;
llvm::errs() << e->line_num
<< ": compilation error, tuples of different length\n";
exit(-1);
}
int i = 0;
@@ -210,11 +187,11 @@ auto TypeCheckExp(const Expression* e, TypeEnv types, Env values,
const Value* arg_expected = nullptr;
if (expected && expected->tag() == ValKind::TupleValue) {
if (expected->GetTupleValue().elements[i].name != arg->name) {
std::cerr << e->line_num
<< ": compilation error, field names do not match, "
<< "expected "
<< expected->GetTupleValue().elements[i].name
<< " but got " << arg->name << std::endl;
llvm::errs()
<< e->line_num
<< ": compilation error, field names do not match, expected "
<< expected->GetTupleValue().elements[i].name << " but got "
<< arg->name << "\n";
exit(-1);
}
arg_expected = expected->GetTupleValue().elements[i].value;
@@ -251,10 +228,10 @@ auto TypeCheckExp(const Expression* e, TypeEnv types, Env values,
return TCResult(new_e, method.second, res.types);
}
}
std::cerr << e->line_num << ": compilation error, struct "
<< t->GetStructType().name
<< " does not have a field named "
<< e->GetFieldAccessExpression().field << std::endl;
llvm::errs() << e->line_num << ": compilation error, struct "
<< t->GetStructType().name
<< " does not have a field named "
<< e->GetFieldAccessExpression().field << "\n";
exit(-1);
case ValKind::TupleValue:
for (const TupleElement& field : t->GetTupleValue().elements) {
@@ -264,10 +241,10 @@ auto TypeCheckExp(const Expression* e, TypeEnv types, Env values,
return TCResult(new_e, field.value, res.types);
}
}
std::cerr << e->line_num << ": compilation error, struct "
<< t->GetStructType().name
<< " does not have a field named "
<< e->GetFieldAccessExpression().field << std::endl;
llvm::errs() << e->line_num << ": compilation error, struct "
<< t->GetStructType().name
<< " does not have a field named "
<< e->GetFieldAccessExpression().field << "\n";
exit(-1);
case ValKind::ChoiceType:
for (auto vt = t->GetChoiceType().alternatives.begin();
@@ -279,18 +256,17 @@ auto TypeCheckExp(const Expression* e, TypeEnv types, Env values,
return TCResult(new_e, fun_ty, res.types);
}
}
std::cerr << e->line_num << ": compilation error, struct "
<< t->GetStructType().name
<< " does not have a field named "
<< e->GetFieldAccessExpression().field << std::endl;
llvm::errs() << e->line_num << ": compilation error, struct "
<< t->GetStructType().name
<< " does not have a field named "
<< e->GetFieldAccessExpression().field << "\n";
exit(-1);
default:
std::cerr << e->line_num
<< ": compilation error in field access, expected a struct"
<< std::endl;
PrintExp(e);
std::cerr << std::endl;
llvm::errs()
<< e->line_num
<< ": compilation error in field access, expected a struct\n"
<< *e << "\n";
exit(-1);
}
}
@@ -300,8 +276,8 @@ auto TypeCheckExp(const Expression* e, TypeEnv types, Env values,
if (type) {
return TCResult(e, *type, types);
} else {
std::cerr << e->line_num << ": could not find `"
<< e->GetIdentifierExpression().name << "`" << std::endl;
llvm::errs() << e->line_num << ": could not find `"
<< e->GetIdentifierExpression().name << "`\n";
exit(-1);
}
}
@@ -382,11 +358,9 @@ auto TypeCheckExp(const Expression* e, TypeEnv types, Env values,
return TCResult(new_e, fun_t->GetFunctionType().ret, arg_res.types);
}
default: {
std::cerr << e->line_num
<< ": compilation error in call, expected a function"
<< std::endl;
PrintExp(e);
std::cerr << std::endl;
llvm::errs() << e->line_num
<< ": compilation error in call, expected a function\n"
<< *e << "\n";
exit(-1);
}
}
@@ -584,9 +558,8 @@ auto CheckOrEnsureReturn(const Statement* stmt, bool void_return, int line_num)
return Statement::MakeReturn(line_num,
Expression::MakeTupleLiteral(line_num, {}));
} else {
std::cerr
<< "control-flow reaches end of non-void function without a return"
<< std::endl;
llvm::errs()
<< "control-flow reaches end of non-void function without a return\n";
exit(-1);
}
}
@@ -641,11 +614,10 @@ auto CheckOrEnsureReturn(const Statement* stmt, bool void_return, int line_num)
Statement::MakeReturn(stmt->line_num, Expression::MakeTupleLiteral(
stmt->line_num, {})));
} else {
std::cerr
llvm::errs()
<< stmt->line_num
<< ": control-flow reaches end of non-void function without a "
"return"
<< std::endl;
"return\n";
exit(-1);
}
}
@@ -812,8 +784,7 @@ auto TopLevel(std::list<Declaration>* fs) -> TypeCheckContext {
}
if (found_main == false) {
std::cerr << "error, program must contain a function named `main`"
<< std::endl;
llvm::errs() << "error, program must contain a function named `main`\n";
exit(-1);
}
return tops;
executable_semantics/interpreter/typecheck.h
+1 -4
View File
@@ -7,6 +7,7 @@
#include <set>
#include "common/ostream.h"
#include "executable_semantics/ast/expression.h"
#include "executable_semantics/ast/statement.h"
#include "executable_semantics/interpreter/dictionary.h"
@@ -16,8 +17,6 @@ namespace Carbon {
using TypeEnv = Dictionary<std::string, const Value*>;
void PrintTypeEnv(TypeEnv types);
enum class TCContext { ValueContext, PatternContext, TypeContext };
struct TCResult {
@@ -49,8 +48,6 @@ auto MakeTypeChecked(const Declaration& decl, const TypeEnv& types,
const Env& values) -> Declaration;
auto TopLevel(std::list<Declaration>* fs) -> TypeCheckContext;
void PrintErrorString(const std::string& s);
} // namespace Carbon
#endif // EXECUTABLE_SEMANTICS_INTERPRETER_TYPECHECK_H_
executable_semantics/interpreter/value.cpp
+33 -53
View File
@@ -5,7 +5,6 @@
#include "executable_semantics/interpreter/value.h"
#include <algorithm>
#include <iostream>
#include "common/check.h"
@@ -252,9 +251,8 @@ auto GetMember(const Value* v, const std::string& f, int line_num)
const Value* field =
v->GetStructValue().inits->GetTupleValue().FindField(f);
if (field == nullptr) {
std::cerr << "runtime error, member " << f << " not in ";
PrintValue(v, std::cerr);
std::cerr << std::endl;
llvm::errs() << "runtime error, member " << f << " not in " << *v
<< "\n";
exit(-1);
}
return field;
@@ -262,26 +260,20 @@ auto GetMember(const Value* v, const std::string& f, int line_num)
case ValKind::TupleValue: {
const Value* field = v->GetTupleValue().FindField(f);
if (field == nullptr) {
std::cerr << "field " << f << " not in ";
PrintValue(v, std::cerr);
std::cerr << std::endl;
llvm::errs() << "field " << f << " not in " << *v << "\n";
exit(-1);
}
return field;
}
case ValKind::ChoiceType: {
if (FindInVarValues(f, v->GetChoiceType().alternatives) == nullptr) {
std::cerr << "alternative " << f << " not in ";
PrintValue(v, std::cerr);
std::cerr << std::endl;
llvm::errs() << "alternative " << f << " not in " << *v << "\n";
exit(-1);
}
return Value::MakeAlternativeConstructorValue(f, v->GetChoiceType().name);
}
default:
std::cerr << "field access not allowed for value ";
PrintValue(v, std::cerr);
std::cerr << std::endl;
llvm::errs() << "field access not allowed for value " << *v << "\n";
exit(-1);
}
}
@@ -318,9 +310,7 @@ auto SetFieldImpl(const Value* value,
return element.name == *path_begin;
});
if (it == elements.end()) {
std::cerr << "field " << *path_begin << " not in ";
PrintValue(value, std::cerr);
std::cerr << std::endl;
llvm::errs() << "field " << *path_begin << " not in " << *value << "\n";
exit(-1);
}
it->value = SetFieldImpl(it->value, path_begin + 1, path_end, field_value,
@@ -328,9 +318,7 @@ auto SetFieldImpl(const Value* value,
return Value::MakeTupleValue(elements);
}
default:
std::cerr << "field access not allowed for value ";
PrintValue(value, std::cerr);
std::cerr << std::endl;
llvm::errs() << "field access not allowed for value " << *value << "\n";
exit(-1);
}
}
@@ -343,63 +331,60 @@ auto Value::SetField(const FieldPath& path, const Value* field_value,
field_value, line_num);
}
auto PrintValue(const Value* val, std::ostream& out) -> void {
switch (val->tag()) {
void Value::Print(llvm::raw_ostream& out) const {
switch (tag()) {
case ValKind::AlternativeConstructorValue: {
out << val->GetAlternativeConstructorValue().choice_name << "."
<< val->GetAlternativeConstructorValue().alt_name;
out << GetAlternativeConstructorValue().choice_name << "."
<< GetAlternativeConstructorValue().alt_name;
break;
}
case ValKind::BindingPlaceholderValue: {
const BindingPlaceholderValue& placeholder =
val->GetBindingPlaceholderValue();
const BindingPlaceholderValue& placeholder = GetBindingPlaceholderValue();
if (placeholder.name.has_value()) {
out << *placeholder.name;
} else {
out << "_";
}
out << ": ";
PrintValue(val->GetBindingPlaceholderValue().type, out);
out << ": " << *placeholder.type;
break;
}
case ValKind::AlternativeValue: {
out << "alt " << val->GetAlternativeValue().choice_name << "."
<< val->GetAlternativeValue().alt_name << " ";
PrintValue(val->GetAlternativeValue().argument, out);
out << "alt " << GetAlternativeValue().choice_name << "."
<< GetAlternativeValue().alt_name << " "
<< *GetAlternativeValue().argument;
break;
}
case ValKind::StructValue: {
out << val->GetStructValue().type->GetStructType().name;
PrintValue(val->GetStructValue().inits, out);
out << GetStructValue().type->GetStructType().name
<< *GetStructValue().inits;
break;
}
case ValKind::TupleValue: {
out << "(";
bool add_commas = false;
for (const TupleElement& element : val->GetTupleValue().elements) {
for (const TupleElement& element : GetTupleValue().elements) {
if (add_commas) {
out << ", ";
} else {
add_commas = true;
}
out << element.name << " = ";
PrintValue(element.value, out);
out << element.name << " = " << *element.value;
}
out << ")";
break;
}
case ValKind::IntValue:
out << val->GetIntValue();
out << GetIntValue();
break;
case ValKind::BoolValue:
out << std::boolalpha << val->GetBoolValue();
out << (GetBoolValue() ? "true" : "false");
break;
case ValKind::FunctionValue:
out << "fun<" << val->GetFunctionValue().name << ">";
out << "fun<" << GetFunctionValue().name << ">";
break;
case ValKind::PointerValue:
out << "ptr<" << val->GetPointerValue() << ">";
out << "ptr<" << GetPointerValue() << ">";
break;
case ValKind::BoolType:
out << "Bool";
@@ -417,20 +402,17 @@ auto PrintValue(const Value* val, std::ostream& out) -> void {
out << "Continuation";
break;
case ValKind::PointerType:
PrintValue(val->GetPointerType().type, out);
out << "*";
out << *GetPointerType().type << "*";
break;
case ValKind::FunctionType:
out << "fn ";
PrintValue(val->GetFunctionType().param, out);
out << " -> ";
PrintValue(val->GetFunctionType().ret, out);
out << "fn " << *GetFunctionType().param << " -> "
<< *GetFunctionType().ret;
break;
case ValKind::StructType:
out << "struct " << val->GetStructType().name;
out << "struct " << GetStructType().name;
break;
case ValKind::ChoiceType:
out << "choice " << val->GetChoiceType().name;
out << "choice " << GetChoiceType().name;
break;
case ValKind::ContinuationValue:
out << "continuation";
@@ -538,10 +520,9 @@ auto TypeEqual(const Value* t1, const Value* t2) -> bool {
case ValKind::TypeType:
return true;
default:
std::cerr << "TypeEqual used to compare non-type values" << std::endl;
PrintValue(t1, std::cerr);
std::cerr << std::endl;
PrintValue(t2, std::cerr);
llvm::errs() << "TypeEqual used to compare non-type values\n"
<< *t1 << "\n"
<< *t2 << "\n";
exit(-1);
}
}
@@ -603,8 +584,7 @@ auto ValueEqual(const Value* v1, const Value* v2, int line_num) -> bool {
case ValKind::BindingPlaceholderValue:
case ValKind::AlternativeConstructorValue:
case ValKind::ContinuationValue:
std::cerr << "ValueEqual does not support this kind of value."
<< std::endl;
llvm::errs() << "ValueEqual does not support this kind of value.\n";
exit(-1);
}
}
executable_semantics/interpreter/value.h
+3 -2
View File
@@ -11,6 +11,7 @@
#include <variant>
#include <vector>
#include "common/ostream.h"
#include "executable_semantics/ast/statement.h"
#include "executable_semantics/interpreter/address.h"
#include "executable_semantics/interpreter/field_path.h"
@@ -229,6 +230,8 @@ struct Value {
auto SetField(const FieldPath& path, const Value* field_value,
int line_num) const -> const Value*;
void Print(llvm::raw_ostream& out) const;
private:
std::variant<IntValue, FunctionValue, PointerValue, BoolValue, StructValue,
AlternativeValue, TupleValue, IntType, BoolType, TypeType,
@@ -238,8 +241,6 @@ struct Value {
value;
};
void PrintValue(const Value* val, std::ostream& out);
auto CopyVal(const Value* val, int line_num) -> const Value*;
auto TypeEqual(const Value* t1, const Value* t2) -> bool;
executable_semantics/main.cpp
+4
View File
@@ -12,6 +12,10 @@
#include "llvm/Support/CommandLine.h"
int main(int argc, char* argv[]) {
// Printing to stderr should flush stdout. This is most noticeable when stderr
// is piped to stdout.
llvm::errs().tie(&llvm::outs());
using llvm::cl::desc;
using llvm::cl::opt;
opt<bool> trace_option("trace", desc("Enable tracing"));
executable_semantics/syntax/BUILD
+1
View File
@@ -29,6 +29,7 @@ cc_library(
],
deps = [
":paren_contents",
"//common:ostream",
"//executable_semantics:tracing_flag",
"//executable_semantics/ast:declaration",
"//executable_semantics/ast:expression",
executable_semantics/syntax/syntax_helpers.cpp
+9 -10
View File
@@ -4,8 +4,7 @@
#include "executable_semantics/syntax/syntax_helpers.h"
#include <iostream>
#include "common/ostream.h"
#include "executable_semantics/interpreter/interpreter.h"
#include "executable_semantics/interpreter/typecheck.h"
#include "executable_semantics/tracing_flag.h"
@@ -14,11 +13,11 @@ namespace Carbon {
void ExecProgram(std::list<Declaration>* fs) {
if (tracing_output) {
std::cout << "********** source program **********" << std::endl;
llvm::outs() << "********** source program **********\n";
for (const auto& decl : *fs) {
decl.Print();
llvm::outs() << decl;
}
std::cout << "********** type checking **********" << std::endl;
llvm::outs() << "********** type checking **********\n";
}
state = new State(); // Compile-time state.
TypeCheckContext p = TopLevel(fs);
@@ -29,15 +28,15 @@ void ExecProgram(std::list<Declaration>* fs) {
new_decls.push_back(MakeTypeChecked(decl, top, ct_top));
}
if (tracing_output) {
std::cout << std::endl;
std::cout << "********** type checking complete **********" << std::endl;
llvm::outs() << "\n";
llvm::outs() << "********** type checking complete **********\n";
for (const auto& decl : new_decls) {
decl.Print();
llvm::outs() << decl;
}
std::cout << "********** starting execution **********" << std::endl;
llvm::outs() << "********** starting execution **********\n";
}
int result = InterpProgram(&new_decls);
std::cout << "result: " << result << std::endl;
llvm::outs() << "result: " << result << "\n";
}
} // namespace Carbon