Source Code for Module pygccxml.declarations.class_declaration

  1  # Copyright 2004-2008 Roman Yakovenko. 
  2  # Distributed under the Boost Software License, Version 1.0. (See 
  3  # accompanying file LICENSE_1_0.txt or copy at 
  4  # http://www.boost.org/LICENSE_1_0.txt) 
  5   
  6  """ 
  7  defines classes, that describes C++ classes 
  8   
  9  This modules contains definition for next C++ declarations: 
 10      - class definition 
 11      - class declaration 
 12      - small helper class for describing C++ class hierarchy 
 13  """ 
 14   
 15  import scopedef 
 16  import itertools 
 17  import compilers 
 18  import algorithm 
 19  import declaration 
 20  import dependencies 
 21  from pygccxml import utils 
 22   
 23 -class ACCESS_TYPES: 
 24      """class that defines "access" constants""" 
 25      PUBLIC = "public" 
 26      PRIVATE = "private" 
 27      PROTECTED = "protected" 
 28      ALL = [ PUBLIC, PRIVATE, PROTECTED ] 
 29   
 30 -class CLASS_TYPES: 
 31      """class that defines "class" type constants""" 
 32      CLASS = "class" 
 33      STRUCT = "struct" 
 34      UNION = "union" 
 35      ALL = [ CLASS, STRUCT, UNION ] 
 36   
 37 -def get_partial_name( name ): 
 38      import templates 
 39      import container_traits #prevent cyclic dependencies 
 40      ct = container_traits.find_container_traits( name ) 
 41      if ct: 
 42          return ct.remove_defaults( name ) 
 43      elif templates.is_instantiation( name ): 
 44          tmpl_name, args = templates.split( name ) 
 45          for i, arg_name in enumerate( args ): 
 46              args[i] = get_partial_name( arg_name.strip() ) 
 47          return templates.join( tmpl_name, args ) 
 48      else: 
 49          return name 
 50   
 51   
 52 -class hierarchy_info_t( object ): 
 53      """describes class relationship""" 
 54 -    def __init__(self, related_class=None, access=None, is_virtual=False ): 
 55          """creates class that contains partial information about class relationship""" 
 56          if related_class: 
 57              assert( isinstance( related_class, class_t ) ) 
 58          self._related_class = related_class 
 59          if access: 
 60              assert( access in ACCESS_TYPES.ALL) 
 61          self._access=access 
 62          self._is_virtual = is_virtual 
 63   
 64 -    def __eq__(self, other): 
 65          if not isinstance( other, hierarchy_info_t ): 
 66              return False 
 67          return algorithm.declaration_path( self.related_class ) == algorithm.declaration_path( other.related_class ) \ 
 68                 and self.access == other.access \ 
 69                 and self.is_virtual == other.is_virtual 
 70   
 71 -    def __ne__( self, other): 
 72          return not self.__eq__( other ) 
 73   
 74 -    def __lt__(self, other): 
 75          if not isinstance( other, self.__class__ ): 
 76              return self.__class__.__name__ < other.__class__.__name__ 
 77          return ( algorithm.declaration_path( self.related_class ), self.access, self.is_virtual  ) \ 
 78                 < ( algorithm.declaration_path( other.related_class ), other.access, self.is_virtual ) 
 79   
 80 -    def _get_related_class(self): 
 81          return self._related_class 
 82 -    def _set_related_class(self, new_related_class): 
 83          if new_related_class: 
 84              assert( isinstance( new_related_class, class_t ) ) 
 85          self._related_class = new_related_class 
 86      related_class = property( _get_related_class, _set_related_class 
 87                                , doc="reference to base or derived L{class<class_t>}") 
 88   
 89 -    def _get_access(self): 
 90          return self._access 
 91 -    def _set_access(self, new_access): 
 92          assert( new_access in ACCESS_TYPES.ALL ) 
 93          self._access = new_access 
 94      access = property( _get_access, _set_access ) 
 95      access_type = property( _get_access, _set_access 
 96                              , doc="describes L{hierarchy type<ACCESS_TYPES>}") 
 97   
 98      #TODO: check whether GCC XML support this and if so parser this information 
 99 -    def _get_is_virtual(self): 
