another set of changes to PDB reader

Author: roman_yakovenko

pygccxml/declarations/class_declaration.py

@@ -275,7 +275,18 @@ def recursive_derived(self):
         return self._recursive_derived
 
     def _get_is_abstract(self):
-        return self._is_abstract
+        if self.compiler == compilers.MSVC_PDB_9:
+            import calldef
+            import matchers #prevent cyclic dependencies
+            m = matchers.virtuality_type_matcher_t( calldef.VIRTUALITY_TYPES.PURE_VIRTUAL )
+            if self.calldefs( m, recursive=False, allow_empty=True ):
+                return True
+            for base in self.recursive_bases:
+                if base.related_class.calldefs( m, recursive=False, allow_empty=True ):
+                    return True
+            return False
+        else:
+            return self._is_abstract
     def _set_is_abstract( self, is_abstract ):
         self._is_abstract = is_abstract
     is_abstract = property( _get_is_abstract, _set_is_abstract

pygccxml/declarations/decl_printer.py

@@ -9,8 +9,9 @@
 
 import os
 import sys
-import decl_visitor
+import calldef
 import algorithm
+import decl_visitor
 
 
 class decl_printer_t( decl_visitor.decl_visitor_t ):
@@ -33,7 +34,7 @@ def __init__( self, level=0, print_details=True, recursive=True, writer=None ):
         self.__recursive = recursive
         self.__writer = writer
         if not self.__writer:
-            self.__writer = sys.stdout.write
+            self.__writer = lambda x: sys.stdout.write( x + os.linesep )
 
     def clone(self, increment_level=True):
         level = self.__level
@@ -83,20 +84,27 @@ def __nice_decl_name( self, inst ):
 
     def print_decl_header(self):
         header = self.__nice_decl_name( self.__inst ) + ": '%s'" % self.__inst.name
-        self.writer( ' ' * self.level * self.INDENT_SIZE + header.ljust( self.JUSTIFY ) + os.linesep )
+        self.writer( ' ' * self.level * self.INDENT_SIZE + header.ljust( self.JUSTIFY ))
         if self.__print_details:
             curr_level = self.level + 1
             if self.__inst.location:
                 location = 'location: [%s]:%s'%(self.__inst.location.file_name, self.__inst.location.line)
-                self.writer( ' ' * curr_level * self.INDENT_SIZE + location + os.linesep )
+                self.writer( ' ' * curr_level * self.INDENT_SIZE + location)
             artificial = 'artificial: ' + "'%s'" % str(self.__inst.is_artificial)
-            self.writer( ' ' * curr_level * self.INDENT_SIZE + artificial.ljust( self.JUSTIFY ) + os.linesep )
+            self.writer( ' ' * curr_level * self.INDENT_SIZE + artificial.ljust( self.JUSTIFY ))
             if self.__inst.attributes:
                 attributes = 'attributes: %s'%(self.__inst.attributes)
-                self.writer( ' ' * curr_level * self.INDENT_SIZE + attributes + os.linesep )
+                self.writer( ' ' * curr_level * self.INDENT_SIZE + attributes)
+            if self.__inst.demangled:
+                demangled = 'demangled: %s'%(self.__inst.demangled)
+                self.writer( ' ' * curr_level * self.INDENT_SIZE + demangled)
+            if self.__inst.mangled:
+                mangled = 'mangled: %s'%(self.__inst.mangled)
+                self.writer( ' ' * curr_level * self.INDENT_SIZE + mangled)
+
 
 
-    def __get_method_signature(self, decl=None):
+    def print_calldef_info(self, decl=None):
         """ Returns function signature: [retval, [arg1, ..., argN]]. """
         if None is decl:
             decl = self.__inst
@@ -106,46 +114,45 @@ def __get_method_signature(self, decl=None):
             retval = decl.return_type.decl_string
         args = []
         for arg in decl.arguments:
-            args.append(arg.type.decl_string)
-        return [retval, args]
+            args.append(arg.type.decl_string + ' ' + arg.name)
+        indent = ' ' * (self.level+1) * self.INDENT_SIZE
+        self.writer( indent + "return type: " + str(retval) )
+        self.writer( indent + "arguments type: " + ', '.join(args))
+        if isinstance( decl, calldef.member_calldef_t ):
+            self.writer( indent + "virtual: " + str(decl.virtuality))
+            self.writer( indent + "is const: " + str(decl.has_const))
+            self.writer( indent + "is static: " + str(decl.has_static))
 
     def visit_member_function( self ):
         self.print_decl_header()
-        self.writer(  ' ' * (self.level+1) * self.INDENT_SIZE
-                        + "Signature: " + str( self.__get_method_signature() ) + os.linesep )
+        self.print_calldef_info()
 
     def visit_constructor( self ):
         self.print_decl_header()
-        self.writer(  ' ' * (self.level+1) * self.INDENT_SIZE
-                        + "Signature: " + str( self.__get_method_signature() ) + os.linesep )
+        self.print_calldef_info()
 
         if self.__print_details:
             self.writer( ' ' * ( self.level + 1 ) * self.INDENT_SIZE
-                         + 'copy constructor: ' + str(self.__inst.is_copy_constructor)
-                         + os.linesep )
+                         + 'copy constructor: ' + str(self.__inst.is_copy_constructor) )
 
     def visit_destructor( self ):
         self.print_decl_header()
 
     def visit_member_operator( self ):
         self.print_decl_header()
