teascade/c-compiler
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: teascade:21d17bb02d5199f2116eca2406ff6d49395af861
Branches Tags
teascade:main
teascade:typechecker
..
compare: teascade:55388bc6e341d195a6bf59003ebd037d9d931b5d
Branches Tags
teascade:main
teascade:typechecker

No commits in common. "21d17bb02d5199f2116eca2406ff6d49395af861" and "55388bc6e341d195a6bf59003ebd037d9d931b5d" have entirely different histories.
21d17bb02d ... 55388bc6e3

14 changed files with 133 additions and 630 deletions
Show Stats Expand all files Collapse all files

11
src/ast.cpp
View File

@ -68,13 +68,6 @@ namespace AST {
return out.str(); return out.str();
} }
std::string FieldAccessExpression::formatted() {
std::stringstream out{ "" };
out << this->m_expr->formatted();
out << "." << this->m_field;
return out.str();
}
std::string ListInitializerExpression::formatted() { std::string ListInitializerExpression::formatted() {
std::stringstream out{ "" }; std::stringstream out{ "" };
out << "{ "; out << "{ ";
@ -156,8 +149,4 @@ namespace AST {
} }
return out.str(); return out.str();
} }
std::string TopLevelTypedef::formatted() {
return this->m_ty->formatted();
}
} }

42
src/ast.h
View File

@ -245,32 +245,6 @@ namespace AST {
) override; ) override;
}; };
/// @brief Same as value.field
class FieldAccessExpression : public Expression {
private:
std::unique_ptr<Expression> m_expr;
std::string m_field;
public:
FieldAccessExpression(
token::Metadata meta,
std::unique_ptr<Expression> expr,
std::string field)
: Expression{ meta }
, m_expr{ std::move(expr) }
, m_field{ field } {
}
virtual ~FieldAccessExpression() override = default;
virtual std::string formatted() override;
virtual codegen::StackValue codegen(codegen::Builder& builder, codegen::Scope& scope) override;
virtual std::shared_ptr<types::Type> get_codegen_type(codegen::Scope& scope) override;
virtual std::shared_ptr<types::Type> typecheck(
typecheck::State& state,
typecheck::Scope& scope,
std::optional<std::shared_ptr<types::Type>> expected_ty
) override;
};
/// @brief Same as {value1, value2}
class ListInitializerExpression : public Expression { class ListInitializerExpression : public Expression {
private: private:
std::vector<std::unique_ptr<Expression>> m_expressions; std::vector<std::unique_ptr<Expression>> m_expressions;
@ -399,22 +373,6 @@ namespace AST {
virtual void codegen(codegen::Builder& builder, codegen::Scope& scope) override; virtual void codegen(codegen::Builder& builder, codegen::Scope& scope) override;
virtual void typecheck(typecheck::State& state, typecheck::Scope& scope) override; virtual void typecheck(typecheck::State& state, typecheck::Scope& scope) override;
}; };
class TopLevelTypedef : public TopLevelStatement {
private:
std::shared_ptr<types::Type> m_ty;
public:
TopLevelTypedef(
token::Metadata meta,
std::shared_ptr<types::Type> type)
: TopLevelStatement{ meta }
, m_ty{ type } {
}
virtual ~TopLevelTypedef() override = default;
virtual std::string formatted() override;
virtual void codegen(codegen::Builder& builder, codegen::Scope& scope) override;
virtual void typecheck(typecheck::State& state, typecheck::Scope& scope) override;
};
} }
#endif #endif

4
src/builder.h
View File

@ -1,8 +1,6 @@
#ifndef BUILDER_H #ifndef BUILDER_H
#define BUILDER_H #define BUILDER_H
#include <map>
#include <llvm/IR/LLVMContext.h> #include <llvm/IR/LLVMContext.h>
#include <llvm/IR/IRBuilder.h> #include <llvm/IR/IRBuilder.h>
@ -13,8 +11,6 @@ namespace codegen {
std::unique_ptr<llvm::IRBuilder<>> builder; std::unique_ptr<llvm::IRBuilder<>> builder;
llvm::BasicBlock* block; llvm::BasicBlock* block;
}; };
typedef std::map<std::string, llvm::Type*> TypeMap;
} }
#endif #endif

14
src/casting.cpp
View File

@ -32,15 +32,13 @@ namespace types {
if (target_ty->is_signed()) { if (target_ty->is_signed()) {
casts.push_back(CastDefinition{ source_ty, target_ty, allow_implicit, casts.push_back(CastDefinition{ source_ty, target_ty, allow_implicit,
[](codegen::Builder& builder, std::shared_ptr<Type> target, llvm::Value* value) { [](codegen::Builder& builder, std::shared_ptr<Type> target, llvm::Value* value) {
codegen::TypeMap empty {}; return builder.builder->CreateSExtOrTrunc(value, target->codegen(builder), "cast");
return builder.builder->CreateSExtOrTrunc(value, target->codegen(builder, empty), "cast");
} }); } });
} }
else { else {
casts.push_back(CastDefinition{ source_ty, target_ty, allow_implicit, casts.push_back(CastDefinition{ source_ty, target_ty, allow_implicit,
[](codegen::Builder& builder, std::shared_ptr<Type> target, llvm::Value* value) { [](codegen::Builder& builder, std::shared_ptr<Type> target, llvm::Value* value) {
codegen::TypeMap empty {}; return builder.builder->CreateZExtOrTrunc(value, target->codegen(builder), "cast");
return builder.builder->CreateZExtOrTrunc(value, target->codegen(builder, empty), "cast");
} }); } });
} }
} }
@ -62,6 +60,14 @@ namespace types {
return {}; return {};
return CastDefinition{ casted_ty, target_ty, true, return CastDefinition{ casted_ty, target_ty, true,
[](codegen::Builder&, std::shared_ptr<Type>, llvm::Value* value) { [](codegen::Builder&, std::shared_ptr<Type>, llvm::Value* value) {
// auto ptr_ty = dynamic_cast<types::PointerType*>(target.get());
// std::vector<llvm::Value*> indices {};
// indices.push_back(llvm::ConstantInt::get(
// builder.builder->getInt32Ty(),
// 0
// ));
// return builder.builder->CreateGEP(ptr_ty->m_inner->codegen(builder), value, indices, "arraydecay");
return value; return value;
} }; } };
} }

189
src/codegen.cpp
View File

