Implement if statement ast_dumper and type_checker

fruits-lab · Nov 27, 2023 · f2eb940 · f2eb940
1 parent e227f3c
commit f2eb940
Show file tree

Hide file tree

Showing 10 changed files with 44 additions and 3 deletions.
diff --git a/include/ast.hpp b/include/ast.hpp
@@ -93,6 +93,18 @@ struct NullStmtNode : public StmtNode {
   virtual void Accept(ModifyingVisitor&) override;
 };
 
+struct IfStmtNode : public StmtNode {
+  IfStmtNode(std::unique_ptr<ExprNode> expr,
+             std::unique_ptr<BlockStmtNode> block)
+      : predicate{std::move(expr)}, body{std::move(block)} {}
+
+  virtual void Accept(NonModifyingVisitor&) const override;
+  virtual void Accept(ModifyingVisitor&) override;
+
+  std::unique_ptr<ExprNode> predicate;
+  std::unique_ptr<BlockStmtNode> body;
+};
+
 struct ReturnStmtNode : public StmtNode {
   ReturnStmtNode(std::unique_ptr<ExprNode> expr) : expr{std::move(expr)} {}
 

diff --git a/include/ast_dumper.hpp b/include/ast_dumper.hpp
@@ -10,6 +10,7 @@ class AstDumper : public NonModifyingVisitor {
   void Visit(const BlockStmtNode&) override;
   void Visit(const ProgramNode&) override;
   void Visit(const NullStmtNode&) override;
+  void Visit(const IfStmtNode&) override;
   void Visit(const ReturnStmtNode&) override;
   void Visit(const ExprStmtNode&) override;
   void Visit(const IdExprNode&) override;

diff --git a/include/qbe_ir_generator.hpp b/include/qbe_ir_generator.hpp
@@ -9,6 +9,7 @@ class QbeIrGenerator : public NonModifyingVisitor {
   void Visit(const BlockStmtNode&) override;
   void Visit(const ProgramNode&) override;
   void Visit(const NullStmtNode&) override;
+  void Visit(const IfStmtNode&) override;
   void Visit(const ReturnStmtNode&) override;
   void Visit(const ExprStmtNode&) override;
   void Visit(const IdExprNode&) override;

diff --git a/include/type_checker.hpp b/include/type_checker.hpp
@@ -13,6 +13,7 @@ class TypeChecker : public ModifyingVisitor {
   void Visit(BlockStmtNode&) override;
   void Visit(ProgramNode&) override;
   void Visit(NullStmtNode&) override;
+  void Visit(IfStmtNode&) override;
   void Visit(ReturnStmtNode&) override;
   void Visit(ExprStmtNode&) override;
   void Visit(IdExprNode&) override;

diff --git a/include/visitor.hpp b/include/visitor.hpp
@@ -13,6 +13,7 @@ struct DeclNode;
 struct BlockStmtNode;
 struct ProgramNode;
 struct NullStmtNode;
+struct IfStmtNode;
 struct ReturnStmtNode;
 struct ExprStmtNode;
 struct IdExprNode;
@@ -55,6 +56,7 @@ class Visitor {
   virtual void Visit(CondMut<BlockStmtNode>&){};
   virtual void Visit(CondMut<ProgramNode>&){};
   virtual void Visit(CondMut<NullStmtNode>&){};
+  virtual void Visit(CondMut<IfStmtNode>&){};
   virtual void Visit(CondMut<ReturnStmtNode>&){};
   virtual void Visit(CondMut<ExprStmtNode>&){};
   virtual void Visit(CondMut<IdExprNode>&){};

diff --git a/parser.y b/parser.y
@@ -109,7 +109,7 @@ stmts: stmts stmt {
 stmt: ';' { $$ = std::make_unique<NullStmtNode>(); }
     | RETURN expr ';' { $$ = std::make_unique<ReturnStmtNode>($2); }
     | expr ';' { $$ = std::make_unique<ExprStmtNode>($1); }
-    | IF '(' expr ')' block {}
+    | IF '(' expr ')' block { $$ = std::make_unique<IfStmtNode>($3, $5); }
     ;
 
 expr: ID { $$ = std::make_unique<IdExprNode>($1); }

diff --git a/src/ast.cpp b/src/ast.cpp
@@ -64,6 +64,14 @@ void NullStmtNode::Accept(ModifyingVisitor& v) {
   v.Visit(*this);
 }
 
+void IfStmtNode::Accept(NonModifyingVisitor& v) const {
+  v.Visit(*this);
+}
+
+void IfStmtNode::Accept(ModifyingVisitor& v) {
+  v.Visit(*this);
+}
+
 void ReturnStmtNode::Accept(NonModifyingVisitor& v) const {
   v.Visit(*this);
 }

diff --git a/src/ast_dumper.cpp b/src/ast_dumper.cpp
@@ -57,6 +57,15 @@ void AstDumper::Visit(const NullStmtNode& stmt) {
   std::cout << indenter_.Indent() << "()" << std::endl;
 }
 
+void AstDumper::Visit(const IfStmtNode& if_stmt) {
+  std::cout << indenter_.Indent() << "(if" << std::endl;
+  indenter_.IncreaseLevel();
+  if_stmt.predicate->Accept(*this);
+  if_stmt.body->Accept(*this);
+  indenter_.DecreaseLevel();
+  std::cout << indenter_.Indent() << ')' << std::endl;
+}
+
 void AstDumper::Visit(const ReturnStmtNode& ret_stmt) {
   std::cout << indenter_.Indent() << "(ret" << std::endl;
   indenter_.IncreaseLevel();

diff --git a/src/qbe_ir_generator.cpp b/src/qbe_ir_generator.cpp
@@ -106,6 +106,8 @@ void QbeIrGenerator::Visit(const NullStmtNode&) {
   /* do nothing */
 }
 
+void QbeIrGenerator::Visit(const IfStmtNode& if_stmt) {}
+
 void QbeIrGenerator::Visit(const ReturnStmtNode& ret_stmt) {
   ret_stmt.expr->Accept(*this);
   int ret_num = num_recorder.NumOfPrevExpr();

diff --git a/src/type_checker.cpp b/src/type_checker.cpp
@@ -39,6 +39,11 @@ void TypeChecker::Visit(NullStmtNode&) {
   /* do nothing */
 }
 
+void TypeChecker::Visit(IfStmtNode& if_stmt) {
+  if_stmt.predicate->Accept(*this);
+  if_stmt.body->Accept(*this);
+}
+
 void TypeChecker::Visit(ReturnStmtNode& ret_stmt) {
   ret_stmt.expr->Accept(*this);
   if (ret_stmt.expr->type != ExprType::kInt) {
@@ -100,8 +105,8 @@ void TypeChecker::Visit(SimpleAssignmentExprNode& assign_expr) {
     if (assign_expr.expr->type == symbol->expr_type) {
       // 6.5.16 Assignment operators
       // The type of an assignment expression is the type of the left
-      // operand unless the left operand has qualified type, in which case it is
-      // the unqualified version of the type of the left operand.
+      // operand unless the left operand has qualified type, in which case it
+      // is the unqualified version of the type of the left operand.
       assign_expr.type = symbol->expr_type;
     } else {
       // TODO: assigning to 'symbol->expr_type' from incompatible type