cardinal/rusty-minic
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(ast, ir. sema): Add storage class

Browse Source
This commit is contained in:
insolublehco3
2026-06-12 18:33:54 +08:00
parent 5099bbaab7
commit e3aa2e21c0
11 changed files with 217 additions and 45 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.vscode/launch.json
Vendored
+31
View File
@@ -0,0 +1,31 @@
{
// Use IntelliSense to learn about possible attributes.
// Hover to view descriptions of existing attributes.
// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
"version": "0.2.0",
"configurations": [
{
"name": "Debug executable 'compiler'",
"type": "lldb",
"request": "launch",
"cargo": {
"args": [
"run",
"--bin=compiler"
]
},
"args": []
},
{
"name": "Debug unit tests in executable 'compiler'",
"type": "lldb",
"request": "launch",
"cargo": {
"args": [
"test",
"--bin=compiler"
]
}
}
]
}
src/ast/_types/typ.rs
+32
View File
@@ -0,0 +1,32 @@
use crate::diagnostic::span::Span;
pub struct Type {
span: Span,
kind: TypeKind,
}
pub enum TypeKind {
Builtin(BuiltinType),
Array(ArrayType),
}
pub struct BuiltinType {
span: Span,
kind: BuiltinTypeKind,
}
pub enum BuiltinTypeKind {
Int,
Void,
}
pub struct ArrayType {
span: Span,
element_type: Box<Type>,
dimensions: Vec<ArrayDimension>,
}
pub struct ArrayDimension {
span: Span,
size: Option<Expr>,
}
src/ast/parser/decl.rs
+14 -28
View File
@@ -1,8 +1,8 @@
use crate::{
ast::err::ParseError,
ast::types::{
ArrayDimension, CompileUnit, Expr, FuncDeclStmt, GlobalDeclStmt, Param, VarDeclStmt,
VarDeclStmtValue,
ArrayDimension, CompileUnit, Expr, FuncDeclStmt, GlobalDeclStmt, Param, StorageClass,
VarDeclStmt, VarDeclStmtValue,
},
diagnostic::span::Span,
lexer::types::{TokenValue, TypeIdent},
@@ -10,13 +10,8 @@ use crate::{
use super::{ParseProcessError, ParseType, Parser};
#[derive(Clone, Copy)]
enum StorageClass {
Static,
}
struct DeclSpecifiers {
_storage_class: Option<StorageClass>,
storage_class: Option<StorageClass>,
type_specifier: TypeIdent,
type_span: Span,
}
@@ -111,7 +106,7 @@ impl Parser {
};
Ok(DeclSpecifiers {
_storage_class: storage_class,
storage_class,
type_specifier,
type_span: type_token.span,
})
@@ -183,13 +178,13 @@ impl Parser {
self.advance(1);
span
}
TokenValue::Eof => {
self.diagnostics.add_from_frontend_error(
ParseError::ExpectedBefore(TokenValue::Eof, "`]`"),
start_span,
);
return Err(ParseProcessError::ErrorInMatch);
}
// TokenValue::Eof => {
// self.diagnostics.add_from_frontend_error(
// ParseError::ExpectedBefore(TokenValue::Eof, "`]`"),
// start_span,
// );
// return Err(ParseProcessError::ErrorInMatch);
// }
_ => {
let token = self.next();
self.diagnostics.add_from_frontend_error(
@@ -279,6 +274,7 @@ impl Parser {
let body = self.parse_block_stmt(ParseType::MustParse)?;
Ok(FuncDeclStmt {
return_type: specifiers.type_specifier.into(),
storage_class: specifiers.storage_class,
name,
params,
body,
@@ -292,21 +288,10 @@ impl Parser {
specifiers: DeclSpecifiers,
first_declarator: Declarator,
consume_semicolon: bool,
allow_empty_declarator_list: bool,
_allow_empty_declarator_list: bool,
) -> Result<VarDeclStmt, ParseProcessError> {
let mut values = vec![];
if self.peek().value == TokenValue::Semicolon && allow_empty_declarator_list {
if consume_semicolon {
self.advance(1);
}
return Ok(VarDeclStmt {
values,
type_span: specifiers.type_span,
data_type: specifiers.type_specifier.into(),
});
}
let initializer = self.parse_initializer()?;
values.push(self.init_declarator_to_var_value(InitDeclarator {
declarator: first_declarator,
@@ -328,6 +313,7 @@ impl Parser {
}
Ok(VarDeclStmt {
storage_class: specifiers.storage_class,
values,
type_span: specifiers.type_span,
data_type: specifiers.type_specifier.into(),
src/ast/parser/expr.rs
+2 -2
View File
@@ -133,8 +133,8 @@ impl Parser {
} else {
IncDecOp::Dec
};
let end_span = self.peek_n(1).span;
self.advance(2);
let end_span = self.peek().span;
self.advance(1);
expr = Expr {
span: Span::from_two(expr.span, end_span),
value: ExprValue::IncDec {
src/ast/types.rs
+6 -1
View File
@@ -8,9 +8,13 @@ pub enum GlobalDeclStmt {
VarDecl(VarDeclStmt),
FuncDecl(FuncDeclStmt),
}
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum StorageClass {
Static,
}
pub struct VarDeclStmt {
pub values: Vec<VarDeclStmtValue>,
pub storage_class: Option<StorageClass>,
pub data_type: Type,
pub type_span: Span,
}
@@ -28,6 +32,7 @@ pub struct ArrayDimension {
pub struct FuncDeclStmt {
pub name: String,
pub storage_class: Option<StorageClass>,
pub return_type: Type,
pub params: Vec<Param>,
pub body: BlockStmt,
src/ir/generator.rs
+51 -4
View File
@@ -1,6 +1,6 @@
use std::{collections::BTreeMap, vec};
use crate::{ir::types::{BinaryOp as IRBinaryOp, CmpOp, Function, IRInstr, IRType, MoveRValue, UnaryOp, Variable, VariableOrIntLit, VariableType}, sema::{analyzer::Analyzer as SemaAnalyzer, hir::{HirBlockStmt, HirBreakStmt, HirCompileUnit, HirContinueStmt, HirExpr, HirExprValue, HirForInit, HirForStmt, HirFuncDeclStmt, HirGlobalDeclStmt, HirIfElseBranch, HirIfStmt, HirReturnStmt, HirStatement, HirVarDeclStmt, HirWhileStmt}, symbol::{FunctionId, SymbolId}}};
use crate::{ir::types::{BinaryOp as IRBinaryOp, CmpOp, Function, IRInstr, IRType, MoveRValue, UnaryOp, Variable, VariableOrIntLit, VariableType}, sema::{analyzer::Analyzer as SemaAnalyzer, hir::{HirBlockStmt, HirBreakStmt, HirCompileUnit, HirContinueStmt, HirExpr, HirExprValue, HirForInit, HirForStmt, HirFuncDeclStmt, HirGlobalDeclStmt, HirIfElseBranch, HirIfStmt, HirReturnStmt, HirStatement, HirVarDeclStmt, HirWhileStmt}, symbol::{FunctionId, SymbolId, SymbolKind}}};
use crate::ast::types::BinaryOp as AstBinaryOp;
use crate::ast::types::UnaryOp as AstUnaryOp;
pub struct Generator<'a> {
@@ -14,6 +14,7 @@ pub struct Generator<'a> {
// if child expr isn't logical, we need to do cmp to decide which label to goto
while_exit_label: Vec<(usize, usize)>, // continue exit, break exit
func_exit: Option<(usize, Option<Variable>)>, // (label, return_var)
extra_global_instrs: Vec<IRInstr>,
label_counter: usize
}
@@ -25,6 +26,7 @@ impl<'a> Generator<'a> {
current_exit_label: vec![],
while_exit_label: vec![],
func_exit: None,
extra_global_instrs: vec![],
label_counter: 0,
}
}
@@ -55,7 +57,10 @@ impl<'a> Generator<'a> {
instrs.extend(self.generate_var_decl(var_decl, true));
}
FuncDecl(func_decl) => {
instrs.extend(self.generate_func_decl(func_decl));
let extra_global_start = self.extra_global_instrs.len();
let func_instrs = self.generate_func_decl(func_decl);
instrs.extend(self.extra_global_instrs.drain(extra_global_start..));
instrs.extend(func_instrs);
}
}
}
@@ -65,10 +70,18 @@ impl<'a> Generator<'a> {
fn generate_var_decl(&mut self, var_decl: HirVarDeclStmt, is_global: bool) -> Vec<IRInstr> {
let mut instrs = vec![];
for value in var_decl.values {
let var_type = if is_global { VariableType::Global } else { VariableType::Local };
let symbol_kind = self.sema.get_symbol_kind(value.symbol);
let has_static_storage = is_global || symbol_kind == SymbolKind::StaticLocal || value.is_static_local;
let var_type = if has_static_storage { VariableType::Global } else { VariableType::Local };
let var = self.var_manager.declare_symbol(value.symbol, var_type, self.sema.get_symbol_type(value.symbol).into());
if has_static_storage {
let init = value.value.as_ref().and_then(|expr| Self::const_init_value(expr));
let decl = IRInstr::DeclareGlobal(var, init);
if is_global {
instrs.push(IRInstr::Declare(var));
instrs.push(decl);
} else {
self.extra_global_instrs.push(decl);
}
} else if let Some(init) = value.value {
self.current_exit_label.push(None);
let (init_instrs, init_var) = match self.generate_expr(init) {
@@ -88,6 +101,40 @@ impl<'a> Generator<'a> {
instrs
}
fn const_init_value(expr: &HirExpr) -> Option<i32> {
match &expr.value {
HirExprValue::IntLit(value) => Some(*value as i32),
HirExprValue::UnaryOp { op, operand } => {
let value = Self::const_init_value(operand)?;
match op {
AstUnaryOp::Add => Some(value),
AstUnaryOp::Sub => value.checked_neg(),
AstUnaryOp::Not => Some((value == 0) as i32),
}
}
HirExprValue::BinaryOp { lhs, op, rhs } => {
let lhs = Self::const_init_value(lhs)?;
let rhs = Self::const_init_value(rhs)?;
match op {
AstBinaryOp::Add => lhs.checked_add(rhs),
AstBinaryOp::Sub => lhs.checked_sub(rhs),
AstBinaryOp::Mul => lhs.checked_mul(rhs),
AstBinaryOp::Div => lhs.checked_div(rhs),
AstBinaryOp::Mod => lhs.checked_rem(rhs),
AstBinaryOp::Equal => Some((lhs == rhs) as i32),
AstBinaryOp::NotEqual => Some((lhs != rhs) as i32),
AstBinaryOp::Less => Some((lhs < rhs) as i32),
AstBinaryOp::LessEqual => Some((lhs <= rhs) as i32),
AstBinaryOp::Greater => Some((lhs > rhs) as i32),
AstBinaryOp::GreaterEqual => Some((lhs >= rhs) as i32),
AstBinaryOp::And => Some((lhs != 0 && rhs != 0) as i32),
AstBinaryOp::Or => Some((lhs != 0 || rhs != 0) as i32),
}
}
_ => None,
}
}
fn generate_func_decl(&mut self, func_decl: HirFuncDeclStmt) -> Vec<IRInstr> {
let parameters: Vec<Variable> = func_decl.params.iter()
.map(|param| self.var_manager.declare_symbol(param.symbol, VariableType::Local, param.param_type.clone().into()))
src/ir/types.rs
+3
View File
@@ -21,6 +21,7 @@ impl Display for VariableOrIntLit {
#[derive(Clone)]
pub enum IRInstr {
Declare(Variable),
DeclareGlobal(Variable, Option<i32>),
DefineFunc(Function, Vec<Variable>, Vec<IRInstr>),
Entry,
Binary(Variable, Variable, BinaryOp, Variable),
@@ -54,6 +55,8 @@ impl Display for IRInstr {
IRInstr::Load(dest, addr) => write!(f, "{} = *{}", dest, addr),
IRInstr::Store(addr, value) => write!(f, "*{} = {}", addr, value),
IRInstr::Declare(var) => write!(f, "declare {}", var.to_decl_string()),
IRInstr::DeclareGlobal(var, Some(init)) => write!(f, "declare {} = {}", var.to_decl_string(), init),
IRInstr::DeclareGlobal(var, None) => write!(f, "declare {}", var.to_decl_string()),
IRInstr::DefineFunc(func, args, body) => {
let body_str = body.iter().map(|instr| format!(" {}", instr)).collect::<Vec<_>>().join("\n");
write!(f, "define {} {{\n{}\n}}", func.to_decl_string(args), body_str)
src/sema/analyzer.rs
+73 -9
View File
@@ -3,7 +3,7 @@ use std::collections::BTreeMap;
use crate::{
ast::types::{
ArrayDimension, BinaryOp, BlockStmt, BreakStmt, CompileUnit, ContinueStmt, Expr, ExprValue, ForInit, ForStmt, FuncDeclStmt,
GlobalDeclStmt, IfElseBranch, IfStmt, ReturnStmt, Statement, VarDeclStmt, WhileStmt,
GlobalDeclStmt, IfElseBranch, IfStmt, ReturnStmt, Statement, StorageClass, VarDeclStmt, WhileStmt,
},
diagnostic::{span::Span, Diagnositics},
sema::{
@@ -41,6 +41,7 @@ impl Analyzer {
analyzer.declare_builtin_func("putch", vec![SemaType::I32], SemaType::Void);
analyzer.declare_builtin_func("putarray", vec![SemaType::I32, SemaType::Array(Box::new(SemaType::I32), vec![0])], SemaType::Void);
analyzer.declare_builtin_func("getint", vec![], SemaType::I32);
analyzer.declare_builtin_func("getch", vec![], SemaType::I32);
analyzer.declare_builtin_func("getarray", vec![SemaType::Array(Box::new(SemaType::I32), vec![0])], SemaType::I32);
analyzer
}
@@ -100,13 +101,33 @@ impl Analyzer {
fn analyze_var_decl(&mut self, var_decl: VarDeclStmt, kind: SymbolKind) -> HirVarDeclStmt {
let base_type: SemaType = var_decl.data_type.into();
let is_static_local = kind == SymbolKind::Local && var_decl.storage_class == Some(StorageClass::Static);
let has_static_storage = kind == SymbolKind::Global || is_static_local;
let actual_kind = if is_static_local {
SymbolKind::StaticLocal
} else {
kind
};
let mut values = vec![];
for value in var_decl.values {
let data_type = self.build_var_type(base_type.clone(), &value.dimensions, false);
match self.symbols.declare_variable(&value.name, kind, data_type) {
let initializer_is_not_constant = has_static_storage
&& value
.value
.as_ref()
.is_some_and(|expr| Self::eval_const_expr(expr).is_none());
if initializer_is_not_constant {
if let Some(expr) = &value.value {
self.add_error(SemaError::InitializerNotConstant, expr.span);
}
}
match self.symbols.declare_variable(&value.name, actual_kind, data_type) {
Ok(symbol) => {
let symbol_type = self.symbols.get_symbol(symbol).ty.clone();
let init = value.value.and_then(|expr| {
let init = if initializer_is_not_constant {
None
} else {
value.value.and_then(|expr| {
let span = expr.span;
let init = self.analyze_expr(expr)?;
if init.ty == SemaType::Void {
@@ -115,11 +136,13 @@ impl Analyzer {
self.add_error(SemaError::TypeMismatch(symbol_type.clone(), init.ty.clone()), span);
}
Some(init)
});
})
};
values.push(HirVarDeclStmtValue {
symbol,
name_span: value.name_span,
value: init,
is_static_local,
});
}
Err(e) => self.add_error(e, value.name_span),
@@ -183,6 +206,40 @@ impl Analyzer {
})
}
fn eval_const_expr(expr: &Expr) -> Option<i32> {
match &expr.value {
ExprValue::IntLit(value) => i32::try_from(*value).ok(),
ExprValue::UnaryOp { op, operand } => {
let value = Self::eval_const_expr(operand)?;
match op {
crate::ast::types::UnaryOp::Add => Some(value),
crate::ast::types::UnaryOp::Sub => value.checked_neg(),
crate::ast::types::UnaryOp::Not => Some((value == 0) as i32),
}
}
ExprValue::BinaryOp { lhs, op, rhs } => {
let lhs = Self::eval_const_expr(lhs)?;
let rhs = Self::eval_const_expr(rhs)?;
match op {
BinaryOp::Add => lhs.checked_add(rhs),
BinaryOp::Sub => lhs.checked_sub(rhs),
BinaryOp::Mul => lhs.checked_mul(rhs),
BinaryOp::Div => lhs.checked_div(rhs),
BinaryOp::Mod => lhs.checked_rem(rhs),
BinaryOp::Equal => Some((lhs == rhs) as i32),
BinaryOp::NotEqual => Some((lhs != rhs) as i32),
BinaryOp::Less => Some((lhs < rhs) as i32),
BinaryOp::LessEqual => Some((lhs <= rhs) as i32),
BinaryOp::Greater => Some((lhs > rhs) as i32),
BinaryOp::GreaterEqual => Some((lhs >= rhs) as i32),
BinaryOp::And => Some((lhs != 0 && rhs != 0) as i32),
BinaryOp::Or => Some((lhs != 0 || rhs != 0) as i32),
}
}
_ => None,
}
}
fn build_var_type(&mut self, base_type: SemaType, dimensions: &[ArrayDimension], is_param: bool) -> SemaType {
if dimensions.is_empty() {
return base_type;
@@ -218,6 +275,13 @@ impl Analyzer {
HirBlockStmt { statements }
}
fn analyze_scoped_block_stmt(&mut self, block_stmt: BlockStmt) -> HirBlockStmt {
self.symbols.enter_scope();
let block = self.analyze_block_stmt(block_stmt);
self.symbols.exit_scope();
block
}
fn analyze_statement(&mut self, stmt: Statement) -> Option<HirStatement> {
match stmt {
Statement::Return(stmt) => Some(HirStatement::Return(self.analyze_return_stmt(stmt))),
@@ -273,16 +337,16 @@ impl Analyzer {
fn analyze_if_stmt(&mut self, if_stmt: IfStmt) -> HirIfStmt {
let condition = self.analyze_condition_expr(if_stmt.condition);
let then_branch = self.analyze_block_stmt(if_stmt.then_branch);
let then_branch = self.analyze_scoped_block_stmt(if_stmt.then_branch);
let mut ifelse_branch = vec![];
for branch in if_stmt.ifelse_branch {
let IfElseBranch { condition, then_branch } = branch;
ifelse_branch.push(HirIfElseBranch {
condition: self.analyze_condition_expr(condition),
then_branch: self.analyze_block_stmt(then_branch),
then_branch: self.analyze_scoped_block_stmt(then_branch),
});
}
let else_branch = if_stmt.else_branch.map(|block| self.analyze_block_stmt(block));
let else_branch = if_stmt.else_branch.map(|block| self.analyze_scoped_block_stmt(block));
HirIfStmt {
condition,
then_branch,
@@ -294,7 +358,7 @@ impl Analyzer {
fn analyze_while_stmt(&mut self, while_stmt: WhileStmt) -> HirWhileStmt {
let condition = self.analyze_condition_expr(while_stmt.condition);
self.loop_depth += 1;
let body = self.analyze_block_stmt(while_stmt.body);
let body = self.analyze_scoped_block_stmt(while_stmt.body);
self.loop_depth -= 1;
HirWhileStmt {
condition,
@@ -311,7 +375,7 @@ impl Analyzer {
let condition = for_stmt.condition.map(|expr| self.analyze_condition_expr(expr));
let update = for_stmt.update.and_then(|expr| self.analyze_expr(expr));
self.loop_depth += 1;
let body = self.analyze_block_stmt(for_stmt.body);
let body = self.analyze_scoped_block_stmt(for_stmt.body);
self.loop_depth -= 1;
self.symbols.exit_scope();
HirForStmt {
src/sema/err.rs
+2
View File
@@ -36,4 +36,6 @@ pub enum SemaError {
InvalidArrayDimension,
#[error("subscripted value is not an array or pointer")]
NotSubscriptable,
#[error("initializer element is not constant")]
InitializerNotConstant,
}
src/sema/hir.rs
+1
View File
@@ -19,6 +19,7 @@ pub struct HirVarDeclStmtValue {
pub symbol: SymbolId,
pub name_span: Span,
pub value: Option<HirExpr>,
pub is_static_local: bool,
}
pub struct HirFuncDeclStmt {
src/sema/symbol.rs
+1
View File
@@ -10,6 +10,7 @@ pub enum SymbolKind {
Global,
Local,
Param,
StaticLocal,
}
#[derive(Clone, Debug)]