-        self.writer(  ' ' * (self.level+1) * self.INDENT_SIZE
-                        + "Signature: " + str( self.__get_method_signature() ) + os.linesep )
+        self.print_calldef_info()
 
     def visit_casting_operator( self ):
         self.print_decl_header()
-        self.writer(  ' ' * (self.level+1) * self.INDENT_SIZE
-                        + "Signature: " + str( self.__get_method_signature() ) + os.linesep )
+        self.print_calldef_info()
 
     def visit_free_function( self ):
         self.print_decl_header()
-        self.writer(  ' ' * (self.level+1) * self.INDENT_SIZE
-                        + "Signature: " + str( self.__get_method_signature() ) + os.linesep )
+        self.print_calldef_info()
 
     def visit_free_operator( self ):
         self.print_decl_header()
-        self.writer(  ' ' * (self.level+1) * self.INDENT_SIZE
-                        + "Signature: " + str( self.__get_method_signature() ) + os.linesep )
+        self.print_calldef_info()
 
     def visit_class_declaration(self ):
         self.print_decl_header()
@@ -154,35 +161,35 @@ def visit_class(self ):
         self.print_decl_header()
         curr_level = self.level + 1
         class_type = 'class type: ' + "'%s'" % str(self.__inst.class_type)
-        self.writer( ' ' * curr_level * self.INDENT_SIZE + class_type.ljust( self.JUSTIFY ) + os.linesep )
+        self.writer( ' ' * curr_level * self.INDENT_SIZE + class_type.ljust( self.JUSTIFY ))
         if self.__print_details:
             byte_size = 'size: %d'%(self.__inst.byte_size)
-            self.writer( ' ' * curr_level * self.INDENT_SIZE + byte_size.ljust( self.JUSTIFY ) + os.linesep )
+            self.writer( ' ' * curr_level * self.INDENT_SIZE + byte_size.ljust( self.JUSTIFY ))
             try:
                 byte_align = 'align: %d'%(self.__inst.byte_align)
-                self.writer( ' ' * curr_level * self.INDENT_SIZE + byte_align.ljust( self.JUSTIFY ) + os.linesep )
+                self.writer( ' ' * curr_level * self.INDENT_SIZE + byte_align.ljust( self.JUSTIFY ))
             except NotImplementedError:
-                self.writer( ' ' * curr_level * self.INDENT_SIZE + "align: not implemented".ljust( self.JUSTIFY ) + os.linesep )
+                self.writer( ' ' * curr_level * self.INDENT_SIZE + "align: not implemented".ljust( self.JUSTIFY ))
 
         if self.__inst.aliases:
             aliases = map( lambda typedef: typedef.name, self.__inst.aliases )
             msg = 'aliases: ' + `aliases`
-            self.writer( ' ' * curr_level * self.INDENT_SIZE + msg.ljust( self.JUSTIFY ) + os.linesep )
+            self.writer( ' ' * curr_level * self.INDENT_SIZE + msg.ljust( self.JUSTIFY ))
 
         def print_hierarchy(hierarchy_type, classes, curr_level):
-            self.writer( ' ' * curr_level * self.INDENT_SIZE + hierarchy_type.ljust( self.JUSTIFY ) + os.linesep )
+            self.writer( ' ' * curr_level * self.INDENT_SIZE + hierarchy_type.ljust( self.JUSTIFY ))
             curr_level += 1
             for class_ in classes:
                 class_str = 'class: ' + "'%s'" % str(class_.related_class.decl_string)
