BindPython ABI

integration_tests/CMakeLists.txt

@@ -660,7 +660,7 @@ RUN(NAME bindc_05   LABELS llvm c
         EXTRAFILES bindc_05b.c)
 RUN(NAME bindc_06   LABELS llvm c
         EXTRAFILES bindc_06b.c)
-RUN(NAME bindpy_01           LABELS cpython c_py EXTRA_ARGS --enable-cpython NOFAST COPY_TO_BIN bindpy_01_module.py)
+RUN(NAME bindpy_01           LABELS cpython llvm_py c_py EXTRA_ARGS --enable-cpython NOFAST COPY_TO_BIN bindpy_01_module.py)
 RUN(NAME bindpy_02           LABELS cpython c_py EXTRA_ARGS --link-numpy COPY_TO_BIN bindpy_02_module.py)
 RUN(NAME bindpy_03           LABELS cpython c_py EXTRA_ARGS --link-numpy NOFAST COPY_TO_BIN bindpy_03_module.py)
 RUN(NAME bindpy_04           LABELS cpython c_py EXTRA_ARGS --link-numpy NOFAST COPY_TO_BIN bindpy_04_module.py)

src/bin/lpython.cpp

@@ -321,6 +321,7 @@ int emit_c(const std::string &infile,
     pass_manager.use_default_passes(true);
     compiler_options.po.always_run = true;
     compiler_options.po.run_fun = "f";
+    compiler_options.po.c_backend = true;
 
     pass_manager.apply_passes(al, asr, compiler_options.po, diagnostics);
 

src/libasr/CMakeLists.txt

@@ -37,6 +37,7 @@ set(SRC
     pass/for_all.cpp
     pass/while_else.cpp
     pass/global_stmts.cpp
+    pass/python_bind.cpp
     pass/select_case.cpp
     pass/init_expr.cpp
     pass/implied_do_loops.cpp

src/libasr/pass/pass_manager.h

@@ -54,6 +54,7 @@
 #include <libasr/pass/replace_print_struct_type.h>
 #include <libasr/pass/promote_allocatable_to_nonallocatable.h>
 #include <libasr/pass/replace_function_call_in_declaration.h>
+#include <libasr/pass/python_bind.h>
 #include <libasr/codegen/asr_to_fortran.h>
 #include <libasr/asr_verify.h>
 #include <libasr/pickle.h>
@@ -79,6 +80,7 @@ namespace LCompilers {
             {"do_loops", &pass_replace_do_loops},
             {"while_else", &pass_while_else},
             {"global_stmts", &pass_wrap_global_stmts},
+            {"python_bind", &pass_python_bind},
             {"implied_do_loops", &pass_replace_implied_do_loops},
             {"array_op", &pass_replace_array_op},
             {"symbolic", &pass_replace_symbolic},
@@ -206,6 +208,7 @@ namespace LCompilers {
         PassManager(): apply_default_passes{false},
             c_skip_pass{false} {
             _passes = {
+                "python_bind",
                 "nested_vars",
                 "global_stmts",
                 "transform_optional_argument_functions",

src/libasr/pass/python_bind.h

@@ -0,0 +1,14 @@
+#ifndef LIBASR_PASS_PYTHON_BIND_H
+#define LIBASR_PASS_PYTHON_BIND_H
+
+#include <libasr/asr.h>
+#include <libasr/utils.h>
+
+namespace LCompilers {
+
+    void pass_python_bind(Allocator &al, ASR::TranslationUnit_t &unit,
+                                const PassOptions &pass_options);
+
+} // namespace LCompilers
+
+#endif // LIBASR_PASS_PYTHON_BIND_H

src/libasr/utils.h

@@ -59,6 +59,7 @@ struct PassOptions {
     bool tree = false;
     bool with_intrinsic_mods = false;
     bool c_mangling = false;
+    bool c_backend = false;
 };
 
 struct CompilerOptions {

src/lpython/semantics/python_ast_to_asr.cpp

@@ -4248,6 +4248,7 @@ class SymbolTableVisitor : public CommonVisitor<SymbolTableVisitor> {
     bool is_interface = false;
     std::string interface_name = "";
     bool is_derived_type = false;
+    bool contains_bindpython = false;
     std::vector<std::string> current_procedure_args;
     ASR::abiType current_procedure_abi_type = ASR::abiType::Source;
     std::map<SymbolTable*, ASR::accessType> assgn;
@@ -4428,6 +4429,55 @@ class SymbolTableVisitor : public CommonVisitor<SymbolTableVisitor> {
         //Implemented in BodyVisitor
     }
 
+    void import_cpython(const AST::FunctionDef_t &x, SymbolTable *parent_scope) {
+        std::vector<std::string> pybind_funcs = {
+            "Py_Initialize",
+            "Py_IsInitialized", 
+            "PyRun_SimpleString", 
+            "Py_DecodeLocale", 
+            "PySys_SetArgv", 
+            "Py_FinalizeEx",
+            "PyUnicode_FromString",
+            "PyUnicode_AsUTF8AndSize",
+            "PyImport_Import",
+            "Py_DecRef",
+            "Py_IncRef",
+            "PyObject_GetAttrString",
+            "PyTuple_New",
+            "PyTuple_SetItem",
+            "PyObject_CallObject",
+            "PyLong_AsLongLong",
+            "PyLong_AsUnsignedLongLong",
+            "PyLong_FromLongLong",
+            "PyLong_FromUnsignedLongLong",
+            "PyFloat_FromDouble",
+            "PyFloat_AsDouble",
+            "PyBool_FromLong",
+            "PyObject_IsTrue",
+        };
+        Str s;
+        AST::alias_t *module_symbols =
+            al.allocate<AST::alias_t>(pybind_funcs.size());
+
+        for (size_t i = 0; i < pybind_funcs.size(); i++) {
+            s.from_str(al, pybind_funcs.at(i));
+            (module_symbols + i)->loc = x.base.base.loc;
+            (module_symbols + i)->m_name = s.c_str(al);
+            (module_symbols + i)->m_asname = nullptr;
+        }
+
+        AST::ImportFrom_t *imports =
+            (AST::ImportFrom_t*)AST::make_ImportFrom_t(
+                al, x.base.base.loc,
+                (char*)"cpython_bindings", module_symbols,
+                pybind_funcs.size(), 0);
+
+        SymbolTable *function_scope = current_scope;
+        current_scope = parent_scope;
+        visit_ImportFrom(*imports);
+        current_scope = function_scope;
+    }
+
     void visit_FunctionDef(const AST::FunctionDef_t &x) {
         dependencies.clear(al);
         SymbolTable *parent_scope = current_scope;
@@ -4489,6 +4539,13 @@ class SymbolTableVisitor : public CommonVisitor<SymbolTableVisitor> {
                             current_procedure_abi_type = ASR::abiType::BindPython;
                             current_procedure_interface = true;
                             module_file = extract_keyword_val_from_decorator(call_d, "module");
+
+                            if (!contains_bindpython) {
+
+                                import_cpython(x, parent_scope);
+                            }
+                            contains_bindpython = true;
+
                         } else {
                             throw SemanticError("Unsupported Decorator type",
                                     x.base.base.loc);

src/runtime/cpython_bindings.py

@@ -0,0 +1,93 @@
+from lpython import ccall, Pointer, i32, i64, u64, f64, empty_c_void_p, CPtr, pointer
+
+@ccall(header="Python.h")
+def Py_Initialize():
+    pass
+
+@ccall(header="Python.h")
+def Py_IsInitialized() -> i32:
+    pass
+
+@ccall(header="Python.h")
+def PyRun_SimpleString(s: str) -> i32:
+    pass
+
+@ccall(header="Python.h")
+def Py_DecodeLocale(s: str, p: CPtr) -> CPtr:
+    pass
+
+@ccall(header="Python.h")
+def PySys_SetArgv(n: i32, args: Pointer[CPtr]):
+    pass
+
+@ccall(header="Python.h")
+def Py_FinalizeEx() -> i32:
+    pass
+
+@ccall(header="Python.h")
+def PyUnicode_FromString(s: str) -> CPtr:
+    pass
+
+@ccall(header="Python.h")
+def PyUnicode_AsUTF8AndSize(s: CPtr, l: CPtr) -> str:
+    pass
+
+@ccall(header="Python.h")
+def PyImport_Import(name: CPtr) -> CPtr:
+    pass
+
+@ccall(header="Python.h")
+def Py_DecRef(name: CPtr):
+    pass
+
+@ccall(header="Python.h")
+def Py_IncRef(name: CPtr):
+    pass
+
+@ccall(header="Python.h")
+def PyObject_GetAttrString(m: CPtr, s: str) -> CPtr:
+    pass
+
+@ccall(header="Python.h")
+def PyTuple_New(n: i32) -> CPtr:
+    pass
+
+@ccall(header="Python.h")
+def PyTuple_SetItem(t: CPtr, p: i32, o: CPtr) -> i32:
+    pass
+
+@ccall(header="Python.h")
+def PyObject_CallObject(a: CPtr, b: CPtr) -> CPtr:
+    pass
+
+@ccall(header="Python.h")
+def PyLong_AsLongLong(a: CPtr) -> i64:
+    pass
+
+@ccall(header="Python.h")
+def PyLong_AsUnsignedLongLong(a: CPtr) -> u64:
+    pass
+
+@ccall(header="Python.h")
+def PyLong_FromLongLong(a: i64) -> CPtr:
+    pass
+
+@ccall(header="Python.h")
+def PyLong_FromUnsignedLongLong(a: u64) -> CPtr:
+    pass
+
+@ccall(header="Python.h")
+def PyFloat_FromDouble(a: f64) -> CPtr:
+    pass
+
+@ccall(header="Python.h")
+def PyFloat_AsDouble(a: CPtr) -> f64:
+    pass
+
+@ccall(header="Python.h")
+def PyBool_FromLong(a: i32) -> CPtr:
+    pass
+
+@ccall(header="Python.h")
+def PyObject_IsTrue(a: CPtr) -> i32:
+    pass