Create implementation file emitter in HtmlDartInterfaceGenerator.

lib/dom/scripts/systemnative.py

 #!/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 provides shared functionality for the systems to generate
 native binding from the IDL database."""
 
 import emitter
 import os
 import systembase
 from generator import *
 from systemhtml import DomToHtmlEvent, DomToHtmlEvents, HtmlSystemShared
 from systemhtml import HtmlElementConstructorInfos
 from systemhtml import EmitHtmlElementFactoryConstructors
 
 class NativeImplementationSystem(systembase.System):
 
   def __init__(self, templates, database, emitters, output_dir, auxiliary_dir):
     super(NativeImplementationSystem, self).__init__(
         templates, database, emitters, output_dir)
     self._auxiliary_dir = auxiliary_dir
     self._dom_impl_files = []
     self._cpp_header_files = []
     self._cpp_impl_files = []
     self._html_system = HtmlSystemShared(database)
     self._factory_provider_emitters = {}
 
-  def ProcessInterface(self, interface):
-    interface_name = interface.id
-
-    if IsPureInterface(interface_name):
-      return None
-
-    dart_impl_path = self._FilePathForDartImplementation(interface_name)
-    self._dom_impl_files.append(dart_impl_path)
-
-    cpp_header_path = self._FilePathForCppHeader(interface_name)
-    self._cpp_header_files.append(cpp_header_path)
-
-    cpp_impl_path = self._FilePathForCppImplementation(interface_name)
-    self._cpp_impl_files.append(cpp_impl_path)
-
-    NativeImplementationGenerator(self, interface,
-        self._emitters.FileEmitter(dart_impl_path),
-        self._emitters.FileEmitter(cpp_header_path),
-        self._emitters.FileEmitter(cpp_impl_path),
-        self._BaseDefines(interface),
-        self._templates).Generate()
+  def ImplementationGenerator(self, interface):
+    return NativeImplementationGenerator(self, interface)
 
   def ProcessCallback(self, interface, info):
     self._interface = interface
 
     if IsPureInterface(self._interface.id):
       return None
 
     cpp_impl_includes = set()
     cpp_header_handlers_emitter = emitter.Emitter()
     cpp_impl_handlers_emitter = emitter.Emitter()
@@ skipping 100 matching lines @@
 
     cpp_resolver_emitter = self._emitters.FileEmitter(cpp_resolver_path)
     cpp_resolver_emitter.Emit(
         self._templates.Load('cpp_resolver.template'),
         INCLUDES=includes_emitter.Fragments(),
         RESOLVER_BODY=resolver_body_emitter.Fragments())
 
   def Finish(self):
     pass
 
-  def _FilePathForDartImplementation(self, interface_name):
-    return os.path.join(self._output_dir, 'dart',
-                        '%sImplementation.dart' % interface_name)
-
   def _FilePathForDartFactoryProviderImplementation(self, interface_name):
     return os.path.join(self._output_dir, 'dart',
                         '%sFactoryProviderImplementation.dart' % interface_name)
 
   def _FilePathForCppHeader(self, interface_name):
     return os.path.join(self._output_dir, 'cpp', 'Dart%s.h' % interface_name)
 
   def _FilePathForCppImplementation(self, interface_name):
     return os.path.join(self._output_dir, 'cpp', 'Dart%s.cpp' % interface_name)
 
   def _EmitterForFactoryProviderBody(self, name):
     if name not in self._factory_provider_emitters:
       file_name = self._FilePathForDartFactoryProviderImplementation(name)
       self._dom_impl_files.append(file_name)
       template = self._templates.Load('factoryprovider_%s.darttemplate' % name)
       file_emitter = self._emitters.FileEmitter(file_name)
       self._factory_provider_emitters[name] = file_emitter.Emit(template)
     return self._factory_provider_emitters[name]
 
 
 class NativeImplementationGenerator(systembase.BaseGenerator):
   """Generates Dart implementation for one DOM IDL interface."""
 
-  def __init__(self, system, interface,
-               dart_impl_emitter, cpp_header_emitter, cpp_impl_emitter,
-               base_members, templates):
+  def __init__(self, system, interface):
     """Generates Dart and C++ code for the given interface.
 
     Args:
       system: The NativeImplementationSystem.
       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.
