Sync libasr from LFortran

Author: czgdp1807

src/libasr/ASR.asdl

@@ -170,6 +170,7 @@ abi                   -- External     ABI
 
 stmt
     = Allocate(alloc_arg* args, expr? stat, expr? errmsg, expr? source)
+    | ReAlloc(alloc_arg* args)
     | Assign(int label, identifier variable)
     | Assignment(expr target, expr value, stmt? overloaded)
     | Associate(expr target, expr value)
@@ -193,7 +194,7 @@ stmt
     | If(expr test, stmt* body, stmt* orelse)
     | IfArithmetic(expr test, int lt_label, int eq_label, int gt_label)
     | Print(expr? fmt, expr* values, expr? separator, expr? end)
-    | FileOpen(int label, expr? newunit, expr? filename, expr? status)
+    | FileOpen(int label, expr? newunit, expr? filename, expr? status, expr? form)
     | FileClose(int label, expr? unit, expr? iostat, expr? iomsg, expr? err, expr? status)
     | FileRead(int label, expr? unit, expr? fmt, expr? iomsg, expr? iostat, expr? id, expr* values)
     | FileBackspace(int label, expr? unit, expr? iostat, expr? err)
@@ -221,6 +222,8 @@ stmt
     | SelectType(expr selector, type_stmt* body, stmt* default)
     | CPtrToPointer(expr cptr, expr ptr, expr? shape, expr? lower_bounds)
     | BlockCall(int label, symbol m)
+    | SetInsert(expr a, expr ele)
+    | SetRemove(expr a, expr ele)
     | ListInsert(expr a, expr pos, expr ele)
     | ListRemove(expr a, expr ele)
     | ListClear(expr a)
@@ -261,6 +264,7 @@ expr
     | RealUnaryMinus(expr arg, ttype type, expr? value)
     | RealCompare(expr left, cmpop op, expr right, ttype type, expr? value)
     | RealBinOp(expr left, binop op, expr right, ttype type, expr? value)
+    | RealCopySign(expr target, expr source, ttype type, expr? value)
     | ComplexConstant(float re, float im, ttype type)
     | ComplexUnaryMinus(expr arg, ttype type, expr? value)
     | ComplexCompare(expr left, cmpop op, expr right, ttype type, expr? value)
@@ -311,10 +315,8 @@ expr
     | ArrayBound(expr v, expr? dim, ttype type, arraybound bound,
                  expr? value)
     | ArrayTranspose(expr matrix, ttype type, expr? value)
-    | ArrayMatMul(expr matrix_a, expr matrix_b, ttype type, expr? value)
     | ArrayPack(expr array, expr mask, expr? vector, ttype type, expr? value)
     | ArrayReshape(expr array, expr shape, ttype type, expr? value)
-    | ArrayMaxloc(expr array, expr? dim, expr? mask, expr? kind, expr? back, ttype type, expr? value)
     | ArrayAll(expr mask, expr? dim, ttype type, expr? value)
 
     | BitCast(expr source, expr mold, expr? size, ttype type, expr? value)
@@ -417,6 +419,7 @@ ttype
 array_physical_type
     = DescriptorArray
     | PointerToDataArray
+    | UnboundedPointerToDataArray
     | FixedSizeArray
     | NumPyArray
     | ISODescriptorArray

src/libasr/CMakeLists.txt

@@ -70,6 +70,7 @@ set(SRC
     string_utils.cpp
     asr_scopes.cpp
     modfile.cpp
+    pickle.cpp
     serialization.cpp
     utils2.cpp
 )

src/libasr/asdl.py

@@ -194,7 +194,7 @@ def check(mod):
 
 def parse(filename):
     """Parse ASDL from the given file and return a Module node describing it."""
-    with open(filename) as f:
+    with open(filename, encoding='utf8') as f:
         parser = ASDLParser()
         return parser.parse(f.read())
 

src/libasr/asr_scopes.cpp

@@ -4,8 +4,8 @@
 #include <libasr/asr_scopes.h>
 #include <libasr/asr_utils.h>
 
-
 std::string lcompilers_unique_ID;
+
 namespace LCompilers  {
 
 template< typename T >
@@ -53,7 +53,6 @@ void SymbolTable::mark_all_variables_external(Allocator &al) {
     }
 }
 
