def collect_idl_files(webkit_root): from idl_reader import IdlReader rdr = IdlReader() idl_map = {} imp_map = {} alias_map = {} fcount = 0 for part in ["core", "modules"]: search_root = os.path.join(webkit_root, VARIANT['Source'], part) for node, dirs, files in os.walk(search_root): for idl in fnmatch.filter(files, "*.idl"): idl_path = os.path.join(node, idl) if '/testing/' in idl_path: print >> sys.stderr, "Ignoring 'testing' IDL file '%s'" % idl_path continue idl_data = rdr.read_idl_file(idl_path) fcount += 1 for imp_left, imp_right in idl_implementations(idl_data): try: imp_map[imp_left].add((imp_right, idl_path)) except KeyError: imp_map[imp_left] = set([(imp_right, idl_path)]) for iface, idef in idl_data.interfaces.items(): if 'NamedConstructor' in idef.extended_attributes: alias_map[idef.extended_attributes[ 'NamedConstructor']] = iface try: idl_list = idl_map[iface] if idef.is_partial: idl_list.append((idl_path, idef)) else: idl_list.insert(0, (idl_path, idef)) except KeyError: idl_map[iface] = [(idl_path, idef)] print >> sys.stderr, "Processed %d IDL files" % fcount return idl_map, imp_map, alias_map
class InterfaceInfoCollector(object): """A class that collects interface information from idl files.""" def __init__(self, cache_directory=None): self.reader = IdlReader(interfaces_info=None, outputdir=cache_directory) self.interfaces_info = {} self.partial_interface_files = defaultdict(lambda: { 'full_paths': [], 'include_paths': [], }) self.enumerations = {} self.union_types = set() self.typedefs = {} self.callback_functions = {} def add_paths_to_partials_dict(self, partial_interface_name, full_path, include_paths): paths_dict = self.partial_interface_files[partial_interface_name] paths_dict['full_paths'].append(full_path) paths_dict['include_paths'].extend(include_paths) def check_enum_consistency(self, enum): existing_enum = self.enumerations.get(enum.name) if not existing_enum: return True # TODO(bashi): Ideally we should not allow multiple enum declarations # but we allow them to work around core/module separation. if len(existing_enum.values) != len(enum.values): return False return all(value in existing_enum.values for value in enum.values) def collect_info(self, idl_filename): """Reads an idl file and collects information which is required by the binding code generation.""" def collect_unforgeable_attributes(definition, idl_filename): """Collects [Unforgeable] attributes so that we can define them on sub-interfaces later. The resulting structure is as follows. interfaces_info[interface_name] = { 'unforgeable_attributes': [IdlAttribute, ...], ... } """ interface_info = {} unforgeable_attributes = get_unforgeable_attributes_from_definition( definition) if not unforgeable_attributes: return interface_info if definition.is_partial: interface_basename = idl_filename_to_interface_name( idl_filename) # TODO(yukishiino): [PartialInterfaceImplementedAs] is treated # in interface_dependency_resolver.transfer_extended_attributes. # Come up with a better way to keep them consistent. for attr in unforgeable_attributes: attr.extended_attributes[ 'PartialInterfaceImplementedAs'] = definition.extended_attributes.get( 'ImplementedAs', interface_basename) interface_info['unforgeable_attributes'] = unforgeable_attributes return interface_info definitions = self.reader.read_idl_file(idl_filename) this_union_types = collect_union_types_from_definitions(definitions) self.union_types.update(this_union_types) self.typedefs.update(definitions.typedefs) for callback_function_name, callback_function in \ definitions.callback_functions.iteritems(): # Set 'component_dir' to specify a directory that callback function files belong to self.callback_functions[callback_function_name] = { 'callback_function': callback_function, 'component_dir': idl_filename_to_component(idl_filename), 'full_path': os.path.realpath(idl_filename), } # Check enum duplication. for enum in definitions.enumerations.values(): if not self.check_enum_consistency(enum): raise Exception('Enumeration "%s" is defined more than once ' 'with different valid values' % enum.name) self.enumerations.update(definitions.enumerations) if definitions.interfaces: definition = next(definitions.interfaces.itervalues()) interface_info = { 'is_callback_interface': definition.is_callback, 'is_dictionary': False, # Interfaces that are referenced (used as types) and that we # introspect during code generation (beyond interface-level # data ([ImplementedAs], is_callback_interface, ancestors, and # inherited extended attributes): deep dependencies. # These cause rebuilds of referrers, due to the dependency, # so these should be minimized; currently only targets of # [PutForwards]. 'referenced_interfaces': get_put_forward_interfaces_from_definition(definition), } elif definitions.dictionaries: definition = next(definitions.dictionaries.itervalues()) interface_info = { 'is_callback_interface': False, 'is_dictionary': True, 'referenced_interfaces': None, } else: return if definition.name not in self.interfaces_info: self.interfaces_info[definition.name] = {} # Remember [Unforgeable] attributes. if definitions.interfaces: merge_dict_recursively( self.interfaces_info[definition.name], collect_unforgeable_attributes(definition, idl_filename)) component = idl_filename_to_component(idl_filename) extended_attributes = definition.extended_attributes implemented_as = extended_attributes.get('ImplementedAs') full_path = os.path.realpath(idl_filename) if interface_info['is_dictionary']: this_include_path = include_path(idl_filename) else: this_include_path = include_path(idl_filename, implemented_as) if definition.is_partial: # We don't create interface_info for partial interfaces, but # adds paths to another dict. partial_include_paths = [] if this_include_path: partial_include_paths.append(this_include_path) self.add_paths_to_partials_dict(definition.name, full_path, partial_include_paths) # Collects C++ header paths which should be included from generated # .cpp files. The resulting structure is as follows. # interfaces_info[interface_name] = { # 'cpp_includes': { # 'core': set(['core/foo/Foo.h', ...]), # 'modules': set(['modules/bar/Bar.h', ...]), # }, # ... # } if this_include_path: merge_dict_recursively( self.interfaces_info[definition.name], {'cpp_includes': { component: set([this_include_path]) }}) return # 'includes' statements can be included in either the file for the # interface (lhs of 'includes') or mixin (rhs of 'includes'). Store both # for now, then merge to the interface later. includes_interfaces, includes_mixins = get_includes_from_definitions( definitions, definition.name) interface_info.update({ 'extended_attributes': extended_attributes, 'full_path': full_path, 'union_types': this_union_types, 'implemented_as': implemented_as, 'included_by_interfaces': includes_interfaces, 'including_mixins': includes_mixins, 'include_path': this_include_path, # FIXME: temporary private field, while removing old # treatement of 'implements': http://crbug.com/360435 'is_legacy_treat_as_partial_interface': 'LegacyTreatAsPartialInterface' in extended_attributes, 'parent': definition.parent, 'relative_dir': relative_dir_posix(idl_filename, source_path), }) merge_dict_recursively(self.interfaces_info[definition.name], interface_info) def get_info_as_dict(self): """Returns info packaged as a dict.""" return { 'interfaces_info': self.interfaces_info, # Can't pickle defaultdict, convert to dict # FIXME: this should be included in get_component_info. 'partial_interface_files': dict(self.partial_interface_files), } def get_component_info_as_dict(self, runtime_enabled_features): """Returns component wide information as a dict.""" return { 'callback_functions': self.callback_functions, 'enumerations': dict((enum.name, enum.values) for enum in self.enumerations.values()), 'runtime_enabled_features': runtime_enabled_features, 'typedefs': self.typedefs, 'union_types': self.union_types, }
class InterfaceInfoCollector(object): """A class that collects interface information from idl files.""" def __init__(self, root_directory, extend_attributes_filename, cache_directory=None): self.reader = IdlReader( interfaces_info=None, outputdir=cache_directory, extend_attributes_filename=extend_attributes_filename) self.interfaces_info = {} self.partial_interface_files = defaultdict(lambda: { 'full_paths': [], 'include_paths': [], }) self.enumerations = {} self.union_types = set() self.typedefs = {} self.callback_functions = {} self.root_path = root_directory self.referenced_from_partial_interfaces = defaultdict(lambda: set()) def add_paths_to_partials_dict(self, partial_interface_name, full_path, include_paths): paths_dict = self.partial_interface_files[partial_interface_name] paths_dict['full_paths'].append(full_path) paths_dict['include_paths'].extend(include_paths) def collect_info(self, idl_filename, is_dependency=False): """Reads an idl file and collects information which is required by the binding code generation.""" def collect_unforgeable_attributes(definition, idl_filename): """Collects [Unforgeable] attributes so that we can define them on sub-interfaces later. The resulting structure is as follows. interfaces_info[interface_name] = { 'unforgeable_attributes': { 'core': [IdlAttribute, ...], 'modules': [IdlAttribute, ...], }, ... } """ interface_info = {} unforgeable_attributes = get_unforgeable_attributes_from_definition( definition) if not unforgeable_attributes: return interface_info if definition.is_partial: interface_basename = idl_filename_to_interface_name( idl_filename) # TODO(yukishiino): [PartialInterfaceImplementedAs] is treated # in interface_dependency_resolver.transfer_extended_attributes. # Come up with a better way to keep them consistent. for attr in unforgeable_attributes: attr.extended_attributes[ 'PartialInterfaceImplementedAs'] = definition.extended_attributes.get( 'ImplementedAs', interface_basename) component = idl_filename_to_component(idl_filename) interface_info['unforgeable_attributes'] = {} interface_info['unforgeable_attributes'][ component] = unforgeable_attributes return interface_info definitions = self.reader.read_idl_file(idl_filename) this_union_types = collect_union_types_from_definitions(definitions) self.union_types.update(this_union_types) self.typedefs.update(definitions.typedefs) for callback_function_name, callback_function in definitions.callback_functions.iteritems( ): # Set 'component_dir' to specify a directory that callback function files belong to self.callback_functions[callback_function_name] = { 'callback_function': callback_function, 'component_dir': idl_filename_to_component(idl_filename), 'full_path': os.path.realpath(idl_filename), } # Include more information about the enum for Cobalt. for enum_name, values in definitions.enumerations.iteritems(): # Check enum duplication. if self.enumerations.has_key(enum_name): raise Exception('Enumeration %s has multiple definitions' % enum_name) self.enumerations[enum_name] = { 'values': values, 'full_path': os.path.realpath(idl_filename), } if definitions.interfaces: definition = next(definitions.interfaces.itervalues()) interface_info = { 'is_callback_interface': definition.is_callback, 'is_dictionary': False, # Interfaces that are referenced (used as types) and that we # introspect during code generation (beyond interface-level # data ([ImplementedAs], is_callback_interface, ancestors, and # inherited extended attributes): deep dependencies. # These cause rebuilds of referrers, due to the dependency, # so these should be minimized; currently only targets of # [PutForwards]. 'referenced_interfaces': get_put_forward_interfaces_from_definition(definition), 'is_dependency': is_dependency, 'conditional': definition.extended_attributes.get('Conditional', None), 'unsupported': 'NotSupported' in definition.extended_attributes, } elif definitions.dictionaries: definition = next(definitions.dictionaries.itervalues()) interface_info = { 'is_callback_interface': False, 'is_dictionary': True, 'is_dependency': True, 'conditional': definition.extended_attributes.get('Conditional', None), 'unsupported': 'NotSupported' in definition.extended_attributes, 'referenced_interfaces': None, } else: return if definition.name not in self.interfaces_info: self.interfaces_info[definition.name] = {} # Remember [Unforgeable] attributes. if definitions.interfaces: merge_dict_recursively( self.interfaces_info[definition.name], collect_unforgeable_attributes(definition, idl_filename)) component = idl_filename_to_component(idl_filename) extended_attributes = definition.extended_attributes implemented_as = extended_attributes.get('ImplementedAs') full_path = os.path.realpath(idl_filename) this_include_path = include_path(idl_filename, self.root_path, implemented_as) if definition.is_partial: # We don't create interface_info for partial interfaces, but # adds paths to another dict. partial_include_paths = [] if this_include_path: partial_include_paths.append(this_include_path) for union_type in this_union_types: name = shorten_union_name(union_type) partial_include_paths.append('bindings/%s/v8/%s.h' % (component, name)) self.add_paths_to_partials_dict(definition.name, full_path, partial_include_paths) referenced_from_interface = get_put_forward_interfaces_from_definition( definition) self.referenced_from_partial_interfaces[definition.name].update( referenced_from_interface) # interfaces_info[interface_name] = { # 'cpp_includes': { # 'core': set(['core/foo/Foo.h', ...]), # 'modules': set(['modules/bar/Bar.h', ...]), # }, # ... # } if this_include_path: merge_dict_recursively( self.interfaces_info[definition.name], {'cpp_includes': { component: set([this_include_path]) }}) return # 'implements' statements can be included in either the file for the # implement*ing* interface (lhs of 'implements') or implement*ed* interface # (rhs of 'implements'). Store both for now, then merge to implement*ing* # interface later. left_interfaces, right_interfaces = get_implements_from_definitions( definitions, definition.name) interface_info.update({ 'extended_attributes': extended_attributes, 'full_path': full_path, 'union_types': this_union_types, 'implemented_as': implemented_as, 'implemented_by_interfaces': left_interfaces, 'implements_interfaces': right_interfaces, 'include_path': this_include_path, # FIXME: temporary private field, while removing old treatement of # 'implements': http://crbug.com/360435 'is_legacy_treat_as_partial_interface': 'LegacyTreatAsPartialInterface' in extended_attributes, 'parent': definition.parent, 'relative_dir': relative_dir_posix(idl_filename, self.root_path), }) merge_dict_recursively(self.interfaces_info[definition.name], interface_info) def get_info_as_dict(self): """Returns info packaged as a dict.""" return { 'interfaces_info': self.interfaces_info, # Can't pickle defaultdict, convert to dict # FIXME: this should be included in get_component_info. 'partial_interface_files': dict(self.partial_interface_files), 'partial_interface_referenced_interfaces': dict(self.referenced_from_partial_interfaces), } def get_component_info_as_dict(self): """Returns component wide information as a dict.""" return { 'callback_functions': self.callback_functions, 'enumerations': self.enumerations, 'typedefs': self.typedefs, 'union_types': self.union_types, }
class InterfaceInfoCollector(object): """A class that collects interface information from idl files.""" def __init__(self, cache_directory=None): self.reader = IdlReader(interfaces_info=None, outputdir=cache_directory) self.interfaces_info = {} self.partial_interface_files = defaultdict(lambda: { 'full_paths': [], 'include_paths': [], }) self.enumerations = set() self.union_types = set() self.typedefs = {} def add_paths_to_partials_dict(self, partial_interface_name, full_path, include_paths): paths_dict = self.partial_interface_files[partial_interface_name] paths_dict['full_paths'].append(full_path) paths_dict['include_paths'].extend(include_paths) def collect_info(self, idl_filename): """Reads an idl file and collects information which is required by the binding code generation.""" def collect_unforgeable_attributes(definition, idl_filename): """Collects [Unforgeable] attributes so that we can define them on sub-interfaces later. The resulting structure is as follows. interfaces_info[interface_name] = { 'unforgeable_attributes': { 'core': [IdlAttribute, ...], 'modules': [IdlAttribute, ...], }, ... } """ interface_info = {} unforgeable_attributes = get_unforgeable_attributes_from_definition(definition) if not unforgeable_attributes: return interface_info if definition.is_partial: interface_basename = idl_filename_to_interface_name(idl_filename) # TODO(yukishiino): [PartialInterfaceImplementedAs] is treated # in interface_dependency_resolver.transfer_extended_attributes. # Come up with a better way to keep them consistent. for attr in unforgeable_attributes: attr.extended_attributes['PartialInterfaceImplementedAs'] = definition.extended_attributes.get('ImplementedAs', interface_basename) component = idl_filename_to_component(idl_filename) interface_info['unforgeable_attributes'] = {} interface_info['unforgeable_attributes'][component] = unforgeable_attributes return interface_info definitions = self.reader.read_idl_file(idl_filename) this_union_types = collect_union_types_from_definitions(definitions) self.union_types.update(this_union_types) self.typedefs.update(definitions.typedefs) # Check enum duplication. for enum_name in definitions.enumerations.keys(): for defined_enum in self.enumerations: if defined_enum.name == enum_name: raise Exception('Enumeration %s has multiple definitions' % enum_name) self.enumerations.update(definitions.enumerations.values()) if definitions.interfaces: definition = next(definitions.interfaces.itervalues()) interface_info = { 'is_callback_interface': definition.is_callback, 'is_dictionary': False, # Interfaces that are referenced (used as types) and that we # introspect during code generation (beyond interface-level # data ([ImplementedAs], is_callback_interface, ancestors, and # inherited extended attributes): deep dependencies. # These cause rebuilds of referrers, due to the dependency, # so these should be minimized; currently only targets of # [PutForwards]. 'referenced_interfaces': get_put_forward_interfaces_from_definition(definition), } elif definitions.dictionaries: definition = next(definitions.dictionaries.itervalues()) interface_info = { 'is_callback_interface': False, 'is_dictionary': True, 'referenced_interfaces': None, } else: return if definition.name not in self.interfaces_info: self.interfaces_info[definition.name] = {} # Remember [Unforgeable] attributes. if definitions.interfaces: merge_dict_recursively(self.interfaces_info[definition.name], collect_unforgeable_attributes(definition, idl_filename)) component = idl_filename_to_component(idl_filename) extended_attributes = definition.extended_attributes implemented_as = extended_attributes.get('ImplementedAs') full_path = os.path.realpath(idl_filename) this_include_path = None if 'NoImplHeader' in extended_attributes else include_path(idl_filename, implemented_as) if definition.is_partial: # We don't create interface_info for partial interfaces, but # adds paths to another dict. partial_include_paths = [] if this_include_path: partial_include_paths.append(this_include_path) if this_union_types: partial_include_paths.append( 'bindings/%s/v8/UnionTypes%s.h' % (component, component.capitalize())) self.add_paths_to_partials_dict(definition.name, full_path, partial_include_paths) # Collects C++ header paths which should be included from generated # .cpp files. The resulting structure is as follows. # interfaces_info[interface_name] = { # 'cpp_includes': { # 'core': set(['core/foo/Foo.h', ...]), # 'modules': set(['modules/bar/Bar.h', ...]), # }, # ... # } if this_include_path: merge_dict_recursively( self.interfaces_info[definition.name], {'cpp_includes': {component: set([this_include_path])}}) return # 'implements' statements can be included in either the file for the # implement*ing* interface (lhs of 'implements') or implement*ed* interface # (rhs of 'implements'). Store both for now, then merge to implement*ing* # interface later. left_interfaces, right_interfaces = get_implements_from_definitions( definitions, definition.name) interface_info.update({ 'extended_attributes': extended_attributes, 'full_path': full_path, 'has_union_types': bool(this_union_types), 'implemented_as': implemented_as, 'implemented_by_interfaces': left_interfaces, 'implements_interfaces': right_interfaces, 'include_path': this_include_path, # FIXME: temporary private field, while removing old treatement of # 'implements': http://crbug.com/360435 'is_legacy_treat_as_partial_interface': 'LegacyTreatAsPartialInterface' in extended_attributes, 'parent': definition.parent, 'relative_dir': relative_dir_posix(idl_filename, source_path), }) merge_dict_recursively(self.interfaces_info[definition.name], interface_info) def get_info_as_dict(self): """Returns info packaged as a dict.""" return { 'interfaces_info': self.interfaces_info, # Can't pickle defaultdict, convert to dict # FIXME: this should be included in get_component_info. 'partial_interface_files': dict(self.partial_interface_files), } def get_component_info_as_dict(self): """Returns component wide information as a dict.""" return { 'enumerations': dict((enum.name, enum.values) for enum in self.enumerations), 'typedefs': self.typedefs, 'union_types': self.union_types, }
class InterfaceInfoCollector(object): """A class that collects interface information from idl files.""" def __init__(self, cache_directory=None): self.reader = IdlReader(interfaces_info=None, outputdir=cache_directory) self.interfaces_info = {} self.partial_interface_files = defaultdict(lambda: { 'full_paths': [], 'include_paths': [], }) self.enumerations = set() self.union_types = set() self.typedefs = {} def add_paths_to_partials_dict(self, partial_interface_name, full_path, include_paths): paths_dict = self.partial_interface_files[partial_interface_name] paths_dict['full_paths'].append(full_path) paths_dict['include_paths'].extend(include_paths) def collect_info(self, idl_filename): """Reads an idl file and collects information which is required by the binding code generation.""" definitions = self.reader.read_idl_file(idl_filename) this_union_types = collect_union_types_from_definitions(definitions) self.union_types.update(this_union_types) self.typedefs.update(definitions.typedefs) # Check enum duplication. for enum_name in definitions.enumerations.keys(): for defined_enum in self.enumerations: if defined_enum.name == enum_name: raise Exception('Enumeration %s has multiple definitions' % enum_name) self.enumerations.update(definitions.enumerations.values()) if definitions.interfaces: definition = next(definitions.interfaces.itervalues()) interface_info = { 'is_callback_interface': definition.is_callback, 'is_dictionary': False, # Interfaces that are referenced (used as types) and that we # introspect during code generation (beyond interface-level # data ([ImplementedAs], is_callback_interface, ancestors, and # inherited extended attributes): deep dependencies. # These cause rebuilds of referrers, due to the dependency, # so these should be minimized; currently only targets of # [PutForwards]. 'referenced_interfaces': get_put_forward_interfaces_from_definition(definition), } elif definitions.dictionaries: definition = next(definitions.dictionaries.itervalues()) interface_info = { 'is_callback_interface': False, 'is_dictionary': True, 'referenced_interfaces': None, } else: return extended_attributes = definition.extended_attributes implemented_as = extended_attributes.get('ImplementedAs') full_path = os.path.realpath(idl_filename) this_include_path = None if 'NoImplHeader' in extended_attributes else include_path(idl_filename, implemented_as) if definition.is_partial: # We don't create interface_info for partial interfaces, but # adds paths to another dict. partial_include_paths = [] if this_include_path: partial_include_paths.append(this_include_path) if this_union_types: component = idl_filename_to_component(idl_filename) partial_include_paths.append( 'bindings/%s/v8/UnionTypes%s.h' % (component, component.capitalize())) self.add_paths_to_partials_dict(definition.name, full_path, partial_include_paths) return # 'implements' statements can be included in either the file for the # implement*ing* interface (lhs of 'implements') or implement*ed* interface # (rhs of 'implements'). Store both for now, then merge to implement*ing* # interface later. left_interfaces, right_interfaces = get_implements_from_definitions( definitions, definition.name) interface_info.update({ 'extended_attributes': extended_attributes, 'full_path': full_path, 'has_union_types': bool(this_union_types), 'implemented_as': implemented_as, 'implemented_by_interfaces': left_interfaces, 'implements_interfaces': right_interfaces, 'include_path': this_include_path, # FIXME: temporary private field, while removing old treatement of # 'implements': http://crbug.com/360435 'is_legacy_treat_as_partial_interface': 'LegacyTreatAsPartialInterface' in extended_attributes, 'parent': definition.parent, 'relative_dir': relative_dir_posix(idl_filename), }) self.interfaces_info[definition.name] = interface_info def get_info_as_dict(self): """Returns info packaged as a dict.""" return { 'interfaces_info': self.interfaces_info, # Can't pickle defaultdict, convert to dict # FIXME: this should be included in get_component_info. 'partial_interface_files': dict(self.partial_interface_files), } def get_component_info_as_dict(self): """Returns component wide information as a dict.""" return { 'enumerations': dict((enum.name, enum.values) for enum in self.enumerations), 'typedefs': self.typedefs, 'union_types': self.union_types, }
class InterfaceInfoCollector(object): """A class that collects interface information from idl files.""" def __init__(self, cache_directory=None): self.reader = IdlReader(interfaces_info=None, outputdir=cache_directory) self.interfaces_info = {} self.partial_interface_files = defaultdict(lambda: { 'full_paths': [], 'include_paths': [], }) self.enumerations = set() self.union_types = set() self.typedefs = {} def add_paths_to_partials_dict(self, partial_interface_name, full_path, include_paths): paths_dict = self.partial_interface_files[partial_interface_name] paths_dict['full_paths'].append(full_path) paths_dict['include_paths'].extend(include_paths) def collect_info(self, idl_filename): """Reads an idl file and collects information which is required by the binding code generation.""" definitions = self.reader.read_idl_file(idl_filename) this_union_types = collect_union_types_from_definitions(definitions) self.union_types.update(this_union_types) self.typedefs.update(definitions.typedefs) # Check enum duplication. for enum_name in definitions.enumerations.keys(): for defined_enum in self.enumerations: if defined_enum.name == enum_name: raise Exception('Enumeration %s has multiple definitions' % enum_name) self.enumerations.update(definitions.enumerations.values()) if definitions.interfaces: definition = next(definitions.interfaces.itervalues()) interface_info = { 'is_callback_interface': definition.is_callback, 'is_dictionary': False, # Interfaces that are referenced (used as types) and that we # introspect during code generation (beyond interface-level # data ([ImplementedAs], is_callback_interface, ancestors, and # inherited extended attributes): deep dependencies. # These cause rebuilds of referrers, due to the dependency, # so these should be minimized; currently only targets of # [PutForwards]. 'referenced_interfaces': get_put_forward_interfaces_from_definition(definition), } elif definitions.dictionaries: definition = next(definitions.dictionaries.itervalues()) interface_info = { 'is_callback_interface': False, 'is_dictionary': True, 'referenced_interfaces': None, } else: return extended_attributes = definition.extended_attributes implemented_as = extended_attributes.get('ImplementedAs') full_path = os.path.realpath(idl_filename) this_include_path = None if 'NoImplHeader' in extended_attributes else include_path( idl_filename, implemented_as) if definition.is_partial: # We don't create interface_info for partial interfaces, but # adds paths to another dict. partial_include_paths = [] if this_include_path: partial_include_paths.append(this_include_path) if this_union_types: component = idl_filename_to_component(idl_filename) partial_include_paths.append( 'bindings/%s/v8/UnionTypes%s.h' % (component, component.capitalize())) self.add_paths_to_partials_dict(definition.name, full_path, partial_include_paths) return # 'implements' statements can be included in either the file for the # implement*ing* interface (lhs of 'implements') or implement*ed* interface # (rhs of 'implements'). Store both for now, then merge to implement*ing* # interface later. left_interfaces, right_interfaces = get_implements_from_definitions( definitions, definition.name) interface_info.update({ 'extended_attributes': extended_attributes, 'full_path': full_path, 'has_union_types': bool(this_union_types), 'implemented_as': implemented_as, 'implemented_by_interfaces': left_interfaces, 'implements_interfaces': right_interfaces, 'include_path': this_include_path, # FIXME: temporary private field, while removing old treatement of # 'implements': http://crbug.com/360435 'is_legacy_treat_as_partial_interface': 'LegacyTreatAsPartialInterface' in extended_attributes, 'parent': definition.parent, 'relative_dir': relative_dir_posix(idl_filename), }) self.interfaces_info[definition.name] = interface_info def get_info_as_dict(self): """Returns info packaged as a dict.""" return { 'interfaces_info': self.interfaces_info, # Can't pickle defaultdict, convert to dict # FIXME: this should be included in get_component_info. 'partial_interface_files': dict(self.partial_interface_files), } def get_component_info_as_dict(self): """Returns component wide information as a dict.""" return { 'enumerations': dict((enum.name, enum.values) for enum in self.enumerations), 'typedefs': self.typedefs, 'union_types': self.union_types, }