add some binary expr implement

README.md

 # CS 164: Programming Assignment 3
 
+
+## Current testing result (By GitLab PipeLine)
+
+![](https://git.recolic.net/_r_testing/redirect_to_val/cs164_proj2_test|http://img4me.com/dXlRzPa0.png)
+
+
 ## Getting started
 
 Run the following command to build your compiler, and then run all the provided tests:

src/main/java/chocopy/pa3/CodeGenImpl.java

@@ -7,6 +7,7 @@ import java.util.Map;
 
 import chocopy.common.analysis.SymbolTable;
 import chocopy.common.analysis.AbstractNodeAnalyzer;
+import chocopy.common.analysis.types.SymbolType;
 import chocopy.common.analysis.types.ValueType;
 import chocopy.common.astnodes.*;
 import chocopy.common.codegen.*;
@@ -81,6 +82,19 @@ public class CodeGenImpl extends CodeGenBase {
             emitPush(tmpReg, null);
             backend.emitADDI(tmpReg, SP, backend.getWordSize(), "Return INT address.");
         }
+        public void emitPushBoolVal(RiscVBackend.Register tmpReg, Boolean val, String comment) {
+            emitNoop(comment);
+            backend.emitLI(tmpReg, val ? 1 : 0, "BOOL VAL");
+            emitPush(tmpReg, null);
+            backend.emitLI(tmpReg, 0, "OBJECT HEAD - DISPATCH TBL = NULL");
+            emitPush(tmpReg, null);
+            backend.emitLI(tmpReg, 4, "OBJECT HEAD - SIZE = 3+1");
+            emitPush(tmpReg, null);
+            backend.emitLI(tmpReg, 2, "OBJECT HEAD - TYPE = INT");
+            emitPush(tmpReg, null);
+            backend.emitADDI(tmpReg, SP, backend.getWordSize(), "Return INT address.");
+        }
+
     }
 
     // Every function needs a register manager.
