Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(162)

Unified Diff: Source/bindings/scripts/idl_definitions_builder.py

Issue 15801003: IDL parser rewrite in Python (Closed) Base URL: svn://svn.chromium.org/blink/trunk
Patch Set: Final (rebased). Created 7 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
Index: Source/bindings/scripts/idl_definitions_builder.py
diff --git a/Source/bindings/scripts/idl_definitions_builder.py b/Source/bindings/scripts/idl_definitions_builder.py
new file mode 100644
index 0000000000000000000000000000000000000000..4c5620b767b9e72cf71733ad99692a5dbe1db60a
--- /dev/null
+++ b/Source/bindings/scripts/idl_definitions_builder.py
@@ -0,0 +1,519 @@
+# Copyright (C) 2013 Google Inc. All rights reserved.
+#
+# 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.
+
+"""Builds an IdlDefinitions object from an AST (produced by blink_idl_parser)."""
+
+from idl_definitions import IdlDefinitions, IdlInterface, IdlException, IdlOperation, IdlCallbackFunction, IdlArgument, IdlAttribute, IdlConstant, IdlEnum, IdlTypedef, IdlUnionType
+
+SPECIAL_KEYWORD_LIST = ['GETTER', 'SETTER', 'DELETER']
+
+
+def build_idl_definitions_from_ast(node):
+ if node is None:
+ return None
+ node_class = node.GetClass()
+ if node_class != 'File':
+ raise ValueError('Unrecognized node class: %s' % node_class)
+ return file_node_to_idl_definitions(node)
+
+
+def file_node_to_idl_definitions(node):
+ callback_functions = {}
+ enumerations = {}
+ exceptions = {}
+ file_name = node.GetName() # FIXME: only needed for Perl, remove later
+ interfaces = {}
+ typedefs = {}
+
+ children = node.GetChildren()
+ for child in children:
+ child_class = child.GetClass()
+ if child_class == 'Interface':
+ interface = interface_node_to_idl_interface(child)
+ interfaces[interface.name] = interface
+ elif child_class == 'Exception':
+ exception = exception_node_to_idl_exception(child)
+ exceptions[exception.name] = exception
+ elif child_class == 'Typedef':
+ type_name = child.GetName()
+ typedefs[type_name] = typedef_node_to_idl_typedef(child)
+ elif child_class == 'Enum':
+ enumeration = enum_node_to_idl_enum(child)
+ enumerations[enumeration.name] = enumeration
+ elif child_class == 'Callback':
+ callback_function = callback_node_to_idl_callback_function(child)
+ callback_functions[callback_function.name] = callback_function
+ elif child_class == 'Implements':
+ # Implements is handled at the interface merging step
+ pass
+ else:
+ raise ValueError('Unrecognized node class: %s' % child_class)
+
+ return IdlDefinitions(callback_functions=callback_functions, enumerations=enumerations, exceptions=exceptions, file_name=file_name, interfaces=interfaces, typedefs=typedefs)
+
+# Constructors for Interface definitions and interface members
+
+
+def interface_node_to_idl_interface(node):
+ attributes = []
+ constants = []
+ constructors = None
+ custom_constructors = None
+ extended_attributes = None
+ operations = []
+ is_callback = node.GetProperty('CALLBACK') or False
+ # FIXME: uppercase 'Partial' in base IDL parser
+ is_partial = node.GetProperty('Partial') or False
+ name = node.GetName()
+ parent = None
+
+ children = node.GetChildren()
+ for child in children:
+ child_class = child.GetClass()
+ if child_class == 'Attribute':
+ attribute = attribute_node_to_idl_attribute(child)
+ # FIXME: This is a hack to support [CustomConstructor] for
+ # window.HTMLImageElement. Remove the hack.
+ clear_constructor_attributes(attribute.extended_attributes)
+ attributes.append(attribute)
+ elif child_class == 'Const':
+ constants.append(constant_node_to_idl_constant(child))
+ elif child_class == 'ExtAttributes':
+ extended_attributes = ext_attributes_node_to_extended_attributes(child)
+ constructors, custom_constructors = extended_attributes_to_constructors(extended_attributes)
+ clear_constructor_attributes(extended_attributes)
+ elif child_class == 'Operation':
+ operations.append(operation_node_to_idl_operation(child))
+ elif child_class == 'Inherit':
+ parent = child.GetName()
+ else:
+ raise ValueError('Unrecognized node class: %s' % child_class)
+
+ return IdlInterface(name=name, attributes=attributes, constants=constants, constructors=constructors, custom_constructors=custom_constructors, extended_attributes=extended_attributes, operations=operations, is_callback=is_callback, is_partial=is_partial, parent=parent)
+
+
+def attribute_node_to_idl_attribute(node):
+ data_type = None
+ extended_attributes = {}
+ is_nullable = False
+ is_read_only = node.GetProperty('READONLY') or False
+ is_static = node.GetProperty('STATIC') or False
+ name = node.GetName()
+
+ children = node.GetChildren()
+ for child in children:
+ child_class = child.GetClass()
+ if child_class == 'Type':
+ data_type = type_node_to_type(child)
+ is_nullable = child.GetProperty('NULLABLE') or False
+ elif child_class == 'ExtAttributes':
+ extended_attributes = ext_attributes_node_to_extended_attributes(child)
+ else:
+ raise ValueError('Unrecognized node class: %s' % child_class)
+
+ return IdlAttribute(data_type=data_type, extended_attributes=extended_attributes, is_nullable=is_nullable, is_read_only=is_read_only, is_static=is_static, name=name)
+
+
+def constant_node_to_idl_constant(node):
+ name = node.GetName()
+
+ children = node.GetChildren()
+ num_children = len(children)
+ if num_children < 2 or num_children > 3:
+ raise ValueError('Expected 2 or 3 children, got %s' % num_children)
+
+ type_node = children[0]
+ # ConstType is more limited than Type, so subtree is smaller and we don't
+ # use the full type_node_to_type function.
+ data_type = type_node_inner_to_type(type_node)
+
+ value_node = children[1]
+ value_node_class = value_node.GetClass()
+ if value_node_class != 'Value':
+ raise ValueError('Expected Value node, got %s' % value_node_class)
+ value = value_node.GetName()
+
+ extended_attributes = None
+ if num_children == 3:
+ ext_attributes_node = children[2]
+ extended_attributes = ext_attributes_node_to_extended_attributes(ext_attributes_node)
+
+ return IdlConstant(data_type=data_type, extended_attributes=extended_attributes, name=name, value=value)
+
+
+def operation_node_to_idl_operation(node):
+ name = node.GetName()
+ # FIXME: AST should use None internally
+ if name == '_unnamed_':
+ name = None
+
+ is_static = node.GetProperty('STATIC') or False
+ specials = []
+ property_dictionary = node.GetProperties()
+ for special_keyword in SPECIAL_KEYWORD_LIST:
+ if special_keyword in property_dictionary:
+ specials.append(special_keyword.lower())
+
+ extended_attributes = None
+ arguments = []
+ return_type = None
+ children = node.GetChildren()
+ for child in children:
+ child_class = child.GetClass()
+ if child_class == 'Arguments':
+ arguments = arguments_node_to_arguments(child)
+ elif child_class == 'Type':
+ return_type = type_node_to_type(child)
+ elif child_class == 'ExtAttributes':
+ extended_attributes = ext_attributes_node_to_extended_attributes(child)
+ else:
+ raise ValueError('Unrecognized node class: %s' % child_class)
+
+ return IdlOperation(name=name, data_type=return_type, extended_attributes=extended_attributes, is_static=is_static, arguments=arguments, specials=specials)
+
+
+def arguments_node_to_arguments(node):
+ # [Constructor] and [CustomConstructor] without arguments (the bare form)
+ # have None instead of an arguments node, but have the same meaning as using
+ # an empty argument list, [Constructor()], so special-case this.
+ # http://www.w3.org/TR/WebIDL/#Constructor
+ if node is None:
+ return []
+ arguments = []
+ argument_node_list = node.GetChildren()
+ for argument_node in argument_node_list:
+ arguments.append(argument_node_to_idl_argument(argument_node))
+ return arguments
+
+
+def argument_node_to_idl_argument(node):
+ name = node.GetName()
+
+ data_type = None
+ extended_attributes = {}
+ # FIXME: Boolean values are inconsistent due to Perl compatibility.
+ # Make all default to False once Perl removed.
+ is_nullable = False
+ is_optional = node.GetProperty('OPTIONAL')
+ is_variadic = None
+ children = node.GetChildren()
+ for child in children:
+ child_class = child.GetClass()
+ if child_class == 'Type':
+ data_type = type_node_to_type(child)
+ is_nullable = child.GetProperty('NULLABLE')
+ elif child_class == 'ExtAttributes':
+ extended_attributes = ext_attributes_node_to_extended_attributes(child)
+ elif child_class == 'Argument':
+ child_name = child.GetName()
+ if child_name != '...':
+ raise ValueError('Unrecognized Argument node; expected "...", got "%s"' % child_name)
+ is_variadic = child.GetProperty('ELLIPSIS') or False
+ else:
+ raise ValueError('Unrecognized node class: %s' % child_class)
+
+ return IdlArgument(name=name, data_type=data_type, extended_attributes=extended_attributes, is_nullable=is_nullable, is_optional=is_optional, is_variadic=is_variadic)
+
+# Constructors for for non-interface definitions
+
+
+def callback_node_to_idl_callback_function(node):
+ name = node.GetName()
+ children = node.GetChildren()
+ num_children = len(children)
+ if num_children != 2:
+ raise ValueError('Expected 2 children, got %s' % num_children)
+
+ type_node = children[0]
+ data_type = type_node_to_type(type_node)
+
+ arguments_node = children[1]
+ arguments_node_class = arguments_node.GetClass()
+ if arguments_node_class != 'Arguments':
+ raise ValueError('Expected Value node, got %s' % arguments_node_class)
+ arguments = arguments_node_to_arguments(arguments_node)
+
+ return IdlCallbackFunction(name=name, data_type=data_type, arguments=arguments)
+
+
+def enum_node_to_idl_enum(node):
+ name = node.GetName()
+ values = []
+ for child in node.GetChildren():
+ values.append(child.GetName())
+ return IdlEnum(name=name, values=values)
+
+
+def exception_operation_node_to_idl_operation(node):
+ # Needed to handle one case in DOMException.idl:
+ # // Override in a Mozilla compatible format
+ # [NotEnumerable] DOMString toString();
+ # FIXME: can we remove this? replace with a stringifier?
+ extended_attributes = {}
+ name = node.GetName()
+ children = node.GetChildren()
+ if len(children) < 1 or len(children) > 2:
+ raise ValueError('ExceptionOperation node with %s children, expected 1 or 2' % len(children))
+
+ type_node = children[0]
+ return_type = type_node_to_type(type_node)
+
+ if len(children) > 1:
+ ext_attributes_node = children[1]
+ extended_attributes = ext_attributes_node_to_extended_attributes(ext_attributes_node)
+
+ return IdlOperation(name=name, data_type=return_type, extended_attributes=extended_attributes)
+
+
+def exception_node_to_idl_exception(node):
+ # Exceptions are similar to Interfaces, but simpler
+ attributes = []
+ constants = []
+ extended_attributes = None
+ operations = []
+ name = node.GetName()
+
+ children = node.GetChildren()
+ for child in children:
+ child_class = child.GetClass()
+ if child_class == 'Attribute':
+ attribute = attribute_node_to_idl_attribute(child)
+ attributes.append(attribute)
+ elif child_class == 'Const':
+ constants.append(constant_node_to_idl_constant(child))
+ elif child_class == 'ExtAttributes':
+ extended_attributes = ext_attributes_node_to_extended_attributes(child)
+ elif child_class == 'ExceptionOperation':
+ operations.append(exception_operation_node_to_idl_operation(child))
+ else:
+ raise ValueError('Unrecognized node class: %s' % child_class)
+
+ return IdlException(name=name, attributes=attributes, constants=constants, extended_attributes=extended_attributes, operations=operations)
+
+
+def typedef_node_to_idl_typedef(node):
+ data_type = None
+ extended_attributes = None
+
+ children = node.GetChildren()
+ for child in children:
+ child_class = child.GetClass()
+ if child_class == 'Type':
+ data_type = type_node_to_type(child)
+ elif child_class == 'ExtAttributes':
+ extended_attributes = ext_attributes_node_to_extended_attributes(child)
+ raise ValueError('Extended attributes in a typedef are untested!')
+ else:
+ raise ValueError('Unrecognized node class: %s' % child_class)
+
+ return IdlTypedef(data_type=data_type, extended_attributes=extended_attributes)
+
+# Extended attributes
+
+
+def ext_attributes_node_to_extended_attributes(node):
+ """
+ Returns:
+ Dictionary of {ExtAttributeName: ExtAttributeValue}.
+ Value is usually a string, with three exceptions:
+ Constructors: value is a list of Arguments nodes, corresponding to
+ possibly signatures of the constructor.
+ CustomConstructors: value is a list of Arguments nodes, corresponding to
+ possibly signatures of the custom constructor.
+ NamedConstructor: value is a Call node, corresponding to the single
+ signature of the named constructor.
+ """
+ # Primarily just make a dictionary from the children.
+ # The only complexity is handling various types of constructors:
+ # Constructors and Custom Constructors can have duplicate entries due to
+ # overloading, and thus are stored in temporary lists.
+ # However, Named Constructors cannot be overloaded, and thus do not have
+ # a list.
+ # FIXME: Add overloading for Named Constructors and remove custom bindings
+ # for HTMLImageElement
+ constructors = []
+ custom_constructors = []
+ extended_attributes = {}
+
+ attribute_list = node.GetChildren()
+ for attribute in attribute_list:
+ name = attribute.GetName()
+ children = attribute.GetChildren()
+ if name in ['Constructor', 'CustomConstructor', 'NamedConstructor']:
+ child = None
+ child_class = None
+ if children:
+ if len(children) > 1:
+ raise ValueError('ExtAttributes node with %s children, expected at most 1' % len(children))
+ child = children[0]
+ child_class = child.GetClass()
+ if name == 'Constructor':
+ if child_class and child_class != 'Arguments':
+ raise ValueError('Constructor only supports Arguments as child, but has child of class: %s' % child_class)
+ constructors.append(child)
+ elif name == 'CustomConstructor':
+ if child_class and child_class != 'Arguments':
+ raise ValueError('Custom Constructor only supports Arguments as child, but has child of class: %s' % child_class)
+ custom_constructors.append(child)
+ else: # name == 'NamedConstructor'
+ if child_class and child_class != 'Call':
+ raise ValueError('Named Constructor only supports Call as child, but has child of class: %s' % child_class)
+ extended_attributes[name] = child
+ elif children:
+ raise ValueError('Non-constructor ExtAttributes node with children: %s' % name)
+ else:
+ value = attribute.GetProperty('VALUE')
+ extended_attributes[name] = value
+
+ # Store constructors and custom constructors in special list attributes,
+ # which are deleted later. Note plural in key.
+ if constructors:
+ extended_attributes['Constructors'] = constructors
+ if custom_constructors:
+ extended_attributes['CustomConstructors'] = custom_constructors
+
+ return extended_attributes
+
+
+def extended_attributes_to_constructors(extended_attributes):
+ """Returns constructors and custom_constructors (lists of IdlOperations).
+
+ Auxiliary function for interface_node_to_idl_interface.
+ """
+ constructors = []
+ custom_constructors = []
+ if 'Constructors' in extended_attributes:
+ constructor_list = extended_attributes['Constructors']
+ # If not overloaded, have index 0, otherwise index from 1
+ overloaded_index = 0 if len(constructor_list) == 1 else 1
+ for arguments_node in constructor_list:
+ name = 'Constructor'
+ arguments = arguments_node_to_arguments(arguments_node)
+ constructor = IdlOperation(name=name, extended_attributes=extended_attributes, overloaded_index=overloaded_index, arguments=arguments)
+ constructors.append(constructor)
+ overloaded_index += 1
+
+ # Prefix 'CallWith' and 'RaisesException' with 'Constructor'
+ # FIXME: Change extended attributes to include prefix explicitly.
+ if 'CallWith' in extended_attributes:
+ extended_attributes['ConstructorCallWith'] = extended_attributes['CallWith']
+ del extended_attributes['CallWith']
+ if 'RaisesException' in extended_attributes:
+ extended_attributes['ConstructorRaisesException'] = extended_attributes['RaisesException']
+ del extended_attributes['RaisesException']
+
+ if 'CustomConstructors' in extended_attributes:
+ custom_constructor_list = extended_attributes['CustomConstructors']
+ # If not overloaded, have index 0, otherwise index from 1
+ overloaded_index = 0 if len(custom_constructor_list) == 1 else 1
+ for arguments_node in custom_constructor_list:
+ name = 'CustomConstructor'
+ arguments = arguments_node_to_arguments(arguments_node)
+ custom_constructor = IdlOperation(name=name, extended_attributes=extended_attributes, overloaded_index=overloaded_index, arguments=arguments)
+ custom_constructors.append(custom_constructor)
+ overloaded_index += 1
+
+ if 'NamedConstructor' in extended_attributes:
+ name = 'NamedConstructor'
+ call_node = extended_attributes['NamedConstructor']
+ extended_attributes['NamedConstructor'] = call_node.GetName()
+ overloaded_index = None # named constructors are not overloaded
+ children = call_node.GetChildren()
+ if len(children) != 1:
+ raise ValueError('NamedConstructor node expects 1 child, got %s.' % len(children))
+ arguments_node = children[0]
+ arguments = arguments_node_to_arguments(arguments_node)
+ named_constructor = IdlOperation(name=name, extended_attributes=extended_attributes, overloaded_index=overloaded_index, arguments=arguments)
+ constructors.append(named_constructor)
+
+ return constructors, custom_constructors
+
+
+def clear_constructor_attributes(extended_attributes):
+ # Deletes Constructor*s* (plural), sets Constructor (singular)
+ if 'Constructors' in extended_attributes:
+ del extended_attributes['Constructors']
+ extended_attributes['Constructor'] = None
+ if 'CustomConstructors' in extended_attributes:
+ del extended_attributes['CustomConstructors']
+ extended_attributes['CustomConstructor'] = None
+
+
+# Types
+
+
+def type_node_to_type(node):
+ children = node.GetChildren()
+ if len(children) < 1 or len(children) > 2:
+ raise ValueError('Type node expects 1 or 2 children (type + optional array []), got %s (multi-dimensional arrays are not supported).' % len(children))
+
+ type_node_child = children[0]
+ data_type = type_node_inner_to_type(type_node_child)
+
+ if len(children) == 2:
+ array_node = children[1]
+ array_node_class = array_node.GetClass()
+ if array_node_class != 'Array':
+ raise ValueError('Expected Array node as TypeSuffix, got %s node.' % array_node_class)
+ data_type += '[]'
+
+ return data_type
+
+
+def type_node_inner_to_type(node):
+ node_class = node.GetClass()
+ # FIXME: Typedef is misspelled as Type*r*ef in base parser.
+ if node_class in ['PrimitiveType', 'Typeref']:
+ return node.GetName()
+ elif node_class == 'Any':
+ return 'any'
+ elif node_class == 'Sequence':
+ return sequence_node_to_type(node)
+ elif node_class == 'UnionType':
+ return union_type_node_to_idl_union_type(node)
+ raise ValueError('Unrecognized node class: %s' % node_class)
+
+
+def sequence_node_to_type(node):
+ children = node.GetChildren()
+ if len(children) != 1:
+ raise ValueError('Sequence node expects exactly 1 child, got %s' % len(children))
+ sequence_child = children[0]
+ sequence_child_class = sequence_child.GetClass()
+ if sequence_child_class != 'Type':
+ raise ValueError('Unrecognized node class: %s' % sequence_child_class)
+ sequence_type = type_node_to_type(sequence_child)
+ return 'sequence<%s>' % sequence_type
+
+
+def union_type_node_to_idl_union_type(node):
+ union_member_types = []
+ for member_type_node in node.GetChildren():
+ member_type = type_node_to_type(member_type_node)
+ union_member_types.append(member_type)
+ return IdlUnionType(union_member_types=union_member_types)

Powered by Google App Engine
This is Rietveld 408576698