Minor : use ndim initialized to 0 + add conditions if the string is p…

…hysical descriptor string
lfortran · certik · Oct 31, 2024 · Sep 25, 2024 · Sep 25, 2024 · Oct 8, 2024
commit 784bf86b18f544c55786c8fd1511f08d326e124d
diff --git a/src/libasr/asr_utils.h b/src/libasr/asr_utils.h
@@ -2608,7 +2608,7 @@ static inline ASR::ttype_t* duplicate_type(Allocator& al, const ASR::ttype_t* t,
         case ASR::ttypeType::Character: {
             ASR::Character_t* tnew = ASR::down_cast<ASR::Character_t>(t);
             t_ = ASRUtils::TYPE(ASR::make_Character_t(al, t->base.loc,
-                    tnew->m_kind, tnew->m_len, tnew->m_len_expr, ASR::string_physical_typeType::PointerString));
+                    tnew->m_kind, tnew->m_len, tnew->m_len_expr, tnew->m_physical_type));
             break;
         }
         case ASR::ttypeType::StructType: {

diff --git a/src/libasr/codegen/asr_to_fortran.cpp b/src/libasr/codegen/asr_to_fortran.cpp
@@ -1601,6 +1601,12 @@ class ASRToFortranVisitor : public ASR::BaseVisitor<ASRToFortranVisitor>
         src = r;
     }
 
+    void visit_StringPhysicalCast(const ASR::StringPhysicalCast_t &x) {
+        visit_expr(*x.m_arg);
+    }
+
+
+
     // void visit_CPtrCompare(const ASR::CPtrCompare_t &x) {}
 
     // void visit_SymbolicCompare(const ASR::SymbolicCompare_t &x) {}

diff --git a/src/libasr/codegen/asr_to_llvm.cpp b/src/libasr/codegen/asr_to_llvm.cpp
@@ -994,7 +994,6 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor<ASRToLLVMVisitor>
             ASR::ttype_t* curr_arg_m_a_type = ASRUtils::type_get_past_pointer(
                 ASRUtils::type_get_past_allocatable(
                 ASRUtils::expr_type(tmp_expr)));
-            llvm::Type* llvm_arg_type = llvm_utils->get_type_from_ttype_t_util(curr_arg_m_a_type, module.get());
             size_t n_dims = ASRUtils::extract_n_dims_from_ttype(curr_arg_m_a_type);
             curr_arg_m_a_type = ASRUtils::type_get_past_array(curr_arg_m_a_type);
             if( n_dims == 0 ) {
@@ -2886,7 +2885,7 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor<ASRToLLVMVisitor>
         } else if(x.m_type->type == ASR::ttypeType::Pointer ||
                     x.m_type->type == ASR::ttypeType::Allocatable) {
             ASR::dimension_t* m_dims = nullptr;
-            int n_dims = -1, a_kind = -1;
+            int n_dims = 0, a_kind = -1;
             bool is_array_type = false, is_malloc_array_type = false, is_list = false;
             llvm::Type* x_ptr = llvm_utils->get_type_from_ttype_t(
                 x.m_type, nullptr, x.m_storage, is_array_type,
@@ -3690,7 +3689,8 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor<ASRToLLVMVisitor>
                     bool is_llvm_ptr = false;
                     if ( LLVM::is_llvm_pointer(*v->m_type) &&
                             !ASR::is_a<ASR::ClassType_t>(*ASRUtils::type_get_past_pointer(
-                            ASRUtils::type_get_past_allocatable(v->m_type))) ) {
+                            ASRUtils::type_get_past_allocatable(v->m_type))) && 
+                            !ASRUtils::is_physical_descriptorString(v->m_type) ) {
                         is_llvm_ptr = true;
                     }
                     ptr = llvm_utils->CreateAlloca(*builder, type_, array_size,
@@ -8934,8 +8934,9 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor<ASRToLLVMVisitor>
                                 }
                                 if( !ASR::is_a<ASR::CPtr_t>(*arg_type) &&
                                     !(orig_arg && !LLVM::is_llvm_pointer(*orig_arg->m_type) &&
-                                      LLVM::is_llvm_pointer(*arg_type) &&
-                                      !ASRUtils::is_character(*orig_arg->m_type)) && !ASR::is_a<ASR::StructInstanceMember_t>(*x.m_args[i].m_value) ) {
+                                    LLVM::is_llvm_pointer(*arg_type) &&
+                                    !ASRUtils::is_character(*orig_arg->m_type) && 
+                                    ASRUtils::is_physical_descriptorString(arg_type)) && !ASR::is_a<ASR::StructInstanceMember_t>(*x.m_args[i].m_value) ) {
                                     llvm::AllocaInst *target = llvm_utils->CreateAlloca(
                                         target_type, nullptr, "call_arg_value");
                                     if( ASR::is_a<ASR::Tuple_t>(*arg_type) ||

diff --git a/src/libasr/codegen/c_utils.h b/src/libasr/codegen/c_utils.h
@@ -1718,7 +1718,7 @@ namespace BindPyUtils {
                 util_func_decls += indent + signature + ";\n";
                 std::string body = indent + signature + " {\n";
                 body += indent + tab + "char *s = (char*)PyUnicode_AsUTF8(pValue);\n";
-                body += indent + tab + "return _lfortran_str_copy(s, 1, 0);\n";
+                body += indent + tab + "return _lfortran_str_copy(s, 1, 0, -1, -1);\n";
                 body += indent + "}\n\n";
                 util_funcs += body;
             }

diff --git a/src/libasr/codegen/llvm_utils.cpp b/src/libasr/codegen/llvm_utils.cpp
@@ -1531,7 +1531,7 @@ namespace LCompilers {
         bool is_array_type_local, is_malloc_array_type_local;
         bool is_list_local;
         ASR::dimension_t* m_dims_local;
-        int n_dims_local, a_kind_local;
+        int n_dims_local = 0, a_kind_local = 0;
         return get_type_from_ttype_t(asr_type, nullptr, m_storage_local, is_array_type_local,
                                      is_malloc_array_type_local, is_list_local,
                                      m_dims_local, n_dims_local, a_kind_local, module, asr_abi);