feat: add support for opaque pointer

Author: edimetia3d

pybind11_weaver/entity/entity_base.py

@@ -13,10 +13,10 @@ def _inject_docstring(code: str, cursor: cindex.Cursor, insert_mode: str):
     if not cursor.raw_comment:
         return code
     if insert_mode == "append":
-        code += f',R"({cursor.raw_comment})"'
+        code += f',R"_pb11_weaver({cursor.raw_comment})_pb11_weaver"'
     if insert_mode == "last_arg":
         pos = code.rfind(")")
-        code = code[:pos] + f',R"({cursor.raw_comment})"' + code[pos:]
+        code = code[:pos] + f',R"_pb11_weaver({cursor.raw_comment})_pb11_weaver"' + code[pos:]
     return code
 
 

pybind11_weaver/entity/funktion.py

@@ -26,9 +26,8 @@ def update_stmts(self, pybind11_obj_sym: str) -> List[str]:
         code = []
         targets = [self.cursor] + self.overloads
         for t in targets:
-            fn_pointer_type = fn.get_fn_pointer_type(t)
             code.append(
-                f"{pybind11_obj_sym}.def(\"{self.name}\",static_cast<{fn_pointer_type}>(&{self.qualified_name()}));")
+                f"{pybind11_obj_sym}.def(\"{self.name}\",{fn.get_fn_value_expr(t)});")
             if self.gu.io_config.gen_docstring:
                 code[-1] = entity_base._inject_docstring(code[-1], t, "last_arg")
         return code

pybind11_weaver/entity/klass.py

@@ -36,9 +36,8 @@ def is_static(cursor):
             return cursor.is_static_method()
 
         # to support overload, we will cast member function to function pointer
-        pointer = f"&{scope_full_name}::{cursor.spelling}"
-        method_pointer_type = fn.get_fn_pointer_type(cursor)
-        casted_pointer = f"static_cast<{method_pointer_type}>({pointer})"
+
+        casted_pointer = fn.get_fn_value_expr(cursor)
         if is_static(cursor):
             self.body.append(
                 f"obj.def_static(\"{cursor.spelling}\",{casted_pointer});")
@@ -53,6 +52,15 @@ def is_static(cursor):
                 self.body[-1], cursor, "last_arg")
 
 
+def _is_bindable_type(type: cindex.Type):
+    type = type.get_canonical()
+    if type.kind in [cindex.TypeKind.CONSTANTARRAY, cindex.TypeKind.INCOMPLETEARRAY, cindex.TypeKind.VARIABLEARRAY]:
+        return False
+    if fn.warp_type(type, "")[0] is not None:
+        return False
+    return True
+
+
 class ClassEntity(entity_base.Entity):
 
     def __init__(self, gu: gen_unit.GenUnit, cursor: cindex.Cursor):
@@ -126,7 +134,7 @@ def not_operator(cursor):
         for cursor in self.cursor.get_children():
             if cursor.kind == cindex.CursorKind.FIELD_DECL and \
                     is_pubic(cursor) and \
-                    cursor.type.kind != cindex.TypeKind.CONSTANTARRAY:
+                    _is_bindable_type(cursor.type):
                 filed_binder = "def_readwrite"
                 if cursor.type.is_const_qualified():
                     filed_binder = "def_readonly"

pybind11_weaver/gen_code.py

@@ -5,9 +5,10 @@
 from .entity import entity_base
 from . import entity_tree
 from . import gen_unit