-                self.writer( ' ' * curr_level * self.INDENT_SIZE + class_str.ljust( self.JUSTIFY ) + os.linesep )
+                self.writer( ' ' * curr_level * self.INDENT_SIZE + class_str.ljust( self.JUSTIFY ))
                 access = 'access type: ' + "'%s'" % str(class_.access)
-                self.writer( ' ' * (curr_level + 1)* self.INDENT_SIZE + access.ljust( self.JUSTIFY ) + os.linesep )
+                self.writer( ' ' * (curr_level + 1)* self.INDENT_SIZE + access.ljust( self.JUSTIFY ))
                 if not ( None is class_.is_virtual ):
                     is_virtual = 'virtual inheritance: ' + "'%s'" % str(class_.is_virtual)
-                    self.writer( ' ' * (curr_level + 1)* self.INDENT_SIZE + is_virtual.ljust( self.JUSTIFY ) + os.linesep )
+                    self.writer( ' ' * (curr_level + 1)* self.INDENT_SIZE + is_virtual.ljust( self.JUSTIFY ))
 
         def print_members(members_type, members, curr_level):
-            self.writer( ' ' * curr_level * self.INDENT_SIZE + members_type.ljust( self.JUSTIFY ) + os.linesep )
+            self.writer( ' ' * curr_level * self.INDENT_SIZE + members_type.ljust( self.JUSTIFY ))
             if self.__recursive:
                curr_level += 1
                for member in members:
@@ -207,7 +214,7 @@ def visit_enumeration(self):
         value_level = ' ' * ( curr_level + 1 )* self.INDENT_SIZE
         self.writer( os.linesep )
         for name, value in self.__inst.values:
-            self.writer( value_level + "%s : %s"% (name, value) + os.linesep )
+            self.writer( value_level + "%s : %s"% (name, value))
 
     def visit_namespace(self ):
         self.print_decl_header()
@@ -220,24 +227,24 @@ def visit_namespace(self ):
     def visit_typedef(self ):
         self.print_decl_header()
         curr_level = self.level + 1
-        self.writer( ' ' * curr_level * self.INDENT_SIZE + 'alias to: ' + self.__inst.type.decl_string + os.linesep )
+        self.writer( ' ' * curr_level * self.INDENT_SIZE + 'alias to: ' + self.__inst.type.decl_string)
 
     def visit_variable(self ):
         self.print_decl_header()
         curr_level = self.level + 1
         self.writer( ' ' * curr_level * self.INDENT_SIZE + 'type: %s  value: %s'%(self.__inst.type.decl_string, self.__inst.value)  + os.linesep)
         if self.__print_details:
             byte_size = 'size: %d'%(self.__inst.type.byte_size)
-            self.writer( ' ' * curr_level * self.INDENT_SIZE + byte_size.ljust( self.JUSTIFY ) + os.linesep )
+            self.writer( ' ' * curr_level * self.INDENT_SIZE + byte_size.ljust( self.JUSTIFY ))
             try:
                 byte_align = 'align: %d'%(self.__inst.type.byte_align)
-                self.writer( ' ' * curr_level * self.INDENT_SIZE + byte_align.ljust( self.JUSTIFY ) + os.linesep )
+                self.writer( ' ' * curr_level * self.INDENT_SIZE + byte_align.ljust( self.JUSTIFY ))
             except NotImplementedError:
-                self.writer( ' ' * curr_level * self.INDENT_SIZE + "align: not implemented".ljust( self.JUSTIFY ) + os.linesep )
+                self.writer( ' ' * curr_level * self.INDENT_SIZE + "align: not implemented".ljust( self.JUSTIFY ))
             byte_offset = 'offset: %d'%(self.__inst.byte_offset)
             self.writer( ' ' * curr_level * self.INDENT_SIZE + byte_offset + os.linesep)
 
-def print_declarations( decls, detailed=True, recursive=True, writer=sys.stdout.write ):
+def print_declarations( decls, detailed=True, recursive=True, writer=lambda x: sys.stdout.write( x + os.linesep ) ):
     """ Print decl tree rooted at each of the included nodes.
         decls - either a single decl or a list of decls.
     """

pygccxml/msvc/pdb/loader.py

@@ -178,6 +178,8 @@ def ns_filter( smbl ):
         self.logger.debug( 'scanning symbols table - done' )
 
     def __update_decls_tree( self, decl ):