-      dart_impl_emitter: an Emitter for the file containing the Dart
-         implementation class.
-      cpp_header_emitter: an Emitter for the file containing the C++ header.
-      cpp_impl_emitter: an Emitter for the file containing the C++
-         implementation.
-      base_members: a set of names of members defined in a base class.  This is
-          used to avoid static member 'overriding' in the generated Dart code.
     """
     super(NativeImplementationGenerator, self).__init__(
         system._database, interface)
     self._system = system
-    self._dart_impl_emitter = dart_impl_emitter
-    self._cpp_header_emitter = cpp_header_emitter
-    self._cpp_impl_emitter = cpp_impl_emitter
-    self._base_members = base_members
-    self._templates = templates
     self._current_secondary_parent = None
     self._html_system = self._system._html_system
     self._html_renames = self._html_system._html_renames
 
+  def HasImplementation(self):
+    return not IsPureInterface(self._interface.id)
+
+  def FilePathForDartImplementation(self):
+    return os.path.join(self._system._output_dir, 'dart',
+                        '%sImplementation.dart' % self._interface.id)
+
+  def SetImplementationEmitter(self, implementation_emitter):
+    self._dart_impl_emitter = implementation_emitter
+
   def StartInterface(self):
+    # Create emitters for c++ implementation.
+    if self.HasImplementation():
+      cpp_header_path = self._system._FilePathForCppHeader(self._interface.id)
+      self._system._cpp_header_files.append(cpp_header_path)
+      self._cpp_header_emitter = self._system._emitters.FileEmitter(cpp_header_path)
+      cpp_impl_path = self._system._FilePathForCppImplementation(self._interface.id)
+      self._system._cpp_impl_files.append(cpp_impl_path)
+      self._cpp_impl_emitter = self._system._emitters.FileEmitter(cpp_impl_path)
+    else:
+      self._cpp_header_emitter = emitter.Emitter()
+      self._cpp_impl_emitter = emitter.Emitter()
+
     self._interface_type_info = GetIDLTypeInfo(self._interface.id)
     self._members_emitter = emitter.Emitter()
     self._cpp_declarations_emitter = emitter.Emitter()
     self._cpp_impl_includes = set()
     self._cpp_definitions_emitter = emitter.Emitter()
     self._cpp_resolver_emitter = emitter.Emitter()
 
     self._GenerateConstructors()
     self._GenerateEvents()
 
@@ skipping 232 matching lines @@
         INTERFACE=html_interface_name,
         PARAMETERS=constructor_info.ParametersImplementationDeclaration(self._DartType),
         ARGUMENTS=constructor_info.ParametersAsArgumentList(),
         NATIVE_NAME=native_implementation_function)
 
   def FinishInterface(self):
     html_interface_name = self._HTMLInterfaceName(self._interface.id)
     template = None
     if html_interface_name == self._interface.id or not self._database.HasInterface(html_interface_name):
       template_file = 'impl_%s.darttemplate' % html_interface_name
-      template = self._templates.TryLoad(template_file)
+      template = self._system._templates.TryLoad(template_file)
     if not template:
-      template = self._templates.Load('dart_implementation.darttemplate')
+      template = self._system._templates.Load('dart_implementation.darttemplate')
 
     class_name = self._ImplClassName(self._interface.id)
     members_emitter = self._dart_impl_emitter.Emit(
         template,
         CLASSNAME=class_name,
         EXTENDS=' extends ' + self._BaseClassName(),
         IMPLEMENTS=' implements ' + html_interface_name,
         NATIVESPEC='')
     members_emitter.Emit(''.join(self._members_emitter.Fragments()))
 
     self._GenerateCppHeader()
 
     self._cpp_impl_emitter.Emit(
-        self._templates.Load('cpp_implementation.template'),
+        self._system._templates.Load('cpp_implementation.template'),
         INTERFACE=self._interface.id,
         INCLUDES=_GenerateCPPIncludes(self._cpp_impl_includes),
         CALLBACKS=self._cpp_definitions_emitter.Fragments(),
         RESOLVER=self._cpp_resolver_emitter.Fragments(),
         DART_IMPLEMENTATION_CLASS=class_name)
 
   def _GenerateCppHeader(self):
     to_native_emitter = emitter.Emitter()
     if self._interface_type_info.custom_to_native():
       to_native_emitter.Emit(
@@ skipping 18 matching lines @@
       to_dart_emitter.Emit(
           '    static Dart_Handle toDart(NativeType* value)\n'
           '    {\n'
           '        return DartDOMWrapper::toDart<Dart$(INTERFACE)>(value);\n'
           '    }\n',
           INTERFACE=self._interface.id)
 
     webcore_includes = _GenerateCPPIncludes(self._interface_type_info.webcore_includes())
     wrapper_type = _DOMWrapperType(self._database, self._interface)
     self._cpp_header_emitter.Emit(
-        self._templates.Load('cpp_header.template'),
+        self._system._templates.Load('cpp_header.template'),
         INTERFACE=self._interface.id,
         WEBCORE_INCLUDES=webcore_includes,
         WEBCORE_CLASS_NAME=self._interface_type_info.native_type(),
         DECLARATIONS=self._cpp_declarations_emitter.Fragments(),
         NATIVE_TRAITS_TYPE='DartDOMWrapper::%sTraits' % wrapper_type,
         TO_NATIVE=to_native_emitter.Fragments(),
         TO_DART=to_dart_emitter.Fragments())
 
   def _GenerateCallWithHandling(self, node, parameter_definitions_emitter, arguments):
     if 'CallWith' not in node.ext_attrs:
@@ skipping 546 matching lines @@
 
 def _IsArgumentOptionalInWebCore(argument):
   return IsOptional(argument) and not 'Callback' in argument.ext_attrs
 
 def _ToWebKitName(name):
   name = name[0].lower() + name[1:]
   name = re.sub(r'^(hTML|uRL|jS|xML|xSLT)', lambda s: s.group(1).lower(),
                 name)
   return re.sub(r'^(create|exclusive)', lambda s: 'is' + s.group(1).capitalize(),
                 name)