chore: 중간 커밋 — 문법 수정 및 semantic 모듈 초기 구현

- grammer.md: for문에 declaration_statement 허용 추가
- lib.rs: semantic 모듈 노출
- main.rs: lexing → parsing → semantic 분석 실행 흐름 구현
- parser/utils.rs: start_pos, end_pos 유틸 메서드 추가
- semantic/: Resolver, Analyzer, 오류 타입 등 기본 뼈대 구현

Author: tape4

grammer.md

@@ -39,7 +39,7 @@ expression_statement  ::= expression? ";"
 
 if_statement          ::= "if" "(" expression ")" statement ( "else" statement )?  
 while_statement       ::= "while" "(" expression ")" statement  
-for_statement         ::= "for" "(" expression? ";" expression? ";" expression? ")" statement  
+for_statement         ::= "for" "(" (declaration_statement | expression)? ";" expression? ";" expression? ")" statement  
 return_statement      ::= "return" expression? ";"  
 break_statement       ::= "break" ";"  
 continue_statement    ::= "continue" ";"  

src/ast/node.rs

@@ -0,0 +1,10 @@
+use crate::ast::Expr;
+use crate::ast::program::Span;
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct Node<T> {
+    pub span: Span,
+    pub node: T,
+}
+
+pub type ExprNode = Node<Expr>;

src/ast/program.rs

@@ -5,5 +5,29 @@ pub struct Program {
     pub functions: Vec<Function>,
 }
 
+#[derive(Debug, Clone, PartialEq)]
+pub struct Span {
+    pub start: Pos,
+    pub end: Pos
+}
+
+impl Span {
+    pub fn new(start: Pos, end: Pos) -> Span {
+        Span { start, end }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct Pos {
+    pub line: usize,
+    pub column: usize,
+}
+
+impl Pos {
+    pub fn new(line: usize, column: usize) -> Pos {
+        Pos {line, column}
+    }
+}
+
 // 프로그램 전체: 0개 이상의 함수 정의
 // program               ::= function_definition*

src/lib.rs

@@ -1,3 +1,4 @@
 pub mod ast;
 pub mod lexer;
 pub mod parser;
+pub mod semantic;

src/main.rs

@@ -1,5 +1,23 @@
+use rustc_tape4::lexer::Lexer;
+use rustc_tape4::parser::Parser;
+use rustc_tape4::semantic;
+use semantic::analyzer::analyzer::Analyzer;
+
 mod lexer;
 
 fn main() {
-    println!("Hello, world!");
+    let source = std::fs::read_to_string("tests/fixtures/sample.c").expect("could not read file");
+
+    // lexing
+    let tokens = Lexer::new(&source).collect_spanned_tokens();
+
+    // parsing
+    let mut parser = Parser::new(tokens);
+    let program = parser.parse_program().expect("Parsing Failed");
+
+    // println!("{:#?}", program);
+    // semantic analysis
+    let mut analyzer = Analyzer::new(&program);
+    let result = analyzer.analyze().expect("Analyzing Failed");
+    // println!("Hello, world!");
 }

src/parser/utils.rs

@@ -1,3 +1,4 @@
+use crate::ast::program::Pos;
 use crate::lexer::Token;
 use crate::parser::Parser;
 use crate::parser::parser::ParseResult;
@@ -79,4 +80,17 @@ impl Parser {
             self.unexpected_token(expected)
         }
     }
+
+    /// 아직 소비되지 않은 현재 토큰의 위치
+    pub fn start_pos(&self) -> Pos {
+        let st = &self.tokens[self.pos];
+        Pos::new(st.line, st.column)
+    }
+
+    /// 직전에 소비된 토큰의 위치
+    pub fn end_pos(&self) -> Pos {
+        let idx = self.pos.saturating_sub(1);
+        let st = &self.tokens[idx];
+        Pos::new(st.line, st.column)
+    }
 }

src/semantic/analyzer/analyzer.rs

