def test_ParseFile(self): includepath_map = cache_basics.MapToIndex() canonical_path = cache_basics.CanonicalPath() parse_file_obj = parse_file.ParseFile(includepath_map) symbol_table = {} self.assertEqual( parse_file_obj.Parse("test_data/more_macros.c", symbol_table), ([], [], ['TEMPLATE_VARNAME(foo)'], [])) self.assertEqual(symbol_table.keys(), [ 'ILLFORMED', 'AS_STRING_INTERNAL', 'TEMPLATE_VARNAME', 'AS_STRING' ]) [([arg], val)] = symbol_table['TEMPLATE_VARNAME'] self.assertEqual(arg, '_filename_') self.assertEqual(val, 'AS_STRING(maps/_filename_.tpl.varnames.h)') self.assertEqual( parse_file_obj.Parse("test_data/computed_includes.c", symbol_table), ([], [], ['A', 'm(abc)'], [])) self.assertEqual(symbol_table['A'], ['"p1.h"']) [val] = symbol_table['ILLFORMED'] self.assertEqual( val, "(_filename_,(x)) " + "AS_STRING(maps/_filename_.tpl.varnames.h, " + "NOTHANDLED(_filename_))")
def _InitializeAllCaches(self): # Make cache for parsed files. self.file_cache = {} # Make table for symbols in #define's. self.symbol_table = {} # Erect the edifice of caches. caches = self.caches = ( cache_basics.SetUpCaches(self.client_root_keeper.client_root)) # Migrate the cache stuff to self namespace. self.includepath_map = caches.includepath_map self.directory_map = caches.directory_map self.realpath_map = caches.realpath_map self.canonical_path = caches.canonical_path self.dirname_cache = caches.dirname_cache self.compiler_defaults = caches.compiler_defaults self.systemdir_prefix_cache = caches.systemdir_prefix_cache self.simple_build_stat = caches.simple_build_stat self.build_stat_cache = caches.build_stat_cache self.IsIncludepathIndex = caches.IsIncludepathIndex self.IsSearchdirIndex = caches.IsSearchdirIndex self.IsCurrdirIndex = caches.IsCurrdirIndex self.IsRealpathIndex = caches.IsRealpathIndex self.IsFilepathPair = caches.IsFilepathPair # Make a cache for the symbolic links encountered; also for their # replication into root directory. self.mirror_path = mirror_path.MirrorPath(self.simple_build_stat, self.canonical_path, self.realpath_map, self.systemdir_prefix_cache) # Make a parser for C/C++. self.parse_file = parse_file.ParseFile(self.includepath_map) # Make a compressor for source files. self.compress_files = compress_files.CompressFiles(self.includepath_map, self.directory_map, self.realpath_map, self.mirror_path) # A fast cache for avoiding calls into the mirror_path object. self.mirrored = set([]) # For statistics only. We measure the different search lists # (search paths) by accumulating them all in sets. self.quote_dirs_set = set([]) # quote search lists self.angle_dirs_set = set([]) # angle searchlists self.include_dir_pairs = set([]) # the pairs (quote search list,
def test_ResolveExpr(self): # Erect the edifice of caches. caches = cache_basics.SetUpCaches(self.tmp) parse_file_obj = parse_file.ParseFile(caches.includepath_map) symbol_table = {} # Set up symbol_table by parsing test_data/more_macros.c. self.assertEqual( parse_file_obj.Parse("test_data/more_macros.c", symbol_table), ([], [], ['TEMPLATE_VARNAME(foo)'], [])) # Check what we got in symbol_table. self.assertEqual( macro_eval.EvalExpression("TEMPLATE_VARNAME(foo)", symbol_table), set([ 'TEMPLATE_VARNAME(foo)', '"maps/foo.tpl.varnames.h"', 'AS_STRING(maps/foo.tpl.varnames.h)', 'AS_STRING_INTERNAL(maps/foo.tpl.varnames.h)' ])) # Verify that resolving this expression yields one actual file (which we # have placed in test_data/map). [((d, ip), rp)], symbols = macro_eval.ResolveExpr( caches.includepath_map.Index, caches.build_stat_cache.Resolve, 'TEMPLATE_VARNAME(foo)', caches.directory_map.Index(os.getcwd()), # current dir caches.directory_map.Index(""), # file directory [caches.directory_map.Index("test_data")], # search directory [], symbol_table) self.assertEqual(caches.directory_map.string[d], "test_data/") self.assertEqual(caches.includepath_map.string[ip], "maps/foo.tpl.varnames.h") self.assertEqual( symbols, set([ 'TEMPLATE_VARNAME', 'maps', 'AS_STRING', 'AS_STRING_INTERNAL', 'tpl', 'varnames', 'h', 'foo' ]))