-
 ASR::symbol_t *SymbolTable::find_scoped_symbol(const std::string &name,
         size_t n_scope_names, char **m_scope_names) {
     const SymbolTable *s = this;

src/libasr/asr_utils.cpp

@@ -1266,13 +1266,13 @@ ASR::asr_t* make_Cast_t_value(Allocator &al, const Location &a_loc,
                                 ASRUtils::expr_value(a_arg))->m_n;
             value = ASR::down_cast<ASR::expr_t>(ASR::make_UnsignedIntegerConstant_t(al, a_loc, int_value, a_type));
         } else if (a_kind == ASR::cast_kindType::UnsignedIntegerToInteger) {
-            int64_t int_value = ASR::down_cast<ASR::UnsignedIntegerConstant_t>(
-                                ASRUtils::expr_value(a_arg))->m_n;
-            value = ASR::down_cast<ASR::expr_t>(ASR::make_IntegerConstant_t(al, a_loc, int_value, a_type));
+             int64_t int_value = ASR::down_cast<ASR::UnsignedIntegerConstant_t>(
+                                 ASRUtils::expr_value(a_arg))->m_n;
+             value = ASR::down_cast<ASR::expr_t>(ASR::make_IntegerConstant_t(al, a_loc, int_value, a_type));
         } else if (a_kind == ASR::cast_kindType::UnsignedIntegerToUnsignedInteger) {
-            int64_t int_value = ASR::down_cast<ASR::UnsignedIntegerConstant_t>(
-                                ASRUtils::expr_value(a_arg))->m_n;
-            value = ASR::down_cast<ASR::expr_t>(ASR::make_UnsignedIntegerConstant_t(al, a_loc, int_value, a_type));
+             int64_t int_value = ASR::down_cast<ASR::UnsignedIntegerConstant_t>(
+                                 ASRUtils::expr_value(a_arg))->m_n;
+             value = ASR::down_cast<ASR::expr_t>(ASR::make_UnsignedIntegerConstant_t(al, a_loc, int_value, a_type));
         } else if (a_kind == ASR::cast_kindType::IntegerToLogical) {
             // TODO: implement
         } else if (a_kind == ASR::cast_kindType::ComplexToComplex) {
@@ -1345,6 +1345,47 @@ ASR::symbol_t* import_class_procedure(Allocator &al, const Location& loc,
     return original_sym;
 }
 
+ASR::asr_t* make_Binop_util(Allocator &al, const Location& loc, ASR::binopType binop,
+                        ASR::expr_t* lexpr, ASR::expr_t* rexpr, ASR::ttype_t* ttype) {
+    switch (ttype->type) {
+        case ASR::ttypeType::Real: {
+            return ASR::make_RealBinOp_t(al, loc, lexpr, binop, rexpr,
+                ASRUtils::duplicate_type(al, ttype), nullptr);
+        }
+        case ASR::ttypeType::Integer: {
+            return ASR::make_IntegerBinOp_t(al, loc, lexpr, binop, rexpr,
+                ASRUtils::duplicate_type(al, ttype), nullptr);
+        }
+        case ASR::ttypeType::Complex: {
+            return ASR::make_ComplexBinOp_t(al, loc, lexpr, binop, rexpr,
+                ASRUtils::duplicate_type(al, ttype), nullptr);
+        }
+        default:
+            throw LCompilersException("Not implemented " + std::to_string(ttype->type));
+    }
+}
+
+ASR::asr_t* make_Cmpop_util(Allocator &al, const Location& loc, ASR::cmpopType cmpop,
+                        ASR::expr_t* lexpr, ASR::expr_t* rexpr, ASR::ttype_t* ttype) {
+    ASR::ttype_t* expr_type = ASRUtils::TYPE(ASR::make_Logical_t(al, loc, 4));
+    switch (ttype->type) {
+        case ASR::ttypeType::Real: {
+            return ASR::make_RealCompare_t(al, loc, lexpr, cmpop, rexpr, expr_type, nullptr);
+        }
+        case ASR::ttypeType::Integer: {
+            return ASR::make_IntegerCompare_t(al, loc, lexpr, cmpop, rexpr, expr_type, nullptr);
+        }
+        case ASR::ttypeType::Complex: {
+            return ASR::make_ComplexCompare_t(al, loc, lexpr, cmpop, rexpr, expr_type, nullptr);
+        }
+        case ASR::ttypeType::Character: {
+            return ASR::make_StringCompare_t(al, loc, lexpr, cmpop, rexpr, expr_type, nullptr);
+        }
+        default:
+            throw LCompilersException("Not implemented " + std::to_string(ttype->type));
+    }
+}
+
 //Initialize pointer to zero so that it can be initialized in first call to get_instance
 ASRUtils::LabelGenerator* ASRUtils::LabelGenerator::label_generator = nullptr;