@@ -0,0 +1,177 @@
+use crate::ast::{Expr, Program, Stmt};
+use crate::semantic::analyzer::error::SemanticError;
+use crate::semantic::resolver::resolver::Resolver;
+pub type AnalzeResult<T> = Result<T, SemanticError>;
+pub struct Analyzer<'a> {
+    pub name_resolver: Resolver,
+    pub program: &'a Program,
+    pub loop_depth: usize,
+}
+impl<'a> Analyzer<'a> {
+    pub fn new(program: &'a Program) -> Self {
+        Analyzer {
+            name_resolver: Resolver::new(),
+            program,
+            loop_depth: 0,
+        }
+    }
+    pub fn analyze(&mut self) -> AnalzeResult<()> {
+        for func in self.program.functions.iter() {
+            self.name_resolver.declare_function(func).map_err(|_| {
+                SemanticError::DuplicateDeclaration {
+                    name: func.name.clone(),
+                }
+            })?;
+        }
+
+        for func in self.program.functions.iter() {
+            self.name_resolver.push_scope();
+            for param in &func.params {
+                self.name_resolver
+                    .declare_variable(&param.name, &param.ty)
+                    .map_err(|_| SemanticError::DuplicateDeclaration {
+                        name: param.name.clone(),
+                    })?;
+            }
+            self.analyze_block(&Stmt::Block(func.body.clone()))?;
+            self.name_resolver.pop_scope();
+        }
+        Ok(())
+    }
+    fn analyze_block(&mut self, stmt: &Stmt) -> Result<(), SemanticError> {
+        if let Stmt::Block(block) = stmt {
+            for s in &block.statements {
+                self.analyze_stmt(s)?;
+            }
+        } else {
+            // println!("{:?}", stmt);
+            self.analyze_stmt(stmt)?;
+        }
+        Ok(())
+    }
+    fn analyze_stmt(&mut self, stmt: &Stmt) -> Result<(), SemanticError> {
+        match stmt {
+            Stmt::ExprStmt(expr) => {
+                if let Some(expr_opt) = expr {
+                    self.analyze_expr(expr_opt)?
+                }
+            }
+            Stmt::If {
+                cond,
+                then_branch,
+                else_branch,
+            } => {
+                self.analyze_expr(cond)?;
+                self.analyze_block(then_branch)?;
+                if let Some(else_branch_opt) = else_branch {
+                    self.analyze_block(else_branch_opt)?;
+                }
+            }
+            Stmt::While { cond, body } => {
+                self.loop_depth += 1;
+                self.analyze_expr(cond)?;
+                self.analyze_stmt(body)?;
+                self.loop_depth -= 1;
+            }
+            Stmt::Return(expr) => {
+                if let Some(expr_opt) = expr {
+                    self.analyze_expr(expr_opt)?;
+                }
+            }
+            Stmt::Block(inner_stmts) => {
+                self.analyze_block(&Stmt::Block(inner_stmts.clone()))?;
+            }
+            Stmt::For {
+                init,
+                cond,
+                step,
+                body,
+            } => {
+                self.loop_depth += 1;
+                self.name_resolver.push_scope();
+                if let Some(init_stmt) = init {
+                    self.analyze_stmt(init_stmt)?;
+                }
+                if let Some(cond_expr) = cond {
+                    self.analyze_expr(cond_expr)?;
+                }
+                self.analyze_stmt(body)?;
+                if let Some(step_expr) = step {
+                    self.analyze_expr(step_expr)?;
+                }
+                self.name_resolver.pop_scope();
+                self.loop_depth -= 1;
+            }
+            Stmt::Declaration { ty, declarators } => {
+                for declarator in declarators {
+                    self.name_resolver
+                        .declare_variable(&declarator.name, ty)
+                        .map_err(|_| SemanticError::DuplicateDeclaration {
+                            name: declarator.name.clone(),
+                        })?;
+                    if let Some(init_expr) = &declarator.init {
+                        self.analyze_expr(&init_expr)?;
+                    }
+                }
+            }
+            Stmt::Continue => {
+                if self.loop_depth == 0 {
+                    return Err(SemanticError::InvalidContinue);
+                }
+            }
+            Stmt::Break => {
+                if self.loop_depth == 0 {
+                    return Err(SemanticError::InvalidBreak);
+                }
+            }
+        }
+        Ok(())
+    }
+    fn analyze_expr(&mut self, expr: &Expr) -> Result<(), SemanticError> {
+        match expr {
+            Expr::Ident(name) => {
+                self.name_resolver
+                    .resolve_identifier(name)
+                    .map_err(|_| SemanticError::UndefinedSymbol { name: name.clone() })?;
+            }
+            Expr::BinaryOp { lhs, rhs, .. } => {
+                self.analyze_expr(lhs)?;
+                self.analyze_expr(rhs)?;
+            }
+            Expr::UnaryPostfixOp { lhs, .. } => {
+                self.analyze_expr(lhs)?;
+            }
+            Expr::UnaryPrefixOp { rhs, .. } => {
+                self.analyze_expr(rhs)?;
+            }
+            Expr::Assignment { left, right, .. } => {
+                self.analyze_expr(left)?;
+                self.analyze_expr(right)?;
+            }
+            Expr::ArrayIndex { array, index } => {
+                self.analyze_expr(array)?;
+                self.analyze_expr(index)?;
+            }
+            Expr::Call { func, args, .. } => match func.as_ref() {
+                Expr::Ident(func_name) => {
+                    self.name_resolver
+                        .resolve_identifier(func_name)
+                        .map_err(|_| SemanticError::UndefinedSymbol {
+                            name: func_name.clone(),
+                        })?;
+                    for arg in args {
+                        self.analyze_expr(arg)?;
+                    }
+                }
+                _ => unreachable!(),
+            },
+            Expr::InitializerList(exprs) => {
+                for e in exprs {
+                    self.analyze_expr(e)?;
+                }
+            }
+            Expr::CharLiteral(_) | Expr::IntLiteral(_) => {}
+        }
+        Ok(())
+    }
+}

src/semantic/analyzer/error.rs

@@ -0,0 +1,8 @@
+#[derive(Debug)]
+pub enum SemanticError {
+    UndefinedSymbol { name: String },
+    DuplicateDeclaration { name: String },
+    InvalidReturnType { expected: String, found: String },
+    InvalidContinue,
+    InvalidBreak,
+}

src/semantic/analyzer/mod.rs

@@ -0,0 +1,2 @@
+pub mod analyzer;
+mod error;

src/semantic/mod.rs

@@ -0,0 +1,3 @@
+pub mod analyzer;
+pub mod resolver;
+pub mod symbol;