def __find_out_class_dependencies(self, class_): full_name = declarations.full_name #class depends on it's base classes i_depend_on_them = set( [full_name(base.related_class) for base in class_.bases]) #class depends on all classes that used in function as argument # types and those arguments have default value calldefs = [ decl for decl in declarations.make_flatten(class_) if isinstance(decl, declarations.calldef_t) ] for calldef in calldefs: for arg in calldef.arguments: if declarations.is_enum(arg.type): top_class_inst = self.__get_top_class_inst( declarations.enum_declaration(arg.type)) if top_class_inst: i_depend_on_them.add(full_name(top_class_inst)) continue if not arg.default_value: continue if declarations.is_pointer( arg.type) and arg.default_value == 0: continue base_type = declarations.base_type(arg.type) if not isinstance(base_type, declarations.declarated_t): continue top_class_inst = self.__get_top_class_inst( base_type.declaration) if top_class_inst: i_depend_on_them.add(full_name(top_class_inst)) if self.__include_vars: vars = [ decl for decl in declarations.make_flatten(class_) if isinstance(decl, declarations.variable_t) ] for var in vars: if declarations.is_pointer(var.type): continue base_type = declarations.base_type(var.type) if not isinstance(base_type, declarations.declarated_t): continue top_class_inst = self.__get_top_class_inst( base_type.declaration) if top_class_inst: i_depend_on_them.add(full_name(top_class_inst)) for internal_cls in class_.classes(allow_empty=True): internal_cls_dependencies = self.__find_out_class_dependencies( internal_cls) i_depend_on_them.update(internal_cls_dependencies) i_depend_on_them = list(i_depend_on_them) i_depend_on_them.sort() return i_depend_on_them
def test_by_location(self): reader = parser.source_reader_t( self.config ) decls = reader.read_file( self.__fname ) decls_count = len( declarations.make_flatten( decls ) ) filtered = declarations.filtering.by_location( decls, [autoconfig.data_directory] ) flatten_filtered = declarations.make_flatten( filtered ) self.failUnless( len( flatten_filtered ) != decls_count ) for decl in flatten_filtered: if decl.location: self.failUnless( declarations.filtering.normalize_path( decl.location.file_name ) , self.__fpath ) self.failUnless( declarations.find_declaration( filtered , name='color' , type=declarations.enumeration_t , recursive=False) )
def parseIncludeFile(f, define=[], includes=[], ps=4): global ptr_size ptr_size = ps gccxmlexe = os.getenv("GCCXML", "gccxml") config = parser.config_t(gccxml_path=gccxmlexe, define_symbols=define, include_paths=includes) functions = {} if isinstance(f, list): global_ns = parser.parse(f, config) else: global_ns = parser.parse([f], config) all_decls = declarations.make_flatten(global_ns) all_functions = filter(lambda decl: isinstance(decl, declarations.free_function_t), \ all_decls) for f in all_functions: if not f.name.startswith("__"): # if f.name == "ReadFileEx": functions[f.name] = parseFunction(f) return functions
def test_remove_va_list_tag(self): if "gccxml" in self.config.xml_generator: return True self.config.flags = [] src_reader = parser.source_reader_t(self.config) decls = declarations.make_flatten(src_reader.read_string(self.__code)) classes = [ i for i in decls if isinstance(i, declarations.class_t)] typedefs = [ i for i in decls if isinstance(i, declarations.typedef_t)] variables = [ i for i in decls if isinstance(i, declarations.variable_t)] tag = "__va_list_tag" self.assertFalse(tag in [class_.name for class_ in classes]) self.assertTrue("a" in [class_.name for class_ in classes]) self.assertTrue(len(classes) == 1) self.assertFalse(tag in [ty.name for ty in typedefs]) self.assertTrue(len(typedefs) == 3) self.assertFalse( tag in [var.decl_string.split("::")[1] for var in variables]) self.assertTrue(len(variables) == 0)
def parseIncludeFile(f, define = [], includes = [], ps = 4): global ptr_size ptr_size = ps gccxmlexe = os.getenv("GCCXML", "gccxml") config = parser.config_t(gccxml_path = gccxmlexe, define_symbols = define, include_paths = includes) functions = {} if isinstance(f, list): global_ns = parser.parse(f, config) else: global_ns = parser.parse([f], config) all_decls = declarations.make_flatten(global_ns) all_functions = filter(lambda decl: isinstance(decl, declarations.free_function_t), \ all_decls) for f in all_functions: if not f.name.startswith("__"): # if f.name == "ReadFileEx": functions[f.name] = parseFunction(f) return functions
def test_remove_va_list_tag(self): if "gccxml" in self.config.xml_generator: return True self.config.flags = [] src_reader = parser.source_reader_t(self.config) decls = declarations.make_flatten(src_reader.read_string(self.__code)) classes = [i for i in decls if isinstance(i, declarations.class_t)] typedefs = [i for i in decls if isinstance(i, declarations.typedef_t)] variables = [ i for i in decls if isinstance(i, declarations.variable_t) ] tag = "__va_list_tag" self.assertFalse(tag in [class_.name for class_ in classes]) self.assertTrue("a" in [class_.name for class_ in classes]) self.assertTrue(len(classes) == 1) self.assertFalse(tag in [ty.name for ty in typedefs]) self.assertTrue(len(typedefs) == 3) self.assertFalse( tag in [var.decl_string.split("::")[1] for var in variables]) self.assertTrue(len(variables) == 0)
def __find_out_class_dependencies( self, class_ ): full_name = declarations.full_name #class depends on it's base classes i_depend_on_them = set( [ full_name( base.related_class ) for base in class_.bases ] ) #class depends on all classes that used in function as argument # types and those arguments have default value calldefs = filter( lambda decl: isinstance( decl, declarations.calldef_t ) , declarations.make_flatten( class_ )) for calldef in calldefs: for arg in calldef.arguments: if declarations.is_enum( arg.type ): top_class_inst = self.__get_top_class_inst( declarations.enum_declaration( arg.type ) ) if top_class_inst: i_depend_on_them.add( full_name( top_class_inst ) ) continue if not arg.default_value: continue if declarations.is_pointer( arg.type ) and arg.default_value == 0: continue base_type = declarations.base_type( arg.type ) if not isinstance( base_type, declarations.declarated_t ): continue top_class_inst = self.__get_top_class_inst( base_type.declaration ) if top_class_inst: i_depend_on_them.add( full_name( top_class_inst ) ) for internal_cls in class_.classes(allow_empty=True): internal_cls_dependencies = self.__find_out_class_dependencies( internal_cls ) i_depend_on_them.update( internal_cls_dependencies ) i_depend_on_them = list( i_depend_on_them ) i_depend_on_them.sort() return i_depend_on_them
def test_comparison_declaration_by_declaration(self): parsed = parser.parse([self.header], self.config) copied = copy.deepcopy(parsed) parsed = declarations.make_flatten(parsed) copied = declarations.make_flatten(copied) parsed.sort() copied.sort() failuers = [] for parsed_decl, copied_decl, index in \ zip(parsed, copied, list(range(len(copied)))): if parsed_decl != copied_decl: failuers.append(("__lt__ and/or __qe__ does not working " + "properly in case of %s, %s, index %d") % (parsed_decl.__class__.__name__, copied_decl.__class__.__name__, index)) self.assertTrue(not failuers, 'Failures: ' + '\n\t'.join(failuers))
def test_comparison_declaration_by_declaration(self): parsed = parser.parse([self.header], self.config) copied = copy.deepcopy(parsed) parsed = declarations.make_flatten(parsed) copied = declarations.make_flatten(copied) parsed.sort() copied.sort() failuers = [] for parsed_decl, copied_decl, index in \ zip(parsed, copied, list(range(len(copied)))): if parsed_decl != copied_decl: failuers.append( ("__lt__ and/or __qe__ does not working " + "properly in case of %s, %s, index %d") % (parsed_decl.__class__.__name__, copied_decl.__class__.__name__, index)) self.failUnless(not failuers, 'Failures: ' + '\n\t'.join(failuers))
def patch_it(self): for decl in declarations.make_flatten( self.decls ): if not isinstance( decl, declarations.calldef_t ): continue for arg in decl.arguments: if not arg.default_value: continue fixer = self.__find_fixer( decl, arg ) if fixer: arg.default_value = fixer( decl, arg )
def test_recursive_derived(self): src_reader = parser.source_reader_t( self.config ) decls = declarations.make_flatten( src_reader.read_string( self.__code ) ) classes = filter( lambda inst: isinstance( inst, declarations.class_t ), decls ) for class_ in classes: self.failUnless( self.__recursive_derived.has_key( class_.name ) ) all_derived = class_.recursive_derived control_derived = self.__recursive_derived[ class_.name ] self.failUnless( len(control_derived) == len( all_derived ) ) all_derived_names = map( lambda hi: hi.related_class.name, all_derived ) self.failUnless( set( all_derived_names ) == control_derived )
def test_recursive_bases(self): src_reader = parser.source_reader_t(self.config) decls = declarations.make_flatten(src_reader.read_string(self.__code)) classes = filter(lambda inst: isinstance(inst, declarations.class_t), decls) for class_ in classes: self.failUnless(self.__recursive_bases.has_key(class_.name)) all_bases = class_.recursive_bases control_bases = self.__recursive_bases[class_.name] self.failUnless(len(control_bases) == len(all_bases)) all_bases_names = map(lambda hi: hi.related_class.name, all_bases) self.failUnless(set(all_bases_names) == control_bases)
def test_recursive_bases(self): src_reader = parser.source_reader_t(self.config) decls = declarations.make_flatten(src_reader.read_string(self.__code)) classes = [ inst for inst in decls if isinstance(inst, declarations.class_t)] for class_ in classes: self.assertTrue(class_.name in self.__recursive_bases) all_bases = class_.recursive_bases control_bases = self.__recursive_bases[class_.name] self.assertTrue(len(control_bases) == len(all_bases)) all_bases_names = [hi.related_class.name for hi in all_bases] self.assertTrue(set(all_bases_names) == control_bases)
def test_keep_va_list_tag(self): if "gccxml" in self.config.xml_generator or \ platform.system() == 'Windows': return True self.config.flags = ["f1"] src_reader = parser.source_reader_t(self.config) decls = declarations.make_flatten(src_reader.read_string(self.__code)) classes = [ i for i in decls if isinstance(i, declarations.class_t)] typedefs = [ i for i in decls if isinstance(i, declarations.typedef_t)] variables = [ i for i in decls if isinstance(i, declarations.variable_t)] tag = "__va_list_tag" self.assertTrue(tag in [class_.name for class_ in classes]) self.assertTrue("a" in [class_.name for class_ in classes]) if len(classes) == 2: for c in self.known_classes: self.assertTrue(c in [cl.name for cl in classes]) elif len(classes) == 3: for c in self.known_classes_llvm39: # This is for llvm 3.9 self.assertTrue(c in [cl.name for cl in classes]) self.assertTrue(len(typedefs) == 4 or len(typedefs) == 5) if len(typedefs) == 5: # This is for llvm 3.9. The class __va_list_tag struct is still # there but the typedef is gone for t in self.known_typedefs_llvm39: self.assertTrue(t in [ty.name for ty in typedefs]) self.assertTrue( "__NSConstantString_tag" in [class_.name for class_ in classes]) self.assertTrue( "__NSConstantString" in [ty.name for ty in typedefs]) else: for t in self.known_typedefs: self.assertTrue(t in [ty.name for ty in typedefs]) self.assertTrue( tag in [var.decl_string.split("::")[1] for var in variables]) # 4 variables in __va_list_tag, and 4 more in __NSConstantString_tag # for llvm 3.9 self.assertTrue(len(variables) == 4 or len(variables) == 8)
def __apply_decls_defaults(self, decls): flatten_decls = decls_package.make_flatten( decls ) self.__filter_by_location( flatten_decls ) call_policies_resolver = creators_factory.built_in_resolver_t() calldefs = [decl for decl in flatten_decls if isinstance( decl, decls_package.calldef_t )] for calldef in calldefs: calldef.set_call_policies( call_policies_resolver( calldef ) ) mem_vars = [decl for decl in flatten_decls if isinstance( decl, decls_package.variable_t ) and isinstance( decl.parent, decls_package.class_t )] for mem_var in mem_vars: mem_var.set_getter_call_policies( call_policies_resolver( mem_var, 'get' ) ) for mem_var in mem_vars: mem_var.set_setter_call_policies( call_policies_resolver( mem_var, 'set' ) )
def test_keep_va_list_tag(self): if "gccxml" in self.config.xml_generator: return True self.config.flags = ["f1"] src_reader = parser.source_reader_t(self.config) decls = declarations.make_flatten(src_reader.read_string(self.__code)) classes = [ i for i in decls if isinstance(i, declarations.class_t)] typedefs = [ i for i in decls if isinstance(i, declarations.typedef_t)] variables = [ i for i in decls if isinstance(i, declarations.variable_t)] tag = "__va_list_tag" self.assertTrue(tag in [class_.name for class_ in classes]) self.assertTrue("a" in [class_.name for class_ in classes]) if len(classes) == 2: for c in self.known_classes: self.assertTrue(c in [cl.name for cl in classes]) elif len(classes) == 3: for c in self.known_classes_llvm39: # This is for llvm 3.9 self.assertTrue(c in [cl.name for cl in classes]) self.assertTrue(len(typedefs) == 4 or len(typedefs) == 5) if len(typedefs) == 5: # This is for llvm 3.9. The class __va_list_tag struct is still # there but the typedef is gone for t in self.known_typedefs_llvm39: self.assertTrue(t in [ty.name for ty in typedefs]) self.assertTrue( "__NSConstantString_tag" in [class_.name for class_ in classes]) self.assertTrue( "__NSConstantString" in [ty.name for ty in typedefs]) else: for t in self.known_typedefs: self.assertTrue(t in [ty.name for ty in typedefs]) self.assertTrue( tag in [var.decl_string.split("::")[1] for var in variables]) # 4 variables in __va_list_tag, and 4 more in __NSConstantString_tag # for llvm 3.9 self.assertTrue(len(variables) == 4 or len(variables) == 8)
def test_template_split_std_vector(self): """ Demonstrate error in pattern parser, see #60 """ if self.config.xml_generator == "gccxml": return decls = parser.parse([self.header], self.config) for decl in declarations.make_flatten(decls): if "myClass" in decl.name: _ = decl.partial_name
def test_recursive_derived(self): src_reader = parser.source_reader_t(self.config) decls = declarations.make_flatten(src_reader.read_string(self.__code)) classes = [ inst for inst in decls if isinstance( inst, declarations.class_t)] for class_ in classes: self.failUnless(class_.name in self.__recursive_derived) all_derived = class_.recursive_derived control_derived = self.__recursive_derived[class_.name] self.failUnless(len(control_derived) == len(all_derived)) all_derived_names = [hi.related_class.name for hi in all_derived] self.failUnless(set(all_derived_names) == control_derived)
def register_opaque( self, creator, decl_or_decls ): opaque_decls = [] for decl in declarations.make_flatten( decl_or_decls ): opaque_decls.extend( self.__find_out_opaque_decls( decl ) ) for decl in opaque_decls: opaque_type_registrator = None if id(decl) not in self.__exposed_opaque_decls.keys(): opaque_type_registrator = code_creators.opaque_type_registrator_t( decl ) self.__exposed_opaque_decls[ id(decl) ] = opaque_type_registrator self.__extmodule.adopt_declaration_creator( opaque_type_registrator ) else: opaque_type_registrator = self.__exposed_opaque_decls[ id(decl) ] creator.associated_decl_creators.append(opaque_type_registrator)
def __apply_decls_defaults(self, decls): flatten_decls = decls_package.make_flatten( decls ) self.__filter_by_location( flatten_decls ) call_policies_resolver = mcreator_package.built_in_resolver_t() calldefs = filter( lambda decl: isinstance( decl, decls_package.calldef_t ) , flatten_decls ) map( lambda calldef: calldef.set_call_policies( call_policies_resolver( calldef ) ) , calldefs ) mem_vars = filter( lambda decl: isinstance( decl, decls_package.variable_t ) and isinstance( decl.parent, decls_package.class_t ) , flatten_decls ) map( lambda mem_var: mem_var.set_getter_call_policies( call_policies_resolver( mem_var, 'get' ) ) , mem_vars ) map( lambda mem_var: mem_var.set_setter_call_policies( call_policies_resolver( mem_var, 'set' ) ) , mem_vars )
def register_opaque(self, creator, decl_or_decls): opaque_decls = [] for decl in declarations.make_flatten(decl_or_decls): opaque_decls.extend(self.__find_out_opaque_decls(decl)) for decl in opaque_decls: opaque_type_registrator = None if id(decl) not in self.__exposed_opaque_decls.keys(): opaque_type_registrator = code_creators.opaque_type_registrator_t( decl) self.__exposed_opaque_decls[id(decl)] = opaque_type_registrator self.__extmodule.adopt_declaration_creator( opaque_type_registrator) else: opaque_type_registrator = self.__exposed_opaque_decls[id(decl)] creator.associated_decl_creators.append(opaque_type_registrator)
def test_recursive_bases(self): src_reader = parser.source_reader_t(self.config) decls = declarations.make_flatten(src_reader.read_string(self.__code)) classes = [ inst for inst in decls if isinstance(inst, declarations.class_t)] for class_ in classes: if "CastXML" in utils.xml_generator and \ class_.name == "__va_list_tag": # With CastXML; there is a __va_list_tag which is generated by # clang. Do not run the tests for it. continue self.failUnless(class_.name in self.__recursive_bases) all_bases = class_.recursive_bases control_bases = self.__recursive_bases[class_.name] self.failUnless(len(control_bases) == len(all_bases)) all_bases_names = [hi.related_class.name for hi in all_bases] self.failUnless(set(all_bases_names) == control_bases)
def test(self): mb = module_builder.module_builder_t( self._get_files(), gccxml_path=autoconfig.gccxml.executable, include_paths=[autoconfig.boost.include], undefine_symbols=['__MINGW32__'], compiler=pygccxml.utils.native_compiler.get_gccxml_compiler()) classes = [ d for d in declarations.make_flatten(mb.global_ns) if isinstance(d, module_builder.class_t) ] mdw = module_builder.mdecl_wrapper_t(classes) #check set to property functionality for d in mdw: d.always_expose_using_scope = False mdw.always_expose_using_scope = True all_true = True for d in mdw: all_true &= d.always_expose_using_scope self.failUnless(all_true) #check call method functionality for d in mdw: d.ignore = True mdw.include() all_false = False for d in mdw: all_true |= d.ignore self.failUnless(not all_false) #check for exception: try: mdw.call_policies = None self.fail("Runtime error has not been raised.") except RuntimeError as err: pass
def test_remove_va_list_tag(self): if "gccxml" in self.config.xml_generator or \ platform.system() == 'Windows': return True self.config.flags = [] src_reader = parser.source_reader_t(self.config) decls = declarations.make_flatten(src_reader.read_string(self.__code)) classes = [ i for i in decls if isinstance(i, declarations.class_t)] typedefs = [ i for i in decls if isinstance(i, declarations.typedef_t)] variables = [ i for i in decls if isinstance(i, declarations.variable_t)] tag = "__va_list_tag" self.assertFalse(tag in [class_.name for class_ in classes]) self.assertTrue("a" in [class_.name for class_ in classes]) self.assertTrue(len(classes) == 1) self.assertFalse(tag in [ty.name for ty in typedefs]) self.assertTrue(len(typedefs) == 3 or len(typedefs) == 4) if len(typedefs) == 4: # This is for llvm 3.9 for t in self.known_typedefs_llvm39: self.assertTrue(t in [ty.name for ty in typedefs]) self.assertFalse( "__NSConstantString_tag" in [class_.name for class_ in classes]) self.assertFalse( "__NSConstantString" in [ty.name for ty in typedefs]) else: for t in self.known_typedefs: self.assertTrue(t in [ty.name for ty in typedefs]) self.assertFalse( tag in [var.decl_string.split("::")[1] for var in variables]) self.assertTrue(len(variables) == 0)
def test_remove_va_list_tag(self): if "gccxml" in self.config.xml_generator or \ platform.system() == 'Windows': return True self.config.flags = [] src_reader = parser.source_reader_t(self.config) decls = declarations.make_flatten(src_reader.read_string(self.__code)) classes = [i for i in decls if isinstance(i, declarations.class_t)] typedefs = [i for i in decls if isinstance(i, declarations.typedef_t)] variables = [ i for i in decls if isinstance(i, declarations.variable_t) ] tag = "__va_list_tag" self.assertFalse(tag in [class_.name for class_ in classes]) self.assertTrue("a" in [class_.name for class_ in classes]) self.assertTrue(len(classes) == 1) self.assertFalse(tag in [ty.name for ty in typedefs]) self.assertTrue(len(typedefs) == 3 or len(typedefs) == 4) if len(typedefs) == 4: # This is for llvm 3.9 for t in self.known_typedefs_llvm39: self.assertTrue(t in [ty.name for ty in typedefs]) self.assertFalse("__NSConstantString_tag" in [class_.name for class_ in classes]) self.assertFalse( "__NSConstantString" in [ty.name for ty in typedefs]) else: for t in self.known_typedefs: self.assertTrue(t in [ty.name for ty in typedefs]) self.assertFalse( tag in [var.decl_string.split("::")[1] for var in variables]) self.assertTrue(len(variables) == 0)
def _prepare_decls( self, decls ): to_be_exposed = [] for decl in declarations.make_flatten( decls ): if decl.ignore: continue if isinstance( decl, declarations.namespace_t ): continue if isinstance( decl, declarations.class_types ): if decl.opaque: continue if not decl.exportable: #leave only decls that user wants to export and that could be exported self.__print_readme( decl ) continue if decl.already_exposed: #check wether this is already exposed in other module continue if isinstance( decl.parent, declarations.namespace_t ): #leave only declarations defined under namespace, but remove namespaces to_be_exposed.append( decl ) #Right now this functionality introduce a bug: declarations that should #not be exported for some reason are not marked as such. I will need to #find out. #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 ) self.__print_readme( decl ) return to_be_exposed
def test(self): mb = module_builder.module_builder_t( self._get_files(), gccxml_path=autoconfig.gccxml.executable, include_paths=[autoconfig.boost.include], undefine_symbols=["__MINGW32__"], ) classes = filter(lambda d: isinstance(d, module_builder.class_t), declarations.make_flatten(mb.global_ns)) mdw = module_builder.mdecl_wrapper_t(classes) # check set to property functionality for d in mdw: d.always_expose_using_scope = False mdw.always_expose_using_scope = True all_true = True for d in mdw: all_true &= d.always_expose_using_scope self.failUnless(all_true) # check call method functionality for d in mdw: d.ignore = True mdw.include() all_false = False for d in mdw: all_true |= d.ignore self.failUnless(not all_false) # check for exception: try: mdw.call_policies = None self.fail("Runtime error has not been raised.") except RuntimeError, err: pass
def test__str__(self): decls = declarations.make_flatten(self.decls) for decl in decls: str(decl)
def parse(self): """Parse the header files and setup the known declarations. Currently this method can only be called once. This method can be called anytime after initialization and all Template() calls have been made. :rtype: Returns the root of the declaration tree @rtype: L{IDecl<declwrapper.IDecl>} @postcondition: This class can act as a wrapper for namespace("::") and all declarations are set to be ignored. """ if self.mHeaderFiles == []: raise ValueError, "No header files specified" if self.mVerbose: print "Parsing headers: ", self.mHeaderFiles # Record the time when parsing started... self.mStartTime = time.time() # Create and initialize the config object parser_cfg = parser.config_t(self.mGccXmlPath, self.mWorkingDir, self.mIncludePaths, define_symbols=self.mDefines, undefine_symbols=self.mUndefines, start_with_declarations=None) full_header_list = self.mHeaderFiles[:] # Handle template instantiation as needed temp_file, temp_filename = (None, None) template_instantiation_text = self.buildTemplateFileContents() if None != template_instantiation_text: temp_filename = pygccxml.utils.create_temp_file_name(suffix=".h") temp_file = file(temp_filename, 'w') temp_file.write(template_instantiation_text) temp_file.close() if self.mVerbose: print " creating template instantiation file: ", temp_filename full_header_list.append(temp_filename) # Create the cache object... if self.mCacheDir != None: if self.mVerbose: print "Using directory cache in '%s'" % self.mCacheDir cache = parser.directory_cache_t(self.mCacheDir) elif self.mCacheFile != None: if self.mVerbose: print "Using file cache '%s'" % self.mCacheFile cache = parser.file_cache_t(self.mCacheFile) else: if self.mVerbose: print "No cache in use" cache = None # Create the parser object... the_parser = parser.project_reader_t( config=parser_cfg, cache=cache, decl_factory=decl_wrappers.dwfactory_t()) # ...and parse the headers parsed_decls = the_parser.read_files( full_header_list, parser.project_reader.COMPILATION_MODE.FILE_BY_FILE) assert len(parsed_decls) == 1 # assume that we get root of full tree self.mDeclRoot = parsed_decls[0] # Parse the files and add to decl root # - then traverse tree setting everything to ignore self.mDeclRootWrapper = DeclWrapper(self.mDeclRoot) # Set the module builder instance (this is done here and not in the # constructor so that Allen's DeclWrapper object still work as well) self.mDeclRootWrapper.modulebuilder = self self.mDeclRootWrapper.ignore() # Cleanup if temp_filename: pygccxml.utils.remove_file_no_raise(temp_filename) typedef_decls = declarations.make_flatten(parsed_decls) typedef_decls = decls = filter( lambda x: (isinstance(x, declarations.typedef_t) and not x.name.startswith( '__') and x.location.file_name != "<internal>"), typedef_decls) self.mTypeDefMap = {} for d in typedef_decls: type_def_name = d.name full_name = declarations.full_name(d) if full_name.startswith("::"): # Remove the base namespace full_name = full_name[2:] real_type_name = d.type.decl_string if real_type_name.startswith("::"): # Remove base namespace real_type_name = real_type_name[2:] self.mTypeDefMap[full_name] = real_type_name self.mParseEndTime = time.time() if self.mVerbose: print "Completed parsing in %s." % self._time2str( self.mParseEndTime - self.mStartTime) return self.mDeclRootWrapper
def patch_it(self): for decl in declarations.make_flatten( self.decls ): if not isinstance( decl, declarations.casting_operator_t): continue decl.name = 'operator ' + decl.return_type.decl_string
def parse(self): """Parse the header files and setup the known declarations. Currently this method can only be called once. This method can be called anytime after initialization and all Template() calls have been made. @returns: Returns the root of the declaration tree @rtype: L{IDecl<declwrapper.IDecl>} @postcondition: This class can act as a wrapper for namespace("::") and all declarations are set to be ignored. """ if self.mHeaderFiles==[]: raise ValueError, "No header files specified" if self.mVerbose: print "Parsing headers: ", self.mHeaderFiles # Record the time when parsing started... self.mStartTime = time.time() # Create and initialize the config object parser_cfg = parser.config_t(self.mGccXmlPath, self.mWorkingDir, self.mIncludePaths, define_symbols=self.mDefines, undefine_symbols=self.mUndefines, start_with_declarations=None) full_header_list = self.mHeaderFiles[:] # Handle template instantiation as needed temp_file, temp_filename = (None,None) template_instantiation_text = self.buildTemplateFileContents() if None != template_instantiation_text: temp_filename = pygccxml.utils.create_temp_file_name(suffix=".h") temp_file = file(temp_filename, 'w') temp_file.write(template_instantiation_text) temp_file.close() if self.mVerbose: print " creating template instantiation file: ", temp_filename full_header_list.append(temp_filename) # Create the cache object... if self.mCacheDir!=None: if self.mVerbose: print "Using directory cache in '%s'"%self.mCacheDir cache = parser.directory_cache_t(self.mCacheDir) elif self.mCacheFile!=None: if self.mVerbose: print "Using file cache '%s'"%self.mCacheFile cache = parser.file_cache_t(self.mCacheFile) else: if self.mVerbose: print "No cache in use" cache = None # Create the parser object... the_parser = parser.project_reader_t(config=parser_cfg, cache=cache, decl_factory=decl_wrappers.dwfactory_t()) # ...and parse the headers parsed_decls = the_parser.read_files(full_header_list, parser.project_reader.COMPILATION_MODE.FILE_BY_FILE) assert len(parsed_decls) == 1 # assume that we get root of full tree self.mDeclRoot = parsed_decls[0] # Parse the files and add to decl root # - then traverse tree setting everything to ignore self.mDeclRootWrapper = DeclWrapper(self.mDeclRoot) # Set the module builder instance (this is done here and not in the # constructor so that Allen's DeclWrapper object still work as well) self.mDeclRootWrapper.modulebuilder = self self.mDeclRootWrapper.ignore() # Cleanup if temp_filename: pygccxml.utils.remove_file_no_raise( temp_filename ) typedef_decls = declarations.make_flatten(parsed_decls) typedef_decls = decls = filter( lambda x: (isinstance( x, declarations.typedef_t ) and not x.name.startswith('__') and x.location.file_name != "<internal>") , typedef_decls ) self.mTypeDefMap = {} for d in typedef_decls: type_def_name = d.name full_name = declarations.full_name(d) if full_name.startswith("::"): # Remove the base namespace full_name = full_name[2:] real_type_name = d.type.decl_string if real_type_name.startswith("::"): # Remove base namespace real_type_name = real_type_name[2:] self.mTypeDefMap[full_name] = real_type_name self.mParseEndTime = time.time() if self.mVerbose: print "Completed parsing in %s."%self._time2str(self.mParseEndTime-self.mStartTime) return self.mDeclRootWrapper