@ -11,7 +11,7 @@
namespace codegen { namespace codegen {
Scope Scope::with_lvalue() { Scope Scope::with_lvalue() {
return Scope{ this->binops, this->casts, this->structs, this->values, true }; return Scope{ this->binops, this->casts, this->values, true };
} }
} }
@ -20,8 +20,8 @@ namespace AST {
return this->m_ty; return this->m_ty;
} }
codegen::StackValue IntLiteralExpression::codegen(codegen::Builder& builder, codegen::Scope& scope) { codegen::StackValue IntLiteralExpression::codegen(codegen::Builder& builder, codegen::Scope&) {
auto ty = this->m_ty->codegen(builder, scope.structs); auto ty = this->m_ty->codegen(builder);
return codegen::StackValue{ return codegen::StackValue{
llvm::ConstantInt::get(ty, this->m_value), llvm::ConstantInt::get(ty, this->m_value),
@ -56,7 +56,7 @@ namespace AST {
} }
else { else {
return codegen::StackValue{ return codegen::StackValue{
builder.builder->CreateLoad(stack_type->codegen(builder, scope.structs), global_str, "literal"), builder.builder->CreateLoad(stack_type->codegen(builder), global_str, "literal"),
std::unique_ptr<types::Type>{stack_type}, std::unique_ptr<types::Type>{stack_type},
}; };
} }
@ -83,7 +83,7 @@ namespace AST {
return value->second; return value->second;
} }
else { else {
auto loaded = value->second.ty->load(builder, value->second.value, scope.structs); auto loaded = value->second.ty->load(builder, value->second.value);
return codegen::StackValue{ return codegen::StackValue{
loaded.first, loaded.first,
loaded.second loaded.second
@ -160,7 +160,7 @@ namespace AST {
} }
auto function = this->m_fn_expr->codegen(builder, scope); auto function = this->m_fn_expr->codegen(builder, scope);
auto value = builder.builder->CreateCall(llvm::dyn_cast<llvm::FunctionType>(function.ty->codegen(builder, scope.structs)), function.value, args, "call"); auto value = builder.builder->CreateCall(llvm::dyn_cast<llvm::FunctionType>(function.ty->codegen(builder)), function.value, args, "call");
return codegen::StackValue{ return codegen::StackValue{
value, value,
*function.ty->return_type(), *function.ty->return_type(),
@ -226,7 +226,7 @@ namespace AST {
codegen::StackValue DerefExpression::codegen(codegen::Builder& builder, codegen::Scope& scope) { codegen::StackValue DerefExpression::codegen(codegen::Builder& builder, codegen::Scope& scope) {
auto value = this->m_expr->codegen(builder, scope); auto value = this->m_expr->codegen(builder, scope);
if (value.ty->m_kind == types::TypeKind::Pointer) { if (value.ty->m_kind == types::TypeKind::Pointer) {
auto loaded = value.ty->load(builder, value.value, scope.structs); auto loaded = value.ty->load(builder, value.value);
return codegen::StackValue{ return codegen::StackValue{
loaded.first, loaded.first,
loaded.second loaded.second
@ -267,7 +267,7 @@ namespace AST {
if (ptr_ty->m_inner->m_kind == types::TypeKind::Pointer) { if (ptr_ty->m_inner->m_kind == types::TypeKind::Pointer) {
auto inner_ptr_ty = dynamic_cast<types::PointerType*>(ptr_ty->m_inner.get()); auto inner_ptr_ty = dynamic_cast<types::PointerType*>(ptr_ty->m_inner.get());
auto gep_value = builder.builder->CreateGEP(inner_ptr_ty->m_inner->codegen(builder, scope.structs), value.value, idx_list, "GEP"); auto gep_value = builder.builder->CreateGEP(inner_ptr_ty->m_inner->codegen(builder), value.value, idx_list, "GEP");
if (scope.is_lvalue) { if (scope.is_lvalue) {
return codegen::StackValue{ return codegen::StackValue{
gep_value, gep_value,
@ -275,7 +275,7 @@ namespace AST {
}; };
} }
else { else {
auto loaded = value.ty->load(builder, gep_value, scope.structs); auto loaded = value.ty->load(builder, gep_value);
return codegen::StackValue{ return codegen::StackValue{
loaded.first, loaded.first,
loaded.second loaded.second
@ -283,9 +283,11 @@ namespace AST {
} }
} }
else if (ptr_ty->m_inner->m_kind == types::TypeKind::Array) { else if (ptr_ty->m_inner->m_kind == types::TypeKind::Array) {
std::cout << ptr_ty->m_inner->formatted() << std::endl;
// Must be an array otherwise // Must be an array otherwise
auto arr_ty = dynamic_cast<types::ArrayType*>(ptr_ty->m_inner.get()); auto arr_ty = dynamic_cast<types::ArrayType*>(ptr_ty->m_inner.get());
auto gep_value = builder.builder->CreateGEP(arr_ty->m_inner->codegen(builder, scope.structs), value.value, idx_list, "GEP"); auto gep_value = builder.builder->CreateGEP(arr_ty->m_inner->codegen(builder), value.value, idx_list, "GEP");
if (scope.is_lvalue) { if (scope.is_lvalue) {
return codegen::StackValue{ return codegen::StackValue{
gep_value, gep_value,
@ -294,7 +296,7 @@ namespace AST {
} }
else { else {
auto inner_ptr_ty = types::PointerType{ arr_ty->m_inner }; auto inner_ptr_ty = types::PointerType{ arr_ty->m_inner };
auto loaded = inner_ptr_ty.load(builder, gep_value, scope.structs); auto loaded = inner_ptr_ty.load(builder, gep_value);
return codegen::StackValue{ return codegen::StackValue{
loaded.first, loaded.first,
loaded.second loaded.second
@ -302,7 +304,7 @@ namespace AST {
} }
} }
else { else {
auto gep_value = builder.builder->CreateGEP(ptr_ty->m_inner->codegen(builder, scope.structs), value.value, idx_list, "GEP"); auto gep_value = builder.builder->CreateGEP(ptr_ty->m_inner->codegen(builder), value.value, idx_list, "GEP");
if (scope.is_lvalue) { if (scope.is_lvalue) {
return codegen::StackValue{ return codegen::StackValue{
gep_value, gep_value,
@ -310,7 +312,7 @@ namespace AST {
}; };
} }
else { else {
auto loaded = value.ty->load(builder, gep_value, scope.structs); auto loaded = value.ty->load(builder, gep_value);
return codegen::StackValue{ return codegen::StackValue{
loaded.first, loaded.first,
loaded.second loaded.second
@ -323,79 +325,13 @@ namespace AST {
} }
std::shared_ptr<types::Type> FieldAccessExpression::get_codegen_type(codegen::Scope& scope) {
auto ty = this->m_expr->get_codegen_type(scope);
if (ty->m_kind == types::TypeKind::Struct) {
auto struct_ty = dynamic_cast<types::StructType*>(ty.get());
if (struct_ty->m_fields) {
for (auto& field : *struct_ty->m_fields) {
if (field.first == this->m_field)
return field.second;
}
throw CompileError("Unknown field", this->m_meta);
}
throw CompileError("Cannot access a field of opaque struct", this->m_meta);
}
else {
throw CompileError("Tried accessing a non-struct", this->m_meta);
}
}
codegen::StackValue FieldAccessExpression::codegen(codegen::Builder& builder, codegen::Scope& scope) {
auto lvalued = scope.with_lvalue();
auto struct_ptr = this->m_expr->codegen(builder, lvalued);
if (struct_ptr.ty->m_kind == types::TypeKind::Pointer) {
auto ptr_ty = dynamic_cast<types::PointerType*>(struct_ptr.ty.get());
if (ptr_ty->m_inner->m_kind == types::TypeKind::Struct) {
auto struct_ty = dynamic_cast<types::StructType*>(ptr_ty->m_inner.get());
int idx = -1;
auto field_ty = std::shared_ptr<types::Type>{};
for (int i = 0; i < static_cast<int>(struct_ty->m_fields->size()); i++) {
auto field = (*struct_ty->m_fields)[i];
if (field.first == this->m_field) {
idx = i;
field_ty = field.second;
break;
}
}
auto gep = builder.builder->CreateStructGEP(
ptr_ty->m_inner->codegen(builder, scope.structs), struct_ptr.value, idx);
auto ptr_ty = std::shared_ptr<types::Type>{
new types::PointerType { field_ty }
};
if (scope.is_lvalue) {
return codegen::StackValue{
gep,
ptr_ty
};
}
else {
auto loaded = ptr_ty->load(builder, gep, scope.structs);
return codegen::StackValue{ loaded.first, loaded.second };
}
}
else {
throw CompileError("Tried field-accessing a non-struct-pointer", this->m_meta);
}
}
else {
throw CompileError("Tried field-accessing a non-pointer", this->m_meta);
}
}
std::shared_ptr<types::Type> ListInitializerExpression::get_codegen_type(codegen::Scope&) { std::shared_ptr<types::Type> ListInitializerExpression::get_codegen_type(codegen::Scope&) {
return this->m_ty; return this->m_ty;
} }
codegen::StackValue ListInitializerExpression::codegen(codegen::Builder& builder, codegen::Scope& scope) { codegen::StackValue ListInitializerExpression::codegen(codegen::Builder& builder, codegen::Scope& scope) {
auto value_ptr = builder.builder->CreateAlloca(this->m_ty->codegen(builder, scope.structs)); auto array_ptr = builder.builder->CreateAlloca(this->m_ty->codegen(builder));
if (this->m_ty->m_kind == types::TypeKind::Array) { if (this->m_ty->m_kind == types::TypeKind::Array) {
auto array_ty = dynamic_cast<types::ArrayType*>(this->m_ty.get()); auto array_ty = dynamic_cast<types::ArrayType*>(this->m_ty.get());
@ -405,7 +341,7 @@ namespace AST {
std::vector<llvm::Value*> indices{}; std::vector<llvm::Value*> indices{};
indices.push_back(llvm::ConstantInt::get(builder.builder->getInt32Ty(), counter++)); indices.push_back(llvm::ConstantInt::get(builder.builder->getInt32Ty(), counter++));
auto gep = builder.builder->CreateGEP( auto gep = builder.builder->CreateGEP(
array_ty->m_inner->codegen(builder, scope.structs), value_ptr, indices, "GEP"); array_ty->m_inner->codegen(builder), array_ptr, indices, "GEP");
builder.builder->CreateStore(expr->codegen(builder, scope).value, gep); builder.builder->CreateStore(expr->codegen(builder, scope).value, gep);
} }
@ -414,38 +350,13 @@ namespace AST {
}; };
if (scope.is_lvalue) { if (scope.is_lvalue) {
return codegen::StackValue{ value_ptr, ptr_ty }; return codegen::StackValue{ array_ptr, ptr_ty };
} }
else { else {
auto loaded = ptr_ty->load(builder, value_ptr, scope.structs); auto loaded = ptr_ty->load(builder, array_ptr);
return codegen::StackValue{ loaded.first, loaded.second }; return codegen::StackValue{ loaded.first, loaded.second };
} }
} }
else if (this->m_ty->m_kind == types::TypeKind::Struct) {
auto struct_ty = dynamic_cast<types::StructType*>(this->m_ty.get());
for (int i = 0; i < static_cast<int>(this->m_expressions.size()); i++) {
std::vector<llvm::Value*> indices{};
auto gep = builder.builder->CreateStructGEP(
struct_ty->codegen(builder, scope.structs), value_ptr, i, "struct_gep"
);
builder.builder->CreateStore(
this->m_expressions[i]->codegen(builder, scope).value, gep);
}
auto ptr_ty = std::shared_ptr<types::Type>{
new types::PointerType{this->m_ty}
};
if (scope.is_lvalue) {
return codegen::StackValue{ value_ptr, ptr_ty };
}
else {
auto loaded = ptr_ty->load(builder, value_ptr, scope.structs);
return codegen::StackValue{ loaded.first, loaded.second };
}
}
else { else {
throw CompileError("Tried to list-initialize a non-array!", this->m_meta); throw CompileError("Tried to list-initialize a non-array!", this->m_meta);
} }
@ -476,7 +387,7 @@ namespace AST {
builder.builder->SetInsertPoint(builder.block); builder.builder->SetInsertPoint(builder.block);
auto ty = this->m_type->codegen(builder, scope.structs); auto ty = this->m_type->codegen(builder);
auto ptr = builder.builder->CreateAlloca(ty); auto ptr = builder.builder->CreateAlloca(ty);
if (this->m_expr.has_value()) { if (this->m_expr.has_value()) {
auto value = this->m_expr->get()->codegen(builder, scope); auto value = this->m_expr->get()->codegen(builder, scope);
@ -534,7 +445,7 @@ namespace AST {
auto fn_ty_ptr = std::shared_ptr<types::Type>{ new types::FunctionType{ ret_ty_ptr, param_ty_ptrs, this->m_is_vararg } }; auto fn_ty_ptr = std::shared_ptr<types::Type>{ new types::FunctionType{ ret_ty_ptr, param_ty_ptrs, this->m_is_vararg } };
auto fn_ty = fn_ty_ptr->codegen(builder, scope.structs); auto fn_ty = fn_ty_ptr->codegen(builder);
auto function = llvm::Function::Create( auto function = llvm::Function::Create(
llvm::dyn_cast<llvm::FunctionType>(fn_ty), llvm::dyn_cast<llvm::FunctionType>(fn_ty),
llvm::GlobalValue::LinkageTypes::ExternalLinkage, llvm::GlobalValue::LinkageTypes::ExternalLinkage,
@ -565,7 +476,7 @@ namespace AST {
} }
else { else {
builder.builder->SetInsertPoint(BB); builder.builder->SetInsertPoint(BB);
auto arg_ptr = builder.builder->CreateAlloca(param_ty_ptrs[counter]->codegen(builder, scope.structs)); auto arg_ptr = builder.builder->CreateAlloca(param_ty_ptrs[counter]->codegen(builder));
auto param_ty_ptr = std::shared_ptr<types::Type>{ auto param_ty_ptr = std::shared_ptr<types::Type>{
new types::PointerType { param_ty_ptrs[counter]} new types::PointerType { param_ty_ptrs[counter]}
}; };
@ -592,20 +503,10 @@ namespace AST {
builder.block = nullptr; builder.block = nullptr;
} }
void TopLevelTypedef::codegen(codegen::Builder& builder, codegen::Scope& scope) {
auto ty = this->m_ty->codegen(builder, scope.structs);
if (this->m_ty->m_kind == types::TypeKind::Struct) {
auto struct_ty = dynamic_cast<types::StructType*>(this->m_ty.get());
if (struct_ty->m_name) {
scope.structs[*struct_ty->m_name] = ty;
}
}
}
} }
namespace types { namespace types {
llvm::Type* FundamentalType::codegen(codegen::Builder& builder, codegen::TypeMap&) { llvm::Type* FundamentalType::codegen(codegen::Builder& builder) {
switch (this->m_ty) { switch (this->m_ty) {
case FundamentalTypeKind::Int: case FundamentalTypeKind::Int:
return builder.builder->getInt32Ty(); return builder.builder->getInt32Ty();
@ -620,55 +521,23 @@ namespace types {
} }
} }
llvm::Type* FunctionType::codegen(codegen::Builder& builder, codegen::TypeMap& structs) { llvm::Type* FunctionType::codegen(codegen::Builder& builder) {
std::vector<llvm::Type*> params{}; std::vector<llvm::Type*> params{};
for (auto& param : this->m_param_tys) { for (auto& param : this->m_param_tys) {
params.push_back(param->codegen(builder, structs)); params.push_back(param->codegen(builder));
} }
auto ret_ty = this->m_ret_ty->codegen(builder, structs); auto ret_ty = this->m_ret_ty->codegen(builder);
return llvm::FunctionType::get(ret_ty, params, this->m_vararg); return llvm::FunctionType::get(ret_ty, params, this->m_vararg);
} }
llvm::Type* PointerType::codegen(codegen::Builder& builder, codegen::TypeMap&) { llvm::Type* PointerType::codegen(codegen::Builder& builder) {
return llvm::PointerType::get(*builder.context, 0); return llvm::PointerType::get(*builder.context, 0);
} }
llvm::Type* ArrayType::codegen(codegen::Builder& builder, codegen::TypeMap& structs) { llvm::Type* ArrayType::codegen(codegen::Builder& builder) {
return llvm::ArrayType::get(this->m_inner->codegen(builder, structs), this->m_size); return llvm::ArrayType::get(this->m_inner->codegen(builder), this->m_size);
} }
llvm::Type* StructType::codegen(codegen::Builder& builder, codegen::TypeMap& structs) {
if (this->m_is_ref) {
if (this->m_name) {
return structs[*this->m_name];
}
else {
throw CompileError("reference to nonexistant struct", {});
}
}
if (this->m_fields) {
std::vector<llvm::Type*> fields{};
for (auto& field : *this->m_fields) {
fields.push_back(field.second->codegen(builder, structs));
}
auto ty = llvm::StructType::create(*builder.context, fields);
if (this->m_name)
ty->setName(*this->m_name);
return ty;
}
else {
auto ty = llvm::StructType::create(*builder.context);
if (this->m_name)
ty->setName(*this->m_name);
return ty;
}
}
// llvm::Type* StructRef::codegen(codegen::Builder&, codegen::TypeMap& structs) {
// return structs[this->m_name];
// }
} }

2
src/codegen.h
View File

@ -22,9 +22,7 @@ namespace codegen {
std::vector<types::BinopDefinition>& binops; std::vector<types::BinopDefinition>& binops;
std::vector<types::CastDefinition>& casts; std::vector<types::CastDefinition>& casts;
TypeMap structs;
std::map<std::string, StackValue> values; std::map<std::string, StackValue> values;
bool is_lvalue; bool is_lvalue;
Scope with_lvalue(); Scope with_lvalue();

9
src/main.cpp
View File

@ -70,14 +70,12 @@ std::optional<CompileOutput> compile(std::string_view in_filename) {
} }
// Parse tokens // Parse tokens
parsing::Scope parse_scope{};
auto stream = token::TokenStream{ tokens }; auto stream = token::TokenStream{ tokens };
std::vector<std::unique_ptr<AST::TopLevelStatement>> statements; std::vector<std::unique_ptr<AST::TopLevelStatement>> statements;
auto statement = parsing::parse_top_level_statement(stream, parse_scope); auto statement = parsing::parse_top_level_statement(stream);
while (statement.ok()) { while (statement.ok()) {
statements.push_back(statement.unwrap()); statements.push_back(statement.unwrap());
statement = parsing::parse_top_level_statement(stream, parse_scope); statement = parsing::parse_top_level_statement(stream);
} }
if (stream.peek().type != token::Type::Eof) { if (stream.peek().type != token::Type::Eof) {
std::cerr << statement.unwrap_err() << std::endl; std::cerr << statement.unwrap_err() << std::endl;
@ -124,7 +122,6 @@ std::optional<CompileOutput> compile(std::string_view in_filename) {
codegen::Scope cg_scope{ codegen::Scope cg_scope{
.binops = typecheck_state.binops, .binops = typecheck_state.binops,
.casts = typecheck_state.casts, .casts = typecheck_state.casts,
.structs = {},
.values = {}, .values = {},
.is_lvalue = false, .is_lvalue = false,
}; };
@ -165,7 +162,7 @@ std::optional<CompileOutput> compile(std::string_view in_filename) {
builder.mod->print(llvm_ir_dest, nullptr); builder.mod->print(llvm_ir_dest, nullptr);
llvm_ir_dest.flush(); llvm_ir_dest.flush();
// std::cout << llvm_ir_string << std::endl; std::cout << llvm_ir_string << std::endl;
// Print output to obj-file // Print output to obj-file
std::error_code EC; std::error_code EC;

205
src/parsing.cpp
View File

@ -5,67 +5,18 @@
namespace parsing { namespace parsing {
namespace { namespace {
Result<std::unique_ptr<AST::Expression>, std::string> parse_expression(token::TokenStream& stream, Scope& scope); Result<std::unique_ptr<AST::Expression>, std::string> parse_expression(token::TokenStream& stream);
Result<std::shared_ptr<types::Type>, std::string> parse_type(token::TokenStream& stream, Scope& scope) { Result<std::shared_ptr<types::Type>, std::string> parse_type(token::TokenStream& stream) {
token::TokenStream inner{ stream }; token::TokenStream inner{ stream };
try { try {
auto token = inner.expect(token::Type::Ident); auto token = inner.expect(token::Type::Ident);
std::shared_ptr<types::Type> returned{};
if (token.content == "struct") {
std::optional<std::string> struct_name{};
if (inner.peek().type == token::Type::Ident) {
struct_name = inner.expect(token::Type::Ident).content;
}
std::optional<std::vector<types::StructField>> maybe_fields{};
if (inner.peek().content == "{") {
std::vector<types::StructField> fields{};
inner.expect(token::Type::Symbol, "{");
int counter = 0;
while (inner.peek().content != "}") {
if (counter++ > 0)
inner.expect(token::Type::Symbol, ";");
auto ty = parse_type(inner, scope);
if (!ty.ok())
break;
auto field_name = inner.expect(token::Type::Ident);
fields.push_back(types::StructField{ field_name.content, ty.unwrap() });
}
inner.expect(token::Type::Symbol, "}");
maybe_fields = fields;
}
if (!struct_name && !maybe_fields) {
throw std::runtime_error("Struct must have a name or fields!");
}
if (struct_name && !maybe_fields && scope.structs.find(*struct_name) != scope.structs.end()) {
auto original_ty = scope.structs[*struct_name];
auto original_struct_ty = dynamic_cast<types::StructType*>(original_ty.get());
auto ty = new types::StructType{ struct_name, original_struct_ty->m_fields, true };
returned = std::shared_ptr<types::Type>{ ty };
}
else {
auto ty = new types::StructType{ struct_name, maybe_fields, false };
returned = std::shared_ptr<types::Type>{ ty };
}
}
else {
// TODO eventually make this be potentially more than one word // TODO eventually make this be potentially more than one word
std::string type_name = token.content; std::string type_name = token.content;
std::shared_ptr<types::Type> returned{};
if (type_name == "int") { if (type_name == "int") {
auto ty = new types::FundamentalType{ types::FundamentalTypeKind::Int }; auto ty = new types::FundamentalType{ types::FundamentalTypeKind::Int };
returned = std::shared_ptr<types::Type>{ ty }; returned = std::shared_ptr<types::Type>{ ty };
@ -81,7 +32,6 @@ namespace parsing {
else { else {
throw std::runtime_error("Expected type name, got " + type_name); throw std::runtime_error("Expected type name, got " + type_name);
} }
}
while (inner.peek().type == token::Type::Symbol && inner.peek().content == "*") { while (inner.peek().type == token::Type::Symbol && inner.peek().content == "*") {
inner.next(); inner.next();
@ -99,7 +49,7 @@ namespace parsing {
} }
} }
Result<std::optional<uint32_t>, std::string> parse_array_postfix(token::TokenStream& stream, bool allow_empty, Scope&) { Result<std::optional<uint32_t>, std::string> parse_array_postfix(token::TokenStream& stream, bool allow_empty) {
token::TokenStream inner{ stream }; token::TokenStream inner{ stream };
try { try {
std::optional<uint32_t> returned{}; std::optional<uint32_t> returned{};
@ -121,7 +71,7 @@ namespace parsing {
} }
} }
Result<std::unique_ptr<AST::Expression>, std::string> parse_list_initializer(token::TokenStream& stream, Scope& scope) { Result<std::unique_ptr<AST::Expression>, std::string> parse_list_initializer(token::TokenStream& stream) {
token::TokenStream inner{ stream }; token::TokenStream inner{ stream };
try { try {
auto before_meta = inner.metadata(); auto before_meta = inner.metadata();
@ -135,7 +85,7 @@ namespace parsing {
if (counter++ > 0) { if (counter++ > 0) {
inner.expect(token::Type::Symbol, ","); inner.expect(token::Type::Symbol, ",");
} }
expressions.push_back(parse_expression(inner, scope).unwrap()); expressions.push_back(parse_expression(inner).unwrap());
} }
inner.expect(token::Type::Symbol, "}"); inner.expect(token::Type::Symbol, "}");
@ -155,10 +105,10 @@ namespace parsing {
} }
} }
Result<std::unique_ptr<AST::Expression>, std::string> parse_plain_expression(token::TokenStream& stream, Scope& scope) { Result<std::unique_ptr<AST::Expression>, std::string> parse_plain_expression(token::TokenStream& stream) {
token::TokenStream inner{ stream }; token::TokenStream inner{ stream };
try { try {
if (auto list_init = parse_list_initializer(inner, scope); list_init.ok()) { if (auto list_init = parse_list_initializer(inner); list_init.ok()) {
stream.m_position = inner.m_position; stream.m_position = inner.m_position;
return std::unique_ptr<AST::Expression> { list_init.unwrap() }; return std::unique_ptr<AST::Expression> { list_init.unwrap() };
@ -192,11 +142,11 @@ namespace parsing {
} }
} }
Result<std::shared_ptr<types::Type>, std::string> parse_cast(token::TokenStream& stream, Scope& scope) { Result<std::shared_ptr<types::Type>, std::string> parse_cast(token::TokenStream& stream) {
token::TokenStream inner{ stream }; token::TokenStream inner{ stream };
try { try {
inner.expect(token::Type::Symbol, "("); inner.expect(token::Type::Symbol, "(");
auto ty = parse_type(inner, scope).unwrap(); auto ty = parse_type(inner).unwrap();
inner.expect(token::Type::Symbol, ")"); inner.expect(token::Type::Symbol, ")");
stream.m_position = inner.m_position; stream.m_position = inner.m_position;
@ -208,14 +158,14 @@ namespace parsing {
} }
} }
Result<std::unique_ptr<AST::Expression>, std::string> parse_primary_expression(token::TokenStream& stream, Scope& scope) { Result<std::unique_ptr<AST::Expression>, std::string> parse_primary_expression(token::TokenStream& stream) {
token::TokenStream inner{ stream }; token::TokenStream inner{ stream };
try { try {
auto before_meta = inner.metadata(); auto before_meta = inner.metadata();
if (auto cast = parse_cast(inner, scope); cast.ok()) { if (auto cast = parse_cast(inner); cast.ok()) {
auto expr = parse_primary_expression(inner, scope).unwrap(); auto expr = parse_primary_expression(inner).unwrap();
stream.m_position = inner.m_position; stream.m_position = inner.m_position;
return std::unique_ptr<AST::Expression>{ return std::unique_ptr<AST::Expression>{
new AST::CastExpression{ new AST::CastExpression{
@ -227,14 +177,14 @@ namespace parsing {
} }
else if (inner.peek().content == "(") { else if (inner.peek().content == "(") {
inner.next(); inner.next();
auto expr = parse_expression(inner, scope).unwrap(); auto expr = parse_expression(inner).unwrap();
inner.expect(token::Type::Symbol, ")"); inner.expect(token::Type::Symbol, ")");
stream.m_position = inner.m_position; stream.m_position = inner.m_position;
return expr; return expr;
} }
else if (inner.peek().content == "&") { else if (inner.peek().content == "&") {
inner.next(); inner.next();
auto expr = parse_primary_expression(inner, scope).unwrap(); auto expr = parse_primary_expression(inner).unwrap();
stream.m_position = inner.m_position; stream.m_position = inner.m_position;
return std::unique_ptr<AST::Expression> { return std::unique_ptr<AST::Expression> {
new AST::RefExpression(before_meta + inner.metadata(), std::move(expr)) new AST::RefExpression(before_meta + inner.metadata(), std::move(expr))
@ -242,15 +192,15 @@ namespace parsing {
} }
else if (inner.peek().content == "*") { else if (inner.peek().content == "*") {
inner.next(); inner.next();
auto expr = parse_primary_expression(inner, scope).unwrap(); auto expr = parse_primary_expression(inner).unwrap();
stream.m_position = inner.m_position; stream.m_position = inner.m_position;
return std::unique_ptr<AST::Expression> { return std::unique_ptr<AST::Expression> {
new AST::DerefExpression(before_meta + inner.metadata(), std::move(expr)) new AST::DerefExpression(before_meta + inner.metadata(), std::move(expr))
}; };
} }
auto plain_expr = parse_plain_expression(inner, scope); auto plain_expr = parse_plain_expression(inner);
while (inner.peek().content == "(" || inner.peek().content == "[" || inner.peek().content == ".") { while (inner.peek().content == "(" || inner.peek().content == "[") {
if (inner.peek().content == "(") { if (inner.peek().content == "(") {
inner.next(); inner.next();
@ -260,7 +210,7 @@ namespace parsing {
while (inner.peek().content != ")") { while (inner.peek().content != ")") {
if (counter++ > 0) if (counter++ > 0)
inner.expect(token::Type::Symbol, ","); inner.expect(token::Type::Symbol, ",");
args.push_back(parse_expression(inner, scope).unwrap()); args.push_back(parse_expression(inner).unwrap());
} }
inner.expect(token::Type::Symbol, ")"); inner.expect(token::Type::Symbol, ")");
@ -268,19 +218,11 @@ namespace parsing {
auto fn_call = new AST::FunctionCallExpression{ before_meta + inner.metadata(), plain_expr.unwrap(), std::move(args) }; auto fn_call = new AST::FunctionCallExpression{ before_meta + inner.metadata(), plain_expr.unwrap(), std::move(args) };
plain_expr = std::unique_ptr<AST::Expression>{ fn_call }; plain_expr = std::unique_ptr<AST::Expression>{ fn_call };
} }
else if (auto postfix = parse_array_postfix(inner, false, scope); postfix.ok()) { else if (auto postfix = parse_array_postfix(inner, false); postfix.ok()) {
auto idx_expr = new AST::IndexAccessExpression{ auto idx_expr = new AST::IndexAccessExpression{
before_meta + inner.metadata(), plain_expr.unwrap(), *postfix.unwrap() }; before_meta + inner.metadata(), plain_expr.unwrap(), *postfix.unwrap() };
plain_expr = std::unique_ptr<AST::Expression>{ idx_expr }; plain_expr = std::unique_ptr<AST::Expression>{ idx_expr };
} }
else if (inner.peek().content == ".") {
inner.next();
std::string field_name = inner.expect(token::Type::Ident).content;
plain_expr = std::unique_ptr<AST::Expression>{
new AST::FieldAccessExpression{before_meta + inner.metadata(), plain_expr.unwrap(), field_name}
};
}
} }
@ -292,7 +234,7 @@ namespace parsing {
} }
} }
Result<types::BinOp, std::string> parse_binop(token::TokenStream& stream, Scope&) { Result<types::BinOp, std::string> parse_binop(token::TokenStream& stream) {
token::TokenStream inner{ stream }; token::TokenStream inner{ stream };
try { try {
auto token = inner.next(); auto token = inner.next();
@ -328,32 +270,32 @@ namespace parsing {
} }
std::unique_ptr<AST::Expression> parse_rhs( std::unique_ptr<AST::Expression> parse_rhs(
token::TokenStream& stream, std::unique_ptr<AST::Expression> lhs, int prev_precedence, Scope& scope) { token::TokenStream& stream, std::unique_ptr<AST::Expression> lhs, int prev_precedence) {
auto before = stream.metadata(); auto before = stream.metadata();
auto binop_res = parse_binop(stream, scope); auto binop_res = parse_binop(stream);
while (binop_res.ok()) { while (binop_res.ok()) {
auto binop = binop_res.unwrap(); auto binop = binop_res.unwrap();
auto rhs = parse_primary_expression(stream, scope).unwrap(); auto rhs = parse_primary_expression(stream).unwrap();
if (types::operator_precedence(binop) > prev_precedence) { if (types::operator_precedence(binop) > prev_precedence) {
rhs = parse_rhs(stream, std::move(rhs), types::operator_precedence(binop), scope); rhs = parse_rhs(stream, std::move(rhs), types::operator_precedence(binop));
} }
auto binop_expr = new AST::BinaryOperationExpression{ before + stream.metadata(), std::move(lhs), binop, std::move(rhs) }; auto binop_expr = new AST::BinaryOperationExpression{ before + stream.metadata(), std::move(lhs), binop, std::move(rhs) };
lhs = std::unique_ptr<AST::Expression>{ binop_expr }; lhs = std::unique_ptr<AST::Expression>{ binop_expr };
binop_res = parse_binop(stream, scope); binop_res = parse_binop(stream);
} }
return lhs; return lhs;
} }
Result<std::unique_ptr<AST::Expression>, std::string> parse_expression(token::TokenStream& stream, Scope& scope) { Result<std::unique_ptr<AST::Expression>, std::string> parse_expression(token::TokenStream& stream) {
try { try {
auto lhs = parse_primary_expression(stream, scope).unwrap(); auto lhs = parse_primary_expression(stream).unwrap();
return std::unique_ptr{ parse_rhs(stream, std::move(lhs), 0, scope) }; return std::unique_ptr{ parse_rhs(stream, std::move(lhs), 0) };
} }
catch (std::runtime_error& error) { catch (std::runtime_error& error) {
return std::string{ error.what() }; return std::string{ error.what() };
@ -362,16 +304,16 @@ namespace parsing {
Result<std::unique_ptr<AST::InitializationStatement>, std::string> parse_init_statement(token::TokenStream& stream, Scope& scope) { Result<std::unique_ptr<AST::InitializationStatement>, std::string> parse_init_statement(token::TokenStream& stream) {
token::TokenStream inner{ stream }; token::TokenStream inner{ stream };
auto before_meta = inner.metadata(); auto before_meta = inner.metadata();
try { try {
auto ty = parse_type(inner, scope).unwrap(); auto ty = parse_type(inner).unwrap();
auto name = inner.expect(token::Type::Ident); auto name = inner.expect(token::Type::Ident);
auto array_postfix = parse_array_postfix(inner, false, scope); auto array_postfix = parse_array_postfix(inner, false);
while (array_postfix.ok()) { while (array_postfix.ok()) {
auto postfix = array_postfix.unwrap(); auto postfix = array_postfix.unwrap();
if (postfix) { if (postfix) {
@ -384,13 +326,13 @@ namespace parsing {
new types::PointerType(ty) new types::PointerType(ty)
}; };
} }
array_postfix = parse_array_postfix(inner, false, scope); array_postfix = parse_array_postfix(inner, false);
} }
std::optional<std::unique_ptr<AST::Expression>> expr = {}; std::optional<std::unique_ptr<AST::Expression>> expr = {};
if (inner.peek().type == token::Type::Symbol && inner.peek().content == "=") { if (inner.peek().type == token::Type::Symbol && inner.peek().content == "=") {
inner.expect(token::Type::Symbol, "="); inner.expect(token::Type::Symbol, "=");
expr = parse_expression(inner, scope).unwrap(); expr = parse_expression(inner).unwrap();
} }
inner.expect(token::Type::Symbol, ";"); inner.expect(token::Type::Symbol, ";");
@ -404,13 +346,13 @@ namespace parsing {
} }
} }
Result<std::unique_ptr<AST::Statement>, std::string> parse_statement(token::TokenStream& stream, Scope& scope) { Result<std::unique_ptr<AST::Statement>, std::string> parse_statement(token::TokenStream& stream) {
token::TokenStream inner{ stream }; token::TokenStream inner{ stream };
auto before_meta = inner.metadata(); auto before_meta = inner.metadata();
try { try {
if (inner.peek().type == token::Type::ReturnKeyword) { if (inner.peek().type == token::Type::ReturnKeyword) {
inner.next(); inner.next();
auto expression = parse_expression(inner, scope).unwrap(); auto expression = parse_expression(inner).unwrap();
inner.expect(token::Type::Symbol, ";"); inner.expect(token::Type::Symbol, ";");
stream.m_position = inner.m_position; stream.m_position = inner.m_position;
@ -421,14 +363,14 @@ namespace parsing {
else if (inner.peek().type == token::Type::IfKeyword) { else if (inner.peek().type == token::Type::IfKeyword) {
inner.next(); inner.next();
inner.expect(token::Type::Symbol, "("); inner.expect(token::Type::Symbol, "(");
auto expression = parse_expression(inner, scope).unwrap(); auto expression = parse_expression(inner).unwrap();
inner.expect(token::Type::Symbol, ")"); inner.expect(token::Type::Symbol, ")");
auto then_statement = parse_statement(inner, scope).unwrap(); auto then_statement = parse_statement(inner).unwrap();
std::optional<std::unique_ptr<AST::Statement>> else_statement{}; std::optional<std::unique_ptr<AST::Statement>> else_statement{};
if (inner.peek().type == token::Type::ElseKeyword) { if (inner.peek().type == token::Type::ElseKeyword) {
inner.next(); inner.next();
else_statement = parse_statement(inner, scope).unwrap(); else_statement = parse_statement(inner).unwrap();
} }
stream.m_position = inner.m_position; stream.m_position = inner.m_position;
@ -441,11 +383,11 @@ namespace parsing {
}; };
return std::unique_ptr<AST::Statement>{ statement }; return std::unique_ptr<AST::Statement>{ statement };
} }
else if (auto init = parse_init_statement(inner, scope); init.ok()) { else if (auto init = parse_init_statement(inner); init.ok()) {
stream.m_position = inner.m_position; stream.m_position = inner.m_position;
return std::unique_ptr<AST::Statement>{ init.unwrap() }; return std::unique_ptr<AST::Statement>{ init.unwrap() };
} }
else if (auto expr = parse_expression(inner, scope); expr.ok()) { else if (auto expr = parse_expression(inner); expr.ok()) {
stream.m_position = inner.m_position; stream.m_position = inner.m_position;
stream.expect(token::Type::Symbol, ";"); stream.expect(token::Type::Symbol, ";");
auto expr_statement = new AST::ExpressionStatement{ before_meta + stream.metadata(), expr.unwrap() }; auto expr_statement = new AST::ExpressionStatement{ before_meta + stream.metadata(), expr.unwrap() };
@ -462,11 +404,11 @@ namespace parsing {
} }
} }
Result<std::unique_ptr<AST::TopLevelStatement>, std::string> parse_function(token::TokenStream& stream, Scope& scope) { Result<std::unique_ptr<AST::TopLevelStatement>, std::string> parse_top_level_statement(token::TokenStream& stream) {
token::TokenStream inner{ stream }; token::TokenStream inner{ stream };
auto before_meta = inner.metadata(); auto before_meta = inner.metadata();
try { try {
auto type = parse_type(inner, scope).unwrap(); auto type = parse_type(inner).unwrap();
auto name_token = inner.expect(token::Type::Ident); auto name_token = inner.expect(token::Type::Ident);
inner.expect(token::Type::Symbol, "("); inner.expect(token::Type::Symbol, "(");
@ -485,12 +427,13 @@ namespace parsing {
break; break;
} }
auto param_ty = parse_type(inner, scope).unwrap(); auto param_ty = parse_type(inner).unwrap();
std::optional<std::string> param_name{}; std::optional<std::string> param_name{};
if (inner.peek().type == token::Type::Ident) { if (inner.peek().type == token::Type::Ident) {
param_name = inner.expect(token::Type::Ident).content; param_name = inner.expect(token::Type::Ident).content;
auto postfix = parse_array_postfix(inner, true, scope); std::cout << inner.peek().formatted() << std::endl;
auto postfix = parse_array_postfix(inner, true);
while (postfix.ok()) { while (postfix.ok()) {
auto array_postfix = postfix.unwrap(); auto array_postfix = postfix.unwrap();
if (array_postfix) { if (array_postfix) {
@ -503,7 +446,7 @@ namespace parsing {
new types::PointerType(param_ty) new types::PointerType(param_ty)
}; };
} }
postfix = parse_array_postfix(inner, true, scope); postfix = parse_array_postfix(inner, true);
} }
} }
@ -512,18 +455,16 @@ namespace parsing {
inner.expect(token::Type::Symbol, ")"); inner.expect(token::Type::Symbol, ")");
auto inner_scope = parsing::Scope{ scope };
std::optional<std::vector<std::unique_ptr<AST::Statement>>> statements{}; std::optional<std::vector<std::unique_ptr<AST::Statement>>> statements{};
if (inner.peek().content == "{") { if (inner.peek().content == "{") {
inner.expect(token::Type::Symbol, "{"); inner.expect(token::Type::Symbol, "{");
std::vector<std::unique_ptr<AST::Statement>> statement_list{}; std::vector<std::unique_ptr<AST::Statement>> statement_list{};
auto statement = parse_statement(inner, inner_scope); auto statement = parse_statement(inner);
while (statement.ok()) { while (statement.ok()) {
statement_list.push_back(statement.unwrap()); statement_list.push_back(statement.unwrap());
statement = parse_statement(inner, inner_scope); statement = parse_statement(inner);
} }
statements = std::optional{ std::move(statement_list) }; statements = std::optional{ std::move(statement_list) };
@ -549,50 +490,4 @@ namespace parsing {
return std::string(error.what()); return std::string(error.what());
} }
} }
Result<std::unique_ptr<AST::TopLevelStatement>, std::string> parse_tl_typedef(token::TokenStream& stream, Scope& scope) {
token::TokenStream inner{ stream };
auto before_meta = inner.metadata();
try {
auto ty = parse_type(inner, scope).unwrap();
inner.expect(token::Type::Symbol, ";");
if (ty->m_kind == types::TypeKind::Struct) {
auto struct_ty = dynamic_cast<types::StructType*>(ty.get());
if (!struct_ty->m_is_ref && struct_ty->m_name) {
scope.structs[*struct_ty->m_name] = ty;
}
}
stream.m_position = inner.m_position;
auto tl_typedef = new AST::TopLevelTypedef{
before_meta + stream.metadata(), ty
};
return std::unique_ptr<AST::TopLevelStatement>{tl_typedef};
}
catch (std::runtime_error& error) {
return std::string(error.what());
}
}
Result<std::unique_ptr<AST::TopLevelStatement>, std::string> parse_top_level_statement(token::TokenStream& stream, Scope& scope) {
token::TokenStream inner{ stream };
auto before_meta = inner.metadata();
try {
if (auto func = parse_function(inner, scope); func.ok()) {
stream.m_position = inner.m_position;
return func.unwrap();
}
else if (auto tl_typedef = parse_tl_typedef(inner, scope); tl_typedef.ok()) {
stream.m_position = inner.m_position;
return tl_typedef.unwrap();
}
else {
throw std::runtime_error("Expected top-level statement, got " + inner.peek().formatted());
}
}
catch (std::runtime_error& error) {
return std::string(error.what());
}
}
} }

9
src/parsing.h
View File

@ -1,19 +1,12 @@
#ifndef PARSING_H #ifndef PARSING_H
#define PARSING_H #define PARSING_H
#include <map>
#include "ast.h" #include "ast.h"
#include "result.h" #include "result.h"
#include "tokens.h" #include "tokens.h"
namespace parsing { namespace parsing {
struct Scope { Result<std::unique_ptr<AST::TopLevelStatement>, std::string> parse_top_level_statement(token::TokenStream& stream);
std::map<std::string, std::shared_ptr<types::Type>> structs;
};
Result<std::unique_ptr<AST::TopLevelStatement>, std::string> parse_top_level_statement(
token::TokenStream& stream, Scope& scope);
} }
#endif #endif

85
src/typechecker.cpp
View File

@ -309,39 +309,6 @@ namespace AST {
}; };
} }
std::shared_ptr<types::Type> FieldAccessExpression::typecheck(
typecheck::State& state,
typecheck::Scope& scope,
std::optional<std::shared_ptr<types::Type>>
) {
auto expr_ty = this->m_expr->typecheck(state, scope, {});
if (expr_ty->m_kind != types::TypeKind::Struct) {
state.errors.push_back(
CompileError("Tried to access " + expr_ty->formatted() + "." + this->m_field, this->m_meta));
return std::shared_ptr<types::Type> {
new types::FundamentalType{ types::FundamentalTypeKind::Void }
};
}
auto struct_ty = dynamic_cast<types::StructType*>(expr_ty.get());
if (struct_ty->m_fields) {
for (auto& field : *struct_ty->m_fields) {
if (field.first == this->m_field) {
return field.second;
}
}
state.errors.push_back(CompileError("No such field", this->m_meta));
return std::shared_ptr<types::Type> {
new types::FundamentalType{ types::FundamentalTypeKind::Void }
};
}
state.errors.push_back(CompileError("Cannot access fields of opaque struct", this->m_meta));
return std::shared_ptr<types::Type> {
new types::FundamentalType{ types::FundamentalTypeKind::Void }
};
}
std::shared_ptr<types::Type> ListInitializerExpression::typecheck( std::shared_ptr<types::Type> ListInitializerExpression::typecheck(
typecheck::State& state, typecheck::State& state,
typecheck::Scope& scope, typecheck::Scope& scope,
@ -363,41 +330,6 @@ namespace AST {
} }
}; };
} }
else if ((*expected_ty)->m_kind == types::TypeKind::Struct) {
auto struct_ty = dynamic_cast<types::StructType*>(expected_ty->get());
if (struct_ty->m_fields) {
if (this->m_expressions.size() > struct_ty->m_fields->size()) {
state.errors.push_back(CompileError(
"Too many initializer values for " + struct_ty->formatted(),
this->m_meta));
return *expected_ty;
}
for (int i = 0; i < static_cast<int>(this->m_expressions.size()); i++) {
auto expected_field = (*struct_ty->m_fields)[i];
auto expr_ty = this->m_expressions[i]->typecheck(state, scope, expected_field.second);
auto res = check_type(state, expr_ty, expected_field.second);
this->m_expressions[i] = handle_res(std::move(this->m_expressions[i]), res, state);
}
this->m_ty = *expected_ty;
return this->m_ty;
}
else {
if (this->m_expressions.size() > 0) {
state.errors.push_back(CompileError(
"Too many initializer values for " + struct_ty->formatted(),
this->m_meta));
return *expected_ty;
}
else {
this->m_ty = *expected_ty;
return this->m_ty;
}
}
}
else { else {
return std::shared_ptr<types::Type> { return std::shared_ptr<types::Type> {
new types::FundamentalType{ types::FundamentalTypeKind::Void } new types::FundamentalType{ types::FundamentalTypeKind::Void }
@ -496,21 +428,4 @@ namespace AST {
} }
} }
} }
void TopLevelTypedef::typecheck(typecheck::State& state, typecheck::Scope& scope) {
if (this->m_ty->m_kind == types::TypeKind::Struct) {
auto struct_ty = dynamic_cast<types::StructType*>(this->m_ty.get());
if (struct_ty->m_is_ref) {
return;
}
if (struct_ty->m_name) {
if (scope.structs.find(*struct_ty->m_name) == scope.structs.end()) {
scope.structs[*struct_ty->m_name] = this->m_ty;
}
else {
state.errors.push_back(CompileError("Struct " + *struct_ty->m_name + " declared twice!", this->m_meta));
}
}
}
}
} }

1
src/typechecker.h
View File

@ -11,7 +11,6 @@
namespace typecheck { namespace typecheck {
struct Scope { struct Scope {
std::map<std::string, std::shared_ptr<types::Type>> symbols; std::map<std::string, std::shared_ptr<types::Type>> symbols;
std::map<std::string, std::shared_ptr<types::Type>> structs;
std::optional<std::shared_ptr<types::Type>> return_ty; std::optional<std::shared_ptr<types::Type>> return_ty;
}; };

100
src/types.cpp
View File

@ -4,7 +4,6 @@
#include "types.h" #include "types.h"
#include "binops.h" #include "binops.h"
#include "builder.h"
namespace types { namespace types {
int operator_precedence(BinOp& op) { int operator_precedence(BinOp& op) {
@ -64,7 +63,7 @@ namespace types {
return false; return false;
} }
std::pair<llvm::Value*, std::shared_ptr<Type>> FundamentalType::load(codegen::Builder&, llvm::Value* ptr, codegen::TypeMap&) { std::pair<llvm::Value*, std::shared_ptr<Type>> FundamentalType::load(codegen::Builder&, llvm::Value* ptr) {
auto self = std::make_shared<FundamentalType>(*this); auto self = std::make_shared<FundamentalType>(*this);
return std::pair(ptr, self); return std::pair(ptr, self);
} }
@ -119,7 +118,7 @@ namespace types {
return this->m_ret_ty; return this->m_ret_ty;
} }
std::pair<llvm::Value*, std::shared_ptr<Type>> FunctionType::load(codegen::Builder&, llvm::Value* ptr, codegen::TypeMap&) { std::pair<llvm::Value*, std::shared_ptr<Type>> FunctionType::load(codegen::Builder&, llvm::Value* ptr) {
auto self = std::make_shared<FunctionType>(*this); auto self = std::make_shared<FunctionType>(*this);
return std::pair(ptr, self); return std::pair(ptr, self);
} }
@ -134,9 +133,9 @@ namespace types {
return out.str(); return out.str();
} }
std::pair<llvm::Value*, std::shared_ptr<Type>> PointerType::load(codegen::Builder& builder, llvm::Value* ptr, codegen::TypeMap& structs) { std::pair<llvm::Value*, std::shared_ptr<Type>> PointerType::load(codegen::Builder& builder, llvm::Value* ptr) {
return std::pair( return std::pair(
builder.builder->CreateLoad(this->m_inner->codegen(builder, structs), ptr), builder.builder->CreateLoad(this->m_inner->codegen(builder), ptr),
this->m_inner this->m_inner
); );
} }
@ -152,7 +151,7 @@ namespace types {
return out.str(); return out.str();
} }
std::pair<llvm::Value*, std::shared_ptr<Type>> ArrayType::load(codegen::Builder&, llvm::Value* ptr, codegen::TypeMap&) { std::pair<llvm::Value*, std::shared_ptr<Type>> ArrayType::load(codegen::Builder&, llvm::Value* ptr) {
auto self = std::make_shared<ArrayType>(*this); auto self = std::make_shared<ArrayType>(*this);
return std::pair(ptr, self); return std::pair(ptr, self);
} }
@ -161,63 +160,18 @@ namespace types {
return this->m_size * this->m_inner->size(); return this->m_size * this->m_inner->size();
} }
std::string StructType::formatted() {
std::stringstream out{ "" };
out << "struct";
if (this->m_is_ref)
out << "(ref)";
out << " ";
if (this->m_name) {
out << *this->m_name << " ";
}
if (this->m_fields) {
out << "{ ";
int counter = 0;
for (auto& field : *this->m_fields) {
if (counter++ > 0)
out << ", ";
out << field.first << ": " << field.second->formatted() << " ";
}
out << "}";
}
return out.str();
}
std::pair<llvm::Value*, std::shared_ptr<Type>> StructType::load(codegen::Builder&, llvm::Value* ptr, codegen::TypeMap&) {
auto self = std::make_shared<StructType>(*this);
return std::pair(ptr, self);
}
uint32_t StructType::size() {
uint32_t size{ 0 };
if (this->m_fields) {
for (auto& field : *this->m_fields) {
size += field.second->size();
}
}
return size;
}
// std::string StructRef::formatted() {
// std::stringstream out{ "" };
// out << "struct(ref) " << this->m_name;
// return out.str();
// }
// std::pair<llvm::Value*, std::shared_ptr<Type>> StructRef::load(codegen::Builder&, llvm::Value* ptr, codegen::TypeMap&) {
// auto self = std::make_shared<StructRef>(*this);
// return std::pair(ptr, self);
// }
// uint32_t StructRef::size() {
// return this->m_referred->size();
// }
bool types_equal(std::shared_ptr<types::Type> type1, std::shared_ptr<types::Type> type2) { bool types_equal(std::shared_ptr<types::Type> type1, std::shared_ptr<types::Type> type2) {
// if (type1->m_kind == TypeKind::Array && type2->m_kind == TypeKind::Pointer) {
// auto ty1 = dynamic_cast<ArrayType*>(type1.get());
// auto ty2 = dynamic_cast<PointerType*>(type2.get());
// return types_equal(ty1->m_inner, ty2->m_inner);
// }
// else if (type1->m_kind == TypeKind::Pointer && type2->m_kind == TypeKind::Array) {
// auto ty1 = dynamic_cast<PointerType*>(type1.get());
// auto ty2 = dynamic_cast<ArrayType*>(type2.get());
// return types_equal(ty1->m_inner, ty2->m_inner);
// }
if (type1->m_kind != type2->m_kind) if (type1->m_kind != type2->m_kind)
return false; return false;
@ -258,28 +212,6 @@ namespace types {
return types_equal(ty1->m_inner, ty2->m_inner) && ty1->m_size == ty2->m_size; return types_equal(ty1->m_inner, ty2->m_inner) && ty1->m_size == ty2->m_size;
} }
else if (type1->m_kind == TypeKind::Struct) {
auto ty1 = dynamic_cast<StructType*>(type1.get());
auto ty2 = dynamic_cast<StructType*>(type2.get());
if (ty1->m_fields.has_value() != ty2->m_fields.has_value())
return false;
if (ty1->m_fields) {
if (ty1->m_fields->size() != ty2->m_fields->size())
return false;
for (int i = 0; i < static_cast<int>(ty1->m_fields->size()); i++) {
auto field1 = (*ty1->m_fields)[i];
auto field2 = (*ty2->m_fields)[i];
if (!types_equal(field1.second, field2.second))
return false;
}
}
return true;
}
else { else {
return false; return false;
} }

54
src/types.h
View File

@ -12,7 +12,6 @@ namespace types {
Function, Function,
Pointer, Pointer,
Array, Array,
Struct,
}; };
enum FundamentalTypeKind { enum FundamentalTypeKind {
@ -30,8 +29,8 @@ namespace types {
Type(TypeKind kind) : m_kind{ kind } {} Type(TypeKind kind) : m_kind{ kind } {}
virtual ~Type() = default; virtual ~Type() = default;
virtual std::string formatted() = 0; virtual std::string formatted() = 0;
virtual llvm::Type* codegen(codegen::Builder& builder, codegen::TypeMap& structs) = 0; virtual llvm::Type* codegen(codegen::Builder& builder) = 0;
virtual std::pair<llvm::Value*, std::shared_ptr<Type>> load(codegen::Builder& builder, llvm::Value* ptr, codegen::TypeMap& structs) = 0; virtual std::pair<llvm::Value*, std::shared_ptr<Type>> load(codegen::Builder& builder, llvm::Value* ptr) = 0;
virtual std::optional<std::shared_ptr<Type>> return_type(); virtual std::optional<std::shared_ptr<Type>> return_type();
virtual bool is_signed(); virtual bool is_signed();
virtual uint32_t size() = 0; virtual uint32_t size() = 0;
@ -43,8 +42,8 @@ namespace types {
FundamentalType(FundamentalTypeKind kind) : Type(TypeKind::Fundamental), m_ty{ kind } {} FundamentalType(FundamentalTypeKind kind) : Type(TypeKind::Fundamental), m_ty{ kind } {}
virtual ~FundamentalType() override = default; virtual ~FundamentalType() override = default;
virtual std::string formatted() override; virtual std::string formatted() override;
virtual llvm::Type* codegen(codegen::Builder& builder, codegen::TypeMap& structs) override; virtual llvm::Type* codegen(codegen::Builder& builder) override;
virtual std::pair<llvm::Value*, std::shared_ptr<Type>> load(codegen::Builder& builder, llvm::Value* ptr, codegen::TypeMap& structs) override; virtual std::pair<llvm::Value*, std::shared_ptr<Type>> load(codegen::Builder& builder, llvm::Value* ptr) override;
virtual bool is_signed() override; virtual bool is_signed() override;
virtual uint32_t size() override; virtual uint32_t size() override;
}; };
@ -63,8 +62,8 @@ namespace types {
} }
virtual ~FunctionType() override = default; virtual ~FunctionType() override = default;
virtual std::string formatted() override; virtual std::string formatted() override;
virtual llvm::Type* codegen(codegen::Builder& builder, codegen::TypeMap& structs) override; virtual llvm::Type* codegen(codegen::Builder& builder) override;
virtual std::pair<llvm::Value*, std::shared_ptr<Type>> load(codegen::Builder& builder, llvm::Value* ptr, codegen::TypeMap& structs) override; virtual std::pair<llvm::Value*, std::shared_ptr<Type>> load(codegen::Builder& builder, llvm::Value* ptr) override;
virtual std::optional<std::shared_ptr<Type>> return_type() override; virtual std::optional<std::shared_ptr<Type>> return_type() override;
virtual uint32_t size() override; virtual uint32_t size() override;
}; };
@ -78,8 +77,8 @@ namespace types {
} }
virtual ~PointerType() override = default; virtual ~PointerType() override = default;
virtual std::string formatted() override; virtual std::string formatted() override;
virtual llvm::Type* codegen(codegen::Builder& builder, codegen::TypeMap& structs) override; virtual llvm::Type* codegen(codegen::Builder& builder) override;
virtual std::pair<llvm::Value*, std::shared_ptr<Type>> load(codegen::Builder& builder, llvm::Value* ptr, codegen::TypeMap& structs) override; virtual std::pair<llvm::Value*, std::shared_ptr<Type>> load(codegen::Builder& builder, llvm::Value* ptr) override;
virtual uint32_t size() override; virtual uint32_t size() override;
}; };
@ -93,44 +92,11 @@ namespace types {
} }
virtual ~ArrayType() override = default; virtual ~ArrayType() override = default;
virtual std::string formatted() override; virtual std::string formatted() override;
virtual llvm::Type* codegen(codegen::Builder& builder, codegen::TypeMap& structs) override; virtual llvm::Type* codegen(codegen::Builder& builder) override;
virtual std::pair<llvm::Value*, std::shared_ptr<Type>> load(codegen::Builder& builder, llvm::Value* ptr, codegen::TypeMap& structs) override; virtual std::pair<llvm::Value*, std::shared_ptr<Type>> load(codegen::Builder& builder, llvm::Value* ptr) override;
virtual uint32_t size() override; virtual uint32_t size() override;
}; };
typedef std::pair<std::string, std::shared_ptr<types::Type>> StructField;
class StructType : public Type {
public:
std::optional<std::string> m_name;
std::optional<std::vector<StructField>> m_fields;
bool m_is_ref;
StructType(std::optional<std::string> name, std::optional<std::vector<StructField>> fields, bool is_ref)
: Type(TypeKind::Struct), m_name{ name }, m_fields{ fields }, m_is_ref{ is_ref } {
}
virtual ~StructType() override = default;
virtual std::string formatted() override;
virtual llvm::Type* codegen(codegen::Builder& builder, codegen::TypeMap& structs) override;
virtual std::pair<llvm::Value*, std::shared_ptr<Type>> load(codegen::Builder& builder, llvm::Value* ptr, codegen::TypeMap& structs) override;
virtual uint32_t size() override;
};
// class StructRef : public Type {
// public:
// std::string m_name;
// std::shared_ptr<types::Type> m_referred;
// StructRef(std::string name, std::shared_ptr<types::Type> referred)
// : Type(TypeKind::StructRef), m_name{ name }, m_referred{ referred } {
// }
// virtual ~StructRef() override = default;
// virtual std::string formatted() override;
// virtual llvm::Type* codegen(codegen::Builder& builder, codegen::TypeMap& structs) override;
// virtual std::pair<llvm::Value*, std::shared_ptr<Type>> load(codegen::Builder& builder, llvm::Value* ptr, codegen::TypeMap& structs) override;
// virtual uint32_t size() override;
// };
bool types_equal(std::shared_ptr<types::Type> type1, std::shared_ptr<types::Type> type2); bool types_equal(std::shared_ptr<types::Type> type1, std::shared_ptr<types::Type> type2);
} }

12
test.c
View File

@ -10,10 +10,6 @@ void change_first(char otus[5]) {
otus[0] = 115; otus[0] = 115;
} }
struct Otus {
int field
};
int main() { int main() {
char text[29] = "10th fibonacci number is %d!"; char text[29] = "10th fibonacci number is %d!";
printf(text, fibonacci(10)); printf(text, fibonacci(10));
@ -22,11 +18,5 @@ int main() {
change_first(somelist); change_first(somelist);
printf(" first element: %d!", somelist[0]); return somelist[0];
struct Otus otus = { 5 };
printf(" first field: %d!", otus.field);
return 0;
} }