|
From: <rom...@us...> - 2006-05-02 05:24:15
|
Revision: 52 Author: roman_yakovenko Date: 2006-05-01 22:24:01 -0700 (Mon, 01 May 2006) ViewCVS: http://svn.sourceforge.net/pygccxml/?rev=52&view=rev Log Message: ----------- updating "creator_t" class to use functionality provided by decl_wrapper classes Modified Paths: -------------- pyplusplus_dev/pyplusplus/module_creator/creator.py Modified: pyplusplus_dev/pyplusplus/module_creator/creator.py =================================================================== --- pyplusplus_dev/pyplusplus/module_creator/creator.py 2006-05-02 05:22:43 UTC (rev 51) +++ pyplusplus_dev/pyplusplus/module_creator/creator.py 2006-05-02 05:24:01 UTC (rev 52) @@ -10,6 +10,9 @@ import types_database from pyplusplus import code_repository from sets import Set as set + +ACCESS_TYPES = declarations.ACCESS_TYPES +VIRTUALITY_TYPES = declarations.VIRTUALITY_TYPES #TODO: don't export functions that returns non const pointer to fundamental types #TODO: add print decl_wrapper.readme messages @@ -82,8 +85,8 @@ decls = declarations.make_flatten( decls ) self.__decls = self._filter_decls( self._reorder_decls( self._prepare_decls( decls ) ) ) - self.__curr_parent = self.__module_body - self.__curr_decl = None + self.curr_code_creator = self.__module_body + self.curr_decl = None self.__cr_array_1_included = False self.__array_1_registered = set() #(type.decl_string,size) self.__free_operators = [] @@ -122,69 +125,24 @@ new_ordered.extend( others ) new_ordered.extend( variables ) return new_ordered # - - def _is_calldef_exposable(self, declaration): - #see http://www.boost.org/libs/python/doc/v2/faq.html#funcptr - if len( declaration.arguments ) > 10: - return False #boost.tuple can not contain more than 10 args - all_types = [ arg.type for arg in declaration.arguments ] - all_types.append( declaration.return_type ) - for some_type in all_types: - units = declarations.decompose_type( some_type ) - ptr2functions = filter( lambda unit: isinstance( unit, declarations.calldef_type_t ) - , units ) - if ptr2functions: - return False - #Function that take as agrument some instance of non public class - #will not be exported. Same to the return variable - if isinstance( units[-1], declarations.declarated_t ): - dtype = units[-1] - if isinstance( dtype.declaration.parent, declarations.class_t ): - if dtype.declaration not in dtype.declaration.parent.public_members: - return False - - if isinstance( declaration, declarations.operator_t ): - if isinstance( declaration, declarations.casting_operator_t ): - return True - if isinstance( declaration, declarations.member_operator_t ) \ - and declaration.symbol in ( '()', '[]' ): - return True - if not code_creators.operator_t.supported.is_supported( declaration ): - #see http://www.boost.org/libs/python/doc/v2/operators.html#introduction - return False - if isinstance( declaration, declarations.constructor_t ) \ - and declaration.is_artificial: - return False - return True def _exportable_class_members( self, class_decl ): assert isinstance( class_decl, declarations.class_t ) - members = [] - for member in class_decl.public_members: - if isinstance( member, declarations.variable_t ) : - if member.bits == 0 and member.name == "": - continue #alignement bit - type_ = declarations.remove_const( member.type ) - if declarations.is_pointer( type_ ) \ - and member.type_qualifiers.has_static: - continue #right now I don't know what code should be generated in this case - members.append( member ) + members = filter( lambda mv: mv.ignore == False, class_decl.public_members ) #protected and private virtual functions that not overridable and not pure #virtual should not be exported for member in class_decl.protected_members: if not isinstance( member, declarations.calldef_t ): continue - if member.virtuality != declarations.VIRTUALITY_TYPES.VIRTUAL: + else: members.append( member ) - if self._is_overridable( member ): - members.append( member ) - + vfunction_selector = lambda member: isinstance( member, declarations.member_function_t ) \ - and member.virtuality == declarations.VIRTUALITY_TYPES.PURE_VIRTUAL + and member.virtuality == VIRTUALITY_TYPES.PURE_VIRTUAL members.extend( filter( vfunction_selector, class_decl.private_members ) ) #now lets filter out none public operators: pyplusplus does not support them right now members = filter( lambda decl: not isinstance( decl, declarations.member_operator_t ) - or decl.access_type == declarations.ACCESS_TYPES.PUBLIC + or decl.access_type == ACCESS_TYPES.PUBLIC , members ) #-#if declarations.has_destructor( class_decl ) \ #-# and not declarations.has_public_destructor( class_decl ): @@ -199,11 +157,6 @@ def _does_class_have_smth_to_export(self, exportable_members ): return bool( self._filter_decls( self._reorder_decls( exportable_members ) ) ) - def _is_public_class( self, class_decl ): - if isinstance( class_decl.parent, declarations.namespace_t ): - return True - return class_decl in class_decl.parent.public_members - def _is_constructor_of_abstract_class( self, decl ): assert isinstance( decl, declarations.constructor_t ) return decl.parent.is_abstract @@ -214,26 +167,63 @@ decls = filter( lambda x: not (x.is_artificial and not (isinstance(x, ( declarations.class_t, declarations.enumeration_t)))) , decls ) - # Filter out internal compiler methods - decls = filter( lambda x: not x.name.startswith( '__' ), decls ) - decls = filter( lambda x: x.location.file_name != "<internal>", decls ) # Filter out type defs decls = filter( lambda x: not isinstance( x, declarations.typedef_t ), decls ) - # Filter out non-exposable calls - decls = filter( lambda x: not isinstance( x, declarations.calldef_t) - or self._is_calldef_exposable(x) - , decls ) - decls = filter( lambda x: not isinstance( x, declarations.class_t) - or self._is_public_class( x ) - , decls ) + return decls - def _is_wrapper_needed(self, exportable_members): - if isinstance( self.__curr_decl, declarations.class_t ) \ - and self.__curr_decl.wrapper_user_code: + def __is_same_func( self, f1, f2 ): + if not f1.__class__ is f2.__class__: + return False + if isinstance( f1, declarations.member_calldef_t ) and f1.has_const != f2.has_const: + return False + if f1.name != f2.name: + return False + if f1.return_type != f2.return_type: + return False + if len( f1.arguments ) != len(f2.arguments): + return False + for f1_arg, f2_arg in zip( f1.arguments, f2.arguments ): + if f1_arg.type != f2_arg.type: + return False + return True + + def redefined_funcs( self, cls ): + all_included = declarations.custom_matcher_t( lambda decl: decl.ignore == False ) + all_protected = declarations.access_type_matcher_t( 'protected' ) & all_included + all_pure_virtual = declarations.virtuality_type_matcher_t( VIRTUALITY_TYPES.PURE_VIRTUAL ) + + query = all_protected | all_pure_virtual + + funcs = set() + for base in cls.recursive_bases: + if base.access == ACCESS_TYPES.PRIVATE: + continue + base_cls = base.related_class + funcs.update( base_cls.member_functions( query, allow_empty=True ) ) + funcs.update( base_cls.member_operators( query, allow_empty=True ) ) + + not_reimplemented_funcs = set() + for f in funcs: + cls_fs = cls.calldefs( name=f.name, recursive=False, allow_empty=True ) + for cls_f in cls_fs: + if self.__is_same_func( f, cls_f ): + break + else: + #should test whether this function has been added or not + for f_impl in not_reimplemented_funcs: + if self.__is_same_func( f, f_impl ): + break + else: + not_reimplemented_funcs.add( f ) + return not_reimplemented_funcs + + def _is_wrapper_needed(self, class_inst, exportable_members): + if isinstance( self.curr_decl, declarations.class_t ) \ + and self.curr_decl.wrapper_user_code: return True - elif isinstance( self.__curr_parent, declarations.class_t ) \ - and self.__curr_parent.wrapper_user_code: + elif isinstance( self.curr_code_creator, declarations.class_t ) \ + and self.curr_code_creator.wrapper_user_code: return True else: pass @@ -250,12 +240,12 @@ return True if isinstance( member, declarations.class_t ): return True - if isinstance( member, declarations.member_calldef_t ): - if member.access_type != declarations.ACCESS_TYPES.PUBLIC: - return True - if self._is_overridable( member ): - return True - return False + if isinstance( member, declarations.calldef_t ): + if member.virtuality != VIRTUALITY_TYPES.NOT_VIRTUAL: + return True #virtual and pure virtual functions requieres wrappers. + if member.access_type in ( ACCESS_TYPES.PROTECTED, ACCESS_TYPES.PRIVATE ): + return True #we already decided that those functions should be exposed, so I need wrapper for them + return bool( self.redefined_funcs(class_inst) ) def _adopt_free_operator( self, operator ): def adopt_operator_impl( operator, found_creators ): @@ -350,7 +340,7 @@ self.__extmodule.adopt_include(code_creators.include_t(header=h)) # Invoke the appropriate visit_*() method on all decls for decl in self.__decls: - self.__curr_decl = decl + self.curr_decl = decl declarations.apply_visitor( self, decl ) for operator in self.__free_operators: self._adopt_free_operator( operator ) @@ -366,175 +356,205 @@ include = code_creators.include_t( header=fn ) self.__extmodule.adopt_include(include) - def _is_overridable( self, decl ): - #virtual functions that returns const reference to something - #could not be overriden by Python. The reason is simple: - #in boost::python::override::operator(...) result of marshaling - #(Python 2 C++) is saved on stack, after functions returns the result - #will be reference to no where - access violetion. - #For example see temporal variable tester - assert isinstance( decl, declarations.member_calldef_t ) - if decl.virtuality == declarations.VIRTUALITY_TYPES.VIRTUAL \ - and decl.access_type == declarations.ACCESS_TYPES.PROTECTED \ - and declarations.is_reference( decl.return_type ): - return True - if decl.virtuality == declarations.VIRTUALITY_TYPES.VIRTUAL \ - and declarations.is_reference( decl.return_type ): - return False - if decl.virtuality == declarations.VIRTUALITY_TYPES.PURE_VIRTUAL: - return True - if decl.access_type != declarations.ACCESS_TYPES.PUBLIC: - return True - if declarations.is_reference( decl.return_type ): - return False - return decl.virtuality != declarations.VIRTUALITY_TYPES.NOT_VIRTUAL \ - or decl in decl.parent.protected_members - + + def guess_functions_code_creators( self ): + maker_cls = None + fwrapper_cls = None + access_level = self.curr_decl.parent.find_out_member_access_type( self.curr_decl ) + if access_level == ACCESS_TYPES.PUBLIC: + if self.curr_decl.virtuality == VIRTUALITY_TYPES.NOT_VIRTUAL: + maker_cls = code_creators.mem_fun_t + elif self.curr_decl.virtuality == VIRTUALITY_TYPES.PURE_VIRTUAL: + fwrapper_cls = code_creators.mem_fun_pv_wrapper_t + maker_cls = code_creators.mem_fun_pv_t + else: + if self.curr_decl.overridable: + fwrapper_cls = code_creators.mem_fun_v_wrapper_t + maker_cls = code_creators.mem_fun_v_t + elif access_level == ACCESS_TYPES.PROTECTED: + if self.curr_decl.virtuality == VIRTUALITY_TYPES.NOT_VIRTUAL: + if self.curr_decl.has_static: + fwrapper_cls = code_creators.mem_fun_protected_s_wrapper_t + maker_cls = code_creators.mem_fun_protected_s_t + else: + fwrapper_cls = code_creators.mem_fun_protected_wrapper_t + maker_cls = code_creators.mem_fun_protected_t + elif self.curr_decl.virtuality == VIRTUALITY_TYPES.VIRTUAL: + if self.curr_decl.overridable: + fwrapper_cls = code_creators.mem_fun_protected_v_wrapper_t + maker_cls = code_creators.mem_fun_protected_v_t + else: + fwrapper_cls = code_creators.mem_fun_protected_pv_wrapper_t + maker_cls = code_creators.mem_fun_protected_pv_t + else: #private + if self.curr_decl.virtuality == VIRTUALITY_TYPES.NOT_VIRTUAL: + pass#in general we should not come here + elif self.curr_decl.virtuality == VIRTUALITY_TYPES.PURE_VIRTUAL: + fwrapper_cls = code_creators.mem_fun_private_pv_wrapper_t + else: + if self.curr_decl.overridable: + fwrapper_cls = code_creators.mem_fun_v_wrapper_t + maker_cls = code_creators.mem_fun_v_t + return ( maker_cls, fwrapper_cls ) + def visit_member_function( self ): - if self.__curr_decl.ignore: + if self.curr_decl.ignore: return - if self.__curr_decl.name == 'invert_sign': - i = 0 fwrapper = None - self.__types_db.update( self.__curr_decl ) - access_level = self.__curr_decl.parent.find_out_member_access_type( self.__curr_decl ) - if self._is_overridable( self.__curr_decl ) or access_level == declarations.ACCESS_TYPES.PROTECTED: - class_wrapper = self.__curr_parent.wrapper - fwrapper = code_creators.function_wrapper_t( function=self.__curr_decl ) + self.__types_db.update( self.curr_decl ) + if None is self.curr_decl.call_policies: + self.curr_decl.call_policies = self.__call_policies_resolver( self.curr_decl ) + + maker_cls, fwrapper_cls = self.guess_functions_code_creators() + + maker = None + fwrapper = None + if fwrapper_cls: + fwrapper = fwrapper_cls( function=self.curr_decl ) + class_wrapper = self.curr_code_creator.wrapper class_wrapper.adopt_creator( fwrapper ) - if access_level == declarations.ACCESS_TYPES.PRIVATE: - return - maker = code_creators.function_t( function=self.__curr_decl, wrapper=fwrapper ) - if None is maker.call_policies: - maker.call_policies = self.__call_policies_resolver( self.__curr_decl ) - self.__curr_parent.adopt_creator( maker ) - if self.__curr_decl.has_static: + + if maker_cls: + if fwrapper: + maker = maker_cls( function=self.curr_decl, wrapper=fwrapper ) + else: + maker = maker_cls( function=self.curr_decl ) + self.curr_code_creator.adopt_creator( maker ) + + if self.curr_decl.has_static: #static_method should be created only once. found = filter( lambda creator: isinstance( creator, code_creators.static_method_t ) - and creator.declaration.name == self.__curr_decl.name - , self.__curr_parent.creators ) + and creator.declaration.name == self.curr_decl.name + , self.curr_code_creator.creators ) if not found: - static_method = code_creators.static_method_t( function=self.__curr_decl + static_method = code_creators.static_method_t( function=self.curr_decl , function_code_creator=maker ) - self.__curr_parent.adopt_creator( static_method ) + self.curr_code_creator.adopt_creator( static_method ) def visit_constructor( self ): - if self.__curr_decl.ignore: + if self.curr_decl.ignore: return - if self.__curr_decl.is_copy_constructor: + if self.curr_decl.is_copy_constructor: return - self.__types_db.update( self.__curr_decl ) - if not self._is_constructor_of_abstract_class( self.__curr_decl ) \ - and 1 == len( self.__curr_decl.arguments ) \ + self.__types_db.update( self.curr_decl ) + if not self._is_constructor_of_abstract_class( self.curr_decl ) \ + and 1 == len( self.curr_decl.arguments ) \ and self.__create_castinig_constructor \ - and self.__curr_decl.access_type == declarations.ACCESS_TYPES.PUBLIC: - maker = code_creators.casting_constructor_t( constructor=self.__curr_decl ) + and self.curr_decl.access_type == ACCESS_TYPES.PUBLIC: + maker = code_creators.casting_constructor_t( constructor=self.curr_decl ) self.__module_body.adopt_creator( maker ) cwrapper = None - exportable_members = self._exportable_class_members(self.__curr_parent.declaration) - if self._is_wrapper_needed( exportable_members ): - class_wrapper = self.__curr_parent.wrapper - cwrapper = code_creators.constructor_wrapper_t( constructor=self.__curr_decl ) + exportable_members = self._exportable_class_members(self.curr_code_creator.declaration) + if self._is_wrapper_needed( self.curr_decl.parent, exportable_members ): + class_wrapper = self.curr_code_creator.wrapper + cwrapper = code_creators.constructor_wrapper_t( constructor=self.curr_decl ) class_wrapper.adopt_creator( cwrapper ) - maker = code_creators.constructor_t( constructor=self.__curr_decl, wrapper=cwrapper ) + maker = code_creators.constructor_t( constructor=self.curr_decl, wrapper=cwrapper ) if None is maker.call_policies: - maker.call_policies = self.__call_policies_resolver( self.__curr_decl ) - self.__curr_parent.adopt_creator( maker ) + maker.call_policies = self.__call_policies_resolver( self.curr_decl ) + self.curr_code_creator.adopt_creator( maker ) def visit_destructor( self ): pass def visit_member_operator( self ): - if self.__curr_decl.ignore: + if self.curr_decl.ignore: return - if self.__curr_decl.symbol in ( '()', '[]' ): + if self.curr_decl.symbol in ( '()', '[]' ): self.visit_member_function() else: - self.__types_db.update( self.__curr_decl ) - maker = code_creators.operator_t( operator=self.__curr_decl ) - self.__curr_parent.adopt_creator( maker ) + self.__types_db.update( self.curr_decl ) + maker = code_creators.operator_t( operator=self.curr_decl ) + self.curr_code_creator.adopt_creator( maker ) def visit_casting_operator( self ): - if self.__curr_decl.ignore: + if self.curr_decl.ignore: return - if not declarations.is_fundamental( self.__curr_decl.return_type ) \ - and not self.__curr_decl.has_const: + if not declarations.is_fundamental( self.curr_decl.return_type ) \ + and not self.curr_decl.has_const: return #only const casting operators can generate implicitly_convertible - - self.__types_db.update( self.__curr_decl ) - if not self.__curr_decl.parent.is_abstract \ - and not declarations.is_reference( self.__curr_decl.return_type ): - maker = code_creators.casting_operator_t( operator=self.__curr_decl ) + + if None is self.curr_decl.call_policies: + self.curr_decl.call_policies = self.__call_policies_resolver( self.curr_decl ) + + self.__types_db.update( self.curr_decl ) + if not self.curr_decl.parent.is_abstract \ + and not declarations.is_reference( self.curr_decl.return_type ): + maker = code_creators.casting_operator_t( operator=self.curr_decl ) self.__module_body.adopt_creator( maker ) #what to do if class is abstract - if self.__curr_decl.access_type == declarations.ACCESS_TYPES.PUBLIC: - maker = code_creators.casting_member_operator_t( operator=self.__curr_decl ) - if None is maker.call_policies: - maker.call_policies = self.__call_policies_resolver( self.__curr_decl ) - self.__curr_parent.adopt_creator( maker ) + if self.curr_decl.access_type == ACCESS_TYPES.PUBLIC: + maker = code_creators.casting_member_operator_t( operator=self.curr_decl ) + self.curr_code_creator.adopt_creator( maker ) def visit_free_function( self ): - if self.__curr_decl.ignore: + if self.curr_decl.ignore: return - self.__types_db.update( self.__curr_decl ) - maker = code_creators.function_t( function=self.__curr_decl ) - if None is maker.call_policies: - maker.call_policies = self.__call_policies_resolver( self.__curr_decl ) - self.__curr_parent.adopt_creator( maker ) + self.__types_db.update( self.curr_decl ) + maker = code_creators.free_function_t( function=self.curr_decl ) + if None is self.curr_decl.call_policies: + self.curr_decl.call_policies = self.__call_policies_resolver( self.curr_decl ) + self.curr_code_creator.adopt_creator( maker ) def visit_free_operator( self ): - if self.__curr_decl.ignore: + if self.curr_decl.ignore: return - self.__types_db.update( self.__curr_decl ) - self.__free_operators.append( self.__curr_decl ) + self.__types_db.update( self.curr_decl ) + self.__free_operators.append( self.curr_decl ) def visit_class_declaration(self ): pass def visit_class(self ): - if self.__curr_decl.ignore: + if self.curr_decl.ignore: return - assert isinstance( self.__curr_decl, declarations.class_t ) - temp_curr_decl = self.__curr_decl - temp_curr_parent = self.__curr_parent - exportable_members = self._exportable_class_members(self.__curr_decl) + assert isinstance( self.curr_decl, declarations.class_t ) + temp_curr_decl = self.curr_decl + temp_curr_parent = self.curr_code_creator + exportable_members = self._exportable_class_members(self.curr_decl) wrapper = None - class_inst = code_creators.class_t( class_inst=self.__curr_decl ) + class_inst = code_creators.class_t( class_inst=self.curr_decl ) - if self._is_wrapper_needed( exportable_members ): - wrapper = code_creators.class_wrapper_t( declaration=self.__curr_decl + if self._is_wrapper_needed( self.curr_decl, exportable_members ): + wrapper = code_creators.class_wrapper_t( declaration=self.curr_decl , class_creator=class_inst ) class_inst.wrapper = wrapper #insert wrapper before module body - if isinstance( self.__curr_decl.parent, declarations.class_t ): + if isinstance( self.curr_decl.parent, declarations.class_t ): #we deal with internal class - self.__curr_parent.wrapper.adopt_creator( wrapper ) + self.curr_code_creator.wrapper.adopt_creator( wrapper ) else: self.__extmodule.adopt_creator( wrapper, self.__extmodule.creators.index( self.__module_body ) ) - if declarations.has_trivial_copy( self.__curr_decl ): + if declarations.has_trivial_copy( self.curr_decl ): #I don't know but sometimes boost.python requieres #to construct wrapper from wrapped classe - if not declarations.is_noncopyable( self.__curr_decl ): - scons = code_creators.special_constructor_wrapper_t( class_inst=self.__curr_decl ) + if not declarations.is_noncopyable( self.curr_decl ): + scons = code_creators.special_constructor_wrapper_t( class_inst=self.curr_decl ) wrapper.adopt_creator( scons ) - trivial_constr = declarations.find_trivial_constructor(self.__curr_decl) + trivial_constr = declarations.find_trivial_constructor(self.curr_decl) if trivial_constr and trivial_constr.is_artificial: #this constructor is not going to be exposed - tcons = code_creators.trivial_constructor_wrapper_t( class_inst=self.__curr_decl ) + tcons = code_creators.trivial_constructor_wrapper_t( class_inst=self.curr_decl ) wrapper.adopt_creator( tcons ) - self.__curr_parent.adopt_creator( class_inst ) - self.__curr_parent = class_inst + self.curr_code_creator.adopt_creator( class_inst ) + self.curr_code_creator = class_inst for decl in self._filter_decls( self._reorder_decls( exportable_members ) ): - self.__curr_decl = decl + self.curr_decl = decl declarations.apply_visitor( self, decl ) + for redefined_func in self.redefined_funcs( temp_curr_decl ): + if isinstance( redefined_func, declarations.operator_t ): + continue + self.curr_decl = redefined_func + declarations.apply_visitor( self, redefined_func ) + #all static_methods_t should be moved to the end #better approach is to move them after last def of relevant function static_methods = filter( lambda creator: isinstance( creator, code_creators.static_method_t ) @@ -542,21 +562,21 @@ for static_method in static_methods: class_inst.remove_creator( static_method ) class_inst.adopt_creator( static_method ) - - self.__curr_decl = temp_curr_decl - self.__curr_parent = temp_curr_parent + self.curr_decl = temp_curr_decl + self.curr_code_creator = temp_curr_parent + def visit_enumeration(self): - if self.__curr_decl.ignore: + if self.curr_decl.ignore: return - assert isinstance( self.__curr_decl, declarations.enumeration_t ) + assert isinstance( self.curr_decl, declarations.enumeration_t ) maker = None - if self.__curr_decl.name: - maker = code_creators.enum_t( enum=self.__curr_decl ) + if self.curr_decl.name: + maker = code_creators.enum_t( enum=self.curr_decl ) else: - maker = code_creators.unnamed_enum_t( unnamed_enum=self.__curr_decl ) - self.__curr_parent.adopt_creator( maker ) + maker = code_creators.unnamed_enum_t( unnamed_enum=self.curr_decl ) + self.curr_code_creator.adopt_creator( maker ) def visit_namespace(self): pass @@ -573,45 +593,45 @@ return True def visit_variable(self): - if self.__curr_decl.ignore: + if self.curr_decl.ignore: return - self.__types_db.update( self.__curr_decl ) + self.__types_db.update( self.curr_decl ) - if declarations.is_array( self.__curr_decl.type ): + if declarations.is_array( self.curr_decl.type ): if not self.__cr_array_1_included: self.__extmodule.adopt_creator( code_creators.include_t( code_repository.array_1.file_name ) , self.__extmodule.first_include_index() + 1) self.__cr_array_1_included = True - if self._register_array_1( self.__curr_decl.type ): - array_1_registrator = code_creators.array_1_registrator_t( array_type=self.__curr_decl.type ) - self.__curr_parent.adopt_creator( array_1_registrator ) + if self._register_array_1( self.curr_decl.type ): + array_1_registrator = code_creators.array_1_registrator_t( array_type=self.curr_decl.type ) + self.curr_code_creator.adopt_creator( array_1_registrator ) - if isinstance( self.__curr_decl.parent, declarations.namespace_t ): + if isinstance( self.curr_decl.parent, declarations.namespace_t ): maker = None wrapper = None - if declarations.is_array( self.__curr_decl.type ): - wrapper = code_creators.array_gv_wrapper_t( variable=self.__curr_decl ) - maker = code_creators.array_gv_t( variable=self.__curr_decl, wrapper=wrapper ) + if declarations.is_array( self.curr_decl.type ): + wrapper = code_creators.array_gv_wrapper_t( variable=self.curr_decl ) + maker = code_creators.array_gv_t( variable=self.curr_decl, wrapper=wrapper ) else: - maker = code_creators.global_variable_t( variable=self.__curr_decl ) + maker = code_creators.global_variable_t( variable=self.curr_decl ) if wrapper: self.__extmodule.adopt_creator( wrapper , self.__extmodule.creators.index( self.__module_body ) ) else: maker = None wrapper = None - if self.__curr_decl.bits != None: - wrapper = code_creators.bit_field_wrapper_t( variable=self.__curr_decl ) - maker = code_creators.bit_field_t( variable=self.__curr_decl, wrapper=wrapper ) - elif declarations.is_array( self.__curr_decl.type ): - wrapper = code_creators.array_mv_wrapper_t( variable=self.__curr_decl ) - maker = code_creators.array_mv_t( variable=self.__curr_decl, wrapper=wrapper ) - elif declarations.is_pointer( self.__curr_decl.type ): - wrapper = code_creators.member_variable_wrapper_t( variable=self.__curr_decl ) - maker = code_creators.member_variable_t( variable=self.__curr_decl, wrapper=wrapper ) + if self.curr_decl.bits != None: + wrapper = code_creators.bit_field_wrapper_t( variable=self.curr_decl ) + maker = code_creators.bit_field_t( variable=self.curr_decl, wrapper=wrapper ) + elif declarations.is_array( self.curr_decl.type ): + wrapper = code_creators.array_mv_wrapper_t( variable=self.curr_decl ) + maker = code_creators.array_mv_t( variable=self.curr_decl, wrapper=wrapper ) + elif declarations.is_pointer( self.curr_decl.type ): + wrapper = code_creators.member_variable_wrapper_t( variable=self.curr_decl ) + maker = code_creators.member_variable_t( variable=self.curr_decl, wrapper=wrapper ) else: - maker = code_creators.member_variable_t( variable=self.__curr_decl ) + maker = code_creators.member_variable_t( variable=self.curr_decl ) if wrapper: - self.__curr_parent.wrapper.adopt_creator( wrapper ) - self.__curr_parent.adopt_creator( maker ) + self.curr_code_creator.wrapper.adopt_creator( wrapper ) + self.curr_code_creator.adopt_creator( maker ) This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
|
From: <rom...@us...> - 2006-05-23 20:09:14
|
Revision: 156 Author: roman_yakovenko Date: 2006-05-23 12:48:13 -0700 (Tue, 23 May 2006) ViewCVS: http://svn.sourceforge.net/pygccxml/?rev=156&view=rev Log Message: ----------- fixing bug with hierarchy level 3 Modified Paths: -------------- pyplusplus_dev/pyplusplus/module_creator/creator.py Modified: pyplusplus_dev/pyplusplus/module_creator/creator.py =================================================================== --- pyplusplus_dev/pyplusplus/module_creator/creator.py 2006-05-23 19:46:59 UTC (rev 155) +++ pyplusplus_dev/pyplusplus/module_creator/creator.py 2006-05-23 19:48:13 UTC (rev 156) @@ -193,17 +193,23 @@ all_included = declarations.custom_matcher_t( lambda decl: decl.ignore == False ) all_protected = declarations.access_type_matcher_t( 'protected' ) & all_included all_pure_virtual = declarations.virtuality_type_matcher_t( VIRTUALITY_TYPES.PURE_VIRTUAL ) + all_not_pure_virtual = ~all_pure_virtual query = all_protected | all_pure_virtual funcs = set() + defined_funcs = set() + for base in cls.recursive_bases: if base.access == ACCESS_TYPES.PRIVATE: continue base_cls = base.related_class funcs.update( base_cls.member_functions( query, allow_empty=True ) ) funcs.update( base_cls.member_operators( query, allow_empty=True ) ) - + + defined_funcs.update( base_cls.member_functions( all_not_pure_virtual, allow_empty=True ) ) + defined_funcs.update( base_cls.member_operators( all_not_pure_virtual, allow_empty=True ) ) + not_reimplemented_funcs = set() for f in funcs: cls_fs = cls.calldefs( name=f.name, recursive=False, allow_empty=True ) @@ -216,7 +222,15 @@ if self.__is_same_func( f, f_impl ): break else: - not_reimplemented_funcs.add( f ) + #should test whether this function is implemented in base class + if f.virtuality != VIRTUALITY_TYPES.PURE_VIRTUAL: + not_reimplemented_funcs.add( f ) + else: + for f_defined in defined_funcs: + if self.__is_same_func( f, f_defined ): + break + else: + not_reimplemented_funcs.add( f ) return not_reimplemented_funcs def _is_wrapper_needed(self, class_inst, exportable_members): @@ -647,6 +661,9 @@ elif declarations.is_pointer( self.curr_decl.type ): wrapper = code_creators.member_variable_wrapper_t( variable=self.curr_decl ) maker = code_creators.member_variable_t( variable=self.curr_decl, wrapper=wrapper ) + #elif declarations.is_reference( self.curr_decl.type ): + #wrapper = code_creators.mem_var_ref_wrapper_t( variable=self.curr_decl ) + #maker = code_creators.mem_var_ref_t( variable=self.curr_decl, wrapper=wrapper ) else: maker = code_creators.member_variable_t( variable=self.curr_decl ) if wrapper: This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
|
From: <rom...@us...> - 2006-05-29 19:43:38
|
Revision: 182 Author: roman_yakovenko Date: 2006-05-29 12:43:29 -0700 (Mon, 29 May 2006) ViewCVS: http://svn.sourceforge.net/pygccxml/?rev=182&view=rev Log Message: ----------- adding to do Modified Paths: -------------- pyplusplus_dev/pyplusplus/module_creator/creator.py Modified: pyplusplus_dev/pyplusplus/module_creator/creator.py =================================================================== --- pyplusplus_dev/pyplusplus/module_creator/creator.py 2006-05-29 19:42:05 UTC (rev 181) +++ pyplusplus_dev/pyplusplus/module_creator/creator.py 2006-05-29 19:43:29 UTC (rev 182) @@ -17,7 +17,16 @@ #TODO: don't export functions that returns non const pointer to fundamental types #TODO: add print decl_wrapper.readme messages +#class Foo{ +# union { +# struct { +# float r,g,b,a; +# }; +# float val[4]; +# }; +#}; + class creator_t( declarations.decl_visitor_t ): """Creating code creators. This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
|
From: <rom...@us...> - 2006-06-20 13:33:52
|
Revision: 239 Author: roman_yakovenko Date: 2006-06-20 06:33:45 -0700 (Tue, 20 Jun 2006) ViewCVS: http://svn.sourceforge.net/pygccxml/?rev=239&view=rev Log Message: ----------- removing dead code Modified Paths: -------------- pyplusplus_dev/pyplusplus/module_creator/creator.py Modified: pyplusplus_dev/pyplusplus/module_creator/creator.py =================================================================== --- pyplusplus_dev/pyplusplus/module_creator/creator.py 2006-06-20 13:18:16 UTC (rev 238) +++ pyplusplus_dev/pyplusplus/module_creator/creator.py 2006-06-20 13:33:45 UTC (rev 239) @@ -404,9 +404,6 @@ return self.__extmodule def _create_includes(self): - for cls in self.__decls: - if not isinstance( cls, decl_wrappers.class_t ): - continue for fn in declarations.declaration_files( self.__decls ): include = code_creators.include_t( header=fn ) self.__extmodule.adopt_include(include) This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
|
From: <rom...@us...> - 2006-06-21 22:00:20
|
Revision: 243 Author: roman_yakovenko Date: 2006-06-21 15:00:14 -0700 (Wed, 21 Jun 2006) ViewCVS: http://svn.sourceforge.net/pygccxml/?rev=243&view=rev Log Message: ----------- adding warning to indexing suite generated file Modified Paths: -------------- pyplusplus_dev/pyplusplus/module_creator/creator.py Modified: pyplusplus_dev/pyplusplus/module_creator/creator.py =================================================================== --- pyplusplus_dev/pyplusplus/module_creator/creator.py 2006-06-21 21:57:30 UTC (rev 242) +++ pyplusplus_dev/pyplusplus/module_creator/creator.py 2006-06-21 22:00:14 UTC (rev 243) @@ -353,6 +353,11 @@ pass def _treat_indexing_suite( self ): + def create_explanation(cls): + msg = '//WARNING: the next line of code will not compile, because "%s" does not have operator== !' + msg = msg % cls.indexing_suite.value_type().decl_string + return code_creators.custom_text_t( msg ) + def create_cls_cc( cls ): if isinstance( cls, declarations.class_t ): return code_creators.class_t( class_inst=cls ) @@ -365,6 +370,9 @@ self.__extmodule.add_include( header=header ) for cls in self.__types_db.used_vectors: cls_creator = create_cls_cc( cls ) + value_type = cls.indexing_suite.value_type() + if declarations.is_class( value_type ) and not declarations.has_public_equal( value_type ): + cls_creator.adopt_creator( create_explanation( cls ) ) cls_creator.adopt_creator( code_creators.vector_indexing_suite_t() ) self.__module_body.adopt_creator( cls_creator ) if self.__types_db.used_maps: @@ -373,6 +381,9 @@ self.__extmodule.add_include( header=header ) for cls in self.__types_db.used_maps: cls_creator = create_cls_cc( cls ) + value_type = cls.indexing_suite.value_type() + if declarations.is_class( value_type ) and not declarations.has_public_equal( value_type ): + cls_creator.adopt_creator( create_explanation( cls ) ) cls_creator.adopt_creator( code_creators.map_indexing_suite_t() ) self.__module_body.adopt_creator( cls_creator ) This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
|
From: <rom...@us...> - 2006-07-09 11:45:10
|
Revision: 286 Author: roman_yakovenko Date: 2006-07-09 04:45:03 -0700 (Sun, 09 Jul 2006) ViewCVS: http://svn.sourceforge.net/pygccxml/?rev=286&view=rev Log Message: ----------- small bug fix: don't export container, if value type is not exported Modified Paths: -------------- pyplusplus_dev/pyplusplus/module_creator/creator.py Modified: pyplusplus_dev/pyplusplus/module_creator/creator.py =================================================================== --- pyplusplus_dev/pyplusplus/module_creator/creator.py 2006-07-09 07:33:06 UTC (rev 285) +++ pyplusplus_dev/pyplusplus/module_creator/creator.py 2006-07-09 11:45:03 UTC (rev 286) @@ -406,7 +406,13 @@ used_headers.add( isuite[ container_name ] ) cls_creator = create_cls_cc( cls ) - element_type = cls.indexing_suite.element_type + element_type = cls.indexing_suite.element_type + if declarations.is_class( element_type ): + class_traits = declarations.class_traits + value_cls = class_traits.get_declaration( element_type ) + if value_cls.ignore: + continue #this collection could not be exported, because + #the value_type of collection is not exported if isuite is isuite1: if declarations.is_class( element_type ) and not declarations.has_public_equal( element_type ): cls_creator.adopt_creator( create_explanation( cls ) ) This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
|
From: <rom...@us...> - 2006-07-11 18:04:27
|
Revision: 298 Author: roman_yakovenko Date: 2006-07-11 11:04:20 -0700 (Tue, 11 Jul 2006) ViewCVS: http://svn.sourceforge.net/pygccxml/?rev=298&view=rev Log Message: ----------- improving generated code stability Modified Paths: -------------- pyplusplus_dev/pyplusplus/module_creator/creator.py Modified: pyplusplus_dev/pyplusplus/module_creator/creator.py =================================================================== --- pyplusplus_dev/pyplusplus/module_creator/creator.py 2006-07-11 15:44:30 UTC (rev 297) +++ pyplusplus_dev/pyplusplus/module_creator/creator.py 2006-07-11 18:04:20 UTC (rev 298) @@ -410,7 +410,11 @@ } container_suite_header = "boost/python/suite/indexing/container_suite.hpp" - for cls in self.__types_db.used_containers: + + cmp_by_name = lambda cls1, cls2: cmp( cls1.decl_string, cls2.decl_string ) + used_containers = list( self.__types_db.used_containers ) + used_containers.sort( cmp_by_name ) + for cls in used_containers: container_name = cls.name.split( '<' )[0] + '<' if isinstance( cls.indexing_suite, decl_wrappers.indexing_suite1_t ): This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
|
From: <rom...@us...> - 2006-07-23 06:02:26
|
Revision: 334 Author: roman_yakovenko Date: 2006-07-22 23:02:19 -0700 (Sat, 22 Jul 2006) ViewCVS: http://svn.sourceforge.net/pygccxml/?rev=334&view=rev Log Message: ----------- changing from msg = [ 'Declaration "%s" could not be exported.' % full_name ] to [ 'Declaration "%s" could not be exported.' % decl ] Modified Paths: -------------- pyplusplus_dev/pyplusplus/module_creator/creator.py Modified: pyplusplus_dev/pyplusplus/module_creator/creator.py =================================================================== --- pyplusplus_dev/pyplusplus/module_creator/creator.py 2006-07-20 19:12:15 UTC (rev 333) +++ pyplusplus_dev/pyplusplus/module_creator/creator.py 2006-07-23 06:02:19 UTC (rev 334) @@ -145,22 +145,18 @@ readme = decl.readme() if not readme: continue - #Now we should print what py++ has to say to user - full_name = declarations.full_name( decl ) - if not decl.name: - full_name = full_name + '::{unnamed}' if not decl.exportable: reason = readme[0] if reason in DO_NOT_REPORT_MSGS: continue readme = readme[1:] - msg = [ 'Declaration "%s" could not be exported.' % full_name ] + msg = [ 'Declaration "%s" could not be exported.' % decl ] msg.append( reason.replace( os.linesep, os.linesep + '\t' ) ) self.decl_logger.warn( os.linesep.join( msg ) ) for msg in readme: - self.decl_logger.warn( 'Declaration "%s": %s' % ( full_name, msg ) ) + self.decl_logger.warn( 'Declaration "%s": %s' % ( decl, msg ) ) #leave only declarations defined under namespace, but remove namespaces decls = filter( lambda x: not isinstance( x, declarations.namespace_t ) \ This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
|
From: <mb...@us...> - 2006-07-24 15:48:15
|
Revision: 340 Author: mbaas Date: 2006-07-24 08:48:04 -0700 (Mon, 24 Jul 2006) ViewCVS: http://svn.sourceforge.net/pygccxml/?rev=340&view=rev Log Message: ----------- Write the warnings as one single line (<decl>;<msg>). Modified Paths: -------------- pyplusplus_dev/pyplusplus/module_creator/creator.py Modified: pyplusplus_dev/pyplusplus/module_creator/creator.py =================================================================== --- pyplusplus_dev/pyplusplus/module_creator/creator.py 2006-07-24 14:33:50 UTC (rev 339) +++ pyplusplus_dev/pyplusplus/module_creator/creator.py 2006-07-24 15:48:04 UTC (rev 340) @@ -151,12 +151,12 @@ if reason in DO_NOT_REPORT_MSGS: continue readme = readme[1:] - msg = [ 'Declaration "%s" could not be exported.' % decl ] - msg.append( reason.replace( os.linesep, os.linesep + '\t' ) ) - self.decl_logger.warn( os.linesep.join( msg ) ) + msgstr = "%s;%s"%(decl, reason.replace(os.linesep, " ")) + self.decl_logger.warn( msgstr ) for msg in readme: - self.decl_logger.warn( 'Declaration "%s": %s' % ( decl, msg ) ) + msgstr = "%s;%s"%(decl, msg.replace(os.linesep, " ")) + self.decl_logger.warn( msgstr ) #leave only declarations defined under namespace, but remove namespaces decls = filter( lambda x: not isinstance( x, declarations.namespace_t ) \ This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
|
From: <rom...@us...> - 2006-08-20 07:24:11
|
Revision: 422 Author: roman_yakovenko Date: 2006-08-20 00:24:03 -0700 (Sun, 20 Aug 2006) ViewCVS: http://svn.sourceforge.net/pygccxml/?rev=422&view=rev Log Message: ----------- fixing bug: value traits should be declared only once Modified Paths: -------------- pyplusplus_dev/pyplusplus/module_creator/creator.py Modified: pyplusplus_dev/pyplusplus/module_creator/creator.py =================================================================== --- pyplusplus_dev/pyplusplus/module_creator/creator.py 2006-08-20 06:31:37 UTC (rev 421) +++ pyplusplus_dev/pyplusplus/module_creator/creator.py 2006-08-20 07:24:03 UTC (rev 422) @@ -5,7 +5,7 @@ import types_database import class_organizer -import call_policies_resolver +import call_policies_resolver from pygccxml import declarations from pyplusplus import decl_wrappers from pyplusplus import code_creators @@ -26,9 +26,9 @@ # }; #}; -INDEXING_SUITE_1_CONTAINERS = { - 'vector<' : "boost/python/suite/indexing/vector_indexing_suite.hpp" - , 'map<' : "boost/python/suite/indexing/map_indexing_suite.hpp" +INDEXING_SUITE_1_CONTAINERS = { + 'vector<' : "boost/python/suite/indexing/vector_indexing_suite.hpp" + , 'map<' : "boost/python/suite/indexing/map_indexing_suite.hpp" } INDEXING_SUITE_2_CONTAINERS = { @@ -59,7 +59,7 @@ creator tree whose root node is a L{module_t<code_creators.module_t>} object representing the source code for the entire extension module. """ - + def __init__( self , decls , module_name @@ -89,10 +89,10 @@ @type target_configuration: L{target_configuration_t<code_creators.target_configuration_t>} @type doc_extractor: callable """ - declarations.decl_visitor_t.__init__(self) + declarations.decl_visitor_t.__init__(self) self.logger = _logging_.loggers.module_builder self.decl_logger = _logging_.loggers.declarations - + self.__enable_indexing_suite = enable_indexing_suite self.__target_configuration = target_configuration if not self.__target_configuration: @@ -106,28 +106,28 @@ self.__types_db = types_db if not self.__types_db: self.__types_db = types_database.types_database_t() - - self.__extmodule = code_creators.module_t() + + self.__extmodule = code_creators.module_t() self.__extmodule.add_system_header( "boost/python.hpp" ) self.__extmodule.adopt_creator( code_creators.include_t( header="boost/python.hpp" ) ) self.__create_castinig_constructor = create_castinig_constructor if boost_python_ns_name: bp_ns_alias = code_creators.namespace_alias_t( alias=boost_python_ns_name - , full_namespace_name='::boost::python' ) + , full_namespace_name='::boost::python' ) self.__extmodule.adopt_creator( bp_ns_alias ) - + self.__module_body = code_creators.module_body_t( name=module_name ) - self.__extmodule.adopt_creator( self.__module_body ) - + self.__extmodule.adopt_creator( self.__module_body ) + prepared_decls = self._prepare_decls( decls, doc_extractor ) self.__decls = self._filter_decls( self._reorder_decls( prepared_decls ) ) - + self.curr_code_creator = self.__module_body self.curr_decl = None self.__cr_array_1_included = False self.__array_1_registered = set() #(type.decl_string,size) self.__free_operators = [] - + def _prepare_decls( self, decls, doc_extractor ): global DO_NOT_REPORT_MSGS @@ -136,37 +136,37 @@ for decl in decls: if decl.ignore: continue - + if doc_extractor and decl.exportable: decl.documentation = doc_extractor( decl ) readme = decl.readme() if not readme: continue - + if not decl.exportable: reason = readme[0] if reason in DO_NOT_REPORT_MSGS: continue readme = readme[1:] self.decl_logger.warn( "%s;%s" % ( decl, reason ) ) - + for msg in readme: self.decl_logger.warn( "%s;%s" % ( decl, msg ) ) - + #leave only declarations defined under namespace, but remove namespaces decls = filter( lambda x: not isinstance( x, declarations.namespace_t ) \ and isinstance( x.parent, declarations.namespace_t ) , decls ) #leave only decls that user wants to export and that could be exported decls = filter( lambda x: x.ignore == False and x.exportable == True, decls ) - + return decls def _reorder_decls(self, decls ): classes = filter( lambda x: isinstance( x, declarations.class_t ) , decls ) - + ordered = class_organizer.findout_desired_order( classes ) ids = set( [ id( inst ) for inst in ordered ] ) for decl in decls: @@ -191,14 +191,14 @@ else: others.append( inst ) #this will prevent from py++ to change the order of generated code - cmp_by_name = lambda d1, d2: cmp( d1.name, d2.name ) - cmp_by_line = lambda d1, d2: cmp( d1.location.line, d2.location.line ) + cmp_by_name = lambda d1, d2: cmp( d1.name, d2.name ) + cmp_by_line = lambda d1, d2: cmp( d1.location.line, d2.location.line ) enums.sort( cmp=cmp_by_name ) others.sort( cmp=cmp_by_name ) variables.sort( cmp=cmp_by_name ) constructors.sort( cmp=cmp_by_line ) - + new_ordered = [] new_ordered.extend( enums ) new_ordered.extend( classes ) @@ -206,7 +206,7 @@ new_ordered.extend( others ) new_ordered.extend( variables ) return new_ordered # - + def _exportable_class_members( self, class_decl ): assert isinstance( class_decl, declarations.class_t ) members = filter( lambda mv: mv.ignore == False and mv.exportable, class_decl.public_members ) @@ -217,13 +217,13 @@ continue else: members.append( member ) - + vfunction_selector = lambda member: isinstance( member, declarations.member_function_t ) \ - and member.virtuality == VIRTUALITY_TYPES.PURE_VIRTUAL + and member.virtuality == VIRTUALITY_TYPES.PURE_VIRTUAL members.extend( filter( vfunction_selector, class_decl.private_members ) ) #now lets filter out none public operators: Py++ does not support them right now members = filter( lambda decl: not isinstance( decl, declarations.member_operator_t ) - or decl.access_type == ACCESS_TYPES.PUBLIC + or decl.access_type == ACCESS_TYPES.PUBLIC , members ) #-#if declarations.has_destructor( class_decl ) \ #-# and not declarations.has_public_destructor( class_decl ): @@ -234,18 +234,18 @@ members = filter( lambda member: member.ignore == False and member.exportable, members ) ordered_members = self._reorder_decls( members ) return ordered_members - + def _does_class_have_smth_to_export(self, exportable_members ): return bool( self._filter_decls( exportable_members ) ) - + def _is_constructor_of_abstract_class( self, decl ): assert isinstance( decl, declarations.constructor_t ) return decl.parent.is_abstract - + def _filter_decls( self, decls ): # Filter out artificial (compiler created) types unless they are classes # See: http://public.kitware.com/pipermail/gccxml/2004-October/000486.html - decls = filter( lambda x: not (x.is_artificial and + decls = filter( lambda x: not (x.is_artificial and not (isinstance(x, ( declarations.class_t, declarations.enumeration_t)))) , decls ) # Filter out type defs @@ -268,18 +268,18 @@ if f1_arg.type != f2_arg.type: return False return True - + def redefined_funcs( self, cls ): all_included = declarations.custom_matcher_t( lambda decl: decl.ignore == False and decl.exportable ) all_protected = declarations.access_type_matcher_t( 'protected' ) & all_included all_pure_virtual = declarations.virtuality_type_matcher_t( VIRTUALITY_TYPES.PURE_VIRTUAL ) all_not_pure_virtual = ~all_pure_virtual - + query = all_protected | all_pure_virtual - + funcs = set() defined_funcs = set() - + for base in cls.recursive_bases: if base.access == ACCESS_TYPES.PRIVATE: continue @@ -290,7 +290,7 @@ defined_funcs.update( base_cls.member_functions( all_not_pure_virtual, allow_empty=True ) ) defined_funcs.update( base_cls.member_operators( all_not_pure_virtual, allow_empty=True ) ) - not_reimplemented_funcs = set() + not_reimplemented_funcs = set() for f in funcs: cls_fs = cls.calldefs( name=f.name, recursive=False, allow_empty=True ) for cls_f in cls_fs: @@ -315,7 +315,7 @@ functions.sort( cmp=lambda f1, f2: cmp( ( f1.name, f1.location.as_tuple() ) , ( f2.name, f2.location.as_tuple() ) ) ) return functions - + def _is_wrapper_needed(self, class_inst, exportable_members): if isinstance( self.curr_decl, declarations.class_t ) \ and self.curr_decl.wrapper_code: @@ -325,7 +325,7 @@ return True else: pass - + for member in exportable_members: if isinstance( member, declarations.destructor_t ): continue @@ -346,12 +346,12 @@ if member.access_type in ( ACCESS_TYPES.PROTECTED, ACCESS_TYPES.PRIVATE ): return True #we already decided that those functions should be exposed, so I need wrapper for them return bool( self.redefined_funcs(class_inst) ) - + def _adopt_free_operator( self, operator ): def adopt_operator_impl( operator, found_creators ): creator = filter( lambda creator: isinstance( creator, code_creators.class_t ) , found_creators ) - if len(creator) == 1: + if len(creator) == 1: creator = creator[0] #I think I don't need this condition any more if not find( lambda creator: isinstance( creator, code_creators.declaration_based_t ) @@ -392,7 +392,7 @@ return True else: assert not "unknown instace of registrator: " % str( registered ) - + def _treat_smart_pointers( self ): """ Go to all class creators and apply held_type and creator registrators as needed. @@ -411,7 +411,7 @@ if not self._is_registered_smart_pointer_creator( r, registrators_db ): creator.adopt_creator(r) registrators_db.append(r) - + def _append_user_code( self ): find_classes = code_creators.creator_finder.find_by_class_instance class_creators = find_classes( what=code_creators.class_t @@ -422,29 +422,29 @@ for cls_creator in class_creators: cls_decl = cls_creator.declaration #uc = user code - uc_creators = map( lambda uc: ctext_t( uc.text, uc.works_on_instance ) + uc_creators = map( lambda uc: ctext_t( uc.text, uc.works_on_instance ) , cls_decl.registration_code ) cls_creator.adopt_creators( uc_creators ) - + uc_creators = map( lambda uc: ctext_t( uc.text ), cls_decl.wrapper_code ) if uc_creators: cls_creator.wrapper.adopt_creators( uc_creators ) - + uc_creators = map( lambda uc: ctext_t( uc.text ), cls_decl.declaration_code ) insert_pos = self.__extmodule.creators.index( self.__module_body ) self.__extmodule.adopt_creators( uc_creators, insert_pos ) cls_creator.user_declarations.extend( uc_creators ) - + def _treat_indexing_suite( self ): global INDEXING_SUITE_1_CONTAINERS global INDEXING_SUITE_2_CONTAINERS global INDEXING_SUITE_2_MAIN_HEADER - + def create_explanation(cls): msg = '//WARNING: the next line of code will not compile, because "%s" does not have operator== !' msg = msg % cls.indexing_suite.element_type.decl_string return code_creators.custom_text_t( msg, False ) - + def create_cls_cc( cls ): if isinstance( cls, declarations.class_t ): return code_creators.class_t( class_inst=cls ) @@ -452,12 +452,13 @@ return code_creators.class_declaration_t( class_inst=cls ) if not self.__types_db.used_containers: - return - + return + used_headers = set() creators = [] - + created_value_traits = set() + cmp_by_name = lambda cls1, cls2: cmp( cls1.decl_string, cls2.decl_string ) used_containers = list( self.__types_db.used_containers ) used_containers.sort( cmp_by_name ) @@ -471,9 +472,9 @@ if not isuite.has_key( container_name ): continue #not supported - + if isuite is INDEXING_SUITE_2_CONTAINERS: - used_headers.add( INDEXING_SUITE_2_MAIN_HEADER ) + used_headers.add( INDEXING_SUITE_2_MAIN_HEADER ) used_headers.add( isuite[ container_name ] ) @@ -487,15 +488,16 @@ if not ( None is element_type ) \ and declarations.is_class( element_type ) \ and not declarations.has_public_equal( element_type ): - cls_creator.adopt_creator( create_explanation( cls ) ) + cls_creator.adopt_creator( create_explanation( cls ) ) cls_creator.adopt_creator( code_creators.indexing_suite1_t(cls) ) else: class_traits = declarations.class_traits - if not ( None is element_type ) \ - and class_traits.is_my_case( element_type ): + if not ( None is element_type ) and class_traits.is_my_case( element_type ): value_cls = class_traits.get_declaration( element_type ) - element_type_cc = code_creators.value_traits_t( value_cls ) - self.__extmodule.adopt_declaration_creator( element_type_cc ) + if value_cls not in created_value_traits: + created_value_traits.add( value_cls ) + element_type_cc = code_creators.value_traits_t( value_cls ) + self.__extmodule.adopt_declaration_creator( element_type_cc ) cls_creator.adopt_creator( code_creators.indexing_suite2_t(cls) ) if INDEXING_SUITE_2_MAIN_HEADER in used_headers: @@ -503,11 +505,11 @@ used_headers.remove( INDEXING_SUITE_2_MAIN_HEADER ) self.__extmodule.add_system_header( INDEXING_SUITE_2_MAIN_HEADER ) self.__extmodule.add_include( INDEXING_SUITE_2_MAIN_HEADER ) - + for header in used_headers: self.__extmodule.add_system_header( header ) self.__extmodule.add_include( header ) - + #I am going tp find last class registration and to add all container creators #after it. last_cls_index = -1 @@ -519,10 +521,10 @@ creators.reverse() for creator in creators: self.__module_body.adopt_creator( creator, insert_position ) - + def create(self, decl_headers=None): """Create and return the module for the extension. - + @param decl_headers: If None the headers for the wrapped decls are automatically found. But you can pass a list of headers here to override that search. @returns: Returns the root of the code creators tree @@ -592,42 +594,42 @@ fwrapper_cls = code_creators.mem_fun_v_wrapper_t maker_cls = code_creators.mem_fun_v_t return ( maker_cls, fwrapper_cls ) - + def visit_member_function( self ): fwrapper = None self.__types_db.update( self.curr_decl ) if None is self.curr_decl.call_policies: self.curr_decl.call_policies = self.__call_policies_resolver( self.curr_decl ) - + maker_cls, fwrapper_cls = self.guess_functions_code_creators() - + maker = None fwrapper = None if fwrapper_cls: fwrapper = fwrapper_cls( function=self.curr_decl ) class_wrapper = self.curr_code_creator.wrapper class_wrapper.adopt_creator( fwrapper ) - + if maker_cls: if fwrapper: maker = maker_cls( function=self.curr_decl, wrapper=fwrapper ) else: maker = maker_cls( function=self.curr_decl ) - self.curr_code_creator.adopt_creator( maker ) - + self.curr_code_creator.adopt_creator( maker ) + if self.curr_decl.has_static: #static_method should be created only once. - found = filter( lambda creator: isinstance( creator, code_creators.static_method_t ) + found = filter( lambda creator: isinstance( creator, code_creators.static_method_t ) and creator.declaration.name == self.curr_decl.name , self.curr_code_creator.creators ) if not found: static_method = code_creators.static_method_t( function=self.curr_decl , function_code_creator=maker ) self.curr_code_creator.adopt_creator( static_method ) - + def visit_constructor( self ): if self.curr_decl.is_copy_constructor: - return + return self.__types_db.update( self.curr_decl ) if not self._is_constructor_of_abstract_class( self.curr_decl ) \ and 1 == len( self.curr_decl.arguments ) \ @@ -646,10 +648,10 @@ if None is self.curr_decl.call_policies: self.curr_decl.call_policies = self.__call_policies_resolver( self.curr_decl ) self.curr_code_creator.adopt_creator( maker ) - + def visit_destructor( self ): pass - + def visit_member_operator( self ): if self.curr_decl.symbol in ( '()', '[]' ): self.visit_member_function() @@ -657,32 +659,32 @@ self.__types_db.update( self.curr_decl ) maker = code_creators.operator_t( operator=self.curr_decl ) self.curr_code_creator.adopt_creator( maker ) - + def visit_casting_operator( self ): if not declarations.is_fundamental( self.curr_decl.return_type ) \ and not self.curr_decl.has_const: return #only const casting operators can generate implicitly_convertible - + if None is self.curr_decl.call_policies: self.curr_decl.call_policies = self.__call_policies_resolver( self.curr_decl ) - + self.__types_db.update( self.curr_decl ) if not self.curr_decl.parent.is_abstract \ and not declarations.is_reference( self.curr_decl.return_type ): maker = code_creators.casting_operator_t( operator=self.curr_decl ) - self.__module_body.adopt_creator( maker ) + self.__module_body.adopt_creator( maker ) #what to do if class is abstract if self.curr_decl.access_type == ACCESS_TYPES.PUBLIC: maker = code_creators.casting_member_operator_t( operator=self.curr_decl ) self.curr_code_creator.adopt_creator( maker ) - + def visit_free_function( self ): self.__types_db.update( self.curr_decl ) maker = code_creators.free_function_t( function=self.curr_decl ) if None is self.curr_decl.call_policies: - self.curr_decl.call_policies = self.__call_policies_resolver( self.curr_decl ) + self.curr_decl.call_policies = self.__call_policies_resolver( self.curr_decl ) self.curr_code_creator.adopt_creator( maker ) - + def visit_free_operator( self ): self.__types_db.update( self.curr_decl ) self.__free_operators.append( self.curr_decl ) @@ -692,8 +694,8 @@ def visit_class(self ): assert isinstance( self.curr_decl, declarations.class_t ) - temp_curr_decl = self.curr_decl - temp_curr_parent = self.curr_code_creator + temp_curr_decl = self.curr_decl + temp_curr_parent = self.curr_code_creator exportable_members = self._exportable_class_members(self.curr_decl) wrapper = None @@ -703,7 +705,7 @@ wrapper = code_creators.class_wrapper_t( declaration=self.curr_decl , class_creator=class_inst ) class_inst.wrapper = wrapper - #insert wrapper before module body + #insert wrapper before module body if isinstance( self.curr_decl.parent, declarations.class_t ): #we deal with internal class self.curr_code_creator.wrapper.adopt_creator( wrapper ) @@ -714,13 +716,13 @@ #to construct wrapper from wrapped classe if not self.curr_decl.noncopyable: copy_constr = code_creators.copy_constructor_wrapper_t( class_inst=self.curr_decl ) - wrapper.adopt_creator( copy_constr ) + wrapper.adopt_creator( copy_constr ) null_constr = declarations.find_trivial_constructor(self.curr_decl) if null_constr and null_constr.is_artificial: #this constructor is not going to be exposed tcons = code_creators.null_constructor_wrapper_t( class_inst=self.curr_decl ) - wrapper.adopt_creator( tcons ) - + wrapper.adopt_creator( tcons ) + self.curr_code_creator.adopt_creator( class_inst ) self.curr_code_creator = class_inst for decl in exportable_members: @@ -740,10 +742,10 @@ for static_method in static_methods: class_inst.remove_creator( static_method ) class_inst.adopt_creator( static_method ) - - self.curr_decl = temp_curr_decl + + self.curr_decl = temp_curr_decl self.curr_code_creator = temp_curr_parent - + def visit_enumeration(self): assert isinstance( self.curr_decl, declarations.enumeration_t ) maker = None @@ -752,7 +754,7 @@ else: maker = code_creators.unnamed_enum_t( unnamed_enum=self.curr_decl ) self.curr_code_creator.adopt_creator( maker ) - + def visit_namespace(self): pass @@ -765,11 +767,11 @@ return False else: self.__array_1_registered.add( data ) - return True - + return True + def visit_variable(self): self.__types_db.update( self.curr_decl ) - + if declarations.is_array( self.curr_decl.type ): if not self.__cr_array_1_included: self.__extmodule.add_system_header( code_repository.array_1.file_name ) @@ -779,7 +781,7 @@ if self._register_array_1( self.curr_decl.type ): array_1_registrator = code_creators.array_1_registrator_t( array_type=self.curr_decl.type ) self.curr_code_creator.adopt_creator( array_1_registrator ) - + if isinstance( self.curr_decl.parent, declarations.namespace_t ): maker = None wrapper = None @@ -808,9 +810,9 @@ if None is self.curr_decl.setter_call_policies: self.curr_decl.setter_call_policies = self.__call_policies_resolver( self.curr_decl, 'set' ) wrapper = code_creators.mem_var_ref_wrapper_t( variable=self.curr_decl ) - maker = code_creators.mem_var_ref_t( variable=self.curr_decl, wrapper=wrapper ) + maker = code_creators.mem_var_ref_t( variable=self.curr_decl, wrapper=wrapper ) else: - maker = code_creators.member_variable_t( variable=self.curr_decl ) + maker = code_creators.member_variable_t( variable=self.curr_decl ) if wrapper: self.curr_code_creator.wrapper.adopt_creator( wrapper ) - self.curr_code_creator.adopt_creator( maker ) \ No newline at end of file + self.curr_code_creator.adopt_creator( maker ) This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
|
From: <rom...@us...> - 2006-08-30 06:18:32
|
Revision: 493 Author: roman_yakovenko Date: 2006-08-29 23:18:25 -0700 (Tue, 29 Aug 2006) ViewCVS: http://svn.sourceforge.net/pygccxml/?rev=493&view=rev Log Message: ----------- small refactoring before introducing BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS functionality Modified Paths: -------------- pyplusplus_dev/pyplusplus/module_creator/creator.py Modified: pyplusplus_dev/pyplusplus/module_creator/creator.py =================================================================== --- pyplusplus_dev/pyplusplus/module_creator/creator.py 2006-08-30 05:18:13 UTC (rev 492) +++ pyplusplus_dev/pyplusplus/module_creator/creator.py 2006-08-30 06:18:25 UTC (rev 493) @@ -137,6 +137,14 @@ if decl.ignore: continue + if isinstance( decl, declarations.calldef_t ) and not isinstance( decl, declarations.destructor_t ): + self.__types_db.update( decl ) + if None is decl.call_policies: + decl.call_policies = self.__call_policies_resolver( decl ) + + if isinstance( decl, declarations.variable_t ): + self.__types_db.update( decl ) + if doc_extractor and decl.exportable: decl.documentation = doc_extractor( decl ) @@ -154,6 +162,7 @@ for msg in readme: self.decl_logger.warn( "%s;%s" % ( decl, msg ) ) + #leave only declarations defined under namespace, but remove namespaces decls = filter( lambda x: not isinstance( x, declarations.namespace_t ) \ and isinstance( x.parent, declarations.namespace_t ) @@ -597,9 +606,6 @@ def visit_member_function( self ): fwrapper = None - self.__types_db.update( self.curr_decl ) - if None is self.curr_decl.call_policies: - self.curr_decl.call_policies = self.__call_policies_resolver( self.curr_decl ) maker_cls, fwrapper_cls = self.guess_functions_code_creators() @@ -630,7 +636,6 @@ def visit_constructor( self ): if self.curr_decl.is_copy_constructor: return - self.__types_db.update( self.curr_decl ) if not self._is_constructor_of_abstract_class( self.curr_decl ) \ and 1 == len( self.curr_decl.arguments ) \ and self.__create_castinig_constructor \ @@ -656,19 +661,15 @@ if self.curr_decl.symbol in ( '()', '[]' ): self.visit_member_function() else: - self.__types_db.update( self.curr_decl ) maker = code_creators.operator_t( operator=self.curr_decl ) self.curr_code_creator.adopt_creator( maker ) def visit_casting_operator( self ): if not declarations.is_fundamental( self.curr_decl.return_type ) \ and not self.curr_decl.has_const: + #TODO: move this code to decl_wrappers return #only const casting operators can generate implicitly_convertible - if None is self.curr_decl.call_policies: - self.curr_decl.call_policies = self.__call_policies_resolver( self.curr_decl ) - - self.__types_db.update( self.curr_decl ) if not self.curr_decl.parent.is_abstract \ and not declarations.is_reference( self.curr_decl.return_type ): maker = code_creators.casting_operator_t( operator=self.curr_decl ) @@ -679,14 +680,10 @@ self.curr_code_creator.adopt_creator( maker ) def visit_free_function( self ): - self.__types_db.update( self.curr_decl ) maker = code_creators.free_function_t( function=self.curr_decl ) - if None is self.curr_decl.call_policies: - self.curr_decl.call_policies = self.__call_policies_resolver( self.curr_decl ) self.curr_code_creator.adopt_creator( maker ) def visit_free_operator( self ): - self.__types_db.update( self.curr_decl ) self.__free_operators.append( self.curr_decl ) def visit_class_declaration(self ): @@ -778,8 +775,6 @@ return True def visit_variable(self): - self.__types_db.update( self.curr_decl ) - if declarations.is_array( self.curr_decl.type ): if not self.__cr_array_1_included: self.__extmodule.add_system_header( code_repository.array_1.file_name ) This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
|
From: <rom...@us...> - 2006-08-30 06:32:51
|
Revision: 494 Author: roman_yakovenko Date: 2006-08-29 23:32:44 -0700 (Tue, 29 Aug 2006) ViewCVS: http://svn.sourceforge.net/pygccxml/?rev=494&view=rev Log Message: ----------- make variable names clear Modified Paths: -------------- pyplusplus_dev/pyplusplus/module_creator/creator.py Modified: pyplusplus_dev/pyplusplus/module_creator/creator.py =================================================================== --- pyplusplus_dev/pyplusplus/module_creator/creator.py 2006-08-30 06:18:25 UTC (rev 493) +++ pyplusplus_dev/pyplusplus/module_creator/creator.py 2006-08-30 06:32:44 UTC (rev 494) @@ -691,17 +691,17 @@ def visit_class(self ): assert isinstance( self.curr_decl, declarations.class_t ) - temp_curr_decl = self.curr_decl - temp_curr_parent = self.curr_code_creator + cls_decl = self.curr_decl + cls_parent_cc = self.curr_code_creator exportable_members = self._exportable_class_members(self.curr_decl) wrapper = None - class_inst = code_creators.class_t( class_inst=self.curr_decl ) + cls_cc = code_creators.class_t( class_inst=self.curr_decl ) if self._is_wrapper_needed( self.curr_decl, exportable_members ): wrapper = code_creators.class_wrapper_t( declaration=self.curr_decl - , class_creator=class_inst ) - class_inst.wrapper = wrapper + , class_creator=cls_cc ) + cls_cc.wrapper = wrapper #insert wrapper before module body if isinstance( self.curr_decl.parent, declarations.class_t ): #we deal with internal class @@ -720,13 +720,13 @@ tcons = code_creators.null_constructor_wrapper_t( class_inst=self.curr_decl ) wrapper.adopt_creator( tcons ) - self.curr_code_creator.adopt_creator( class_inst ) - self.curr_code_creator = class_inst + cls_parent_cc.adopt_creator( cls_cc ) + self.curr_code_creator = cls_cc for decl in exportable_members: self.curr_decl = decl declarations.apply_visitor( self, decl ) - for redefined_func in self.redefined_funcs( temp_curr_decl ): + for redefined_func in self.redefined_funcs( cls_decl ): if isinstance( redefined_func, declarations.operator_t ): continue self.curr_decl = redefined_func @@ -735,22 +735,23 @@ #all static_methods_t should be moved to the end #better approach is to move them after last def of relevant function static_methods = filter( lambda creator: isinstance( creator, code_creators.static_method_t ) - , class_inst.creators ) + , cls_cc.creators ) for static_method in static_methods: - class_inst.remove_creator( static_method ) - class_inst.adopt_creator( static_method ) + cls_cc.remove_creator( static_method ) + cls_cc.adopt_creator( static_method ) - if temp_curr_decl.exception_translation_code: - translator = code_creators.exception_translator_t( temp_curr_decl ) + if cls_decl.exception_translation_code: + translator = code_creators.exception_translator_t( cls_decl ) self.__extmodule.adopt_declaration_creator( translator ) - class_inst.user_declarations.append( translator ) + cls_cc.user_declarations.append( translator ) translator_register \ - = code_creators.exception_translator_register_t( temp_curr_decl, translator ) - class_inst.adopt_creator( translator_register ) + = code_creators.exception_translator_register_t( cls_decl, translator ) + cls_cc.adopt_creator( translator_register ) - self.curr_decl = temp_curr_decl - self.curr_code_creator = temp_curr_parent + self.curr_decl = cls_decl + self.curr_code_creator = cls_parent_cc + def visit_enumeration(self): assert isinstance( self.curr_decl, declarations.enumeration_t ) maker = None This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
