scripts.dartgenerator.DartGenerator Class Reference

Inheritance diagram for scripts.dartgenerator.DartGenerator:

Public Member Functions
def	__init__ (self, logging_level=logging.WARNING)
def	LoadAuxiliary (self, auxiliary_dir)
def	FilterMembersWithUnidentifiedTypes (self, database)
def	FilterInterfaces (self, database, and_annotations=[], or_annotations=[], exclude_displaced=[], exclude_suppressed=[])
def	Generate (self, database, super_database, generate_interface)
def	IsEventTarget (self, database, interface)
def	FixEventTargets (self, database)
def	AddMissingArguments (self, database)
def	CleanupOperationArguments (self, database)

Detailed Description

Utilities to generate Dart APIs and corresponding JavaScript.

Definition at line 28 of file dartgenerator.py.

Constructor & Destructor Documentation

__init__()

def scripts.dartgenerator.DartGenerator.__init__	(		self,
			logging_level = logging.WARNING
	)

Definition at line 31 of file dartgenerator.py.

    def __init__(self, logging_level=logging.WARNING):
        self._auxiliary_files = {}
        self._dart_templates_re = re.compile(r'[\w.:]+<([\w \.<>:]+)>')
        _logger.setLevel(logging_level)
 

Member Function Documentation

AddMissingArguments()

def scripts.dartgenerator.DartGenerator.AddMissingArguments	(		self,
			database
	)

Definition at line 257 of file dartgenerator.py.

    def AddMissingArguments(self, database):
        ARG = idlnode.IDLArgument([('Type', ('ScopedName', 'object')),
                                   ('Id', 'arg')])
        for interface in database.GetInterfaces():
            for operation in interface.operations:
                call_with = operation.ext_attrs.get('CallWith', [])
                if not (isinstance(call_with, list)):
                    call_with = [call_with]
                constructor_with = operation.ext_attrs.get(
                    'ConstructorCallWith', [])
                if not (isinstance(constructor_with, list)):
                    constructor_with = [constructor_with]
                call_with = call_with + constructor_with
 
                if 'ScriptArguments' in call_with:
                    operation.arguments.append(ARG)
 

CleanupOperationArguments()

def scripts.dartgenerator.DartGenerator.CleanupOperationArguments	(		self,
			database
	)

Definition at line 274 of file dartgenerator.py.

    def CleanupOperationArguments(self, database):
        for interface in database.GetInterfaces():
            for operation in interface.operations:
                # TODO(terry): Hack to remove 3rd arguments in setInterval/setTimeout.
                if ((operation.id == 'setInterval' or operation.id == 'setTimeout') and \
                    operation.arguments[0].type.id == 'any'):
                    operation.arguments.pop(2)
 
                # Massage any operation argument type that is IDLEnum to String.
                for index, argument in enumerate(operation.arguments):
                    type_name = argument.type.id
                    if database.HasEnum(type_name):
                        operation.arguments[index].type = IDLType('DOMString')

FilterInterfaces()

def scripts.dartgenerator.DartGenerator.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.

Definition at line 115 of file dartgenerator.py.

                         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)
 

FilterMembersWithUnidentifiedTypes()

def scripts.dartgenerator.DartGenerator.FilterMembersWithUnidentifiedTypes	(		self,
			database
	)

Removes unidentified types.

Removes constants, attributes, operations and parents with unidentified
types.

Definition at line 81 of file dartgenerator.py.

    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
                    # Ignore constructor warnings.
                    if not (interface.id in [
                            'Window', 'WorkerContext', 'WorkerGlobalScope'
                    ] and type_name.endswith('Constructor')):
                        _logger.warn(
                            'removing %s in %s which has unidentified type %s' %
                            (node_name, interface.id, type_name))
                    return False
                return True
 
            interface.constants = list(filter(IsIdentified,
                                              interface.constants))
            interface.attributes = list(
                filter(IsIdentified, interface.attributes))
            interface.operations = list(
                filter(IsIdentified, interface.operations))
            interface.parents = list(filter(IsIdentified, interface.parents))
 

FixEventTargets()

def scripts.dartgenerator.DartGenerator.FixEventTargets	(		self,
			database
	)

Definition at line 245 of file dartgenerator.py.

    def FixEventTargets(self, database):
        for interface in database.GetInterfaces():
            if self.IsEventTarget(database, interface):
                # Add as an attribute for easy querying in generation code.
                interface.ext_attrs['EventTarget'] = None
            elif 'EventTarget' in interface.ext_attrs:
                # Create fake EventTarget parent interface for interfaces that have
                # 'EventTarget' extended attribute.
                ast = [('Annotation', [('Id', 'WebKit')]),
                       ('InterfaceType', ('ScopedName', 'EventTarget'))]
                interface.parents.append(idlnode.IDLParentInterface(ast))
 

Generate()

def scripts.dartgenerator.DartGenerator.Generate	(		self,
			database,
			super_database,
			generate_interface
	)

Definition at line 178 of file dartgenerator.py.

    def Generate(self, database, super_database, generate_interface):
        self._database = database
 
        # Collect interfaces
        interfaces = []
        for interface in database.GetInterfaces():
            if not MatchSourceFilter(interface):
                # Skip this interface since it's not present in the required source
                _logger.info('Omitting interface - %s' % interface.id)
                continue
            interfaces.append(interface)
 
        # All web_gl constants from WebGLRenderingContextBase, WebGL2RenderingContextBase, WebGLDrawBuffers are generated
        # in a synthesized class WebGL.  Those IDLConstants are in web_gl_constants.
        web_gl_constants = []
 
        # Render all interfaces into Dart and save them in files.
        for interface in self._PreOrderInterfaces(interfaces):
            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
 
            _logger.info('Generating %s' % interface.id)
            generate_interface(interface, gl_constants=web_gl_constants)
 
        # Generate the WEB_GL constants
        web_gl_constants_interface = IDLInterface(None, "WebGL")
        web_gl_constants_interface.constants = web_gl_constants
        self._database._all_interfaces['WebGL'] = web_gl_constants_interface
        generate_interface(web_gl_constants_interface)
 

IsEventTarget()

def scripts.dartgenerator.DartGenerator.IsEventTarget	(		self,
			database,
			interface
	)

Definition at line 234 of file dartgenerator.py.

    def IsEventTarget(self, database, interface):
        if interface.id == 'EventTarget':
            return True
        for parent in interface.parents:
            parent_name = parent.type.id
            if database.HasInterface(parent_name):
                parent_interface = database.GetInterface(parent.type.id)
                if self.IsEventTarget(database, parent_interface):
                    return True
        return False
 

LoadAuxiliary()

def scripts.dartgenerator.DartGenerator.LoadAuxiliary	(		self,
			auxiliary_dir
	)

Definition at line 73 of file dartgenerator.py.

    def LoadAuxiliary(self, auxiliary_dir):
 
        for (dirname, _, names) in os.walk(auxiliary_dir):
            for name in names:
                if name.endswith('.dart'):
                    name = name[0:-5]  # strip off ".dart"
                self._auxiliary_files[name] = os.path.join(dirname, name)
 

---

The documentation for this class was generated from the following file:

• third_party/dart-lang/sdk/tools/dom/scripts/dartgenerator.py