| #!/usr/bin/python | |
| # Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file | |
| # for details. All rights reserved. Use of this source code is governed by a | |
| # BSD-style license that can be found in the LICENSE file. | |
| """This module providesfunctionality for systems to generate | |
| Elemental interfaces from the IDL database.""" | |
| import pdb | |
| import os | |
| import json | |
| import systembaseelemental | |
| from generator_java import * | |
| class ElementalInterfacesSystem(systembaseelemental.SystemElemental): | |
| def __init__(self, templates, database, emitters, output_dir): | |
| super(ElementalInterfacesSystem, self).__init__( | |
| templates, database, emitters, output_dir) | |
| self._dart_interface_file_paths = [] | |
| def InterfaceGenerator(self, | |
| interface, | |
| common_prefix, | |
| super_interface_name, | |
| source_filter): | |
| """.""" | |
| module = getModule(interface.annotations) | |
| if super_interface_name is not None: | |
| interface_name = super_interface_name | |
| else: | |
| interface_name = interface.id | |
| dart_interface_file_path = self._FilePathForElementalInterface(module, interface_name) | |
| self._dart_interface_file_paths.append(dart_interface_file_path) | |
| dart_interface_code = self._emitters.FileEmitter(dart_interface_file_path) | |
| template_file = 'java_interface_%s.darttemplate' % interface_name | |
| template = self._templates.TryLoad(template_file) | |
| if not template: | |
| template = self._templates.Load('java_interface.darttemplate') | |
| return ElementalInterfaceGenerator(module, self._database, | |
| interface, dart_interface_code, | |
| template, | |
| common_prefix, super_interface_name, | |
| source_filter) | |
| def ProcessCallback(self, interface, info): | |
| """Generates a typedef for the callback interface.""" | |
| interface_name = interface.id | |
| module = getModule(interface.annotations) | |
| file_path = self._FilePathForElementalInterface(module, interface_name) | |
| self._dart_callback_file_paths.append(file_path) | |
| code = self._emitters.FileEmitter(file_path) | |
| code.Emit(self._templates.Load('javacallback.darttemplate'), | |
| ID=interface.id, | |
| NAME=interface.id, | |
| TYPE=info.type_name, | |
| PARAMS=info.ParametersImplementationDeclaration(), | |
| PACKAGE='elemental.%s' % module, | |
| IMPORTS='', | |
| CLASSJAVADOC='') | |
| def GenerateLibraries(self, lib_dir): | |
| pass | |
| def _FilePathForElementalInterface(self, module, interface_name): | |
| """Returns the file path of the Dart interface definition.""" | |
| return os.path.join(self._output_dir, 'src', 'elemental', module, | |
| '%s.java' % interface_name) | |
| def _escapeComments(text): | |
| return text.replace('*/', '*/').encode('utf-8') | |
| # ------------------------------------------------------------------------------ | |
| class ElementalInterfaceGenerator(systembaseelemental.ElementalBase): | |
| """Generates Elemental Interface definition for one DOM IDL interface.""" | |
| def _GetJavaDoc(self, interface): | |
| docid = interface.id | |
| if docid not in self._docdatabase: | |
| docid = 'HTML%s' % interface.id | |
| if docid in self._docdatabase: | |
| if 'summary' in self._docdatabase[docid]: | |
| return _escapeComments(self._docdatabase[docid]['summary']) | |
| return "" | |
| def __init__(self, module, database, interface, emitter, template, | |
| common_prefix, super_interface, source_filter): | |
| """Generates Dart code for the given interface. | |
| Args: | |
| interface -- an IDLInterface instance. It is assumed that all types have | |
| been converted to Dart types (e.g. int, String), unless they are in the | |
| same package as the interface. | |
| common_prefix -- the prefix for the common library, if any. | |
| super_interface -- the name of the common interface that this interface | |
| implements, if any. | |
| source_filter -- if specified, rewrites the names of any superinterfaces | |
| that are not from these sources to use the common prefix. | |
| """ | |
| self._module = module | |
| self._database = database | |
| self._interface = interface | |
| self._emitter = emitter | |
| self._template = template | |
| self._common_prefix = common_prefix | |
| self._super_interface = super_interface | |
| self._source_filter = source_filter | |
| current_dir = os.path.dirname(__file__) | |
| self._docdatabase = json.load(open(os.path.join(current_dir, '..', 'docs/database.json'))) | |
| def addImport(self, imports, typeid): | |
| # skip primitive types that are all lowercase first letter | |
| etype = DartType(typeid) | |
| if '<' not in typeid and etype[0].isupper(): | |
| rawtype = etype.split('<')[0] | |
| if rawtype in ['Indexable', 'Settable', 'Mappable']: | |
| pmodule = 'util' | |
| imports['import elemental.%s.%s;\n' % (pmodule, rawtype)]=1 | |
| elif etype not in java_lang and self._database.HasInterface(typeid): | |
| pinterface = self._database.GetInterface(typeid) | |
| pmodule = getModule(pinterface.annotations) | |
| if pmodule != self._module: | |
| imports['import elemental.%s.%s;\n' % (pmodule, rawtype)]=1 | |
| def StartInterface(self): | |
| if self._super_interface: | |
| typename = self._super_interface | |
| else: | |
| typename = self._interface.id | |
| extends = [] | |
| suppressed_extends = [] | |
| imports = {} | |
| implements_raw = {} | |
| for attr in self._interface.attributes: | |
| self.addImport(imports, attr.type.id) | |
| for oper in self._interface.operations: | |
| self.addImport(imports, oper.type.id) | |
| for arg in oper.arguments: | |
| self.addImport(imports, arg.type.id) | |
| alreadyImplemented = {} | |
| if len(self._interface.parents) > 0: | |
| self.getImplements(alreadyImplemented, self._interface.parents[0]) | |
| for parent in self._interface.parents: | |
| if not parent.type.id in alreadyImplemented or parent.type.id == 'ElementalMixinBase': | |
| self.addImport(imports, parent.type.id) | |
| # TODO(vsm): Remove source_filter. | |
| rawtype = DartType(parent.type.id).split('<')[0] | |
| if MatchSourceFilter(self._source_filter, parent) and DartType(parent.type.id) != 'Object' and rawtype not in implements_raw: | |
| # Parent is a DOM type. | |
| extends.append(DartType(parent.type.id)) | |
| implements_raw[rawtype]=1 | |
| #TODO(cromwellian) add in Indexable/IndexableInt/IndexableNumber | |
| # elif '<' in parent.type.id: | |
| # Parent is a Dart collection type. | |
| # TODO(vsm): Make this check more robust. | |
| # extends.append(parent.type.id) | |
| # else: | |
| # suppressed_extends.append('%s.%s' % | |
| # (self._common_prefix, parent.type.id)) | |
| if self._interface.parents: | |
| rawtype = DartType(self._interface.parents[0].type.id).split('<')[0] | |
| if rawtype not in implements_raw: | |
| extends.insert(0, DartType(self._interface.parents[0].type.id)) | |
| self.addImport(imports, self._interface.parents[0].type.id) | |
| comment = ' extends' | |
| extends_str = '' | |
| if extends: | |
| extends_str += ' extends ' + ', '.join(extends) | |
| comment = ',' | |
| if suppressed_extends: | |
| extends_str += ' /*%s %s */' % (comment, ', '.join(suppressed_extends)) | |
| factory_provider = None | |
| constructor_info = AnalyzeConstructor(self._interface) | |
| # TODO(vsm): Add appropriate package / namespace syntax. | |
| (self._members_emitter, | |
| self._top_level_emitter) = self._emitter.Emit( | |
| self._template + '$!TOP_LEVEL', | |
| ID=typename, | |
| EXTENDS=extends_str, PACKAGE='elemental.' + self._module, | |
| CLASSJAVADOC = self._GetJavaDoc(self._interface), | |
| IMPORTS = ''.join(imports.keys())) | |
| # TODO(cromwellian) auto-generate factory classes? | |
| # if constructor_info: | |
| # self._members_emitter.Emit( | |
| # '\n' | |
| # ' $CTOR($PARAMS);\n', | |
| # CTOR=typename, | |
| # PARAMS=constructor_info.ParametersInterfaceDeclaration()); | |
| # element_type = MaybeTypedArrayElementType(self._interface) | |
| # if element_type: | |
| # self._members_emitter.Emit( | |
| # '\n' | |
| # ' $CTOR(int length);\n' | |
| # '\n' | |
| # ' $CTOR.fromList(List<$TYPE> list);\n' | |
| # '\n' | |
| # ' $CTOR.fromBuffer(ArrayBuffer buffer,' | |
| # ' [int byteOffset, int length]);\n', | |
| # CTOR=self._interface.id, | |
| # TYPE=DartType(element_type)) | |
| def FinishInterface(self): | |
| # TODO(vsm): Use typedef if / when that is supported in Dart. | |
| # Define variant as subtype. | |
| if (self._super_interface and | |
| self._interface.id is not self._super_interface): | |
| consts_emitter = self._top_level_emitter.Emit( | |
| '\n' | |
| 'interface $NAME extends $BASE {\n' | |
| '$!CONSTS' | |
| '}\n', | |
| NAME=self._interface.id, | |
| BASE=self._super_interface) | |
| for const in sorted(self._interface.constants, ConstantOutputOrder): | |
| self._EmitConstant(consts_emitter, const) | |
| if self._interface.id == 'Document': | |
| for iface in self._database.GetInterfaces(): | |
| if iface.id.endswith("Element"): | |
| if iface.id == 'Element' or iface.id == 'SVGElement': | |
| continue | |
| callName = DartType(iface.id) | |
| if iface.id == 'SVGSVGElement': | |
| callName = 'SVGElement' | |
| self._members_emitter.Emit('\n $TYPE create$CALL();\n', | |
| CALL = callName, | |
| TYPE=DartType(iface.id)) | |
| if self._interface.id == 'Window': | |
| for iface in self._database.GetInterfaces(): | |
| element_type = MaybeTypedArrayElementType(iface) | |
| if element_type: | |
| self._members_emitter.Emit( | |
| '\n' | |
| ' $TYPE new$CTOR(int length);\n' | |
| '\n' | |
| ' $TYPE new$CTOR(IndexableNumber list);\n' | |
| '\n' | |
| ' $TYPE new$CTOR(ArrayBuffer buffer,' | |
| ' int byteOffset, int length);\n', | |
| CTOR=iface.id, | |
| TYPE=iface.id) | |
| constructor_info = AnalyzeConstructor(iface) | |
| if constructor_info: | |
| self._members_emitter.Emit( | |
| '\n' | |
| ' $TYPE new$CTOR($PARAMS);\n', | |
| TYPE=iface.id, | |
| CTOR=iface.id, | |
| PARAMS=constructor_info.ParametersInterfaceDeclaration()); | |
| def AddConstant(self, constant): | |
| if (not self._super_interface or | |
| self._interface.id is self._super_interface): | |
| self._EmitConstant(self._members_emitter, constant) | |
| def _EmitConstant(self, emitter, constant): | |
| javadoc = self.find_doc(constant.id) | |
| javadoctemplate = '\n /**\n * $JAVADOC\n */\n'; | |
| if javadoc == '': | |
| javadoctemplate = '' | |
| emitter.Emit('%s\n static final $TYPE$NAME = $VALUE;\n' % javadoctemplate, | |
| NAME=constant.id, | |
| TYPE=TypeOrNothing(DartType(constant.type.id), | |
| None), | |
| VALUE=constant.value, | |
| JAVADOC = javadoc) | |
| def AddAttribute(self, getter, setter, inheritedGetter, inheritedSetter): | |
| javadoc = self.find_doc(getter.id) | |
| javadoctemplate = '\n /**\n * $JAVADOC\n */\n'; | |
| if javadoc == '': | |
| javadoctemplate = '' | |
| if getter: | |
| self._members_emitter.Emit('\n%s $TYPE $NAME();\n' % javadoctemplate, | |
| NAME=getterName(getter), | |
| TYPE=TypeOrVar(DartType(getter.type.id), | |
| getter.type.id), | |
| JAVADOC=javadoc) | |
| if setter: | |
| self._members_emitter.Emit('\n void $NAME($TYPE arg);\n', | |
| NAME=setterName(setter), | |
| TYPE=TypeOrVar(DartType(setter.type.id), | |
| setter.type.id), | |
| ARG=setter.type.id) | |
| return | |
| def AddIndexer(self, element_type): | |
| # Interface inherits all operations from List<element_type>. | |
| pass | |
| def AddOperation(self, info, inherited): | |
| """ | |
| Arguments: | |
| operations - contains the overloads, one or more operations with the same | |
| name. | |
| """ | |
| javadoc = self.find_doc(info.name) | |
| javadoctemplate = '\n /**\n * $JAVADOC\n */\n'; | |
| if javadoc == '': | |
| javadoctemplate = '' | |
| get_attrs = [] | |
| set_attrs = [] | |
| for attr in self._interface.attributes: | |
| get_attrs.append(getterName(attr)) | |
| set_attrs.append(setterName(attr)) | |
| if info.name in get_attrs or info.name in set_attrs: | |
| return | |
| return_type = info.type_name | |
| if info.name == 'addEventListener': | |
| return_type = 'EventRemover' | |
| self._members_emitter.Emit('\n%s $TYPE $NAME($PARAMS);\n' % javadoctemplate, | |
| TYPE=return_type, | |
| NAME=self.fixReservedKeyWords(info.name), | |
| PARAMS=info.ParametersInterfaceDeclaration(), | |
| JAVADOC=javadoc) | |
| def AddStaticOperation(self, info, inherited): | |
| pass | |
| # Interfaces get secondary members directly via the superinterfaces. | |
| def AddSecondaryAttribute(self, interface, getter, setter): | |
| pass | |
| def AddSecondaryOperation(self, interface, attr): | |
| pass | |
| def find_doc(self, name): | |
| docid = self._interface.id | |
| if docid not in self._docdatabase: | |
| docid = 'HTML%s' % self._interface.id | |
| docmembers = [] | |
| docmember = {} | |
| if docid in self._docdatabase and 'members' in self._docdatabase[docid]: | |
| docmembers = self._docdatabase[docid]['members'] | |
| for member in docmembers: | |
| if member['name'] == name: | |
| docmember = member | |
| if 'help' in docmember: | |
| return _escapeComments(docmember['help']) | |
| return "" | |
| def ucfirst(string): | |
| """Upper cases the 1st character in a string""" | |
| if len(string): | |
| return '%s%s' % (string[0].upper(), string[1:]) | |
| return string | |
| def getterName(attr): | |
| name = DartDomNameOfAttribute(attr) | |
| if attr.type.id == 'boolean': | |
| if name.startswith('is'): | |
| name = name[2:] | |
| return 'is%s' % ucfirst(name) | |
| return 'get%s' % ucfirst(name) | |
| def setterName(attr): | |
| name = DartDomNameOfAttribute(attr) | |
| return 'set%s' % ucfirst(name) | |
| def getModule(annotations): | |
| htmlaliases = ['audio', 'webaudio', 'inspector', 'offline', 'p2p', 'window', 'websockets', 'threads', 'view', 'storage', 'fileapi'] | |
| module = "dom" | |
| if 'WebKit' in annotations and 'module' in annotations['WebKit']: | |
| module = annotations['WebKit']['module'] | |
| if module in htmlaliases: | |
| return "html" | |
| if module == 'core': | |
| return 'dom' | |
| return module | |
| java_lang = ['Object', 'String', 'Exception', 'DOMTimeStamp', 'DOMString'] | |