wip

Author: czgdp1807

integration_tests/CMakeLists.txt

@@ -149,7 +149,7 @@ RUN(NAME test_str_02         LABELS cpython llvm)
 RUN(NAME test_str_03         LABELS cpython llvm c)
 RUN(NAME test_list_01        LABELS cpython llvm c)
 RUN(NAME test_list_02        LABELS cpython llvm c)
-RUN(NAME test_list_03        LABELS cpython llvm)
+RUN(NAME test_list_03        LABELS cpython llvm c)
 RUN(NAME test_list_04        LABELS cpython llvm)
 RUN(NAME test_list_05        LABELS cpython llvm)
 RUN(NAME test_list_06        LABELS cpython llvm)

src/libasr/codegen/asr_to_c_cpp.h

@@ -126,6 +126,7 @@ class CList {
             list_deepcopy(list_struct_type, list_type_code, list_element_type);
             resize_if_needed(list_struct_type, list_type_code, list_element_type);
             list_append(list_struct_type, list_type_code, list_element_type, list_type->m_type);
+            list_insert(list_struct_type, list_type_code, list_element_type, list_type->m_type);
             return list_struct_type;
         }
 
@@ -144,6 +145,11 @@ class CList {
             return typecode2listfuncs[list_type_code]["list_append"];
         }
 
+        std::string get_list_insert_func(ASR::List_t* list_type) {
+            std::string list_type_code = ASRUtils::get_type_code(list_type->m_type, true);
+            return typecode2listfuncs[list_type_code]["list_insert"];
+        }
+
         std::string get_list_resize_func(std::string list_type_code) {
             return typecode2listfuncs[list_type_code]["list_resize"];
         }
@@ -234,6 +240,40 @@ class CList {
             generated_code += indent + "}\n\n";
         }
 
+        void list_insert(std::string list_struct_type,
+            std::string list_type_code, std::string list_element_type,
+            ASR::ttype_t* m_type) {
+            std::string indent(indentation_level * indentation_spaces, ' ');
+            std::string tab(indentation_spaces, ' ');
+            std::string list_insert_func = global_scope->get_unique_name("list_insert_" + list_type_code);
+            typecode2listfuncs[list_type_code]["list_insert"] = list_insert_func;
+            std::string signature = "void " + list_insert_func + "("
+                                + list_struct_type + "* x, "
+                                + "int pos, "
+                                + list_element_type + " element)";
+            list_func_decls += signature + ";\n";
+            generated_code += indent + signature + " {\n";
+            std::string list_resize_func = get_list_resize_func(list_type_code);
+            generated_code += indent + tab + list_resize_func + "(x);\n";
+            generated_code += indent + tab + "int pos_ptr = pos;\n";
+            generated_code += indent + tab + list_element_type + " tmp_ptr = x->data[pos];\n";
+            generated_code += indent + tab + list_element_type + " tmp = 0;\n";
+
+            generated_code += indent + tab + "while(x->current_end_point > pos_ptr) {\n";
+            generated_code += indent + tab + tab + "tmp = x->data[pos_ptr + 1];\n";
+            generated_code += indent + tab + tab + "x->data[pos_ptr + 1] = tmp_ptr;\n";
+            generated_code += indent + tab + tab + "tmp_ptr = tmp;\n";
+            generated_code += indent + tab + tab + "pos_ptr++;\n";
+            generated_code += indent + tab + "}\n\n";
+
+            if( ASR::is_a<ASR::Character_t>(*m_type) ) {
+                generated_code += indent + tab + "x->data[pos] = malloc(40 * sizeof(char));\n";
+            }
+            generated_code += indent + tab + CUtils::deepcopy("x->data[pos]", "element", m_type) + "\n";
+            generated_code += indent + tab + "x->current_end_point += 1;\n";
+            generated_code += indent + "}\n\n";
+        }
+
         ~CList() {
             typecode2listtype.clear();
             generated_code.clear();
@@ -829,6 +869,20 @@ R"(#include <stdio.h>
         src = indent + list_append_func + "(&" + list_var + ", " + element + ");\n";
     }
 
+    void visit_ListInsert(const ASR::ListInsert_t& x) {
+        ASR::ttype_t* t_ttype = ASRUtils::expr_type(x.m_a);
+        ASR::List_t* t = ASR::down_cast<ASR::List_t>(t_ttype);
+        std::string list_insert_func = list_api->get_list_insert_func(t);
+        self().visit_expr(*x.m_a);
+        std::string list_var = std::move(src);
+        self().visit_expr(*x.m_ele);
+        std::string element = std::move(src);
+        self().visit_expr(*x.m_pos);
+        std::string pos = std::move(src);
+        std::string indent(indentation_level * indentation_spaces, ' ');
+        src = indent + list_insert_func + "(&" + list_var + ", " + pos + ", " + element + ");\n";
+    }
+
     void visit_ListLen(const ASR::ListLen_t& x) {
         if( x.m_value ) {
             self().visit_expr(*x.m_value);
@@ -956,14 +1010,9 @@ R"(#include <stdio.h>
                 break;
             }
             case (ASR::cast_kindType::IntegerToCharacter) : {
-                current_body.clear();
-                const_name += std::to_string(const_list_count);
-                const_list_count += 1;
-                const_name = current_scope->get_unique_name(const_name);
-                std::string indent(indentation_level*indentation_spaces, ' ');
-                current_body += indent + "char* " + const_name + " = (char*) malloc(40 * sizeof(char));\n";
-                current_body += indent + "sprintf(" + const_name + ", \"%d\", " + src + ");\n";
-                src = const_name;
+                ASR::ttype_t* src_type = ASRUtils::expr_type(x.m_arg);
+                int src_kind = ASRUtils::extract_kind_from_ttype_t(src_type);
+                src = "_lfortran_int_to_str" + std::to_string(src_kind) + "(" + src + ")";
                 break ;
             }
             default : throw CodeGenError("Cast kind " + std::to_string(x.m_kind) + " not implemented",