+from .utils import fn
 
 entity_template = """
-
+#ifndef PB11_WEAVER_DISABLE_{entity_struct_name}
 template <class Pybind11T> struct {bind_struct_name} : public EntityBase {{
   using Pybind11Type = Pybind11T;
 
@@ -45,6 +46,7 @@
   {handle_type} handle;
     
 }};
+#endif // PB11_WEAVER_DISABLE_{entity_struct_name}
 """
 
 file_template = """
@@ -67,6 +69,8 @@
 * If the returned guard is not called, the guard will call the update function on its destruction.
 **/
 [[nodiscard]] pybind11_weaver::CallUpdateGuard {decl_fn_name}(pybind11::module & m, const pybind11_weaver::CustomBindingRegistry & registry){{
+{create_warped_pointer_bindings}
+
 {create_entity_var_stmts}
 
     auto update_fn = [=](){{
@@ -147,6 +151,7 @@ def gen_code(config_file: str):
             pybind11_weaver_header=pybind11_weaver_header,
             decl_fn_name=gu.io_config.decl_fn_name,
             entity_struct_decls="\n".join(entity_struct_decls),
+            create_warped_pointer_bindings=gen_wrapped_pointer_code(),
             create_entity_var_stmts="\n".join(create_entity_var_stmts),
             update_entity_var_stmts="\n".join(update_entity_var_stmts),
         )
@@ -156,3 +161,19 @@ def gen_code(config_file: str):
         # format file if clang-format found
         if shutil.which("clang-format") is not None:
             os.system(f"clang-format -i {gu.io_config.output} --style=LLVM")
+
+
+def gen_wrapped_pointer_code():
+    wrapped_types = fn.get_wrapped_types()
+    create_warped_pointer_bindings = []
+    for type in sorted(wrapped_types):
+        wrapped_type_binding_code_template = "pybind11_weaver::PointerWrapper<{type}>::FastBind(m,\"{safe_type_name}\");"
+        safe_type_name = type.replace(" ", "")
+        safe_type_name = safe_type_name.replace(",", "_")
+        safe_type_name = safe_type_name.replace("*", "p")
+        safe_type_name = safe_type_name.replace("(", "6")
+        safe_type_name = safe_type_name.replace(")", "9")
+        create_warped_pointer_bindings.append(
+            wrapped_type_binding_code_template.format(type=type, safe_type_name=safe_type_name))
+    create_warped_pointer_bindings = "\n".join(create_warped_pointer_bindings)
+    return create_warped_pointer_bindings

pybind11_weaver/include/pybind11_weaver/pybind11_weaver.h

@@ -7,6 +7,23 @@
 
 namespace pybind11_weaver {
 
+template <class T> struct PointerWrapper {
+  static_assert(std::is_pointer<T>::value, "T must be a pointer type");
+  T ptr;
+  PointerWrapper(T ptr) : ptr(ptr) {}
+  operator T() { return ptr; }
+  static void FastBind(pybind11::module &m, const std::string &name) {
+    pybind11::class_<PointerWrapper> handle(m, name.c_str());
+    handle.def("get_ptr", [](PointerWrapper &self) {
+      return reinterpret_cast<intptr_t>(self.ptr);
+    });
+    handle.def("set_ptr", [](PointerWrapper &self, intptr_t ptr) {
+      self.ptr = reinterpret_cast<T>(ptr);
+    });
+  }
+};
+
+
 class CallUpdateGuard {
 public:
   using Fn = std::function<void(void)>;

pybind11_weaver/utils/fn.py

@@ -1,19 +1,99 @@
+from typing import List
+
 from clang import cindex
 
 from . import scope_list
 
 
-def fn_arg_type(cursor: cindex.Cursor):
+def fn_arg_type(cursor: cindex.Cursor) -> List[str]:
     return [param.type.get_canonical().spelling for param in cursor.get_arguments()]
 
 
-def fn_ret_type(cursor: cindex.Cursor):
+def fn_ret_type(cursor: cindex.Cursor) -> str:
     return cursor.result_type.get_canonical().spelling
 
 
-def get_fn_pointer_type(cursor: cindex.Cursor):
+def _get_fn_pointer_type(cursor: cindex.Cursor) -> str:
     if cursor.kind == cindex.CursorKind.CXX_METHOD and not cursor.is_static_method():
         const_mark = "const" if cursor.is_const_method() else ""
         return f"{fn_ret_type(cursor)} ({scope_list.get_full_qualified_name(cursor.semantic_parent)}::*)({','.join(fn_arg_type(cursor))}) {const_mark}"
     else:
         return f"{fn_ret_type(cursor)} (*)({','.join(fn_arg_type(cursor))})"
+
+
+def get_fn_pointer(cursor: cindex.Cursor) -> str:
+    pointer = f"&{scope_list.get_full_qualified_name(cursor)}"
+    method_pointer_type = _get_fn_pointer_type(cursor)
+    return f"static_cast<{method_pointer_type}>({pointer})"
+
+
+__wrapped_db = set()
+
+
+def get_wrapped_types():
+    return __wrapped_db
+
+
+def warp_type(type: cindex.Type, param_name: str):
+    type = type.get_canonical()
+    ret = None, param_name
+    if type.kind == cindex.TypeKind.POINTER:
+        pointee = type.get_pointee().get_canonical()
+        # if pointee is a pointer, warp it
+        if pointee.kind in [cindex.TypeKind.POINTER]:
+            ret = f"pybind11_weaver::PointerWrapper<{type.spelling}>", param_name
+        if pointee.kind in [cindex.TypeKind.FUNCTIONPROTO]:
+            ret = f"std::function<{pointee.spelling}>", f"{param_name}.target<{pointee.spelling}>()"
+        # if pointee is a incompelete type, warp it
+        pointee_decl = pointee.get_declaration()
+        if pointee_decl.kind in [cindex.CursorKind.STRUCT_DECL,
+                                 cindex.CursorKind.CLASS_DECL] and not pointee_decl.is_definition():
+            ret = f"pybind11_weaver::PointerWrapper<{type.spelling}>", param_name
+    if ret[0] is not None:
+        __wrapped_db.add(type.spelling)
+    return ret
+
+
+__warpper_template = """[]({params}){{
+    return {ret_expr};
+}}"""
+
+
+def get_fn_wrapper(cursor: cindex.Cursor):
+    params = []
+    if cursor.kind != cindex.CursorKind.FUNCTION_DECL:
+        params.append(f"{cursor.semantic_parent.spelling}& self")
+    args = []
+    warp = False
+    for param in cursor.get_arguments():
+        param_t = param.type.get_canonical()
+        param_spelling = param.spelling
+        if param_spelling == "":
+            param_spelling = "arg" + str(len(args))
+        warp_t, arg_use = warp_type(param_t, param_spelling)
+        if warp_t:
+            warp = True
+            params.append(f"{warp_t} {param_spelling}")
+        else:
+            params.append(f"{param_t.spelling} {param_spelling}")
+        args.append(arg_use)
+    ret_t = cursor.result_type.get_canonical()
+    ret_expr = f"{cursor.spelling}({','.join(args)})"
+    if cursor.kind != cindex.CursorKind.FUNCTION_DECL:
+        ret_expr = f"self.{ret_expr}"
+    warp_t, _ = warp_type(ret_t, "")
+    if warp_t:
+        warp = True
+        ret_expr = f"{warp_t}({ret_expr})"
+    if warp:
+        return __warpper_template.format(params=','.join(params), ret_expr=ret_expr)
+    else:
+        return None
+
+
+def get_fn_value_expr(cursor: cindex.Cursor) -> str:
+    wrapper = get_fn_wrapper(cursor)
+    if wrapper:
+        return wrapper
+    else:
+        return get_fn_pointer(cursor)

pybind11_weaver/utils/scope_list.py

@@ -8,8 +8,10 @@ def get_full_qualified_scopes(cursor: cindex.Cursor):
     if cursor.kind == cindex.CursorKind.TRANSLATION_UNIT:
         return []
     values = []
+    # extern C seems to be a scope with kind of CursorKind.UNEXPOSED_DECL
     cursor = cursor.semantic_parent
-    while cursor is not None and cursor.kind != cindex.CursorKind.TRANSLATION_UNIT:
+    while cursor is not None and cursor.kind not in [cindex.CursorKind.TRANSLATION_UNIT,
+                                                     cindex.CursorKind.UNEXPOSED_DECL]:
         values.append(cursor.spelling)
         cursor = cursor.semantic_parent
     values.reverse()