def test_re_opening_cache_file(): """ Test re-oping cache files. This test is run by file_cache_tester.py in a subprocess. """ data = autoconfig.data_directory # xml_generator has not been set if utils.xml_generator is not None: raise Exception # Try to reopen an old cache file and check if there is an exception # These old files do not know about the xml generator; a RuntimeError # should be thrown, asking to regenerate the cache file. c_file = os.path.join(data, 'old_cache.cache') error = False try: parser.file_cache_t(c_file) except RuntimeError: error = True if error is False: raise Exception # This cache file knows about the xml generator, and was generated # with CastXML. Loading the cache should set the utils.xml_generator. c_file = os.path.join(data, 'new_cache.cache') parser.file_cache_t(c_file) if "CastXML" not in utils.xml_generator: raise Exception
def test_from_file(self): declarations = parser.parse([self.header], self.config) cache = parser.file_cache_t(self.cache_file) cache.update(source_file=self.header, configuration=self.config, declarations=declarations, included_files=[]) self.assertTrue( declarations == cache.cached_value(self.header, self.config), "cached declarations and source declarations are different", ) cache.flush() cache = parser.file_cache_t(self.cache_file) self.assertTrue( declarations == cache.cached_value(self.header, self.config), ("cached declarations and source declarations are different, " + "after pickling"), )
def test_cache(self): cache = parser.file_cache_t(self.cache_file) reader = parser.source_reader_t(self.config, cache) decls1 = reader.read_file(self.header) cache.flush() cache = parser.file_cache_t(self.cache_file) reader = parser.source_reader_t(self.config, cache) decls2 = reader.read_file(self.header) enum_matcher = declarations.declaration_matcher_t( name="EColor", decl_type=declarations.enumeration_t) color1 = declarations.matcher.get_single(enum_matcher, decls1) color2 = declarations.matcher.get_single(enum_matcher, decls2) self.assertTrue(color1.values == color2.values)
def test_cache( self ): cache = parser.file_cache_t( self.cache_file ) reader = parser.source_reader_t( self.config, cache ) decls1 = reader.read_file( self.header ) cache.flush() cache = parser.file_cache_t( self.cache_file ) reader = parser.source_reader_t( self.config, cache ) decls2 = reader.read_file( self.header ) enum_matcher = declarations.declaration_matcher_t( name="EColor" , decl_type=declarations.enumeration_t ) color1 = declarations.matcher.get_single( enum_matcher, decls1 ) color2 = declarations.matcher.get_single( enum_matcher, decls2 ) self.failUnless( color1.values == color2.values )
def test_from_file(self): declarations = parser.parse([self.header], self.config) cache = parser.file_cache_t(self.cache_file) cache.update(source_file=self.header, configuration=self.config, declarations=declarations, included_files=[]) self.assertTrue( declarations == cache.cached_value(self.header, self.config), "cached declarations and source declarations are different") cache.flush() cache = parser.file_cache_t(self.cache_file) self.assertTrue( declarations == cache.cached_value(self.header, self.config), ("cached declarations and source declarations are different, " + "after pickling"))
def test_update(self): # Save the content of the header file for later with open(self.header, "r") as old_header: content = old_header.read() declarations = parser.parse([self.header], self.config) cache = parser.file_cache_t(self.cache_file) cache.update(source_file=self.header, configuration=self.config, declarations=declarations, included_files=[]) self.assertTrue( declarations == cache.cached_value(self.header, self.config), "cached declarations and source declarations are different") self.touch() self.assertTrue( cache.cached_value(self.header, self.config) is None, "cache didn't recognize that some files on disk has been changed") # We wrote a //touch in the header file. Just replace the file with the # original content. The touched file would be sometimes commited by # error as it was modified. with open(self.header, "w") as new_header: new_header.write(content)
def test_update(self): # Save the content of the header file for later with open(self.header, "r") as old_header: content = old_header.read() declarations = parser.parse([self.header], self.config) cache = parser.file_cache_t(self.cache_file) cache.update( source_file=self.header, configuration=self.config, declarations=declarations, included_files=[]) self.assertTrue( declarations == cache.cached_value( self.header, self.config), "cached declarations and source declarations are different") self.touch() self.assertTrue( cache.cached_value(self.header, self.config) is None, "cache didn't recognize that some files on disk has been changed") # We wrote a //touch in the header file. Just replace the file with the # original content. The touched file would be sometimes commited by # error as it was modified. with open(self.header, "w") as new_header: new_header.write(content)
def test_project_on_include_std_dot_hpp(): include_std_header = os.path.join(autoconfig.data_directory, 'include_std.hpp') clock_prev = time.perf_counter() dcache = parser.file_cache_t(dcache_file_name) reader = parser.project_reader_t( parser.xml_generator_configuration_t( xml_generator_path=autoconfig.generator_path), dcache) reader.read_files([include_std_header]) dcache.flush() clock_now = time.perf_counter() print(('without cache: %f seconds' % (clock_now - clock_prev))) clock_prev = time.perf_counter() dcache = parser.file_cache_t(dcache_file_name) reader = parser.project_reader_t( parser.xml_generator_configuration_t( xml_generator_path=autoconfig.generator_path), dcache) reader.read_files([include_std_header]) clock_now = time.perf_counter() print(('with cache : %f seconds' % (clock_now - clock_prev)))
def test_on_windows_dot_h(): he = r"2003\Vc7\PlatformSDK\Include\windows.h" windows_header = r"D:\Program Files\Microsoft Visual Studio .NET " + he clock_prev = time.perf_counter() dcache = parser.file_cache_t(dcache_file_name) reader = parser.source_reader_t( parser.xml_generator_configuration_t( xml_generator_path=autoconfig.generator_path), dcache) reader.read_file(windows_header) dcache.flush() clock_now = time.perf_counter() print(('without cache: %f seconds' % (clock_now - clock_prev))) clock_prev = time.perf_counter() dcache = parser.file_cache_t(dcache_file_name) reader = parser.source_reader_t( parser.xml_generator_configuration_t( xml_generator_path=autoconfig.generator_path), dcache) reader.read_file(windows_header) clock_now = time.perf_counter() print(('with cache : %f seconds' % (clock_now - clock_prev)))
def test_source_on_include_std_dot_hpp(): include_std_header = os.path.join(autoconfig.data_directory, 'include_std.hpp') clock_prev = timeit.default_timer() dcache = parser.file_cache_t(dcache_file_name) reader = parser.source_reader_t( parser.xml_generator_configuration_t( xml_generator_path=autoconfig.generator_path), dcache) reader.read_file(include_std_header) dcache.flush() clock_now = timeit.default_timer() print('without cache: %f seconds' % (clock_now - clock_prev)) clock_prev = timeit.default_timer() dcache = parser.file_cache_t(dcache_file_name) reader = parser.source_reader_t( parser.xml_generator_configuration_t( xml_generator_path=autoconfig.generator_path), dcache) reader.read_file(include_std_header) clock_now = timeit.default_timer() print('with cache : %f seconds' % (clock_now - clock_prev))
def test_on_windows_dot_h(): he = r"2003\Vc7\PlatformSDK\Include\windows.h" windows_header = r"D:\Program Files\Microsoft Visual Studio .NET " + he clock_prev = time.clock() dcache = parser.file_cache_t(dcache_file_name) reader = parser.source_reader_t( parser.xml_generator_configuration_t( xml_generator_path=autoconfig.generator_path), dcache) reader.read_file(windows_header) dcache.flush() clock_now = time.clock() print('without cache: %f seconds' % (clock_now - clock_prev)) clock_prev = time.clock() dcache = parser.file_cache_t(dcache_file_name) reader = parser.source_reader_t( parser.xml_generator_configuration_t( xml_generator_path=autoconfig.generator_path), dcache) reader.read_file(windows_header) clock_now = time.clock() print('with cache : %f seconds' % (clock_now - clock_prev))
def test_project_on_include_std_dot_hpp(): include_std_header = os.path.join( autoconfig.data_directory, 'include_std.hpp') clock_prev = time.clock() dcache = parser.file_cache_t(dcache_file_name) reader = parser.project_reader_t( parser.xml_generator_configuration_t( xml_generator_path=autoconfig.generator_path), dcache) reader.read_files([include_std_header]) dcache.flush() clock_now = time.clock() print('without cache: %f seconds' % (clock_now - clock_prev)) clock_prev = time.clock() dcache = parser.file_cache_t(dcache_file_name) reader = parser.project_reader_t( parser.xml_generator_configuration_t( xml_generator_path=autoconfig.generator_path), dcache) reader.read_files([include_std_header]) clock_now = time.clock() print('with cache : %f seconds' % (clock_now - clock_prev))
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
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 dopypp(task): global included_decls # Set the path for importing additional tools if not os.path.join(task.srcpath, 'tools', 'waf') in sys.path: sys.path.append(os.path.join(task.srcpath, 'tools', 'waf')) # Increase recursion limit for tough includes sys.setrecursionlimit(sys.getrecursionlimit()*2) from pyplusplus import module_builder, messages, utils, code_repository from pygccxml import declarations,parser from pyplusplus.module_builder import call_policies from pypp_utils import TemplateBuilder import logging # Disable some annoying messages if not Logs.verbose: module_builder.set_logger_level(logging.FATAL) messages.disable(messages.W1023) messages.disable(messages.W1025) messages.disable(messages.W1026) messages.disable(messages.W1027) messages.disable(messages.W1031) messages.disable(messages.W1043) elif Logs.verbose > 2: module_builder.set_logger_level(logging.DEBUG) ## ????????????????????????????????????? What is this for ????????????????????????????? logger_lock.acquire() log = logging.getLogger() temp_handler = None if len(log.handlers) > 0: temp_handler = log.handlers[0] log.removeHandler(log.handlers[0]) logger_lock.release() # Create source list with proper directories sources = map(lambda a: os.path.abspath(os.path.join(task.bldpath, a.srcpath(task.env))), task.inputs) # Create include list global_includes = task.includes global_includes += task.env['CPPPATH'] global_includes += [os.path.abspath(os.path.join(task.bldpath, i.srcpath(task.env))) for i in task.path_lst] try: #if int(task.env['CC_VERSION'][1]) >= 3: #compilerExec = task.env['CXX_OLD_VERSION'][0] #else: compilerExec = task.env['CXX'][0] # No cache can be used on mac-osx systems, otherwise pygccxml segfaults if sys.platform != 'darwin': mb = module_builder.module_builder_t( files=sources , start_with_declarations = task.start_decls , define_symbols = task.define_symbols , working_directory = task.bldpath , include_paths = global_includes , compiler = compilerExec , cache=parser.file_cache_t(os.path.abspath(os.path.join(task.bldpath, task.outputs[0].bldpath(task.env)+'_cache' )))) else: mb = module_builder.module_builder_t( files=sources , start_with_declarations = task.start_decls , define_symbols = task.define_symbols , working_directory = task.bldpath , include_paths = global_includes , compiler = compilerExec) except Exception, e: print e if temp_handler: log.addHandler(temp_handler) return 1