scripts.idlnode.IDLFile Class Reference

Inheritance diagram for scripts.idlnode.IDLFile:

Public Member Functions
def	__init__ (self, ast, filename=None)
Public Member Functions inherited from scripts.idlnode.IDLNode
def	__init__ (self, ast, id=None)
def	__repr__ (self)
def	__eq__ (self, other)
def	__hash__ (self)
def	reset_id (self, newId)
def	all (self, type_filter=None)
def	to_dict (self)
def	to_hash (self)

Public Attributes
	filename
	typeDefs
	interfaces
	dictionaries
	implementsStatements
	enums
Public Attributes inherited from scripts.idlnode.IDLNode
	id
	ext_attrs
	annotations
	members

Static Public Attributes
string	DART_IDL = 'dart.idl'

Detailed Description

IDLFile is the top-level node in each IDL file. It may contain interfaces.

Definition at line 413 of file idlnode.py.

Constructor & Destructor Documentation

__init__()

def scripts.idlnode.IDLFile.__init__	(		self,
			ast,
			id = None
	)

Initializes an IDLNode from a PegParser AST output.

Reimplemented from scripts.idlnode.IDLNode.

Definition at line 418 of file idlnode.py.

    def __init__(self, ast, filename=None):
        IDLNode.__init__(self, ast)
        self.filename = filename
 
        filename_basename = os.path.basename(filename)
 
        # Report of union types mapped to any.
 
        # Remember all the typedefs before we start walking the AST.  Some
        # IDLs now have typedefs before interfaces.  So we need to remember
        # to resolve the typedefs.
        self.typeDefs = self._convert_all(ast, 'TypeDef', IDLTypeDef)
        for typedefName in ast.typedefs:
            typedef_type = ast.typedefs[typedefName]
            # Ignore unions and dictionaries for now we just want normal typedefs to resolve our arguments/types.
            if not (isinstance(typedef_type.idl_type, IdlUnionType)) and not (
                    typedef_type.idl_type.base_type == 'Dictionary'):
                _addTypedef(IDLTypeDef(typedef_type))
 
        self.interfaces = self._convert_all(ast, 'Interface', IDLInterface)
        self.dictionaries = self._convert_all(ast, 'Dictionary', IDLDictionary)
 
        if len(ast.callback_functions) > 0:
            callback_functions = self._convert_all(ast, 'Callback_Function',
                                                   IDLCallbackFunction)
            for callback_function in callback_functions:
                for annotation in callback_function.annotations:
                    callback = callback_function.annotations[annotation]
                    cb_interface = IDLInterface(None, callback.name)
                    cb_interface.ext_attrs['Callback'] = len(callback.arguments)
                    op = IDLOperation(None, cb_interface.id, "handleEvent")
                    op.type = IDLType(callback.idl_type)
                    op.type = resolveTypedef(op.type)
 
                    if len(callback.arguments) > 0:
                        op.arguments = self._convert_all(
                            callback, 'Argument', IDLArgument)
 
                    cb_interface.operations = [op]
                    self.interfaces.append(cb_interface)
 
        is_blink = not (isinstance(
            ast, list)) and ast.__module__ == 'idl_definitions'
 
        if is_blink:
            # implements is handled by the interface merging step (see the function
            # merge_interface_dependencies).
            for interface in self.interfaces:
                blink_interface = ast.interfaces.get(interface.id)
                if filename_basename == self.DART_IDL:
                    # Special handling for dart.idl we need to remember the interface,
                    # since we could have many (not one interface / file). Then build up
                    # the IDLImplementsStatement for any implements in dart.idl.
                    interface_info = dependency.get_interfaces_info(
                    )['__dart_idl___']
 
                    self.implementsStatements = []
 
                    implement_pairs = interface_info['implement_pairs']
                    for implement_pair in implement_pairs:
                        interface_name = implement_pair[0]
                        implemented_name = implement_pair[1]
 
                        implementor = new_asts[interface_name].interfaces.get(
                            interface_name)
                        implement_statement = self._createImplementsStatement(
                            implementor, implemented_name)
 
                        self.implementsStatements.append(implement_statement)
                elif interface.id in dependency.get_interfaces_info():
                    interface_info = dependency.get_interfaces_info()[interface.
                                                                      id]
 
                    implements = []
                    if 'implements_interfaces' in interface_info:
                        implements = interface_info['implements_interfaces']
                    if not (blink_interface.is_partial) and len(implements) > 0:
                        implementor = new_asts[interface.id].interfaces.get(
                            interface.id)
 
                        self.implementsStatements = []
 
                        # TODO(terry): Need to handle more than one implements.
                        for implemented_name in implements:
                            implement_statement = self._createImplementsStatement(
                                implementor, implemented_name)
                            self.implementsStatements.append(
                                implement_statement)
                    else:
                        self.implementsStatements = []
        else:
            self.implementsStatements = self._convert_all(
                ast, 'ImplStmt', IDLImplementsStatement)
 
        # Record typedefs that are unions.
        for typedefName in ast.typedefs:
            typedef_type = ast.typedefs[typedefName]
            if isinstance(typedef_type.idl_type, IdlUnionType):
                self.typeDefs.append(IDLTypeDef(typedef_type))
            elif typedef_type.idl_type.base_type == 'Dictionary':
                dictionary = IDLDictionary(typedef_type, True)
                self.dictionaries.append(dictionary)
 
        self.enums = self._convert_all(ast, 'Enum', IDLEnum)
 

Member Data Documentation

DART_IDL

string scripts.idlnode.IDLFile.DART_IDL = 'dart.idl'

static

Definition at line 416 of file idlnode.py.

dictionaries

scripts.idlnode.IDLFile.dictionaries

Definition at line 438 of file idlnode.py.

enums

scripts.idlnode.IDLFile.enums

Definition at line 521 of file idlnode.py.

filename

scripts.idlnode.IDLFile.filename

Definition at line 420 of file idlnode.py.

implementsStatements

scripts.idlnode.IDLFile.implementsStatements

Definition at line 474 of file idlnode.py.

interfaces

scripts.idlnode.IDLFile.interfaces

Definition at line 437 of file idlnode.py.

typeDefs

scripts.idlnode.IDLFile.typeDefs

Definition at line 429 of file idlnode.py.

---

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

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