misc. fixes from https://launchpad.net/pygccxml

Author: mamoll

pygccxml/binary_parsers/parsers.py

@@ -139,7 +139,7 @@ def __init__( self, global_ns, map_file_path ):
 
     def load_symbols( self ):
         """returns dictionary { decorated symbol : original declaration name }"""
-        f = file( self.binary_file )
+        f = open( self.binary_file )
         lines = []
         was_exports = False
         for line in f:
@@ -154,7 +154,7 @@ def load_symbols( self ):
         result = []
         while index < len( lines ):
             line = lines[index].rstrip()
-            found = self.cpp_entry.match( line )
+            found = self.cpp_entry.match( line.decode('ascii') )
             if found:
                 result.append( ( found.group( 'decorated' ), found.group( 'undecorated' ) ) )
             elif index + 1 < len( lines ):

pygccxml/declarations/calldef.py

@@ -21,8 +21,8 @@
 from . import algorithm
 from . import templates
 from . import declaration
-# circular import
-#from . import type_traits
+#from . import type_traits # moved below to fix a cyclic dependency problem
+type_traits = None
 from . import dependencies
 from . import call_invocation
 
@@ -104,6 +104,12 @@ def __eq__(self, other):
                and self.default_value == other.default_value \
                and self.type == other.type
 
+    def __hash__(self, other):
+        return (hash(self.__class__) ^
+                hash(self.name) ^
+                hash(self.default_value) ^
+                hash(self.type))
+
     def __ne__( self, other):
         return not self.__eq__( other )
 
@@ -155,6 +161,11 @@ def _set_attributes( self, attributes ):
 class calldef_t( declaration.declaration_t ):
     """base class for all "callable" declarations"""
     def __init__( self, name='', arguments=None, exceptions=None, return_type=None, has_extern=False, does_throw=True ):
+        # moved here to fix a cyclic dependency problem
+        from . import type_traits as tt
+        global type_traits
+        type_traits = tt
+
         declaration.declaration_t.__init__( self, name )
         if not arguments:
             arguments = []
@@ -195,6 +206,11 @@ def __eq__(self, other):
                and self._sorted_list( self.exceptions ) == other._sorted_list( other.exceptions ) \
                and self.demangled_name == other.demangled_name
 
+    def __hash__(self):
+        return (super.__hash__(self) ^
+                hash(self.return_type) ^
+                hash(self.demangled_name))
+
     def _get_arguments(self):
         return self._arguments
     def _set_arguments(self, arguments):
@@ -296,7 +312,6 @@ def __remove_parent_fname( self, demangled ):
         return demangled
 
     def _get_demangled_name( self ):
-        from . import type_traits
         if not self.demangled:
             self._demangled_name = ''
 
@@ -424,6 +439,8 @@ def __eq__(self, other):
                and self.has_static == other.has_static \
                and self.has_const == other.has_const
 
+    def __hash__(self): return super.__hash__(self)
+
     def get_virtuality(self):
         return self._virtuality
     def set_virtuality(self, virtuality):
@@ -576,7 +593,6 @@ def __str__(self):
     @property
     def is_copy_constructor(self):
         """returns True if described declaration is copy constructor, otherwise False"""
-        from . import type_traits
         args = self.arguments
         if 1 != len( args ):
             return False
@@ -618,9 +634,6 @@ class free_function_t( free_calldef_t ):
     def __init__( self, *args, **keywords ):
         free_calldef_t.__init__( self, *args, **keywords )
 
-    def __hash__(self):
-        return hash(self.get_mangled_name())
-
     def get_mangled_name( self ):
         if not self._mangled and not self._demangled \
            and not '<' in self.name and not self.overloads:
@@ -640,7 +653,6 @@ def __init__( self, *args, **keywords ):
     @property
     def class_types( self ):
         """list of class/class declaration types, extracted from the operator arguments"""
