Tacky conversion for statements

Author: rlivings39

rust_src/ast_to_tacky.rs

@@ -1,19 +1,29 @@
 //! AST to TACKY IR conversion routines
 
-use crate::{ast, tacky};
+use std::collections::HashSet;
+
+use crate::{ast, shared_types::Identifier, tacky};
 
 /// Converter object that does the work going from AST to TACKY
-struct AstToTacky {}
+struct AstToTacky {
+  label_set: HashSet<String>,
+}
 
 type InstructionVec = Vec<tacky::Instruction>;
 
 impl AstToTacky {
+  fn new() -> AstToTacky {
+    AstToTacky {
+      label_set: HashSet::new(),
+    }
+  }
+
   fn convert_program(&mut self, prog: &ast::Program) -> tacky::Program {
     let function = self.convert_function(&prog.function);
     return tacky::Program { function };
   }
 
-  fn convert_function(&self, func: &ast::Function) -> tacky::Function {
+  fn convert_function(&mut self, func: &ast::Function) -> tacky::Function {
     // let mut instructions: InstructionVec = func
     //   .body
     //   .iter()
@@ -40,7 +50,7 @@ impl AstToTacky {
     function
   }
 
-  fn convert_block_item(&self, block: &ast::BlockItem, instructions: &mut InstructionVec) {
+  fn convert_block_item(&mut self, block: &ast::BlockItem, instructions: &mut InstructionVec) {
     match block {
       ast::BlockItem::Declaration(identifier, expr) => {
         if let Some(init) = expr {
@@ -56,7 +66,7 @@ impl AstToTacky {
     };
   }
 
-  fn convert_stmt(&self, stmt: &ast::Stmt, instructions: &mut InstructionVec) {
+  fn convert_stmt(&mut self, stmt: &ast::Stmt, instructions: &mut InstructionVec) {
     match stmt {
       ast::Stmt::Return(expr) => {
         let expr = self.convert_expr(expr, instructions);
@@ -74,26 +84,76 @@ impl AstToTacky {
         false_stmt,
       } => self.convert_if_stmt(cond, true_stmt, false_stmt.as_ref(), instructions),
     };
-    todo!()
   }
 
-  fn convert_expr(&self, expr: &ast::Expr, instructions: &mut InstructionVec) -> tacky::Value {
+  fn convert_expr(&mut self, expr: &ast::Expr, instructions: &mut InstructionVec) -> tacky::Value {
     todo!()
   }
 
   fn convert_if_stmt(
-    &self,
+    &mut self,
     cond: &ast::Expr,
     true_stmt: &ast::Stmt,
     false_stmt: Option<&Box<ast::Stmt>>,
     instructions: &mut InstructionVec,
   ) {
-    todo!()
+    let cond_val = self.convert_expr(cond, instructions);
+    let end_name = "if_end_label";
+    let end_label: tacky::Instruction = self.make_label(end_name);
+
+    if let Some(false_stmt) = false_stmt {
+      /*
+       * With an else branch we emit something like
+       *
+       *   Condition instructions
+       *   Jump to else if condition is 0
+       *   True branch instructions
+       *   Jump to end
+       *   Else label
+       *   False branch instructions
+       *   End label
+       */
+      let else_name = "else_label";
+      let else_label = self.make_label(else_name);
+      let jump_else = tacky::Instruction::JumpIfZero {
+        cond: cond_val,
+        target: Identifier::new(else_name),
+      };
+      let jump_end = tacky::Instruction::Jump(Identifier::new(end_name));
+      instructions.push(jump_else);
+      self.convert_stmt(true_stmt, instructions);
+      instructions.push(jump_end);
+      instructions.push(else_label);
+      self.convert_stmt(false_stmt, instructions);
+      instructions.push(end_label);
+    } else {
+      // Without an else branch we just jump to the end label if the
+      // condition is false and execute the true branch statements otherwise
+      let jump_end = tacky::Instruction::JumpIfZero {
+        cond: cond_val,
+        target: Identifier::new(end_name),
+      };
+      instructions.push(jump_end);
+      self.convert_stmt(true_stmt, instructions);
+      instructions.push(end_label);
+    }
+  }
+
+  fn make_label(&mut self, name: &str) -> tacky::Instruction {
+    let mut counter = 0;
+    let mut label_name: String = name.to_string();
+    while self.label_set.contains(&label_name) {
+      label_name = format!("{name}{counter}");
+      counter += 1;
+    }
+    let label = tacky::Instruction::Label(Identifier::new(&label_name));
+    self.label_set.insert(label_name);
+    label
   }
 }
 
 /// Convert an ast::Program to a tacky::Program
 pub fn ast_to_tacky(ast: &ast::Program) -> tacky::Program {
-  let mut converter = AstToTacky {};
+  let mut converter = AstToTacky::new();
   return converter.convert_program(ast);
 }