| # Copyright (C) 2013 Google Inc. All rights reserved. |
| # coding=utf-8 |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions are |
| # met: |
| # |
| # * Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # * Redistributions in binary form must reproduce the above |
| # copyright notice, this list of conditions and the following disclaimer |
| # in the documentation and/or other materials provided with the |
| # distribution. |
| # * Neither the name of Google Inc. nor the names of its |
| # contributors may be used to endorse or promote products derived from |
| # this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| """Generate template values for an interface. |
| |
| Design doc: http://www.chromium.org/developers/design-documents/idl-compiler |
| """ |
| |
| from collections import defaultdict |
| import itertools |
| from operator import itemgetter |
| |
| import idl_definitions |
| from idl_definitions import IdlOperation |
| import idl_types |
| from idl_types import IdlType, inherits_interface |
| import v8_attributes |
| from v8_globals import includes |
| import v8_methods |
| import v8_types |
| from v8_types import cpp_template_type |
| import v8_utilities |
| from v8_utilities import (capitalize, cpp_name, |
| has_extended_attribute_value, |
| extended_attribute_value_as_list) |
| |
| |
| INTERFACE_H_INCLUDES = frozenset([ |
| 'platform/heap/Handle.h', |
| ]) |
| |
| INTERFACE_CPP_INCLUDES = frozenset([ |
| 'sky/engine/bindings/exception_state.h', |
| 'core/dom/Document.h', |
| 'base/trace_event/trace_event.h', |
| 'wtf/GetPtr.h', |
| 'wtf/RefPtr.h', |
| ]) |
| |
| |
| def interface_context(interface): |
| includes.clear() |
| includes.update(INTERFACE_CPP_INCLUDES) |
| header_includes = set(INTERFACE_H_INCLUDES) |
| |
| parent_interface = interface.parent |
| if parent_interface: |
| header_includes.update(v8_types.includes_for_interface(parent_interface)) |
| extended_attributes = interface.extended_attributes |
| |
| # [DependentLifetime] |
| is_dependent_lifetime = 'DependentLifetime' in extended_attributes |
| |
| # [Iterable] |
| iterator_method = None |
| if 'Iterable' in extended_attributes: |
| iterator_operation = IdlOperation(interface.idl_name) |
| iterator_operation.name = 'iterator' |
| iterator_operation.idl_type = IdlType('Iterator') |
| iterator_operation.extended_attributes['RaisesException'] = None |
| iterator_operation.extended_attributes['CallWith'] = 'ScriptState' |
| iterator_method = v8_methods.method_context(interface, |
| iterator_operation) |
| |
| # [SetWrapperReferenceFrom] |
| reachable_node_function = extended_attributes.get('SetWrapperReferenceFrom') |
| if reachable_node_function: |
| includes.update(['core/dom/Element.h']) |
| |
| # [SetWrapperReferenceTo] |
| set_wrapper_reference_to_list = [{ |
| 'name': argument.name, |
| # FIXME: properly should be: |
| # 'cpp_type': argument.idl_type.cpp_type_args(raw_type=True), |
| # (if type is non-wrapper type like NodeFilter, normally RefPtr) |
| # Raw pointers faster though, and NodeFilter hacky anyway. |
| 'cpp_type': argument.idl_type.implemented_as + '*', |
| 'idl_type': argument.idl_type, |
| } for argument in extended_attributes.get('SetWrapperReferenceTo', [])] |
| for set_wrapper_reference_to in set_wrapper_reference_to_list: |
| set_wrapper_reference_to['idl_type'].add_includes_for_type() |
| |
| # [NotScriptWrappable] |
| is_script_wrappable = 'NotScriptWrappable' not in extended_attributes |
| |
| # [SpecialWrapFor] |
| if 'SpecialWrapFor' in extended_attributes: |
| special_wrap_for = extended_attribute_value_as_list(interface, 'SpecialWrapFor') |
| else: |
| special_wrap_for = [] |
| for special_wrap_interface in special_wrap_for: |
| v8_types.add_includes_for_interface(special_wrap_interface) |
| |
| # [Custom=Wrap], [SetWrapperReferenceFrom] |
| has_visit_dom_wrapper = ( |
| has_extended_attribute_value(interface, 'Custom', 'VisitDOMWrapper') or |
| reachable_node_function or |
| set_wrapper_reference_to_list) |
| |
| wrapper_class_id = ('NodeClassId' if inherits_interface(interface.name, 'Node') else 'ObjectClassId') |
| |
| context = { |
| 'cpp_class': cpp_name(interface), |
| 'has_custom_wrap': has_extended_attribute_value(interface, 'Custom', 'Wrap'), # [Custom=Wrap] |
| 'has_visit_dom_wrapper': has_visit_dom_wrapper, |
| 'header_includes': header_includes, |
| 'interface_name': interface.name, |
| 'is_dependent_lifetime': is_dependent_lifetime, |
| 'is_exception': interface.is_exception, |
| 'is_script_wrappable': is_script_wrappable, |
| 'iterator_method': iterator_method, |
| 'lifetime': 'Dependent' |
| if (has_visit_dom_wrapper or |
| is_dependent_lifetime) |
| else 'Independent', |
| 'parent_interface': parent_interface, |
| 'reachable_node_function': reachable_node_function, |
| 'set_wrapper_reference_to_list': set_wrapper_reference_to_list, |
| 'special_wrap_for': special_wrap_for, |
| 'wrapper_class_id': wrapper_class_id, |
| } |
| |
| # Constructors |
| constructors = [constructor_context(interface, constructor) |
| for constructor in interface.constructors |
| # FIXME: shouldn't put named constructors with constructors |
| # (currently needed for Perl compatibility) |
| # Handle named constructors separately |
| if constructor.name == 'Constructor'] |
| if len(constructors) > 1: |
| context['constructor_overloads'] = overloads_context(constructors) |
| |
| # [CustomConstructor] |
| custom_constructors = [{ # Only needed for computing interface length |
| 'number_of_required_arguments': |
| number_of_required_arguments(constructor), |
| } for constructor in interface.custom_constructors] |
| |
| # [EventConstructor] |
| has_event_constructor = 'EventConstructor' in extended_attributes |
| any_type_attributes = [attribute for attribute in interface.attributes |
| if attribute.idl_type.name == 'Any'] |
| |
| # [NamedConstructor] |
| named_constructor = named_constructor_context(interface) |
| |
| if (constructors or custom_constructors or has_event_constructor or |
| named_constructor): |
| includes.add('core/frame/LocalDOMWindow.h') |
| |
| context.update({ |
| 'any_type_attributes': any_type_attributes, |
| 'constructors': constructors, |
| 'has_custom_constructor': bool(custom_constructors), |
| 'has_event_constructor': has_event_constructor, |
| 'interface_length': |
| interface_length(interface, constructors + custom_constructors), |
| 'is_constructor_raises_exception': extended_attributes.get('RaisesException') == 'Constructor', # [RaisesException=Constructor] |
| 'named_constructor': named_constructor, |
| }) |
| |
| constants = [constant_context(constant) for constant in interface.constants] |
| |
| # Constants |
| context.update({ |
| 'constants': constants, |
| 'has_constant_configuration': True, |
| }) |
| |
| # Attributes |
| attributes = [v8_attributes.attribute_context(interface, attribute) |
| for attribute in interface.attributes] |
| context.update({ |
| 'attributes': attributes, |
| 'has_conditional_attributes': any(attribute['exposed_test'] for attribute in attributes), |
| 'has_constructor_attributes': any(attribute['constructor_type'] for attribute in attributes), |
| 'has_replaceable_attributes': any(attribute['is_replaceable'] for attribute in attributes), |
| }) |
| |
| # Methods |
| methods = [v8_methods.method_context(interface, method) |
| for method in interface.operations |
| if method.name] # Skip anonymous special operations (methods) |
| compute_method_overloads_context(methods) |
| |
| # Stringifier |
| if interface.stringifier: |
| stringifier = interface.stringifier |
| method = IdlOperation(interface.idl_name) |
| method.name = 'toString' |
| method.idl_type = IdlType('DOMString') |
| method.extended_attributes.update(stringifier.extended_attributes) |
| if stringifier.attribute: |
| method.extended_attributes['ImplementedAs'] = stringifier.attribute.name |
| elif stringifier.operation: |
| method.extended_attributes['ImplementedAs'] = stringifier.operation.name |
| methods.append(v8_methods.method_context(interface, method)) |
| |
| conditionally_enabled_methods = [] |
| custom_registration_methods = [] |
| method_configuration_methods = [] |
| |
| for method in methods: |
| # Skip all but one method in each set of overloaded methods. |
| if 'overload_index' in method and 'overloads' not in method: |
| continue |
| |
| if 'overloads' in method: |
| overloads = method['overloads'] |
| conditionally_exposed_function = overloads['exposed_test_all'] |
| has_custom_registration = overloads['has_custom_registration_all'] |
| else: |
| conditionally_exposed_function = method['exposed_test'] |
| has_custom_registration = method['has_custom_registration'] |
| |
| if conditionally_exposed_function: |
| conditionally_enabled_methods.append(method) |
| continue |
| if has_custom_registration: |
| custom_registration_methods.append(method) |
| continue |
| method_configuration_methods.append(method) |
| |
| for method in methods: |
| # The value of the Function object’s “length” property is a Number |
| # determined as follows: |
| # 1. Let S be the effective overload set for regular operations (if the |
| # operation is a regular operation) or for static operations (if the |
| # operation is a static operation) with identifier id on interface I and |
| # with argument count 0. |
| # 2. Return the length of the shortest argument list of the entries in S. |
| # FIXME: This calculation doesn't take into account whether runtime |
| # enabled overloads are actually enabled, so length may be incorrect. |
| # E.g., [RuntimeEnabled=Foo] void f(); void f(long x); |
| # should have length 1 if Foo is not enabled, but length 0 if it is. |
| method['length'] = (method['overloads']['minarg'] if 'overloads' in method else |
| method['number_of_required_arguments']) |
| |
| context.update({ |
| 'conditionally_enabled_methods': conditionally_enabled_methods, |
| 'custom_registration_methods': custom_registration_methods, |
| 'method_configuration_methods': method_configuration_methods, |
| 'methods': methods, |
| }) |
| |
| context.update({ |
| 'indexed_property_getter': indexed_property_getter(interface), |
| 'indexed_property_setter': indexed_property_setter(interface), |
| 'indexed_property_deleter': indexed_property_deleter(interface), |
| 'is_override_builtins': 'OverrideBuiltins' in extended_attributes, |
| 'named_property_getter': named_property_getter(interface), |
| 'named_property_setter': named_property_setter(interface), |
| 'named_property_deleter': named_property_deleter(interface), |
| }) |
| |
| return context |
| |
| |
| # [DeprecateAs] |
| def constant_context(constant): |
| # (Blink-only) string literals are unquoted in tokenizer, must be re-quoted |
| # in C++. |
| if constant.idl_type.name == 'String': |
| value = '"%s"' % constant.value |
| else: |
| value = constant.value |
| |
| extended_attributes = constant.extended_attributes |
| return { |
| 'cpp_class': extended_attributes.get('PartialInterfaceImplementedAs'), |
| 'idl_type': constant.idl_type.name, |
| 'name': constant.name, |
| 'value': value, |
| } |
| |
| |
| ################################################################################ |
| # Overloads |
| ################################################################################ |
| |
| def compute_method_overloads_context(methods): |
| # Regular methods |
| compute_method_overloads_context_by_type([method for method in methods |
| if not method['is_static']]) |
| # Static methods |
| compute_method_overloads_context_by_type([method for method in methods |
| if method['is_static']]) |
| |
| |
| def compute_method_overloads_context_by_type(methods): |
| """Computes |method.overload*| template values. |
| |
| Called separately for static and non-static (regular) methods, |
| as these are overloaded separately. |
| Modifies |method| in place for |method| in |methods|. |
| Doesn't change the |methods| list itself (only the values, i.e. individual |
| methods), so ok to treat these separately. |
| """ |
| # Add overload information only to overloaded methods, so template code can |
| # easily verify if a function is overloaded |
| for name, overloads in method_overloads_by_name(methods): |
| # Resolution function is generated after last overloaded function; |
| # package necessary information into |method.overloads| for that method. |
| overloads[-1]['overloads'] = overloads_context(overloads) |
| overloads[-1]['overloads']['name'] = name |
| |
| |
| def method_overloads_by_name(methods): |
| """Returns generator of overloaded methods by name: [name, [method]]""" |
| # Filter to only methods that are actually overloaded |
| method_counts = Counter(method['name'] for method in methods) |
| overloaded_method_names = set(name |
| for name, count in method_counts.iteritems() |
| if count > 1) |
| overloaded_methods = [method for method in methods |
| if method['name'] in overloaded_method_names] |
| |
| # Group by name (generally will be defined together, but not necessarily) |
| return sort_and_groupby(overloaded_methods, itemgetter('name')) |
| |
| |
| def overloads_context(overloads): |
| """Returns |overloads| template values for a single name. |
| |
| Sets |method.overload_index| in place for |method| in |overloads| |
| and returns dict of overall overload template values. |
| """ |
| assert len(overloads) > 1 # only apply to overloaded names |
| for index, method in enumerate(overloads, 1): |
| method['overload_index'] = index |
| |
| effective_overloads_by_length = effective_overload_set_by_length(overloads) |
| lengths = [length for length, _ in effective_overloads_by_length] |
| name = overloads[0].get('name', '<constructor>') |
| |
| # Check and fail if all overloads with the shortest acceptable arguments |
| # list are runtime enabled, since we would otherwise set 'length' on the |
| # function object to an incorrect value when none of those overloads were |
| # actually enabled at runtime. The exception is if all overloads are |
| # controlled by the same runtime enabled feature, in which case there would |
| # be no function object at all if it is not enabled. |
| shortest_overloads = effective_overloads_by_length[0][1] |
| |
| # Check and fail if overloads disagree on any of the extended attributes |
| # that affect how the method should be registered. |
| # Skip the check for overloaded constructors, since they don't support any |
| # of the extended attributes in question. |
| if not overloads[0].get('is_constructor'): |
| overload_extended_attributes = [ |
| method['custom_registration_extended_attributes'] |
| for method in overloads] |
| for extended_attribute in v8_methods.CUSTOM_REGISTRATION_EXTENDED_ATTRIBUTES: |
| if common_key(overload_extended_attributes, extended_attribute) is None: |
| raise ValueError('Overloads of %s have conflicting extended attribute %s' |
| % (name, extended_attribute)) |
| |
| # Check and fail if overloads disagree about whether the return type |
| # is a Promise or not. |
| promise_overload_count = sum(1 for method in overloads if method.get('idl_type') == 'Promise') |
| if promise_overload_count not in (0, len(overloads)): |
| raise ValueError('Overloads of %s have conflicting Promise/non-Promise types' |
| % (name)) |
| |
| return { |
| 'exposed_test_all': common_value(overloads, 'exposed_test'), # [Exposed] |
| 'has_custom_registration_all': common_value(overloads, 'has_custom_registration'), |
| # 1. Let maxarg be the length of the longest type list of the |
| # entries in S. |
| 'maxarg': lengths[-1], |
| 'minarg': lengths[0], |
| 'valid_arities': lengths |
| # Only need to report valid arities if there is a gap in the |
| # sequence of possible lengths, otherwise invalid length means |
| # "not enough arguments". |
| if lengths[-1] - lengths[0] != len(lengths) - 1 else None, |
| } |
| |
| |
| def effective_overload_set(F): |
| """Returns the effective overload set of an overloaded function. |
| |
| An effective overload set is the set of overloaded functions + signatures |
| (type list of arguments, with optional and variadic arguments included or |
| not), and is used in the overload resolution algorithm. |
| |
| For example, given input [f1(optional long x), f2(DOMString s)], the output |
| is informally [f1(), f1(long), f2(DOMString)], and formally |
| [(f1, [], []), (f1, [long], [optional]), (f2, [DOMString], [required])]. |
| |
| Currently the optionality list is a list of |is_optional| booleans (True |
| means optional, False means required); to support variadics this needs to |
| be tri-valued as required, optional, or variadic. |
| |
| Formally: |
| An effective overload set represents the allowable invocations for a |
| particular operation, constructor (specified with [Constructor] or |
| [NamedConstructor]), legacy caller or callback function. |
| |
| An additional argument N (argument count) is needed when overloading |
| variadics, but we don't use that currently. |
| |
| Spec: http://heycam.github.io/webidl/#dfn-effective-overload-set |
| |
| Formally the input and output lists are sets, but methods are stored |
| internally as dicts, which can't be stored in a set because they are not |
| hashable, so we use lists instead. |
| |
| Arguments: |
| F: list of overloads for a given callable name. |
| |
| Returns: |
| S: list of tuples of the form (callable, type list, optionality list). |
| """ |
| # Code closely follows the algorithm in the spec, for clarity and |
| # correctness, and hence is not very Pythonic. |
| |
| # 1. Initialize S to ∅. |
| # (We use a list because we can't use a set, as noted above.) |
| S = [] |
| |
| # 2. Let F be a set with elements as follows, according to the kind of |
| # effective overload set: |
| # (Passed as argument, nothing to do.) |
| |
| # 3. & 4. (maxarg, m) are only needed for variadics, not used. |
| |
| # 5. For each operation, extended attribute or callback function X in F: |
| for X in F: # X is the "callable", F is the overloads. |
| arguments = X['arguments'] |
| # 1. Let n be the number of arguments X is declared to take. |
| n = len(arguments) |
| # 2. Let t0..n−1 be a list of types, where ti is the type of X’s |
| # argument at index i. |
| # (“type list”) |
| t = tuple(argument['idl_type_object'] for argument in arguments) |
| # 3. Let o0..n−1 be a list of optionality values, where oi is “variadic” |
| # if X’s argument at index i is a final, variadic argument, “optional” |
| # if the argument is optional, and “required” otherwise. |
| # (“optionality list”) |
| # (We’re just using a boolean for optional vs. required.) |
| o = tuple(argument['is_optional'] for argument in arguments) |
| # 4. Add to S the tuple <X, t0..n−1, o0..n−1>. |
| S.append((X, t, o)) |
| # 5. If X is declared to be variadic, then: |
| # (Not used, so not implemented.) |
| # 6. Initialize i to n−1. |
| i = n - 1 |
| # 7. While i ≥ 0: |
| # Spec bug (fencepost error); should be “While i > 0:” |
| # https://www.w3.org/Bugs/Public/show_bug.cgi?id=25590 |
| while i > 0: |
| # 1. If argument i of X is not optional, then break this loop. |
| if not o[i]: |
| break |
| # 2. Otherwise, add to S the tuple <X, t0..i−1, o0..i−1>. |
| S.append((X, t[:i], o[:i])) |
| # 3. Set i to i−1. |
| i = i - 1 |
| # 8. If n > 0 and all arguments of X are optional, then add to S the |
| # tuple <X, (), ()> (where “()” represents the empty list). |
| if n > 0 and all(oi for oi in o): |
| S.append((X, [], [])) |
| # 6. The effective overload set is S. |
| return S |
| |
| |
| def effective_overload_set_by_length(overloads): |
| def type_list_length(entry): |
| # Entries in the effective overload set are 3-tuples: |
| # (callable, type list, optionality list) |
| return len(entry[1]) |
| |
| effective_overloads = effective_overload_set(overloads) |
| return list(sort_and_groupby(effective_overloads, type_list_length)) |
| |
| |
| def distinguishing_argument_index(entries): |
| """Returns the distinguishing argument index for a sequence of entries. |
| |
| Entries are elements of the effective overload set with the same number |
| of arguments (formally, same type list length), each a 3-tuple of the form |
| (callable, type list, optionality list). |
| |
| Spec: http://heycam.github.io/webidl/#dfn-distinguishing-argument-index |
| |
| If there is more than one entry in an effective overload set that has a |
| given type list length, then for those entries there must be an index i |
| such that for each pair of entries the types at index i are |
| distinguishable. |
| The lowest such index is termed the distinguishing argument index for the |
| entries of the effective overload set with the given type list length. |
| """ |
| # Only applicable “If there is more than one entry” |
| assert len(entries) > 1 |
| type_lists = [tuple(idl_type.name for idl_type in entry[1]) |
| for entry in entries] |
| type_list_length = len(type_lists[0]) |
| # Only applicable for entries that “[have] a given type list length” |
| assert all(len(type_list) == type_list_length for type_list in type_lists) |
| name = entries[0][0].get('name', 'Constructor') # for error reporting |
| |
| # The spec defines the distinguishing argument index by conditions it must |
| # satisfy, but does not give an algorithm. |
| # |
| # We compute the distinguishing argument index by first computing the |
| # minimum index where not all types are the same, and then checking that |
| # all types in this position are distinguishable (and the optionality lists |
| # up to this point are identical), since "minimum index where not all types |
| # are the same" is a *necessary* condition, and more direct to check than |
| # distinguishability. |
| types_by_index = (set(types) for types in zip(*type_lists)) |
| try: |
| # “In addition, for each index j, where j is less than the |
| # distinguishing argument index for a given type list length, the types |
| # at index j in all of the entries’ type lists must be the same” |
| index = next(i for i, types in enumerate(types_by_index) |
| if len(types) > 1) |
| except StopIteration: |
| raise ValueError('No distinguishing index found for %s, length %s:\n' |
| 'All entries have the same type list:\n' |
| '%s' % (name, type_list_length, type_lists[0])) |
| # Check optionality |
| # “and the booleans in the corresponding list indicating argument |
| # optionality must be the same.” |
| # FIXME: spec typo: optionality value is no longer a boolean |
| # https://www.w3.org/Bugs/Public/show_bug.cgi?id=25628 |
| initial_optionality_lists = set(entry[2][:index] for entry in entries) |
| if len(initial_optionality_lists) > 1: |
| raise ValueError( |
| 'Invalid optionality lists for %s, length %s:\n' |
| 'Optionality lists differ below distinguishing argument index %s:\n' |
| '%s' |
| % (name, type_list_length, index, set(initial_optionality_lists))) |
| |
| # Check distinguishability |
| # http://heycam.github.io/webidl/#dfn-distinguishable |
| # Use names to check for distinct types, since objects are distinct |
| # FIXME: check distinguishability more precisely, for validation |
| distinguishing_argument_type_names = [type_list[index] |
| for type_list in type_lists] |
| if (len(set(distinguishing_argument_type_names)) != |
| len(distinguishing_argument_type_names)): |
| raise ValueError('Types in distinguishing argument are not distinct:\n' |
| '%s' % distinguishing_argument_type_names) |
| |
| return index |
| |
| |
| ################################################################################ |
| # Utility functions |
| ################################################################################ |
| |
| def Counter(iterable): |
| # Once using Python 2.7, using collections.Counter |
| counter = defaultdict(lambda: 0) |
| for item in iterable: |
| counter[item] += 1 |
| return counter |
| |
| |
| def common(dicts, f): |
| """Returns common result of f across an iterable of dicts, or None. |
| |
| Call f for each dict and return its result if the same across all dicts. |
| """ |
| values = (f(d) for d in dicts) |
| first_value = next(values) |
| if all(value == first_value for value in values): |
| return first_value |
| return None |
| |
| |
| def common_key(dicts, key): |
| """Returns common presence of a key across an iterable of dicts, or None. |
| |
| True if all dicts have the key, False if none of the dicts have the key, |
| and None if some but not all dicts have the key. |
| """ |
| return common(dicts, lambda d: key in d) |
| |
| |
| def common_value(dicts, key): |
| """Returns common value of a key across an iterable of dicts, or None. |
| |
| Auxiliary function for overloads, so can consolidate an extended attribute |
| that appears with the same value on all items in an overload set. |
| """ |
| return common(dicts, lambda d: d.get(key)) |
| |
| |
| def sort_and_groupby(l, key=None): |
| """Returns a generator of (key, list), sorting and grouping list by key.""" |
| l.sort(key=key) |
| return ((k, list(g)) for k, g in itertools.groupby(l, key)) |
| |
| |
| ################################################################################ |
| # Constructors |
| ################################################################################ |
| |
| # [Constructor] |
| def constructor_context(interface, constructor): |
| arguments_need_try_catch = any(v8_methods.argument_needs_try_catch(constructor, argument) |
| for argument in constructor.arguments) |
| |
| # [RaisesException=Constructor] |
| is_constructor_raises_exception = \ |
| interface.extended_attributes.get('RaisesException') == 'Constructor' |
| |
| return { |
| 'arguments': [v8_methods.argument_context(interface, constructor, argument, index) |
| for index, argument in enumerate(constructor.arguments)], |
| 'arguments_need_try_catch': arguments_need_try_catch, |
| 'cpp_type': cpp_template_type( |
| 'RefPtr', |
| cpp_name(interface)), |
| 'cpp_value': v8_methods.cpp_value( |
| interface, constructor, len(constructor.arguments)), |
| 'has_exception_state': |
| is_constructor_raises_exception or |
| any(argument for argument in constructor.arguments |
| if argument.idl_type.name == 'SerializedScriptValue' or |
| argument.idl_type.may_raise_exception_on_conversion), |
| 'is_call_with_document': |
| # [ConstructorCallWith=Document] |
| has_extended_attribute_value(interface, |
| 'ConstructorCallWith', 'Document'), |
| 'is_call_with_execution_context': |
| # [ConstructorCallWith=ExecutionContext] |
| has_extended_attribute_value(interface, |
| 'ConstructorCallWith', 'ExecutionContext'), |
| 'is_constructor': True, |
| 'is_named_constructor': False, |
| 'is_raises_exception': is_constructor_raises_exception, |
| 'number_of_required_arguments': |
| number_of_required_arguments(constructor), |
| } |
| |
| |
| # [NamedConstructor] |
| def named_constructor_context(interface): |
| extended_attributes = interface.extended_attributes |
| if 'NamedConstructor' not in extended_attributes: |
| return None |
| # FIXME: parser should return named constructor separately; |
| # included in constructors (and only name stored in extended attribute) |
| # for Perl compatibility |
| idl_constructor = interface.constructors[-1] |
| assert idl_constructor.name == 'NamedConstructor' |
| context = constructor_context(interface, idl_constructor) |
| context.update({ |
| 'name': extended_attributes['NamedConstructor'], |
| 'is_named_constructor': True, |
| }) |
| return context |
| |
| |
| def number_of_required_arguments(constructor): |
| return len([argument for argument in constructor.arguments |
| if not argument.is_optional]) |
| |
| |
| def interface_length(interface, constructors): |
| # Docs: http://heycam.github.io/webidl/#es-interface-call |
| if 'EventConstructor' in interface.extended_attributes: |
| return 1 |
| if not constructors: |
| return 0 |
| return min(constructor['number_of_required_arguments'] |
| for constructor in constructors) |
| |
| |
| ################################################################################ |
| # Special operations (methods) |
| # http://heycam.github.io/webidl/#idl-special-operations |
| ################################################################################ |
| |
| def property_getter(getter, cpp_arguments): |
| def is_null_expression(idl_type): |
| if idl_type.is_union_type: |
| notnull = ' || '.join([ |
| member_argument['null_check_value'] |
| for member_argument in idl_type.union_arguments]) |
| return '!(%s)' % notnull |
| if idl_type.name == 'String': |
| return 'result.isNull()' |
| if idl_type.is_interface_type: |
| return '!result' |
| return '' |
| |
| idl_type = getter.idl_type |
| extended_attributes = getter.extended_attributes |
| is_raises_exception = 'RaisesException' in extended_attributes |
| |
| # FIXME: make more generic, so can use v8_methods.cpp_value |
| cpp_method_name = 'impl->%s' % cpp_name(getter) |
| |
| if is_raises_exception: |
| cpp_arguments.append('exceptionState') |
| union_arguments = idl_type.union_arguments |
| if union_arguments: |
| cpp_arguments.extend([member_argument['cpp_value'] |
| for member_argument in union_arguments]) |
| |
| cpp_value = '%s(%s)' % (cpp_method_name, ', '.join(cpp_arguments)) |
| |
| return { |
| 'cpp_type': idl_type.cpp_type, |
| 'cpp_value': cpp_value, |
| 'is_custom': |
| 'Custom' in extended_attributes and |
| (not extended_attributes['Custom'] or |
| has_extended_attribute_value(getter, 'Custom', 'PropertyGetter')), |
| 'is_custom_property_enumerator': has_extended_attribute_value( |
| getter, 'Custom', 'PropertyEnumerator'), |
| 'is_custom_property_query': has_extended_attribute_value( |
| getter, 'Custom', 'PropertyQuery'), |
| 'is_enumerable': 'NotEnumerable' not in extended_attributes, |
| 'is_null_expression': is_null_expression(idl_type), |
| 'is_raises_exception': is_raises_exception, |
| 'name': cpp_name(getter), |
| 'union_arguments': union_arguments, |
| } |
| |
| |
| def property_setter(setter): |
| idl_type = setter.arguments[1].idl_type |
| extended_attributes = setter.extended_attributes |
| is_raises_exception = 'RaisesException' in extended_attributes |
| return { |
| 'has_type_checking_interface': |
| has_extended_attribute_value(setter, 'TypeChecking', 'Interface') and |
| idl_type.is_wrapper_type, |
| 'idl_type': idl_type.base_type, |
| 'is_custom': 'Custom' in extended_attributes, |
| 'has_exception_state': is_raises_exception or |
| idl_type.is_integer_type, |
| 'is_raises_exception': is_raises_exception, |
| 'name': cpp_name(setter), |
| } |
| |
| |
| def property_deleter(deleter): |
| idl_type = deleter.idl_type |
| if str(idl_type) != 'boolean': |
| raise Exception( |
| 'Only deleters with boolean type are allowed, but type is "%s"' % |
| idl_type) |
| extended_attributes = deleter.extended_attributes |
| return { |
| 'is_custom': 'Custom' in extended_attributes, |
| 'is_raises_exception': 'RaisesException' in extended_attributes, |
| 'name': cpp_name(deleter), |
| } |
| |
| |
| ################################################################################ |
| # Indexed properties |
| # http://heycam.github.io/webidl/#idl-indexed-properties |
| ################################################################################ |
| |
| def indexed_property_getter(interface): |
| try: |
| # Find indexed property getter, if present; has form: |
| # getter TYPE [OPTIONAL_IDENTIFIER](unsigned long ARG1) |
| getter = next( |
| method |
| for method in interface.operations |
| if ('getter' in method.specials and |
| len(method.arguments) == 1 and |
| str(method.arguments[0].idl_type) == 'unsigned long')) |
| except StopIteration: |
| return None |
| |
| return property_getter(getter, ['index']) |
| |
| |
| def indexed_property_setter(interface): |
| try: |
| # Find indexed property setter, if present; has form: |
| # setter RETURN_TYPE [OPTIONAL_IDENTIFIER](unsigned long ARG1, ARG_TYPE ARG2) |
| setter = next( |
| method |
| for method in interface.operations |
| if ('setter' in method.specials and |
| len(method.arguments) == 2 and |
| str(method.arguments[0].idl_type) == 'unsigned long')) |
| except StopIteration: |
| return None |
| |
| return property_setter(setter) |
| |
| |
| def indexed_property_deleter(interface): |
| try: |
| # Find indexed property deleter, if present; has form: |
| # deleter TYPE [OPTIONAL_IDENTIFIER](unsigned long ARG) |
| deleter = next( |
| method |
| for method in interface.operations |
| if ('deleter' in method.specials and |
| len(method.arguments) == 1 and |
| str(method.arguments[0].idl_type) == 'unsigned long')) |
| except StopIteration: |
| return None |
| |
| return property_deleter(deleter) |
| |
| |
| ################################################################################ |
| # Named properties |
| # http://heycam.github.io/webidl/#idl-named-properties |
| ################################################################################ |
| |
| def named_property_getter(interface): |
| try: |
| # Find named property getter, if present; has form: |
| # getter TYPE [OPTIONAL_IDENTIFIER](DOMString ARG1) |
| getter = next( |
| method |
| for method in interface.operations |
| if ('getter' in method.specials and |
| len(method.arguments) == 1 and |
| str(method.arguments[0].idl_type) == 'DOMString')) |
| except StopIteration: |
| return None |
| |
| getter.name = getter.name or 'anonymousNamedGetter' |
| return property_getter(getter, ['propertyName']) |
| |
| |
| def named_property_setter(interface): |
| try: |
| # Find named property setter, if present; has form: |
| # setter RETURN_TYPE [OPTIONAL_IDENTIFIER](DOMString ARG1, ARG_TYPE ARG2) |
| setter = next( |
| method |
| for method in interface.operations |
| if ('setter' in method.specials and |
| len(method.arguments) == 2 and |
| str(method.arguments[0].idl_type) == 'DOMString')) |
| except StopIteration: |
| return None |
| |
| return property_setter(setter) |
| |
| |
| def named_property_deleter(interface): |
| try: |
| # Find named property deleter, if present; has form: |
| # deleter TYPE [OPTIONAL_IDENTIFIER](DOMString ARG) |
| deleter = next( |
| method |
| for method in interface.operations |
| if ('deleter' in method.specials and |
| len(method.arguments) == 1 and |
| str(method.arguments[0].idl_type) == 'DOMString')) |
| except StopIteration: |
| return None |
| |
| return property_deleter(deleter) |