100          return self._is_virtual 
101 -    def _set_is_virtual(self, new_is_virtual): 
102          self._is_virtual = new_is_virtual 
103      is_virtual = property( _get_is_virtual, _set_is_virtual 
104                             , doc="indicates whether the inheritance is virtual or not") 
105   
106   
107 -class class_declaration_t( declaration.declaration_t ): 
108      """describes class declaration""" 
109 -    def __init__( self, name='' ): 
110          """creates class that describes C++ class declaration( and not definition )""" 
111          declaration.declaration_t.__init__( self, name ) 
112          self._aliases = [] 
113          self._container_traits = None 
114          self._container_traits_set = False 
115   
116 -    def _get__cmp__items(self): 
117          """implementation details""" 
118          return [] 
119   
120 -    def i_depend_on_them( self, recursive=True ): 
121          return [] 
122   
123 -    def _get_aliases(self): 
124          return self._aliases 
125 -    def _set_aliases( self, new_aliases ): 
126          self._aliases = new_aliases 
127      aliases = property( _get_aliases, _set_aliases 
128                           , doc="List of L{aliases<typedef_t>} to this instance") 
129   
130      @property 
131 -    def container_traits( self ): 
132          """reference to L{container traits<container_traits.py>} or None""" 
133          if self._container_traits_set == False: 
134              import container_traits #prevent cyclic dependencies 
135              self._container_traits_set = True 
136              self._container_traits = container_traits.find_container_traits( self ) 
137          return self._container_traits 
138   
139 -    def _get_partial_name_impl( self ): 
140          return get_partial_name( self.name ) 
141   
142 -class class_t( scopedef.scopedef_t ): 
143      """describes class definition""" 
144   
145      USE_DEMANGLED_AS_NAME = True 
146 -    def __init__( self, name='', class_type=CLASS_TYPES.CLASS, is_abstract=False ): 
147          """creates class that describes C++ class definition""" 
148          scopedef.scopedef_t.__init__( self, name ) 
149          if class_type: 
150              assert( class_type in CLASS_TYPES.ALL ) 
151          self._class_type = class_type 
152          self._bases = [] 
153          self._derived = [] 
154          self._is_abstract = is_abstract 
155          self._public_members = [] 
156          self._private_members = [] 
157          self._protected_members = [] 
158          self._aliases = [] 
159          self._byte_size = 0 
160          self._byte_align = 0 
161          self._container_traits = None 
162          self._container_traits_set = False 
163          self._recursive_bases = None 
164          self._recursive_derived = None 
165   
166 -    def _get_name_impl( self ): 
167          if not self._name: #class with empty name 
168              return self._name 
169          elif class_t.USE_DEMANGLED_AS_NAME and self.demangled and 'GCC' in self.compiler: 
170              if not self.cache.demangled_name: 
171                  fname = algorithm.full_name( self.parent ) 
172                  if fname.startswith( '::' ) and not self.demangled.startswith( '::' ): 
173                      fname = fname[2:] 
174                  if self.demangled.startswith( fname ): 
175                      tmp = self.demangled[ len( fname ): ] #demangled::name 
176                      if tmp.startswith( '::' ): 
177                          tmp = tmp[2:] 
178                      if '<' not in tmp and '<' in self._name: 
179                          #we have template class, but for some reason demangled 
180                          #name doesn't contain any template 
181                          #This happens for std::string class, but this breaks 
182                          #other cases, because this behaviour is not consistent 
183                          self.cache.demangled_name = self._name 
184                          return self.cache.demangled_name 
185                      else: 
186                          self.cache.demangled_name = tmp 
187                          return tmp 
188                  else: 
189                      self.cache.demangled_name = self._name 
190                      return self._name 
191              else: 
192                  return self.cache.demangled_name 
193          else: 
194              return self._name 
195   
196 -    def __str__(self): 
197          name = algorithm.full_name(self) 
198          if name[:2]=="::": 
199              name = name[2:] 
200          return "%s [%s]"%(name, self.class_type) 
201   
202 -    def _get__cmp__scope_items(self): 
203          """implementation details""" 
204          return [ self.class_type 
205                   , self._sorted_list( [ algorithm.declaration_path( base.related_class ) for base in self.bases ] ) 
206                   , self._sorted_list( [ algorithm.declaration_path( derive.related_class ) for derive in self.derived ] ) 
207                   , self.is_abstract 
208                   , self._sorted_list( self.public_members ) 
209                   , self._sorted_list( self.private_members ) 
210                   , self._sorted_list( self.protected_members ) ] 
211   
212 -    def __eq__(self, other): 
213          if not scopedef.scopedef_t.__eq__( self, other ): 
214              return False 
215          return self.class_type == other.class_type \ 
216                 and self._sorted_list( [ algorithm.declaration_path( base.related_class ) for base in self.bases ] ) \ 
217                     == other._sorted_list( [ algorithm.declaration_path( base.related_class ) for base in other.bases ] ) \ 
218                 and self._sorted_list( [ algorithm.declaration_path( derive.related_class ) for derive in self.derived ] ) \ 
219                     == other._sorted_list( [ algorithm.declaration_path( derive.related_class ) for derive in other.derived ] ) \ 
220                 and self.is_abstract == other.is_abstract \ 
221                 and self._sorted_list( self.public_members ) \ 
222                     == other._sorted_list( other.public_members ) \ 
223                 and self._sorted_list( self.private_members ) \ 
224                     == other._sorted_list( other.private_members ) \ 
225                 and self._sorted_list( self.protected_members ) \ 
226                     == self._sorted_list( other.protected_members ) 
227   
228 -    def _get_class_type(self): 
229          return self._class_type 
230 -    def _set_class_type( self, new_class_type): 
231          if new_class_type: 
232              assert( new_class_type in CLASS_TYPES.ALL ) 
233          self._class_type = new_class_type 
234      class_type = property( _get_class_type, _set_class_type 
235                             , doc="describes class L{type<CLASS_TYPES>}") 
236   
237 -    def _get_bases(self): 
238          return self._bases 
239 -    def _set_bases( self, new_bases ): 
240          self._bases = new_bases 
241      bases = property( _get_bases, _set_bases 
242                        , doc="list of L{base classes<hierarchy_info_t>}") 
243   
244      @property 
245 -    def recursive_bases(self): 
246          """list of all L{base classes<hierarchy_info_t>}""" 
247          if self._recursive_bases is None: 
248              to_go = self.bases[:] 
249              all_bases = [] 
250              while to_go: 
251                  base = to_go.pop() 
252                  if base not in all_bases: 
253                      all_bases.append( base ) 
254                      to_go.extend( base.related_class.bases ) 
255              self._recursive_bases = all_bases 
256          return self._recursive_bases 
257   
258 -    def _get_derived(self): 
259          return self._derived 
260 -    def _set_derived( self, new_derived ): 
261          self._derived = new_derived 
262      derived = property( _get_derived, _set_derived 
263                          , doc="list of L{derived classes<hierarchy_info_t>}") 
264   
265      @property 
266 -    def recursive_derived(self): 
267          """list of all L{derive classes<hierarchy_info_t>}""" 
268          if self._recursive_derived is None: 
269              to_go = self.derived[:] 
270              all_derived = [] 
271              while to_go: 
272                  derive = to_go.pop() 
273                  if derive not in all_derived: 
274                      all_derived.append( derive ) 
275                      to_go.extend( derive.related_class.derived ) 
276              self._recursive_derived = all_derived 
277          return self._recursive_derived 
278   
279 -    def _get_is_abstract(self): 
280          if self.compiler == compilers.MSVC_PDB_9: 
281              #prevent cyclic dependencies 
282              import calldef 
283              import function_traits 
284              from matchers import virtuality_type_matcher_t as vtmatcher_t 
285              filter_pv = vtmatcher_t( calldef.VIRTUALITY_TYPES.PURE_VIRTUAL ) 
286              if self.calldefs( filter_pv, recursive=False, allow_empty=True ): 
287                  return True 
288              filter_npv = vtmatcher_t( calldef.VIRTUALITY_TYPES.VIRTUAL ) \ 
289                           | vtmatcher_t( calldef.VIRTUALITY_TYPES.NOT_VIRTUAL ) 
290              pv_calldefs = [] 
291              npv_calldefs = [] 
292   
293              npv_calldefs.extend( self.calldefs( filter_npv, recursive=False, allow_empty=True ) ) 
294              for base in self.recursive_bases: 
295                  cls = base.related_class 
296                  pv_calldefs.extend( cls.calldefs( filter_pv, recursive=False, allow_empty=True ) ) 
297                  npv_calldefs.extend( cls.calldefs( filter_npv, recursive=False, allow_empty=True ) ) 
298   
299              for pure_virtual in pv_calldefs: 
300                  impl_found = filter( lambda f: function_traits.is_same_function( pure_virtual, f ) 
301                                       , npv_calldefs ) 
302                  if not impl_found: 
303                      return True 
304              return False 
305          else: 
306              return self._is_abstract 
307 -    def _set_is_abstract( self, is_abstract ): 
308          self._is_abstract = is_abstract 
309      is_abstract = property( _get_is_abstract, _set_is_abstract 
310                              ,doc="describes whether class abstract or not" ) 
311   
312 -    def _get_public_members(self): 
313          return self._public_members 
314 -    def _set_public_members( self, new_public_members ): 
315          self._public_members = new_public_members 
316      public_members = property( _get_public_members, _set_public_members 
317                                 , doc="list of all public L{members<declaration_t>}") 
318   
319 -    def _get_private_members(self): 
320          return self._private_members 
321 -    def _set_private_members( self, new_private_members ): 
322          self._private_members = new_private_members 
323      private_members = property( _get_private_members, _set_private_members 
324                                  , doc="list of all private L{members<declaration_t>}") 
325   
326 -    def _get_protected_members(self): 
327          return self._protected_members 
328 -    def _set_protected_members( self, new_protected_members ): 
329          self._protected_members = new_protected_members 
330      protected_members = property( _get_protected_members, _set_protected_members 
331                                    , doc="list of all protected L{members<declaration_t>}" ) 
332   
333 -    def _get_aliases(self): 
334          return self._aliases 
335 -    def _set_aliases( self, new_aliases ): 
336          self._aliases = new_aliases 
337      aliases = property( _get_aliases, _set_aliases 
338                           , doc="List of L{aliases<typedef_t>} to this instance") 
339   
340 -    def _get_byte_size(self): 
341          return self._byte_size 
342 -    def _set_byte_size( self, new_byte_size ): 
343          self._byte_size = new_byte_size 
344      byte_size = property( _get_byte_size, _set_byte_size 
345                            , doc="Size of this class in bytes @type: int") 
346   
347 -    def _get_byte_align(self): 
348          if self.compiler == compilers.MSVC_PDB_9: 
349              compilers.on_missing_functionality( self.compiler, "byte align" ) 
350          return self._byte_align 
351 -    def _set_byte_align( self, new_byte_align ): 
352          self._byte_align = new_byte_align 
353      byte_align = property( _get_byte_align, _set_byte_align 
354                            , doc="Alignment of this class in bytes @type: int") 
355   
356 -    def _get_declarations_impl(self): 
357          return self.get_members() 
358   
359 -    def get_members( self, access=None): 
360          """ 
361          returns list of members according to access type 
362   
363          If access equals to None, then returned list will contain all members. 
364          You should not modify the list content, otherwise different optimization 
365          data will stop work and may to give you wrong results. 
366   
367          @param access: describes desired members 
368          @type access: L{ACCESS_TYPES} 
369   
370          @return: [ members ] 
371          """ 
372          if access == ACCESS_TYPES.PUBLIC: 
373              return self.public_members 
374          elif access == ACCESS_TYPES.PROTECTED: 
375              return self.protected_members 
376          elif access == ACCESS_TYPES.PRIVATE: 
377              return self.private_members 
378          else: 
379              all_members = [] 
380              all_members.extend( self.public_members ) 
381              all_members.extend( self.protected_members ) 
382              all_members.extend( self.private_members ) 
383              return all_members 
384   
385 -    def adopt_declaration( self, decl, access ): 
386          """adds new declaration to the class 
387   
388          @param decl: reference to a L{declaration<declaration_t>} 
389   
390          @param access: member access type 
391          @type access: L{ACCESS_TYPES} 
392          """ 
393          if access == ACCESS_TYPES.PUBLIC: 
394              self.public_members.append( decl ) 
395          elif access == ACCESS_TYPES.PROTECTED: 
396              self.protected_members.append( decl ) 
397          elif access == ACCESS_TYPES.PRIVATE: 
398              self.private_members.append( decl ) 
399          else: 
400              raise RuntimeError( "Invalid access type: %s." % access ) 
401          decl.parent = self 
402          decl.cache.reset() 
403          decl.cache.access_type = access 
404   
405 -    def remove_declaration( self, decl ): 
406          """ 
407          removes decl from  members list 
408   
409          @param decl: declaration to be removed 
410          @type decl: L{declaration_t} 
411          """ 
412          container = None 
413          access_type = self.find_out_member_access_type( decl ) 
414          if access_type == ACCESS_TYPES.PUBLIC: 
415              container = self.public_members 
416          elif access_type == ACCESS_TYPES.PROTECTED: 
417              container = self.protected_members 
418          else: #decl.cache.access_type == ACCESS_TYPES.PRVATE 
419              container = self.private_members 
420          del container[ container.index( decl ) ] 
421          decl.cache.reset() 
422   
423 -    def find_out_member_access_type( self, member ): 
424          """ 
425          returns member access type 
426   
427          @param member: member of the class 
428          @type member: L{declaration_t} 
429   
430          @return: L{ACCESS_TYPES} 
431          """ 
432          assert member.parent is self 
433          if not member.cache.access_type: 
434              access_type = None 
435              if member in self.public_members: 
436                  access_type = ACCESS_TYPES.PUBLIC 
437              elif member in self.protected_members: 
438                  access_type = ACCESS_TYPES.PROTECTED 
439              elif member in self.private_members: 
440                  access_type = ACCESS_TYPES.PRIVATE 
441              else: 
442                  raise RuntimeError( "Unable to find member within internal members list." ) 
443              member.cache.access_type = access_type 
444              return access_type 
445          else: 
446              return member.cache.access_type 
447   
448 -    def __find_out_member_dependencies( self, access_type ): 
449          members = self.get_members( access_type ) 
450          answer = [] 
451          map( lambda mem: answer.extend( mem.i_depend_on_them(recursive=True) ), members ) 
452          member_ids = set( map( lambda m: id( m ), members ) ) 
453          for dependency in answer: 
454              if id( dependency.declaration ) in member_ids: 
455                  dependency.access_type = access_type 
456          return answer 
457   
458 -    def i_depend_on_them( self, recursive=True ): 
459          report_dependency = lambda *args: dependencies.dependency_info_t( self, *args ) 
460           
461          answer = [] 
462   
463          map( lambda base: answer.append( report_dependency( base.related_class, base.access_type, "base class" ) ) 
464               , self.bases ) 
465   
466          if recursive: 
467              map( lambda access_type: answer.extend( self.__find_out_member_dependencies( access_type ) ) 
468                   , ACCESS_TYPES.ALL ) 
469   
470          return answer 
471   
472      @property 
473 -    def container_traits( self ): 
474          """reference to L{container traits<container_traits.py>} or None""" 
475          if self._container_traits_set == False: 
476              import container_traits #prevent cyclic dependencies 
477              self._container_traits_set = True 
478              self._container_traits = container_traits.find_container_traits( self ) 
479          return self._container_traits 
480   
481 -    def find_copy_constructor( self ): 
482          copy_ = self.constructors( lambda x: x.is_copy_constructor, recursive=False, allow_empty=True ) 
483          if copy_: 
484              return copy_[0] 
485          else: 
486              return None 
487   
488 -    def find_trivial_constructor( self ): 
489          trivial = self.constructors( lambda x: x.is_trivial_constructor, recursive=False, allow_empty=True ) 
490          if trivial: 
491              return trivial[0] 
492          else: 
493              return None 
494   
495 -    def _get_partial_name_impl( self ): 
496          import type_traits #prevent cyclic dependencies 
497          if type_traits.is_std_string( self ): 
498              return 'string' 
499          elif type_traits.is_std_wstring( self ): 
500              return 'wstring' 
501          else: 
502              return get_partial_name( self.name ) 
503       
504 -    def find_noncopyable_vars( self ):         
505          """returns list of all noncopyable variables""" 
506          import type_traits as tt#prevent cyclic dependencies 
507          logger = utils.loggers.cxx_parser 
508          mvars = self.vars( lambda v: not v.type_qualifiers.has_static, recursive=False, allow_empty=True ) 
509          noncopyable_vars = [] 
510          for mvar in mvars: 
511              type_ = tt.remove_reference( mvar.type ) 
512              if tt.is_const( type_ ): 
513                  no_const = tt.remove_const( type_ ) 
514                  if tt.is_fundamental( no_const ) or tt.is_enum( no_const): 
515                      logger.debug( "__contains_noncopyable_mem_var - %s - TRUE - containes const member variable - fundamental or enum" % self.decl_string ) 
516                      noncopyable_vars.append( mvar ) 
517                  if tt.is_class( no_const ): 
518                      logger.debug( "__contains_noncopyable_mem_var - %s - TRUE - containes const member variable - class" % self.decl_string ) 
519                      noncopyable_vars.append( mvar ) 
520                  if tt.is_array( no_const ): 
521                      logger.debug( "__contains_noncopyable_mem_var - %s - TRUE - containes const member variable - array" % self.decl_string ) 
522                      noncopyable_vars.append( mvar ) 
523              if tt.class_traits.is_my_case( type_ ): 
524                  cls = tt.class_traits.get_declaration( type_ ) 
525                  if tt.is_noncopyable( cls ): 
526                      logger.debug( "__contains_noncopyable_mem_var - %s - TRUE - containes member variable - class that is not copyable" % self.decl_string ) 
527                      noncopyable_vars.append( mvar )                 
528          logger.debug( "__contains_noncopyable_mem_var - %s - false - doesn't contains noncopyable members" % self.decl_string ) 
529          return noncopyable_vars 
530   
531   
532  class_types = ( class_t, class_declaration_t ) 
533