@@ -99,7 +113,6 @@ public class CodeGenImpl extends CodeGenBase {
             usageMap.put(T4, false);
             usageMap.put(T5, false);
             usageMap.put(T6, false);
-            usageMap.put(A0, false);
             usageMap.put(A1, false);
             usageMap.put(A2, false);
             usageMap.put(A3, false);
@@ -107,6 +120,7 @@ public class CodeGenImpl extends CodeGenBase {
             usageMap.put(A5, false);
             usageMap.put(A6, false);
             usageMap.put(A7, false);
+            usageMap.put(A0, false);
         }
 
         public RiscVBackend.Register borrowOne() {
@@ -281,8 +295,10 @@ public class CodeGenImpl extends CodeGenBase {
                     }
                     args_reg.add(result);
                 }
-                for(RiscVBackend.Register reg : args_reg)
+                for(RiscVBackend.Register reg : args_reg) {
                     betterBackend.emitPush(reg, "Push function arguments.");
+                    regMgr.returnOne(reg);
+                }
 
                 betterBackend.emitCall(func.getCodeLabel(), null);
 
@@ -297,6 +313,61 @@ public class CodeGenImpl extends CodeGenBase {
             return null;
         }
 
+        @Override
+        public RiscVBackend.Register analyze(BinaryExpr node) {
+            RiscVBackend.Register leftRes = node.left.dispatch(this);
+            RiscVBackend.Register rightRes = node.right.dispatch(this);
+            if(leftRes == null || rightRes == null)
+                throw new RuntimeException("NOT IMPL");
+            switch(node.operator) {
+                case "+":
+                    if(node.left.getInferredType().equals(SymbolType.INT_TYPE)) {
+                        RiscVBackend.Register savedLeftAddr = regMgr.borrowOne();
+                        backend.emitMV(savedLeftAddr, leftRes, "Backup reg leftRes");
+                        backend.emitLW(leftRes, leftRes, 3 * backend.getWordSize(), "Operator+ Fetch left int result");
+                        backend.emitLW(rightRes, rightRes, 3 * backend.getWordSize(), "Operator+ Fetch right int result");
+                        backend.emitADD(leftRes, leftRes, rightRes, "Operator+::INT");
+                        regMgr.returnOne(rightRes);
+                        backend.emitSW(leftRes, savedLeftAddr, 3 * backend.getWordSize(), "Operator+::INT save final res.");
+                        regMgr.returnOne(leftRes);
+                        return savedLeftAddr;
+                    }
+                    if(node.left.getInferredType().isListType()) {
+                        // TODO: Merge two list.
+                        throw new RuntimeException("NOTIMPLEMENTED: ListMerge");
+                    }
+                    if(node.left.getInferredType().equals(SymbolType.STR_TYPE)) {
+                        // TODO: Merge two str.
+                        throw new RuntimeException("NOTIMPLEMENTED: StrMerge");
+                    }
+                case "-":
+                    if(node.left.getInferredType().equals(SymbolType.INT_TYPE)) {
+                        RiscVBackend.Register savedLeftAddr = regMgr.borrowOne();
+                        backend.emitMV(savedLeftAddr, leftRes, "Backup reg leftRes");
+                        backend.emitLW(leftRes, leftRes, 3 * backend.getWordSize(), "Operator- Fetch left int result");
+                        backend.emitLW(rightRes, rightRes, 3 * backend.getWordSize(), "Operator- Fetch right int result");
+                        backend.emitSUB(leftRes, leftRes, rightRes, "Operator-::INT");
+                        regMgr.returnOne(rightRes);
+                        backend.emitSW(leftRes, savedLeftAddr, 3 * backend.getWordSize(), "Operator-::INT save final res.");
+                        regMgr.returnOne(leftRes);
+                        return savedLeftAddr;
+                    }
+                case "*":
+                    if(node.left.getInferredType().equals(SymbolType.INT_TYPE)) {
+                        RiscVBackend.Register savedLeftAddr = regMgr.borrowOne();
+                        backend.emitMV(savedLeftAddr, leftRes, "Backup reg leftRes");
+                        backend.emitLW(leftRes, leftRes, 3 * backend.getWordSize(), "Operator* Fetch left int result");
+                        backend.emitLW(rightRes, rightRes, 3 * backend.getWordSize(), "Operator* Fetch right int result");
+                        backend.emitMUL(leftRes, leftRes, rightRes, "Operator*::INT");
+                        regMgr.returnOne(rightRes);
+                        backend.emitSW(leftRes, savedLeftAddr, 3 * backend.getWordSize(), "Operator*::INT save final res.");
+                        regMgr.returnOne(leftRes);
+                        return savedLeftAddr;
+                    }
+            }
+            return null;
+        }
+
         @Override
         public RiscVBackend.Register analyze(IntegerLiteral node) {
             // emitConstant(node, ValueType.INT_TYPE, "Set constant int literal.");
@@ -304,6 +375,13 @@ public class CodeGenImpl extends CodeGenBase {
             betterBackend.emitPushIntVal(tmpReg, node.value, "Push int literal");
             return tmpReg;
         }
+
+        @Override
+        public RiscVBackend.Register analyze(BooleanLiteral node) {
+            RiscVBackend.Register tmpReg = regMgr.borrowOne();
+            betterBackend.emitPushBoolVal(tmpReg, node.value, "Push bool literal");
+            return tmpReg;
+        }
     }
 
     /**

src/main/java/chocopy/pa3/StudentCodeGen.java

@@ -28,7 +28,11 @@ public class StudentCodeGen {
             if (debug) {
                 e.printStackTrace();
             }
-            return null;
+            return "";
+        } catch (Exception e) {
+            System.err.println("Runtime Exception:" + e.toString());
+            e.printStackTrace();
+            return "";
         }
     }
 }