| # Copyright 2014 The Chromium Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """Translates parse tree to Mojom IR.""" |
| |
| |
| import ast |
| import re |
| |
| |
| def _MapTreeForType(func, tree, type_to_map): |
| assert isinstance(type_to_map, type) |
| if not tree: |
| return [] |
| return [func(subtree) for subtree in tree if isinstance(subtree, type_to_map)] |
| |
| _FIXED_ARRAY_REGEXP = re.compile(r'\[[0-9]+\]') |
| |
| def _MapKind(kind): |
| map_to_kind = {'bool': 'b', |
| 'int8': 'i8', |
| 'int16': 'i16', |
| 'int32': 'i32', |
| 'int64': 'i64', |
| 'uint8': 'u8', |
| 'uint16': 'u16', |
| 'uint32': 'u32', |
| 'uint64': 'u64', |
| 'float': 'f', |
| 'double': 'd', |
| 'string': 's', |
| 'handle': 'h', |
| 'handle<data_pipe_consumer>': 'h:d:c', |
| 'handle<data_pipe_producer>': 'h:d:p', |
| 'handle<message_pipe>': 'h:m', |
| 'handle<shared_buffer>': 'h:s'} |
| if kind.endswith('[]'): |
| typename = kind[0:-2] |
| if _FIXED_ARRAY_REGEXP.search(typename): |
| raise Exception("Arrays of fixed sized arrays not supported") |
| return 'a:' + _MapKind(typename) |
| if kind.endswith(']'): |
| lbracket = kind.rfind('[') |
| typename = kind[0:lbracket] |
| if typename.find('[') != -1: |
| raise Exception("Fixed sized arrays of arrays not supported") |
| return 'a' + kind[lbracket+1:-1] + ':' + _MapKind(typename) |
| if kind.endswith('&'): |
| return 'r:' + _MapKind(kind[0:-1]) |
| if kind in map_to_kind: |
| return map_to_kind[kind] |
| return 'x:' + kind |
| |
| def _AttributeListToDict(attribute_list): |
| if attribute_list is None: |
| return {} |
| assert isinstance(attribute_list, ast.AttributeList) |
| # TODO(vtl): Check for duplicate keys here. |
| return dict([(attribute.key, attribute.value) |
| for attribute in attribute_list]) |
| |
| def _EnumToDict(enum): |
| def EnumValueToDict(enum_value): |
| assert isinstance(enum_value, ast.EnumValue) |
| return {'name': enum_value.name, |
| 'value': enum_value.value} |
| |
| assert isinstance(enum, ast.Enum) |
| return {'name': enum.name, |
| 'fields': map(EnumValueToDict, enum.enum_value_list)} |
| |
| def _ConstToDict(const): |
| assert isinstance(const, ast.Const) |
| return {'name': const.name, |
| 'kind': _MapKind(const.typename), |
| 'value': const.value} |
| |
| |
| class _MojomBuilder(object): |
| def __init__(self): |
| self.mojom = {} |
| |
| def Build(self, tree, name): |
| def StructToDict(struct): |
| def StructFieldToDict(struct_field): |
| assert isinstance(struct_field, ast.StructField) |
| return {'name': struct_field.name, |
| 'kind': _MapKind(struct_field.typename), |
| 'ordinal': struct_field.ordinal.value \ |
| if struct_field.ordinal else None, |
| 'default': struct_field.default_value} |
| |
| assert isinstance(struct, ast.Struct) |
| return {'name': struct.name, |
| 'attributes': _AttributeListToDict(struct.attribute_list), |
| 'fields': _MapTreeForType(StructFieldToDict, struct.body, |
| ast.StructField), |
| 'enums': _MapTreeForType(_EnumToDict, struct.body, ast.Enum), |
| 'constants': _MapTreeForType(_ConstToDict, struct.body, |
| ast.Const)} |
| |
| def InterfaceToDict(interface): |
| def MethodToDict(method): |
| def ParameterToDict(param): |
| assert isinstance(param, ast.Parameter) |
| return {'name': param.name, |
| 'kind': _MapKind(param.typename), |
| 'ordinal': param.ordinal.value if param.ordinal else None} |
| |
| assert isinstance(method, ast.Method) |
| rv = {'name': method.name, |
| 'parameters': map(ParameterToDict, method.parameter_list), |
| 'ordinal': method.ordinal.value if method.ordinal else None} |
| if method.response_parameter_list is not None: |
| rv['response_parameters'] = map(ParameterToDict, |
| method.response_parameter_list) |
| return rv |
| |
| assert isinstance(interface, ast.Interface) |
| attributes = _AttributeListToDict(interface.attribute_list) |
| return {'name': interface.name, |
| 'attributes': attributes, |
| 'client': attributes.get('Client'), |
| 'methods': _MapTreeForType(MethodToDict, interface.body, |
| ast.Method), |
| 'enums': _MapTreeForType(_EnumToDict, interface.body, ast.Enum), |
| 'constants': _MapTreeForType(_ConstToDict, interface.body, |
| ast.Const)} |
| |
| assert isinstance(tree, ast.Mojom) |
| self.mojom['name'] = name |
| self.mojom['namespace'] = tree.module.name[1] if tree.module else '' |
| self.mojom['imports'] = \ |
| [{'filename': imp.import_filename} for imp in tree.import_list] |
| self.mojom['attributes'] = \ |
| _AttributeListToDict(tree.module.attribute_list) if tree.module else {} |
| self.mojom['structs'] = \ |
| _MapTreeForType(StructToDict, tree.definition_list, ast.Struct) |
| self.mojom['interfaces'] = \ |
| _MapTreeForType(InterfaceToDict, tree.definition_list, ast.Interface) |
| self.mojom['enums'] = \ |
| _MapTreeForType(_EnumToDict, tree.definition_list, ast.Enum) |
| self.mojom['constants'] = \ |
| _MapTreeForType(_ConstToDict, tree.definition_list, ast.Const) |
| return self.mojom |
| |
| |
| def Translate(tree, name): |
| return _MojomBuilder().Build(tree, name) |