Remove common parts from asr_to_cpp

Author: namannimmo10

src/libasr/codegen/asr_to_cpp.cpp

@@ -370,166 +370,6 @@ Kokkos::View<T*> from_std_vector(const std::vector<T> &v)
         last_expr_precedence = 2;
     }
 
-    void visit_Compare(const ASR::Compare_t &x) {
-        this->visit_expr(*x.m_left);
-        std::string left = std::move(src);
-        int left_precedence = last_expr_precedence;
-        this->visit_expr(*x.m_right);
-        std::string right = std::move(src);
-        int right_precedence = last_expr_precedence;
-        switch (x.m_op) {
-            case (ASR::cmpopType::Eq) : { last_expr_precedence = 10; break; }
-            case (ASR::cmpopType::Gt) : { last_expr_precedence = 9;  break; }
-            case (ASR::cmpopType::GtE) : { last_expr_precedence = 9; break; }
-            case (ASR::cmpopType::Lt) : { last_expr_precedence = 9;  break; }
-            case (ASR::cmpopType::LtE) : { last_expr_precedence = 9; break; }
-            case (ASR::cmpopType::NotEq): { last_expr_precedence = 10; break; }
-            default : LFORTRAN_ASSERT(false); // should never happen
-        }
-        if (left_precedence <= last_expr_precedence) {
-            src += left;
-        } else {
-            src += "(" + left + ")";
-        }
-        src += ASRUtils::cmpop_to_str(x.m_op);
-        if (right_precedence <= last_expr_precedence) {
-            src += right;
-        } else {
-            src += "(" + right + ")";
-        }
-    }
-
-    void visit_UnaryOp(const ASR::UnaryOp_t &x) {
-        this->visit_expr(*x.m_operand);
-        int expr_precedence = last_expr_precedence;
-        if (x.m_type->type == ASR::ttypeType::Integer) {
-            if (x.m_op == ASR::unaryopType::UAdd) {
-                // src = src;
-                // Skip unary plus, keep the previous precedence
-            } else if (x.m_op == ASR::unaryopType::USub) {
-                last_expr_precedence = 3;
-                if (expr_precedence <= last_expr_precedence) {
-                    src = "-" + src;
-                } else {
-                    src = "-(" + src + ")";
-                }
-            } else if (x.m_op == ASR::unaryopType::Invert) {
-                last_expr_precedence = 3;
-                if (expr_precedence <= last_expr_precedence) {
-                    src = "~" + src;
-                } else {
-                    src = "~(" + src + ")";
-                }
-
-            } else if (x.m_op == ASR::unaryopType::Not) {
-                last_expr_precedence = 3;
-                if (expr_precedence <= last_expr_precedence) {
-                    src = "!" + src;
-                } else {
-                    src = "!(" + src + ")";
-                }
-            } else {
-                throw CodeGenError("Unary type not implemented yet for Integer");
-            }
-            return;
-        } else if (x.m_type->type == ASR::ttypeType::Real) {
-            if (x.m_op == ASR::unaryopType::UAdd) {
-                // src = src;
-                // Skip unary plus, keep the previous precedence
-            } else if (x.m_op == ASR::unaryopType::USub) {
-                last_expr_precedence = 3;
-                if (expr_precedence <= last_expr_precedence) {
-                    src = "-" + src;
-                } else {
-                    src = "-(" + src + ")";
-                }
-            } else if (x.m_op == ASR::unaryopType::Not) {
-                last_expr_precedence = 3;
-                if (expr_precedence <= last_expr_precedence) {
-                    src = "!" + src;
-                } else {
-                    src = "!(" + src + ")";
-                }
-            } else {
-                throw CodeGenError("Unary type not implemented yet for Real");
-            }
-            return;
-        } else if (x.m_type->type == ASR::ttypeType::Logical) {
-            if (x.m_op == ASR::unaryopType::Not) {
-                last_expr_precedence = 3;
-                if (expr_precedence <= last_expr_precedence) {
-                    src = "!" + src;
-                } else {
-                    src = "!(" + src + ")";
-                }
-                return;
-            } else {
-                throw CodeGenError("Unary type not implemented yet for Logical");
-            }
-        } else {
-            throw CodeGenError("UnaryOp: type not supported yet");
-        }
-    }
-
-    void visit_IntegerBinOp(const ASR::IntegerBinOp_t &x) {
-        handle_BinOp(x);
-    }
-
-    void visit_RealBinOp(const ASR::RealBinOp_t &x) {
-        handle_BinOp(x);
-    }
-
-    void visit_ComplexBinOp(const ASR::ComplexBinOp_t &x) {
-        handle_BinOp(x);
-    }
-
-    template <typename T>
-    void handle_BinOp(const T &x) {
-        this->visit_expr(*x.m_left);
-        std::string left = std::move(src);
-        int left_precedence = last_expr_precedence;
-        this->visit_expr(*x.m_right);
-        std::string right = std::move(src);
-        int right_precedence = last_expr_precedence;
-        switch (x.m_op) {
-            case (ASR::binopType::Add) : { last_expr_precedence = 6; break; }
-            case (ASR::binopType::Sub) : { last_expr_precedence = 6; break; }
-            case (ASR::binopType::Mul) : { last_expr_precedence = 5; break; }
-            case (ASR::binopType::Div) : { last_expr_precedence = 5; break; }
-            case (ASR::binopType::Pow) : {
-                src = "std::pow(" + left + ", " + right + ")";
-                return;
-            }
-            default: throw CodeGenError("BinOp: operator not implemented yet");
-        }
-        src = "";
-        if (left_precedence == 3) {
-            src += "(" + left + ")";
-        } else {
-            if (left_precedence <= last_expr_precedence) {
-                src += left;
-            } else {
-                src += "(" + left + ")";
-            }
-        }
-        src += ASRUtils::binop_to_str(x.m_op);
-        if (right_precedence == 3) {
-            src += "(" + right + ")";
-        } else if (x.m_op == ASR::binopType::Sub) {
-            if (right_precedence < last_expr_precedence) {
-                src += right;
-            } else {
-                src += "(" + right + ")";
-            }
-        } else {
-            if (right_precedence <= last_expr_precedence) {
-                src += right;
-            } else {
-                src += "(" + right + ")";
-            }
-        }
-    }
-
     void visit_StringConcat(const ASR::StringConcat_t &x) {
         this->visit_expr(*x.m_left);
         std::string left = std::move(src);
@@ -551,46 +391,6 @@ Kokkos::View<T*> from_std_vector(const std::vector<T> &v)
         }
     }
 