-        from . import type_traits
         if None is self.__class_types:
             self.__class_types = []
             for type_ in self.argument_types:

pygccxml/declarations/class_declaration.py

@@ -67,6 +67,9 @@ def __eq__(self, other):
                and self.access == other.access \
                and self.is_virtual == other.is_virtual
 
+    def __hash__(self):
+        return hash(algorithm.declaration_path(self.related_class))
+
     def __ne__( self, other):
         return not self.__eq__( other )
 
@@ -224,6 +227,9 @@ def __eq__(self, other):
                and self._sorted_list( self.protected_members ) \
                    == self._sorted_list( other.protected_members )
 
+    def __hash__(self):
+        return hash(self.class_type)
+
     def _get_class_type(self):
         return self._class_type
     def _set_class_type( self, new_class_type):

pygccxml/declarations/cpptypes.py

@@ -30,6 +30,9 @@ def __eq__(self, other):
             return False
         return self.decl_string == other.decl_string
 
+    def __hash__(self):
+        return hash(self.decl_string)
+
     def __ne__( self, other):
         return not self.__eq__( other )
 
@@ -713,6 +716,8 @@ def __eq__(self, other):
         return self.has_static == other.has_static \
                and self.has_mutable == other.has_mutable
 
+    def __hash__(self): return super.__hash__(self)
+
     def __ne__( self, other):
         return not self.__eq__( other )
 

pygccxml/declarations/declaration.py

@@ -24,6 +24,9 @@ def __eq__(self, other):
         return self.line == other.line \
                and self.file_name == other.file_name
 
+    def __hash__(self):
+        return hash(self.__class__) ^ hash(self.line) ^ hash(self.file_name)
+
     def __ne__( self, other):
         return not self.__eq__( other )
 
@@ -122,6 +125,11 @@ def __eq__(self, other):
                and algorithm.declaration_path( self.parent ) \
                    == algorithm.declaration_path( other.parent )
 
+    def __hash__(self):
+        return (hash(self.__class__) ^
+                hash(self.name) ^
+                hash(self.location))
+
     def __ne__( self, other):
         """return not self.__eq__( other )"""
         return not self.__eq__( other )

pygccxml/declarations/enumeration.py

@@ -45,6 +45,8 @@ def __eq__(self, other):
             return False
         return self.values == other.values
 
+    def __hash__(self): return super.__hash__(self)
+
     def _get__cmp__items( self ):
         """implementation details"""
         return [self.values]

pygccxml/declarations/scopedef.py

@@ -116,6 +116,9 @@ def __eq__(self, other):
         #else:
             #return  self_decls == other_decls
 
+    def __hash__(self):
+        return super.__hash__(self)
+
     def _get_declarations_impl(self):
         raise NotImplementedError()
 

pygccxml/declarations/type_traits.py

@@ -30,7 +30,6 @@
 from . import enumeration
 from . import class_declaration
 from pygccxml import utils
-import types as build_in_types
 
 def __remove_alias(type_):
     """implementation details"""
@@ -94,7 +93,7 @@ def base_type(type):
 
 def does_match_definition(given, main, secondary ):
     """implementation details"""
-    #assert isinstance( secondary, build_in_types.tuple )
+    assert isinstance( secondary, tuple )
     assert 2 == len( secondary ) #general solution could be provided
     types = decompose_type( given )
     if isinstance( types[0], main ):

pygccxml/declarations/typedef.py

@@ -27,6 +27,9 @@ def __eq__(self, other):
             return False
         return self.type == other.type
 
+    def __hash__(self):
+        return super.__hash__(self)
+
     def _get_type(self):
         return self._type
     def _set_type(self, type):

pygccxml/declarations/variable.py

@@ -36,6 +36,8 @@ def __eq__(self, other):
                and self.value == other.value \
                and self.bits == other.bits
 
+    def __hash__(self): return super.__hash__(self)
+
     def _get_type(self):
         return self._type
     def _set_type(self, type):