+        #~ if decl.name == 'money_base' and isinstance( decl, declarations.class_t ):
+            #~ pdb.set_trace()
         smbl = decl.dia_symbols[0]
         if smbl.classParentId in self.__id2decl:
             self.__adopt_declaration( self.__id2decl[smbl.classParentId], decl )
@@ -208,16 +210,16 @@ def __adopt_declaration( self, parent, decl ):
             self.__id2decl[ smbl.symIndexId ] = decl
         else:
             for other_decl in already_added:
-                for other_smbl in other_decl.dia_symbols:
-                    if self.__are_symbols_equivalent( other_smbl, smbl ):
-                        other_decl.dia_symbols.append( smbl )
-                        self.__id2decl[ smbl.symIndexId ] = other_decl
-                        return
+                if self.__is_same_smbls( other_decl, decl ):
+                    other_decl.dia_symbols.append( smbl )
+                    self.__id2decl[ smbl.symIndexId ] = other_decl
+                    return
             else:
                 if isinstance( parent, declarations.namespace_t ):
                     parent.adopt_declaration( decl )
                 else:
                     parent.adopt_declaration( decl, self.__guess_access_type( smbl )  )
+                self.__id2decl[ smbl.symIndexId ] = decl
 
     def __guess_access_type( self, smbl ):
         if enums.CV_access_e.CV_private == smbl.access:
@@ -327,16 +329,18 @@ def dia_global_scope(self):
     def global_ns(self):
         return self.__global_ns
 
-    def __are_symbols_equivalent( self, smbl1, smbl2 ):
-        result = smbl1.symTag == smbl2.symTag and smbl1.uname == smbl2.uname
-        if not result:
-            result = self.__dia_session.symsAreEquiv( smbl1, smbl2 )
-        if result:
-            msg = 'Symbols "%s(%d)" and  "%s(%d)" are equivalent.'
+    def __is_same_smbls( self, decl1, decl2 ):
+        if not( decl1.__class__ is decl2.__class__ ):
+            return False
+        if decl1.name == decl2.name:
+            if isinstance( decl1, declarations.calldef_t ):
+                #TODO: well, I will have to fix this someday
+                return False
+            else:
+                return True
         else:
-            msg = 'Symbols "%s(%d)" and  "%s(%d)" are NOT equivalent.'
-        self.logger.debug( msg, smbl1.uname, smbl1.symIndexId, smbl2.uname, smbl2.symIndexId )
-        return result
+            return False
+            #~ return self.__dia_session.symsAreEquiv( decl1.dia_symbols[0], decl2.dia_symbols[0] )
 
     def __find_udt( self, name ):
         self.logger.debug( 'testing whether name( "%s" ) is UDT symbol' % name )
@@ -530,6 +534,8 @@ def __guess_constructor( self, smbl, calldef_type ):
 
     def __create_calldef( self, smbl ):
         self.logger.debug( 'creating calldef "%s"', smbl.uname )
+        #~ if smbl.uname == 'some_function':
+            #~ pdb.set_trace()
         name_splitter = impl_details.get_name_splitter( smbl.uname )
         calldef_type = self.create_type( smbl.type ) #what does happen with constructor?
         decl = None
@@ -542,6 +548,10 @@ def __create_calldef( self, smbl ):
                 decl = self.__guess_constructor( smbl, calldef_type )
             if not decl:
                 decl = declarations.member_function_t()
+            if smbl.virtual:
+                decl.virtuality = iif( smbl.pure
+                                       , declarations.VIRTUALITY_TYPES.PURE_VIRTUAL
+                                       , declarations.VIRTUALITY_TYPES.VIRTUAL )
         else:
             decl = self.__guess_operator_type(smbl, calldef_type)
             if not decl:

unittests/data/core_types.hpp

@@ -51,7 +51,12 @@ typedef int (*function_ptr)(int, double);
 struct exception{};
 
 struct members_pointers_t{
-    int some_function( double ) const throw( exception );
+	int some_function( double hi, int i ){
+		return 0;
+	}
+	int some_function( double hi) const throw( exception ){
+		return 0;
+	};
     int m_some_const_member;
     int xxx;
 };

unittests/data/msvc_build/all.cpp

@@ -93,6 +93,10 @@ void use_core_types(){
 	core::types::function_ptr function_ptr_ = 0;
 	core::types::member_function_ptr_t member_function_ptr_ = 0;
 
+	core::types::members_pointers_t members_pointers_inst;
+	members_pointers_inst.some_function( 0.23 );
+	members_pointers_inst.some_function( 0.23, 11 );
+
 }
 
 void use_core_ns_join_3(){