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

Add parsing::Scope

Browse Source
This commit is contained in:
Sofia 2026-04-15 17:45:14 +03:00
parent 55388bc6e3
commit 5fc58ea1c5
3 changed files with 60 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/main.cpp
View File

@ -70,12 +70,14 @@ 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); auto statement = parsing::parse_top_level_statement(stream, parse_scope);
while (statement.ok()) { while (statement.ok()) {
statements.push_back(statement.unwrap()); statements.push_back(statement.unwrap());
statement = parsing::parse_top_level_statement(stream); statement = parsing::parse_top_level_statement(stream, parse_scope);
} }
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;

94
src/parsing.cpp
View File

@ -5,9 +5,9 @@
namespace parsing { namespace parsing {
namespace { namespace {
Result<std::unique_ptr<AST::Expression>, std::string> parse_expression(token::TokenStream& stream); Result<std::unique_ptr<AST::Expression>, std::string> parse_expression(token::TokenStream& stream, Scope& scope);
Result<std::shared_ptr<types::Type>, std::string> parse_type(token::TokenStream& stream) { Result<std::shared_ptr<types::Type>, std::string> parse_type(token::TokenStream& stream, Scope&) {
token::TokenStream inner{ stream }; token::TokenStream inner{ stream };
try { try {
auto token = inner.expect(token::Type::Ident); auto token = inner.expect(token::Type::Ident);
@ -49,7 +49,7 @@ namespace parsing {
} }
} }
Result<std::optional<uint32_t>, std::string> parse_array_postfix(token::TokenStream& stream, bool allow_empty) { Result<std::optional<uint32_t>, std::string> parse_array_postfix(token::TokenStream& stream, bool allow_empty, Scope&) {
token::TokenStream inner{ stream }; token::TokenStream inner{ stream };
try { try {
std::optional<uint32_t> returned{}; std::optional<uint32_t> returned{};
@ -71,7 +71,7 @@ namespace parsing {
} }
} }
Result<std::unique_ptr<AST::Expression>, std::string> parse_list_initializer(token::TokenStream& stream) { Result<std::unique_ptr<AST::Expression>, std::string> parse_list_initializer(token::TokenStream& stream, Scope& scope) {
token::TokenStream inner{ stream }; token::TokenStream inner{ stream };
try { try {
auto before_meta = inner.metadata(); auto before_meta = inner.metadata();
@ -85,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).unwrap()); expressions.push_back(parse_expression(inner, scope).unwrap());
} }
inner.expect(token::Type::Symbol, "}"); inner.expect(token::Type::Symbol, "}");
@ -105,10 +105,10 @@ namespace parsing {
} }
} }
Result<std::unique_ptr<AST::Expression>, std::string> parse_plain_expression(token::TokenStream& stream) { Result<std::unique_ptr<AST::Expression>, std::string> parse_plain_expression(token::TokenStream& stream, Scope& scope) {
token::TokenStream inner{ stream }; token::TokenStream inner{ stream };
try { try {
if (auto list_init = parse_list_initializer(inner); list_init.ok()) { if (auto list_init = parse_list_initializer(inner, scope); 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() };
@ -142,11 +142,11 @@ namespace parsing {
} }
} }
Result<std::shared_ptr<types::Type>, std::string> parse_cast(token::TokenStream& stream) { Result<std::shared_ptr<types::Type>, std::string> parse_cast(token::TokenStream& stream, Scope& scope) {
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).unwrap(); auto ty = parse_type(inner, scope).unwrap();
inner.expect(token::Type::Symbol, ")"); inner.expect(token::Type::Symbol, ")");
stream.m_position = inner.m_position; stream.m_position = inner.m_position;
@ -158,14 +158,14 @@ namespace parsing {
} }
} }
Result<std::unique_ptr<AST::Expression>, std::string> parse_primary_expression(token::TokenStream& stream) { Result<std::unique_ptr<AST::Expression>, std::string> parse_primary_expression(token::TokenStream& stream, Scope& scope) {
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); cast.ok()) { if (auto cast = parse_cast(inner, scope); cast.ok()) {
auto expr = parse_primary_expression(inner).unwrap(); auto expr = parse_primary_expression(inner, scope).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{
@ -177,14 +177,14 @@ namespace parsing {
} }
else if (inner.peek().content == "(") { else if (inner.peek().content == "(") {
inner.next(); inner.next();
auto expr = parse_expression(inner).unwrap(); auto expr = parse_expression(inner, scope).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).unwrap(); auto expr = parse_primary_expression(inner, scope).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))
@ -192,14 +192,14 @@ namespace parsing {
} }
else if (inner.peek().content == "*") { else if (inner.peek().content == "*") {
inner.next(); inner.next();
auto expr = parse_primary_expression(inner).unwrap(); auto expr = parse_primary_expression(inner, scope).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); auto plain_expr = parse_plain_expression(inner, scope);
while (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();
@ -210,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).unwrap()); args.push_back(parse_expression(inner, scope).unwrap());
} }
inner.expect(token::Type::Symbol, ")"); inner.expect(token::Type::Symbol, ")");
@ -218,7 +218,7 @@ 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); postfix.ok()) { else if (auto postfix = parse_array_postfix(inner, false, scope); 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 };
@ -234,7 +234,7 @@ namespace parsing {
} }
} }
Result<types::BinOp, std::string> parse_binop(token::TokenStream& stream) { Result<types::BinOp, std::string> parse_binop(token::TokenStream& stream, Scope&) {
token::TokenStream inner{ stream }; token::TokenStream inner{ stream };
try { try {
auto token = inner.next(); auto token = inner.next();
@ -270,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) { token::TokenStream& stream, std::unique_ptr<AST::Expression> lhs, int prev_precedence, Scope& scope) {
auto before = stream.metadata(); auto before = stream.metadata();
auto binop_res = parse_binop(stream); auto binop_res = parse_binop(stream, scope);
while (binop_res.ok()) { while (binop_res.ok()) {
auto binop = binop_res.unwrap(); auto binop = binop_res.unwrap();
auto rhs = parse_primary_expression(stream).unwrap(); auto rhs = parse_primary_expression(stream, scope).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)); rhs = parse_rhs(stream, std::move(rhs), types::operator_precedence(binop), scope);
} }
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); binop_res = parse_binop(stream, scope);
} }
return lhs; return lhs;
} }
Result<std::unique_ptr<AST::Expression>, std::string> parse_expression(token::TokenStream& stream) { Result<std::unique_ptr<AST::Expression>, std::string> parse_expression(token::TokenStream& stream, Scope& scope) {
try { try {
auto lhs = parse_primary_expression(stream).unwrap(); auto lhs = parse_primary_expression(stream, scope).unwrap();
return std::unique_ptr{ parse_rhs(stream, std::move(lhs), 0) }; return std::unique_ptr{ parse_rhs(stream, std::move(lhs), 0, scope) };
} }
catch (std::runtime_error& error) { catch (std::runtime_error& error) {
return std::string{ error.what() }; return std::string{ error.what() };
@ -304,16 +304,16 @@ namespace parsing {
Result<std::unique_ptr<AST::InitializationStatement>, std::string> parse_init_statement(token::TokenStream& stream) { Result<std::unique_ptr<AST::InitializationStatement>, std::string> parse_init_statement(token::TokenStream& stream, Scope& scope) {
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).unwrap(); auto ty = parse_type(inner, scope).unwrap();
auto name = inner.expect(token::Type::Ident); auto name = inner.expect(token::Type::Ident);
auto array_postfix = parse_array_postfix(inner, false); auto array_postfix = parse_array_postfix(inner, false, scope);
while (array_postfix.ok()) { while (array_postfix.ok()) {
auto postfix = array_postfix.unwrap(); auto postfix = array_postfix.unwrap();
if (postfix) { if (postfix) {
@ -326,13 +326,13 @@ namespace parsing {
new types::PointerType(ty) new types::PointerType(ty)
}; };
} }
array_postfix = parse_array_postfix(inner, false); array_postfix = parse_array_postfix(inner, false, scope);
} }
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).unwrap(); expr = parse_expression(inner, scope).unwrap();
} }
inner.expect(token::Type::Symbol, ";"); inner.expect(token::Type::Symbol, ";");
@ -346,13 +346,13 @@ namespace parsing {
} }
} }
Result<std::unique_ptr<AST::Statement>, std::string> parse_statement(token::TokenStream& stream) { Result<std::unique_ptr<AST::Statement>, std::string> parse_statement(token::TokenStream& stream, Scope& scope) {
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).unwrap(); auto expression = parse_expression(inner, scope).unwrap();
inner.expect(token::Type::Symbol, ";"); inner.expect(token::Type::Symbol, ";");
stream.m_position = inner.m_position; stream.m_position = inner.m_position;
@ -363,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).unwrap(); auto expression = parse_expression(inner, scope).unwrap();
inner.expect(token::Type::Symbol, ")"); inner.expect(token::Type::Symbol, ")");
auto then_statement = parse_statement(inner).unwrap(); auto then_statement = parse_statement(inner, scope).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).unwrap(); else_statement = parse_statement(inner, scope).unwrap();
} }
stream.m_position = inner.m_position; stream.m_position = inner.m_position;
@ -383,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); init.ok()) { else if (auto init = parse_init_statement(inner, scope); 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); expr.ok()) { else if (auto expr = parse_expression(inner, scope); 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() };
@ -404,11 +404,11 @@ namespace parsing {
} }
} }
Result<std::unique_ptr<AST::TopLevelStatement>, std::string> parse_top_level_statement(token::TokenStream& stream) { Result<std::unique_ptr<AST::TopLevelStatement>, std::string> parse_top_level_statement(token::TokenStream& stream, Scope& scope) {
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).unwrap(); auto type = parse_type(inner, scope).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, "(");
@ -427,13 +427,13 @@ namespace parsing {
break; break;
} }
auto param_ty = parse_type(inner).unwrap(); auto param_ty = parse_type(inner, scope).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;
std::cout << inner.peek().formatted() << std::endl; std::cout << inner.peek().formatted() << std::endl;
auto postfix = parse_array_postfix(inner, true); auto postfix = parse_array_postfix(inner, true, scope);
while (postfix.ok()) { while (postfix.ok()) {
auto array_postfix = postfix.unwrap(); auto array_postfix = postfix.unwrap();
if (array_postfix) { if (array_postfix) {
@ -446,7 +446,7 @@ namespace parsing {
new types::PointerType(param_ty) new types::PointerType(param_ty)
}; };
} }
postfix = parse_array_postfix(inner, true); postfix = parse_array_postfix(inner, true, scope);
} }
} }
@ -455,16 +455,18 @@ 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); auto statement = parse_statement(inner, inner_scope);
while (statement.ok()) { while (statement.ok()) {
statement_list.push_back(statement.unwrap()); statement_list.push_back(statement.unwrap());
statement = parse_statement(inner); statement = parse_statement(inner, inner_scope);
} }
statements = std::optional{ std::move(statement_list) }; statements = std::optional{ std::move(statement_list) };

9
src/parsing.h
View File

@ -1,12 +1,19 @@
#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 {
Result<std::unique_ptr<AST::TopLevelStatement>, std::string> parse_top_level_statement(token::TokenStream& stream); struct Scope {
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