Merge branch 'main' into builtin2

Author: namannimmo10

.gitignore

@@ -1,7 +1,6 @@
 # LFortran
 
 src/bin/lpython
-src/bin/cpptranslate
 src/bin/parse
 src/bin/parse2
 src/lpython/parser/parser.output

README.md

@@ -57,6 +57,10 @@ Run tests:
     ctest
     ./run_tests.py
 
+Also, run the integration tests:
+
+    ./integration_tests/run_tests.py
+
 ## Examples
 
 You can run the following examples by hand in a terminal:

ci/build.xsh

@@ -63,9 +63,8 @@ cd ../..
 jupyter kernelspec list --json
 
 cp lpython-$lpython_version/test-bld/src/bin/lpython src/bin
-cp lpython-$lpython_version/test-bld/src/bin/cpptranslate src/bin
 if $WIN == "1":
-    cp lpython-$lpython_version/test-bld/src/runtime/legacy/lfortran_runtime* src/runtime/
+    cp lpython-$lpython_version/test-bld/src/runtime/lfortran_runtime* src/runtime/
 else:
     cp lpython-$lpython_version/test-bld/src/runtime/liblfortran_runtime* src/runtime/
 cp lpython-$lpython_version/test-bld/src/runtime/*.mod src/runtime/

integration_tests/run_tests.py

@@ -15,6 +15,7 @@
     "test_math.py",
     #"test_builtin.py",
     "test_builtin_abs.py",
+    "test_math1.py"
 ]
 
 def main():

integration_tests/test_builtin_abs.py

@@ -6,6 +6,8 @@ def test_abs():
     assert abs(x) == 5.5
     x = -5.5
     assert abs(x) == 5.5
+    assert abs(5.5) == 5.5
+    assert abs(-5.5) == 5.5
 
 
 test_abs()

integration_tests/test_math1.py

@@ -0,0 +1,9 @@
+import math
+
+def f():
+    i: i32
+    i = math.factorial(3)
+    print(i)
+    assert i == 6
+
+f()

src/bin/CMakeLists.txt

@@ -131,6 +131,7 @@ install(TARGETS lpython
     LIBRARY DESTINATION share/lpython/lib
 )
 
-
-add_executable(cpptranslate cpptranslate.cpp)
-target_link_libraries(cpptranslate lfortran_lib)
+set_target_properties(lpython PROPERTIES
+    RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/$<0:>
+    LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/$<0:>
+    ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/$<0:>)

src/bin/cpptranslate.cpp

@@ -153,15 +153,35 @@ static inline std::string unop_to_str(const ASR::unaryopType t) {
     }
 }
 
+static inline std::string binop_to_str(const ASR::binopType t) {
+    switch (t) {
+        case (ASR::binopType::Add): { return " + "; }
+        case (ASR::binopType::Sub): { return " - "; }
+        case (ASR::binopType::Mul): { return "*"; }
+        case (ASR::binopType::Div): { return "/"; }
+        default : throw LFortranException("Cannot represent the binary operator as a string");
+    }
+}
+
 static inline std::string cmpop_to_str(const ASR::cmpopType t) {
     switch (t) {
-        case (ASR::cmpopType::Eq): { return "=="; }
-        case (ASR::cmpopType::NotEq): { return "!="; }
-        case (ASR::cmpopType::Lt): { return "<"; }
-        case (ASR::cmpopType::LtE): { return "<="; }
-        case (ASR::cmpopType::Gt): { return ">"; }
-        case (ASR::cmpopType::GtE): { return ">="; }
-        default : throw LFortranException("Not implemented");
+        case (ASR::cmpopType::Eq): { return " == "; }
+        case (ASR::cmpopType::NotEq): { return " != "; }
+        case (ASR::cmpopType::Lt): { return " < "; }
+        case (ASR::cmpopType::LtE): { return " <= "; }
+        case (ASR::cmpopType::Gt): { return " > "; }
+        case (ASR::cmpopType::GtE): { return " >= "; }
+        default : throw LFortranException("Cannot represent the comparison as a string");
+    }
+}
+
+static inline std::string boolop_to_str(const ASR::boolopType t) {
+    switch (t) {
+        case (ASR::boolopType::And): { return " && "; }
+        case (ASR::boolopType::Or): { return " || "; }
+        case (ASR::boolopType::Eqv): { return " == "; }
+        case (ASR::boolopType::NEqv): { return " != "; }
+        default : throw LFortranException("Cannot represent the boolean operator as a string");
     }
 }
 
@@ -348,6 +368,18 @@ static inline bool is_intrinsic_function(const ASR::Function_t *fn) {
     return false;
 }
 
+// Returns true if the Function is intrinsic, otherwise false
+// This version uses the `intrinsic` member of `Module`, so it
+// should be used instead of is_intrinsic_function
+static inline bool is_intrinsic_function2(const ASR::Function_t *fn) {
+    ASR::symbol_t *sym = (ASR::symbol_t*)fn;
+    ASR::Module_t *m = get_sym_module0(sym);
+    if (m != nullptr) {
+        if (m->m_intrinsic) return true;
+    }
+    return false;
+}
+
 // Returns true if all arguments have a `value`
 static inline bool all_args_have_value(const Vec<ASR::expr_t*> &args) {
     for (auto &a : args) {