-    void visit_LogicalBinOp(const ASR::LogicalBinOp_t &x) {
-        this->visit_expr(*x.m_left);
-        std::string left = std::move(src);
-        int left_precedence = last_expr_precedence;
-        this->visit_expr(*x.m_right);
-        std::string right = std::move(src);
-        int right_precedence = last_expr_precedence;
-        switch (x.m_op) {
-            case (ASR::logicalbinopType::And): {
-                last_expr_precedence = 14;
-                break;
-            }
-            case (ASR::logicalbinopType::Or): {
-                last_expr_precedence = 15;
-                break;
-            }
-            case (ASR::logicalbinopType::NEqv): {
-                last_expr_precedence = 10;
-                break;
-            }
-            case (ASR::logicalbinopType::Eqv): {
-                last_expr_precedence = 10;
-                break;
-            }
-            default : throw CodeGenError("Unhandled switch case");
-        }
-
-        if (left_precedence <= last_expr_precedence) {
-            src += left;
-        } else {
-            src += "(" + left + ")";
-        }
-        src += ASRUtils::logicalbinop_to_str(x.m_op);
-        if (right_precedence <= last_expr_precedence) {
-            src += right;
-        } else {
-            src += "(" + right + ")";
-        }
-    }
-
     void visit_ArrayConstant(const ASR::ArrayConstant_t &x) {
         std::string out = "from_std_vector<float>({";
         for (size_t i=0; i<x.n_args; i++) {