scripts.databasebuilder.DatabaseBuilder Class Reference

Inheritance diagram for scripts.databasebuilder.DatabaseBuilder:

Public Member Functions
def	__init__ (self, database)
def	merge_imported_interfaces (self)
def	import_idl_files (self, file_paths, import_options, is_dart_idl)
def	fix_displacements (self, source)
def	normalize_annotations (self, sources)
def	map_dictionaries (self)
def	fetch_constructor_data (self, options)
def	examine_database (self)

Public Attributes
	conditionals_met
	build
	global_type_defs

Detailed Description

Definition at line 173 of file databasebuilder.py.

Constructor & Destructor Documentation

__init__()

def scripts.databasebuilder.DatabaseBuilder.__init__	(		self,
			database
	)

DatabaseBuilder is used for importing and merging interfaces into
the Database

Definition at line 175 of file databasebuilder.py.

    def __init__(self, database):
        """DatabaseBuilder is used for importing and merging interfaces into
    the Database"""
        self._info_collector = InterfaceInfoCollector()
 
        self._database = database
        self._imported_interfaces = []
        self._impl_stmts = []
        self.conditionals_met = set()
 
        # Spin up the new IDL parser.
        self.build = Build(self)
 
        # Global typedef to mapping.
        self.global_type_defs = monitored.Dict(
            'databasebuilder.global_type_defs', {
                'Transferable': 'MessagePort',
            })
 

Member Function Documentation

examine_database()

def scripts.databasebuilder.DatabaseBuilder.examine_database

(

self

)

Definition at line 822 of file databasebuilder.py.

    def examine_database(self):
        # Contains list of dictionary structure: {'dictionary': dictionary, 'usages': []}
        self._diag_dictionaries = []
        self._dictionaries_used_types = []
 
        # Record any dictionary.
        for dictionary in self._database.GetDictionaries():
            self._diag_dictionaries.append({
                'dictionary': dictionary,
                'usages': []
            })
 
        # Contains list of NoInterfaceObject structures: {'no_interface_object': dictionary, 'usages': []}
        self._diag_no_interfaces = []
        self._no_interfaces_used_types = []
 
        # Record any interface with Blink IDL Extended Attribute 'NoInterfaceObject'.
        for interface in self._database.GetInterfaces():
            if interface.is_no_interface_object:
                self._diag_no_interfaces.append({
                    'no_interface_object':
                    interface,
                    'usages': []
                })
 
        for interface in self._database.GetInterfaces():
            self._constructors(interface)
            self._constructors(interface, check_dictionaries=False)
 
            for attribute in interface.attributes:
                self._attribute_operation(interface, attribute)
                self._attribute_operation(
                    interface, attribute, check_dictionaries=False)
 
            for operation in interface.operations:
                self._attribute_operation(interface, operation)
                self._attribute_operation(
                    interface, operation, check_dictionaries=False)
 
        # Report all dictionaries and their usage.
        self._output_examination()
        # Report all interface marked with NoInterfaceObject and their usage.
        self._output_examination(check_dictionaries=False)
 
        print('''
Key:
  (READ-ONLY) - read-only attribute has relationship
  (GET/SET)   - attribute has relationship
  RETURN      - operation\'s returned value has relationship
  (ARGUMENT)  - operation\'s argument(s) has relationship
 
  (New)       - After dictionary name if constructor(s) exist
  (Ops,Props,New) after a NoInterfaceObject name is defined as:
    Ops       - number of operations for a NoInterfaceObject
    Props     - number of properties for a NoInterfaceObject
    New       - T(#) number constructors for a NoInterfaceObject
                F no constructors for a NoInterfaceObject
                e.g., an interface 5 operations, 3 properties and 2
                      constructors would display (5,3,T(2))
 
 
Examination Complete
''')
 

fetch_constructor_data()

def scripts.databasebuilder.DatabaseBuilder.fetch_constructor_data	(		self,
			options
	)

