First pass at CPP support, thanks to #99

Author: trolldbois

ctypeslib/codegen/cursorhandler.py

@@ -96,6 +96,11 @@ def INIT_LIST_EXPR(self, cursor):
     # now fixed by TranslationUnit.PARSE_SKIP_FUNCTION_BODIES
     COMPOUND_STMT = ClangHandler._do_nothing
 
+    @log_entity
+    def NAMESPACE(self, cursor):
+        for child in cursor.get_children():
+            self.parse_cursor(child)  # FIXME, where is the starElement
+
     ################################
     # TYPE REFERENCES handlers
 
@@ -627,9 +632,12 @@ def _record_decl(self, cursor, _output_type, num=None):
                 '_record_decl: %s is already registered with members',
                 name)
             return self.get_registered(name)
-        # FIXME: lets ignore bases for now.
-        # bases = attrs.get("bases", "").split() # that for cpp ?
-        bases = []  # FIXME: support CXX
+        # CPP bases
+        bases = []
+        for c in cursor.get_children():
+            if c.kind == CursorKind.CXX_BASE_SPECIFIER:
+                bases.append(self.get_registered(self.get_unique_name(c)))
+                log.debug("got base class %s", c.displayname)
         size = cursor.type.get_size()
         align = cursor.type.get_align()
         if size == -2: #

ctypeslib/codegen/handler.py

@@ -126,13 +126,14 @@ def _make_unknown_name(self, cursor, field_name):
 
     def get_unique_name(self, cursor, field_name=None):
         """get the spelling or create a unique name for a cursor"""
-        name = ''
         if cursor.kind in [CursorKind.UNEXPOSED_DECL]:
             return ''
         # covers most cases
         name = cursor.spelling
+        if cursor.kind == CursorKind.CXX_BASE_SPECIFIER:
+            name = cursor.type.spelling
         # if it's a record decl or field decl and its type is anonymous
-        if cursor.spelling == '':
+        if name == '':
             # if cursor.is_anonymous():
             # a unnamed object at the root TU
             if (cursor.semantic_parent
@@ -149,11 +150,13 @@ def get_unique_name(self, cursor, field_name=None):
                 #code.interact(local=locals())
                 return ''
         if cursor.kind in [CursorKind.STRUCT_DECL,CursorKind.UNION_DECL,
-                                 CursorKind.CLASS_DECL]:
+                                 CursorKind.CLASS_DECL, CursorKind.CXX_BASE_SPECIFIER]:
             names= {CursorKind.STRUCT_DECL: 'struct',
                     CursorKind.UNION_DECL: 'union',
                     CursorKind.CLASS_DECL: 'class',
-                    CursorKind.TYPE_REF: ''}
+                    CursorKind.TYPE_REF: '',
+                    CursorKind.CXX_BASE_SPECIFIER: 'class'
+                    }
             name = '%s_%s'%(names[cursor.kind],name)
         log.debug('get_unique_name: name "%s"',name)
         return name

test/data/test-cpp.cpp

@@ -0,0 +1,38 @@
+// sample from Stackoverflow
+// #include "test-cpp-inherit.h"
+
+namespace MySpace {
+
+struct Simple {
+    int i;
+};
+
+class Classy {
+    public:
+    float f;
+    void myMethod() {  // Method/function defined inside the class
+      cout << "Hello World!";
+    }
+    private:
+    long line;
+};
+
+}
+
+class Base {
+
+private:
+  int MyPrivateInt;
+protected:
+  int MyProtectedInt;
+public:
+  int MyPublicInt;
+};
+
+class Extended : Base
+{
+public:
+    Extended();
+    int MyInt;
+    virtual void method() const;
+};

test/test_record.py

@@ -286,26 +286,23 @@ def test_record_named_union(self):
 ''')
         # print(self.text_output)
         self.assertIn('struct_s', self.namespace)
-        self.assertHasFieldNamed('i', self.namespace.struct_s)
+        self.assertHasFieldNamed(self.namespace.struct_s, 'i')
         # we named the unamed anonymous union. .. maybe not the best idea
-        self.assertHasFieldNamed('_0', self.namespace.struct_s)
+        self.assertHasFieldNamed(self.namespace.struct_s, '_0')
         self.assertIn('union_s_0', self.namespace)
         # python ctypes properly merges anonymous union and exposes members
-        self.assertTrue(hasattr(self.namespace.struct_s, 'f1'))
-        self.assertTrue(hasattr(self.namespace.struct_s, 'l1'))
-        # but not as a field
-        self.assertNotHasFieldNamed('f1', self.namespace.struct_s)
-        self.assertNotHasFieldNamed('l1', self.namespace.struct_s)
+        self.assertHasFieldNamed(self.namespace.struct_s, 'f1')
+        self.assertHasFieldNamed(self.namespace.struct_s, 'l1')
         # and not for unamed anonymous union
-        self.assertNotHasFieldNamed('l2', self.namespace.struct_s)
-        self.assertNotHasFieldNamed('f2', self.namespace.struct_s)
+        self.assertNotHasFieldNamed(self.namespace.struct_s, 'l2')
+        self.assertNotHasFieldNamed(self.namespace.struct_s, 'f2')
         # and we have a named union
-        self.assertHasFieldNamed('u', self.namespace.struct_s)
+        self.assertHasFieldNamed(self.namespace.struct_s, 'u')
         # Issue #117
         self.assertNotIn('union_s_1', self.namespace)
         self.assertIn('union_s_u', self.namespace)
-        self.assertHasFieldNamed('l2', self.namespace.union_s_u)
-        self.assertHasFieldNamed('f2', self.namespace.union_s_u)
+        self.assertHasFieldNamed(self.namespace.union_s_u, 'l2')
+        self.assertHasFieldNamed(self.namespace.union_s_u, 'f2')
 
 
 if __name__ == "__main__":

test/util.py

@@ -161,23 +161,17 @@ def assertOffsets(self, name):
                                  name, membername, _c_offset, _p_offset, self.parser.flags))
         return
 
-    def assertHasFieldNamed(self, name, py_record):
+    def assertHasFieldNamed(self, py_record, name):
         """ Check that a Py record has a field named name.
         """
         self.assertTrue(hasattr(py_record, '_fields_'))
-        for field_desc in py_record._fields_:
-            if name == field_desc[0]:
-                self.assertTrue(name, field_desc[0])
-                return
-        self.fail(f"no such field name {name}")
+        self.assertTrue(hasattr(py_record, name), f"no such field name {name} on {py_record}")
 
-    def assertNotHasFieldNamed(self, name, py_record):
+    def assertNotHasFieldNamed(self, py_record, name):
         """ Check that a Py record does not have a field named name.
         """
         self.assertTrue(hasattr(py_record, '_fields_'))
-        for field_desc in py_record._fields_:
-            if name == field_desc[0]:
-                self.fail(f"Field named {name} found in record")
+        self.assertFalse(hasattr(py_record, name), f"Field named {name} found in record")
 
 
 def clang2py(args):