| #!/usr/bin/python |
| # Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file |
| # for details. All rights reserved. Use of this source code is governed by a |
| # BSD-style license that can be found in the LICENSE file. |
| |
| """This module generates Elemental APIs from the IDL database.""" |
| |
| import emitter |
| import idlnode |
| import logging |
| import multiemitter |
| import os |
| import re |
| import shutil |
| from generator_java import * |
| from systembaseelemental import * |
| from systemgwt import * |
| from systemgwtjso import * |
| from templateloader import TemplateLoader |
| |
| _logger = logging.getLogger('elementalgenerator') |
| |
| def MergeNodes(node, other): |
| node.operations.extend(other.operations) |
| for attribute in other.attributes: |
| if not node.has_attribute(attribute): |
| node.attributes.append(attribute) |
| |
| node.constants.extend(other.constants) |
| |
| class ElementalGenerator(object): |
| """Utilities to generate Elemental APIs and corresponding JavaScript.""" |
| |
| def __init__(self, auxiliary_dir, template_dir, base_package): |
| """Constructor for the DartGenerator. |
| |
| Args: |
| auxiliary_dir -- location of auxiliary handwritten classes |
| template_dir -- location of template files |
| base_package -- the base package name for the generated code. |
| """ |
| self._auxiliary_dir = auxiliary_dir |
| self._template_dir = template_dir |
| self._base_package = base_package |
| self._auxiliary_files = {} |
| self._dart_templates_re = re.compile(r'[\w.:]+<([\w\.<>:]+)>') |
| |
| self._emitters = None # set later |
| |
| |
| def _StripModules(self, type_name): |
| return type_name.split('::')[-1] |
| |
| def _IsCompoundType(self, database, type_name): |
| if IsPrimitiveType(type_name): |
| return True |
| |
| striped_type_name = self._StripModules(type_name) |
| if database.HasInterface(striped_type_name): |
| return True |
| |
| dart_template_match = self._dart_templates_re.match(type_name) |
| if dart_template_match: |
| # Dart templates |
| parent_type_name = type_name[0 : dart_template_match.start(1) - 1] |
| sub_type_name = dart_template_match.group(1) |
| return (self._IsCompoundType(database, parent_type_name) and |
| self._IsCompoundType(database, sub_type_name)) |
| return False |
| |
| def _IsDartType(self, type_name): |
| return '.' in type_name |
| |
| def LoadAuxiliary(self): |
| def Visitor(_, dirname, names): |
| for name in names: |
| if name.endswith('.dart'): |
| name = name[0:-5] # strip off ".dart" |
| self._auxiliary_files[name] = os.path.join(dirname, name) |
| os.path.walk(self._auxiliary_dir, Visitor, None) |
| |
| def RenameTypes(self, database, conversion_table, rename_javascript_binding_names): |
| """Renames interfaces using the given conversion table. |
| |
| References through all interfaces will be renamed as well. |
| |
| Args: |
| database: the database to apply the renames to. |
| conversion_table: maps old names to new names. |
| """ |
| |
| if conversion_table is None: |
| conversion_table = {} |
| |
| # Rename interfaces: |
| for old_name, new_name in conversion_table.items(): |
| if database.HasInterface(old_name): |
| _logger.info('renaming interface %s to %s' % (old_name, new_name)) |
| interface = database.GetInterface(old_name) |
| database.DeleteInterface(old_name) |
| if not database.HasInterface(new_name): |
| interface.id = new_name |
| database.AddInterface(interface) |
| else: |
| new_interface = database.GetInterface(new_name) |
| MergeNodes(new_interface, interface) |
| |
| if rename_javascript_binding_names: |
| interface.javascript_binding_name = new_name |
| interface.doc_js_name = new_name |
| for member in (interface.operations + interface.constants |
| + interface.attributes): |
| member.doc_js_interface_name = new_name |
| |
| |
| # Fix references: |
| for interface in database.GetInterfaces(): |
| for idl_type in interface.all(idlnode.IDLType): |
| type_name = self._StripModules(idl_type.id) |
| if type_name in conversion_table: |
| idl_type.id = conversion_table[type_name] |
| |
| def FilterMembersWithUnidentifiedTypes(self, database): |
| """Removes unidentified types. |
| |
| Removes constants, attributes, operations and parents with unidentified |
| types. |
| """ |
| |
| for interface in database.GetInterfaces(): |
| def IsIdentified(idl_node): |
| node_name = idl_node.id if idl_node.id else 'parent' |
| for idl_type in idl_node.all(idlnode.IDLType): |
| type_name = idl_type.id |
| if (type_name is not None and |
| self._IsCompoundType(database, type_name)): |
| continue |
| _logger.warn('removing %s in %s which has unidentified type %s' % |
| (node_name, interface.id, type_name)) |
| return False |
| return True |
| |
| interface.constants = filter(IsIdentified, interface.constants) |
| interface.attributes = filter(IsIdentified, interface.attributes) |
| interface.operations = filter(IsIdentified, interface.operations) |
| interface.parents = filter(IsIdentified, interface.parents) |
| |
| def FilterInterfaces(self, database, |
| and_annotations=[], |
| or_annotations=[], |
| exclude_displaced=[], |
| exclude_suppressed=[]): |
| """Filters a database to remove interfaces and members that are missing |
| annotations. |
| |
| The FremontCut IDLs use annotations to specify implementation |
| status in various platforms. For example, if a member is annotated |
| with @WebKit, this means that the member is supported by WebKit. |
| |
| Args: |
| database -- the database to filter |
| all_annotations -- a list of annotation names a member has to |
| have or it will be filtered. |
| or_annotations -- if a member has one of these annotations, it |
| won't be filtered even if it is missing some of the |
| all_annotations. |
| exclude_displaced -- if a member has this annotation and it |
| is marked as displaced it will always be filtered. |
| exclude_suppressed -- if a member has this annotation and it |
| is marked as suppressed it will always be filtered. |
| """ |
| |
| # Filter interfaces and members whose annotations don't match. |
| for interface in database.GetInterfaces(): |
| def HasAnnotations(idl_node): |
| """Utility for determining if an IDLNode has all |
| the required annotations""" |
| for a in exclude_displaced: |
| if (a in idl_node.annotations |
| and 'via' in idl_node.annotations[a]): |
| return False |
| for a in exclude_suppressed: |
| if (a in idl_node.annotations |
| and 'suppressed' in idl_node.annotations[a]): |
| return False |
| for a in or_annotations: |
| if a in idl_node.annotations: |
| return True |
| if and_annotations == []: |
| return False |
| for a in and_annotations: |
| if a not in idl_node.annotations: |
| return False |
| return True |
| |
| if HasAnnotations(interface): |
| interface.constants = filter(HasAnnotations, interface.constants) |
| interface.attributes = filter(HasAnnotations, interface.attributes) |
| interface.operations = filter(HasAnnotations, interface.operations) |
| interface.parents = filter(HasAnnotations, interface.parents) |
| else: |
| database.DeleteInterface(interface.id) |
| |
| self.FilterMembersWithUnidentifiedTypes(database) |
| |
| |
| def Generate(self, database, output_dir, |
| module_source_preference=[], source_filter=None, |
| super_database=None, common_prefix=None, super_map={}, |
| html_map={}, lib_dir=None, systems=[]): |
| """Generates Dart and JS files for the loaded interfaces. |
| |
| Args: |
| database -- database containing interfaces to generate code for. |
| output_dir -- directory to write generated files to. |
| module_source_preference -- priority order list of source annotations to |
| use when choosing a module name, if none specified uses the module name |
| from the database. |
| source_filter -- if specified, only outputs interfaces that have one of |
| these source annotation and rewrites the names of superclasses not |
| marked with this source to use the common prefix. |
| super_database -- database containing super interfaces that the generated |
| interfaces should extend. |
| common_prefix -- prefix for the common library, if any. |
| lib_file_path -- filename for generated .lib file, None if not required. |
| lib_template -- template file in this directory for generated lib file. |
| """ |
| |
| self._emitters = multiemitter.MultiEmitter() |
| self._database = database |
| self._output_dir = output_dir |
| |
| self._FixEventTargets() |
| self._ComputeInheritanceClosure() |
| |
| self._systems = [] |
| |
| # TODO(jmesserly): only create these if needed |
| if ('gwtjso' in systems): |
| jso_system = ElementalJsoSystem( |
| TemplateLoader(self._template_dir, ['dom/jso', 'dom', '']), |
| self._database, self._emitters, self._output_dir) |
| self._systems.append(jso_system) |
| if ('gwt' in systems): |
| interface_system = ElementalInterfacesSystem( |
| TemplateLoader(self._template_dir, ['dom/interface', 'dom', '']), |
| self._database, self._emitters, self._output_dir) |
| self._systems.append(interface_system) |
| |
| # if 'gwt' in systems: |
| # elemental_system = ElementalSystem( |
| # TemplateLoader(self._template_dir, ['dom/elemental', 'dom', '']), |
| # self._database, self._emitters, self._output_dir) |
| |
| # elemental_system._interface_system = interface_system |
| # self._systems.append(elemental_system) |
| |
| |
| |
| # Collect interfaces |
| interfaces = [] |
| for interface in database.GetInterfaces(): |
| if not MatchSourceFilter(source_filter, interface): |
| # Skip this interface since it's not present in the required source |
| _logger.info('Omitting interface - %s' % interface.id) |
| continue |
| interfaces.append(interface) |
| |
| # TODO(sra): Use this list of exception names to generate information to |
| # tell Frog which exceptions can be passed from JS to Dart code. |
| exceptions = self._CollectExceptions(interfaces) |
| |
| mixins = self._ComputeMixins(self._PreOrderInterfaces(interfaces)) |
| for system in self._systems: |
| # give outputters a chance to see the mixin list before starting |
| system.ProcessMixins(mixins) |
| |
| # copy all mixin methods from every interface to this base interface |
| self.PopulateMixinBase(self._database.GetInterface('ElementalMixinBase'), mixins) |
| |
| # Render all interfaces into Dart and save them in files. |
| for interface in self._PreOrderInterfaces(interfaces): |
| |
| super_interface = None |
| super_name = interface.id |
| |
| if super_name in super_map: |
| super_name = super_map[super_name] |
| |
| if (super_database is not None and |
| super_database.HasInterface(super_name)): |
| super_interface = super_name |
| |
| interface_name = interface.id |
| auxiliary_file = self._auxiliary_files.get(interface_name) |
| if auxiliary_file is not None: |
| _logger.info('Skipping %s because %s exists' % ( |
| interface_name, auxiliary_file)) |
| continue |
| |
| info = RecognizeCallback(interface) |
| if info: |
| for system in self._systems: |
| system.ProcessCallback(interface, info) |
| else: |
| if 'Callback' in interface.ext_attrs: |
| _logger.info('Malformed callback: %s' % interface.id) |
| self._ProcessInterface(interface, super_interface, |
| source_filter, common_prefix) |
| |
| for system in self._systems: |
| system.Finish() |
| |
| def PopulateMixinBase(self, mixinbase, mixins): |
| """Copy all mixin attributes and operations to mixin base class""" |
| for mixin_name in mixins: |
| if self._database.HasInterface(mixin_name): |
| mixin = self._database.GetInterface(mixin_name) |
| mixinbase.attributes.extend(mixin.attributes) |
| mixinbase.operations.extend(mixin.operations) |
| for extattr in mixin.ext_attrs.keys(): |
| mixinbase.ext_attrs[extattr] = mixin.ext_attrs[extattr] |
| |
| # compute all interfaces which are in disjoint type hierarchies |
| # that is, cannot be SingleImplJSO without hoisting |
| def _ComputeMixins(self, interfaces): |
| implementors = {} |
| mixins = {} |
| parents = {} |
| # first compute the set of all inherited super-interfaces of every interface |
| for interface in interfaces: |
| if interface.parents: |
| # the first parent interface is the superclass |
| parent = interface.parents[0] |
| # if we haven't processed this one before |
| if not interface.id in parents: |
| # compute a list of all of the direct superclass this interface |
| parents[interface.id] = [] |
| parents[interface.id].append(parent) |
| if parent.type.id in parents: |
| # inherit all the super-interfaces |
| parents[interface.id].extend(parents[parent.type.id]) |
| |
| implemented_by = None |
| for interface in interfaces: |
| # now, examining secondary interfaces |
| for secondary in interface.parents[1:]: |
| if secondary.type.id in implementors: |
| implemented_by = implementors[secondary.type.id] |
| # if the interface is implemented by someone else who is not one of my parents, it is not SingleJsoImpl |
| if not implemented_by in parents[interface.id]: |
| mixins[secondary.type.id]=implemented_by |
| print "Mixin detected %s, previously implemented by %s, but also implemented by %s" % (secondary.type.id, implemented_by, interface.id) |
| # add all parents of the mixin as well |
| superparents = [] |
| superiface = secondary.type.id |
| if self._database.HasInterface(superiface): |
| self.getParents(self._database.GetInterface(superiface), superparents) |
| for parent in superparents: |
| mixins[parent.id]=implemented_by |
| print "Super Mixin detected %s, previously implemented by %s, but also implemented by %s" % (parent.id, implemented_by, interface.id) |
| |
| else: |
| implementors[secondary.type.id] = interface.id |
| # manual patch for outliers not picked up by this logic |
| mixins['ElementTimeControl']=1 |
| mixins['ElementTraversal']=1 |
| return mixins.keys() |
| |
| def _PreOrderInterfaces(self, interfaces): |
| """Returns the interfaces in pre-order, i.e. parents first.""" |
| seen = set() |
| ordered = [] |
| def visit(interface): |
| if interface.id in seen: |
| return |
| seen.add(interface.id) |
| for parent in interface.parents: |
| if IsDartCollectionType(parent.type.id): |
| continue |
| if self._database.HasInterface(parent.type.id): |
| parent_interface = self._database.GetInterface(parent.type.id) |
| visit(parent_interface) |
| ordered.append(interface) |
| |
| for interface in interfaces: |
| visit(interface) |
| return ordered |
| |
| |
| def _ProcessInterface(self, interface, super_interface_name, |
| source_filter, |
| common_prefix): |
| """.""" |
| |
| _logger.info('Generating %s' % interface.id) |
| |
| generators = [system.InterfaceGenerator(interface, |
| common_prefix, |
| super_interface_name, |
| source_filter) |
| for system in self._systems] |
| generators = filter(None, generators) |
| |
| |
| mixinbase = self._database.GetInterface("ElementalMixinBase") |
| parentops = [] |
| parentattrs = [] |
| |
| |
| directParents = [] |
| mixinOps = [] |
| # compute the immediate parents of each interface (not including secondary interfaces) |
| self.getParents(interface, directParents) |
| |
| # if not the mixin base, add its parents |
| if interface.id != 'ElementalMixinBase': |
| self.getParents(mixinbase, directParents) |
| # add the mixin base class itself as the parent of everything |
| directParents.insert(0, mixinbase) |
| |
| # for each parent interface |
| for pint in directParents: |
| for op in pint.operations: |
| # compute unique method signatures for each operation : |
| op_name = op.ext_attrs.get('DartName', op.id) |
| sig = "%s %s(" % (op.type.id, op_name) |
| for arg in op.arguments: |
| sig += arg.type.id |
| parentops.append(sig) |
| for attr in pint.attributes: |
| # compute attributes |
| if attr.is_fc_getter: |
| parentattrs.append("getter_" + DartDomNameOfAttribute(attr)) |
| if attr.is_fc_setter: |
| parentattrs.append("setter_" + DartDomNameOfAttribute(attr)) |
| |
| for generator in generators: |
| generator.StartInterface() |
| |
| for const in sorted(interface.constants, ConstantOutputOrder): |
| for generator in generators: |
| generator.AddConstant(const) |
| |
| attributes = [attr for attr in interface.attributes] |
| |
| for (getter, setter) in _PairUpAttributes(attributes): |
| for generator in generators: |
| # detect if attribute is inherited (as opposed to just redeclared) |
| inheritedGetter = ("getter_" + DartDomNameOfAttribute(getter)) in parentattrs |
| inheritedSetter = setter and ("setter_" + DartDomNameOfAttribute(setter)) in parentattrs |
| generator.AddAttribute(getter, setter, inheritedGetter, inheritedSetter) |
| |
| # The implementation should define an indexer if the interface directly |
| # extends List. |
| element_type = MaybeListElementType(interface) |
| if element_type: |
| for generator in generators: |
| generator.AddIndexer(element_type) |
| |
| # Generate operations |
| alreadyGenerated = [] |
| for operation in interface.operations: |
| op_name = operation.ext_attrs.get('DartName', operation.id) |
| sig = "%s %s(" % (operation.type.id, op_name) |
| for arg in operation.arguments: |
| sig += arg.type.id |
| if sig in alreadyGenerated: |
| continue |
| alreadyGenerated.append(sig) |
| |
| # hacks, should be able to compute this from IDL database |
| if operation.id == 'toString': |
| # implemented on JSO.toString() |
| continue |
| operations = [] |
| operations.append(operation) |
| info = AnalyzeOperation(interface, operations) |
| for generator in generators: |
| # don't override stuff hoisted to mixin base in implementors |
| inherited = sig in parentops |
| if info.IsStatic(): |
| generator.AddStaticOperation(info, inherited) |
| else: |
| generator.AddOperation(info, inherited) |
| |
| # With multiple inheritance, attributes and operations of non-first |
| # interfaces need to be added. Sometimes the attribute or operation is |
| # defined in the current interface as well as a parent. In that case we |
| # avoid making a duplicate definition and pray that the signatures match. |
| |
| for parent_interface in self._TransitiveSecondaryParents(interface): |
| if isinstance(parent_interface, str): # IsDartCollectionType(parent_interface) |
| continue |
| attributes = [attr for attr in parent_interface.attributes |
| if not FindMatchingAttribute(interface, attr)] |
| for (getter, setter) in _PairUpAttributes(attributes): |
| for generator in generators: |
| generator.AddSecondaryAttribute(parent_interface, getter, setter) |
| |
| # Group overloaded operations by id |
| operationsById = {} |
| for operation in parent_interface.operations: |
| if operation.id not in operationsById: |
| operationsById[operation.id] = [] |
| operationsById[operation.id].append(operation) |
| |
| # Generate operations |
| for id in sorted(operationsById.keys()): |
| if not any(op.id == id for op in interface.operations): |
| operations = operationsById[id] |
| info = AnalyzeOperation(interface, operations) |
| for generator in generators: |
| generator.AddSecondaryOperation(parent_interface, info) |
| |
| for generator in generators: |
| generator.FinishInterface() |
| return |
| |
| def getParents(self, interface, results): |
| if interface.parents: |
| pid = interface.parents[0].type.id |
| if self._database.HasInterface(pid): |
| pint = self._database.GetInterface(interface.parents[0].type.id) |
| results.append(pint) |
| self.getParents(pint, results) |
| |
| def _TransitiveSecondaryParents(self, interface): |
| """Returns a list of all non-primary parents. |
| |
| The list contains the interface objects for interfaces defined in the |
| database, and the name for undefined interfaces. |
| """ |
| def walk(parents): |
| for parent in parents: |
| if IsDartCollectionType(parent.type.id): |
| result.append(parent.type.id) |
| continue |
| if self._database.HasInterface(parent.type.id): |
| parent_interface = self._database.GetInterface(parent.type.id) |
| result.append(parent_interface) |
| walk(parent_interface.parents) |
| |
| result = [] |
| walk(interface.parents[1:]) |
| return result; |
| |
| |
| def _CollectExceptions(self, interfaces): |
| """Returns the names of all exception classes raised.""" |
| exceptions = set() |
| for interface in interfaces: |
| for attribute in interface.attributes: |
| if attribute.get_raises: |
| exceptions.add(attribute.get_raises.id) |
| if attribute.set_raises: |
| exceptions.add(attribute.set_raises.id) |
| for operation in interface.operations: |
| if operation.raises: |
| exceptions.add(operation.raises.id) |
| return exceptions |
| |
| |
| def Flush(self): |
| """Write out all pending files.""" |
| _logger.info('Flush...') |
| self._emitters.Flush() |
| |
| def _FixEventTargets(self): |
| for interface in self._database.GetInterfaces(): |
| # Create fake EventTarget parent interface for interfaces that have |
| # 'EventTarget' extended attribute. |
| if 'EventTarget' in interface.ext_attrs: |
| ast = [('Annotation', [('Id', 'WebKit')]), |
| ('InterfaceType', ('ScopedName', 'EventTarget'))] |
| interface.parents.append(idlnode.IDLParentInterface(ast)) |
| |
| def _ComputeInheritanceClosure(self): |
| def Collect(interface, seen, collected): |
| name = interface.id |
| if '<' in name: |
| # TODO(sra): Handle parameterized types. |
| return |
| if not name in seen: |
| seen.add(name) |
| collected.append(name) |
| for parent in interface.parents: |
| # TODO(sra): Handle parameterized types. |
| if not '<' in parent.type.id: |
| if self._database.HasInterface(parent.type.id): |
| Collect(self._database.GetInterface(parent.type.id), |
| seen, collected) |
| |
| self._inheritance_closure = {} |
| for interface in self._database.GetInterfaces(): |
| seen = set() |
| collected = [] |
| Collect(interface, seen, collected) |
| self._inheritance_closure[interface.id] = collected |
| |
| def _AllImplementedInterfaces(self, interface): |
| """Returns a list of the names of all interfaces implemented by 'interface'. |
| List includes the name of 'interface'. |
| """ |
| return self._inheritance_closure[interface.id] |
| |
| def _PairUpAttributes(attributes): |
| """Returns a list of (getter, setter) pairs sorted by name. |
| |
| One element of the pair may be None. |
| """ |
| names = sorted(set(attr.id for attr in attributes)) |
| getters = {} |
| setters = {} |
| for attr in attributes: |
| if attr.is_fc_getter: |
| getters[attr.id] = attr |
| elif attr.is_fc_setter and 'Replaceable' not in attr.ext_attrs: |
| setters[attr.id] = attr |
| return [(getters.get(id), setters.get(id)) for id in names] |
| |
| # ------------------------------------------------------------------------------ |
| |
| class DummyImplementationSystem(SystemElemental): |
| """Generates a dummy implementation for use by the editor analysis. |
| |
| All the code comes from hand-written library files. |
| """ |
| |
| def __init__(self, templates, database, emitters, output_dir): |
| super(DummyImplementationSystem, self).__init__( |
| templates, database, emitters, output_dir) |
| factory_providers_file = os.path.join(self._output_dir, 'src', 'dummy', |
| 'RegularFactoryProviders.dart') |
| self._factory_providers_emitter = self._emitters.FileEmitter( |
| factory_providers_file) |
| self._impl_file_paths = [factory_providers_file] |
| |
| def InterfaceGenerator(self, |
| interface, |
| common_prefix, |
| super_interface_name, |
| source_filter): |
| return DummyInterfaceGenerator(self, interface) |
| |
| def ProcessCallback(self, interface, info): |
| pass |
| |
| def GenerateLibraries(self, lib_dir): |
| # Library generated for implementation. |
| self._GenerateLibFile( |
| 'dom_dummy.darttemplate', |
| os.path.join(lib_dir, 'dom_dummy.dart'), |
| (self._interface_system._dart_interface_file_paths + |
| self._interface_system._dart_callback_file_paths + |
| self._impl_file_paths)) |
| |
| |
| # ------------------------------------------------------------------------------ |
| |
| class DummyInterfaceGenerator(object): |
| """Generates dummy implementation.""" |
| |
| def __init__(self, system, interface): |
| self._system = system |
| self._interface = interface |
| |
| def StartInterface(self): |
| # There is no implementation to match the interface, but there might be a |
| # factory constructor for the Dart interface. |
| constructor_info = AnalyzeConstructor(self._interface) |
| if constructor_info: |
| dart_interface_name = self._interface.id |
| self._EmitFactoryProvider(dart_interface_name, constructor_info) |
| |
| def _EmitFactoryProvider(self, interface_name, constructor_info): |
| factory_provider = '_' + interface_name + 'FactoryProvider' |
| self._system._factory_providers_emitter.Emit( |
| self._system._templates.Load('factoryprovider.darttemplate'), |
| FACTORYPROVIDER=factory_provider, |
| CONSTRUCTOR=interface_name, |
| PARAMETERS=constructor_info.ParametersImplementationDeclaration()) |
| |
| def FinishInterface(self): |
| pass |
| |
| def AddConstant(self, constant): |
| pass |
| |
| def AddAttribute(self, getter, setter, inheritedGetter, inheritedSetter): |
| pass |
| |
| def AddSecondaryAttribute(self, interface, getter, setter): |
| pass |
| |
| def AddSecondaryOperation(self, interface, info): |
| pass |
| |
| def AddIndexer(self, element_type): |
| pass |
| |
| def AddTypedArrayConstructors(self, element_type): |
| pass |
| |
| def AddOperation(self, info, inherited): |
| pass |
| |
| def AddStaticOperation(self, info, inherited): |
| pass |
| |
| def AddEventAttributes(self, event_attrs): |
| pass |