Definition at line 801 of file databasebuilder.py.

    def fetch_constructor_data(self, options):
        window_interface = self._database.GetInterface('Window')
        for attr in window_interface.attributes:
            type = attr.type.id
            if not type.endswith('Constructor'):
                continue
            type = re.sub('(Constructor)+$', '', type)
            # TODO(antonm): Ideally we'd like to have pristine copy of WebKit IDLs and fetch
            # this information directly from it.  Unfortunately right now database is massaged
            # a lot so it's difficult to maintain necessary information on Window itself.
            interface = self._database.GetInterface(type)
            if 'V8EnabledPerContext' in attr.ext_attrs:
                interface.ext_attrs['synthesizedV8EnabledPerContext'] = \
                    attr.ext_attrs['V8EnabledPerContext']
            if 'V8EnabledAtRuntime' in attr.ext_attrs:
                interface.ext_attrs['synthesizedV8EnabledAtRuntime'] = \
                    attr.ext_attrs['V8EnabledAtRuntime'] or attr.id
 

fix_displacements()

def scripts.databasebuilder.DatabaseBuilder.fix_displacements	(		self,
			source
	)

E.g. In W3C, something is declared on HTMLDocument but in WebKit
its on Document, so we need to mark that something in HTMLDocument
with @WebKit(via=Document). The 'via' attribute specifies the
parent interface that has the declaration.

Definition at line 711 of file databasebuilder.py.

    def fix_displacements(self, source):
        """E.g. In W3C, something is declared on HTMLDocument but in WebKit
    its on Document, so we need to mark that something in HTMLDocument
    with @WebKit(via=Document). The 'via' attribute specifies the
    parent interface that has the declaration."""
 
        for interface in self._database.GetInterfaces():
            changed = False
 
            _logger.info('fixing displacements in %s' % interface.id)
 
            for parent_interface in self._get_parent_interfaces(interface):
                _logger.info('scanning parent %s of %s' % (parent_interface.id,
                                                           interface.id))
 
                def fix_nodes(local_list, parent_list):
                    changed = False
                    parent_signatures_map = self._build_signatures_map(
                        parent_list)
                    for idl_node in local_list:
                        sig = self._sign(idl_node)
                        if sig in parent_signatures_map:
                            parent_member = parent_signatures_map[sig]
                            if (source in parent_member.annotations and
                                    source not in idl_node.annotations and
                                    _VIA_ANNOTATION_ATTR_NAME not in
                                    parent_member.annotations[source]):
                                idl_node.annotations[source] = IDLAnnotation({
                                    _VIA_ANNOTATION_ATTR_NAME:
                                    parent_interface.id
                                })
                                changed = True
                    return changed
 
                changed = fix_nodes(interface.constants,
                                    parent_interface.constants) or changed
                changed = fix_nodes(interface.attributes,
                                    parent_interface.attributes) or changed
                changed = fix_nodes(interface.operations,
                                    parent_interface.operations) or changed
            if changed:
                _logger.info(
                    'fixed displaced declarations in %s' % interface.id)
 

import_idl_files()

def scripts.databasebuilder.DatabaseBuilder.import_idl_files	(		self,
			file_paths,
			import_options,
			is_dart_idl
	)

Definition at line 628 of file databasebuilder.py.

    def import_idl_files(self, file_paths, import_options, is_dart_idl):
        self._blink_compile_idl_files(file_paths, import_options, is_dart_idl)
 
        start_time = time.time()
 
        # Parse the IDL files in serial.
        for file_path in file_paths:
            file_path = os.path.normpath(file_path)
            idl_file = _load_idl_file(self.build, file_path, import_options)
            _logger.info('Processing %s' % os.path.splitext(
                os.path.basename(file_path))[0])
            self._process_idl_file(idl_file, import_options, is_dart_idl)
 
        end_time = time.time()
 
        for warning in report_unions_to_any():
            _logger.warning(warning)
 
        print('Total %s files %sprocessed in databasebuilder in %s seconds' % \
        (len(file_paths), '', round((end_time - start_time), 2)))
 

map_dictionaries()

def scripts.databasebuilder.DatabaseBuilder.map_dictionaries

(

self

)

Changes the type of operations/constructors arguments from an IDL
dictionary to a Dictionary.  The IDL dictionary is just an enums of
strings which are checked at run-time.

Definition at line 783 of file databasebuilder.py.

    def map_dictionaries(self):
        """Changes the type of operations/constructors arguments from an IDL
       dictionary to a Dictionary.  The IDL dictionary is just an enums of
       strings which are checked at run-time."""
 
        def dictionary_to_map(type_node):
            if self._database.HasDictionary(type_node.id):
                type_node.dictionary = type_node.id
                type_node.id = 'Dictionary'
 
        def all_types(node):
            list(map(dictionary_to_map, node.all(IDLType)))
 
        for interface in self._database.GetInterfaces():
            list(map(all_types, interface.all(IDLExtAttrFunctionValue)))
            list(map(all_types, interface.attributes))
            list(map(all_types, interface.operations))
 

merge_imported_interfaces()

def scripts.databasebuilder.DatabaseBuilder.merge_imported_interfaces

(

self

)

Merges all imported interfaces and loads them into the DB.

Definition at line 534 of file databasebuilder.py.

    def merge_imported_interfaces(self):
        """Merges all imported interfaces and loads them into the DB."""
        imported_interfaces = self._imported_interfaces
 
        # Step 1: Pre process imported interfaces
        for interface, import_options in imported_interfaces:
            self._annotate(interface, import_options)
 
        # Step 2: Add all new interfaces and merge overlapping ones
        for interface, import_options in imported_interfaces:
            if not interface.is_supplemental:
                if self._database.HasInterface(interface.id):
                    old_interface = self._database.GetInterface(interface.id)
                    self._merge_interfaces(old_interface, interface,
                                           import_options)
                else:
                    if import_options.add_new_interfaces:
                        self._database.AddInterface(interface)
 
        # Step 3: Merge in supplemental interfaces
        for interface, import_options in imported_interfaces:
            if interface.is_supplemental:
                target = interface.id
                if self._database.HasInterface(target):
                    old_interface = self._database.GetInterface(target)
                    self._merge_interfaces(old_interface, interface,
                                           import_options)
                else:
                    _logger.warning("Supplemental target '%s' not found",
                                    target)
 
        # Step 4: Resolve 'implements' statements
        for impl_stmt, import_options in self._impl_stmts:
            self._merge_impl_stmt(impl_stmt, import_options)
 
        self._impl_stmts = []
        self._imported_interfaces = []
 

normalize_annotations()

def scripts.databasebuilder.DatabaseBuilder.normalize_annotations	(		self,
			sources
	)

Makes the IDLs less verbose by removing annotation attributes
that are identical to the ones defined at the interface level.

Args:
sources -- list of source names to normalize.

Definition at line 755 of file databasebuilder.py.

    def normalize_annotations(self, sources):
        """Makes the IDLs less verbose by removing annotation attributes
    that are identical to the ones defined at the interface level.
 
    Args:
      sources -- list of source names to normalize."""
        for interface in self._database.GetInterfaces():
            _logger.debug('normalizing annotations for %s' % interface.id)
            for source in sources:
                if (source not in interface.annotations or
                        not interface.annotations[source]):
                    continue
                top_level_annotation = interface.annotations[source]
 
                def normalize(idl_node):
                    if (source in idl_node.annotations and
                            idl_node.annotations[source]):
                        annotation = idl_node.annotations[source]
                        for name, value in list(annotation.items()):
                            if (name in top_level_annotation and
                                    value == top_level_annotation[name]):
                                del annotation[name]
 
                list(map(normalize, interface.parents))
                list(map(normalize, interface.constants))
                list(map(normalize, interface.attributes))
                list(map(normalize, interface.operations))
 

Member Data Documentation

build

scripts.databasebuilder.DatabaseBuilder.build

Definition at line 186 of file databasebuilder.py.

conditionals_met

scripts.databasebuilder.DatabaseBuilder.conditionals_met

Definition at line 183 of file databasebuilder.py.

global_type_defs

scripts.databasebuilder.DatabaseBuilder.global_type_defs

Definition at line 189 of file databasebuilder.py.

---

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

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