Refactor file paths handling in generator.

lib/html/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 *
 
 
 class NativeImplementationSystem(systembase.System):
 
-  def __init__(self, options):
+  def __init__(self, options, cpp_library_emitter):
     super(NativeImplementationSystem, self).__init__(options)
-    self._cpp_header_files = []
-    self._cpp_impl_files = []
+    self._cpp_library_emitter = cpp_library_emitter
 
   def ImplementationGenerator(self, interface):
     return NativeImplementationGenerator(self, interface)
 
   def ProcessCallback(self, interface, info):
     self._interface = interface
 
     if IsPureInterface(self._interface.id):
       return None
 
@@ skipping 33 matching lines @@
           '    DartIsolate::Scope scope(m_callback.isolate());\n'
           '    DartApiScope apiScope;\n'
           '    $ARGUMENTS_DECLARATION;\n'
           '    return m_callback.handleEvent($ARGUMENT_COUNT, arguments);\n'
           '}\n',
           CLASS_NAME=class_name,
           PARAMETERS=', '.join(parameters),
           ARGUMENTS_DECLARATION=arguments_declaration,
           ARGUMENT_COUNT=len(arguments))
 
-    cpp_header_path = self._FilePathForCppHeader(self._interface.id)
-    cpp_header_emitter = self._emitters.FileEmitter(cpp_header_path)
+    cpp_header_emitter = self._cpp_library_emitter.CreateHeaderEmitter(self._interface.id, True)
     cpp_header_emitter.Emit(
         self._templates.Load('cpp_callback_header.template'),
         INTERFACE=self._interface.id,
         HANDLERS=cpp_header_handlers_emitter.Fragments())
 
-    cpp_impl_path = self._FilePathForCppImplementation(self._interface.id)
-    self._cpp_impl_files.append(cpp_impl_path)
-    cpp_impl_emitter = self._emitters.FileEmitter(cpp_impl_path)
+    cpp_impl_emitter = self._cpp_library_emitter.CreateSourceEmitter(self._interface.id)
     cpp_impl_emitter.Emit(
         self._templates.Load('cpp_callback_implementation.template'),
         INCLUDES=_GenerateCPPIncludes(cpp_impl_includes),
         INTERFACE=self._interface.id,
         HANDLERS=cpp_impl_handlers_emitter.Fragments())
 
-  def GenerateLibraries(self, interface_files):
-    # Generate dart:html library.
-    auxiliary_dir = os.path.relpath(self._auxiliary_dir, self._output_dir)
-    self._GenerateLibFile(
-        'html_dartium.darttemplate',
-        os.path.join(self._output_dir, 'html_dartium.dart'),
-        interface_files,
-        AUXILIARY_DIR=systembase.MassagePath(auxiliary_dir))
-
-    # Generate DartDerivedSourcesXX.cpp.
-    partitions = 20 # FIXME: this should be configurable.
-    sources_count = len(self._cpp_impl_files)
-    for i in range(0, partitions):
-      derived_sources_path = os.path.join(self._output_dir,
-          'DartDerivedSources%02i.cpp' % (i + 1))
-
-      includes_emitter = emitter.Emitter()
-      for impl_file in self._cpp_impl_files[i::partitions]:
-          path = os.path.relpath(impl_file, os.path.dirname(derived_sources_path))
-          includes_emitter.Emit('#include "$PATH"\n', PATH=path)
-
-      derived_sources_emitter = self._emitters.FileEmitter(derived_sources_path)
-      derived_sources_emitter.Emit(
-          self._templates.Load('cpp_derived_sources.template'),
-          INCLUDES=includes_emitter.Fragments())
-
-    # Generate DartResolver.cpp.
-    cpp_resolver_path = os.path.join(self._output_dir, 'DartResolver.cpp')
-
-    includes_emitter = emitter.Emitter()
-    resolver_body_emitter = emitter.Emitter()
-    for file in self._cpp_header_files:
-        path = os.path.relpath(file, os.path.dirname(cpp_resolver_path))
-        includes_emitter.Emit('#include "$PATH"\n', PATH=path)
-        resolver_body_emitter.Emit(
-            '    if (Dart_NativeFunction func = $CLASS_NAME::resolver(name, argumentCount))\n'
-            '        return func;\n',
-            CLASS_NAME=os.path.splitext(os.path.basename(path))[0])
-
-    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 _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)
-
 
 class NativeImplementationGenerator(systembase.BaseGenerator):
   """Generates Dart implementation for one DOM IDL interface."""
 
   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
@@ skipping 17 matching lines @@
 
   def ImplementsMergedMembers(self):
     # We could not add merged functions to implementation class because
     # underlying c++ object doesn't implement them. Merged functions are
     # generated on merged interface implementation instead.
     return False
 
   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)
+      self._cpp_header_emitter = self._system._cpp_library_emitter.CreateHeaderEmitter(self._interface.id)
+      self._cpp_impl_emitter = self._system._cpp_library_emitter.CreateSourceEmitter(self._interface.id)
     else:
       self._cpp_header_emitter = emitter.Emitter()
       self._cpp_impl_emitter = emitter.Emitter()
 
     self._interface_type_info = self._TypeInfo(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()
@@ skipping 115 matching lines @@
 
     class_name = self._ImplClassName(self._interface.id)
     members_emitter = self._dart_impl_emitter.Emit(
         template,
         CLASSNAME=class_name,
         EXTENDS=' extends ' + self._BaseClassName(),
         IMPLEMENTS=' implements ' + self._html_interface_name,
         NATIVESPEC='')
     members_emitter.Emit(''.join(self._members_emitter.Fragments()))
 
-    self._GenerateCppHeader()
+    self._GenerateCPPHeader()
 
     self._cpp_impl_emitter.Emit(
         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):
+  def _GenerateCPPHeader(self):
     to_native_emitter = emitter.Emitter()
     if self._interface_type_info.custom_to_native():
       to_native_emitter.Emit(
           '    static PassRefPtr<NativeType> toNative(Dart_Handle handle, Dart_Handle& exception);\n')
     else:
       to_native_emitter.Emit(
           '    static NativeType* toNative(Dart_Handle handle, Dart_Handle& exception)\n'
           '    {\n'
           '        return DartDOMWrapper::unwrapDartWrapper<Dart$INTERFACE>(handle, exception);\n'
           '    }\n',
@@ skipping 574 matching lines @@
       return False
     if operation.id in ['addEventListener', 'removeEventListener'] and argument.id == 'useCapture':
       return False
     # Another option would be to adjust in IDLs, but let's keep it here for now
     # as it's a single instance.
     if self._interface.id == 'CSSStyleDeclaration' and operation.id == 'setProperty' and argument.id == 'priority':
       return False
     return True
 
 
+class CPPLibraryEmitter():
+  def __init__(self, emitters, cpp_sources_dir):
+    self._emitters = emitters
+    self._cpp_sources_dir = cpp_sources_dir
+    self._headers_list = []
+    self._sources_list = []
+
+  def CreateHeaderEmitter(self, interface_name, is_callback=False):
+    path = os.path.join(self._cpp_sources_dir, 'Dart%s.h' % interface_name)
+    if not is_callback:
+      self._headers_list.append(path)
+    return self._emitters.FileEmitter(path)
+
+  def CreateSourceEmitter(self, interface_name):
+    path = os.path.join(self._cpp_sources_dir, 'Dart%s.cpp' % interface_name)
+    self._sources_list.append(path)
+    return self._emitters.FileEmitter(path)
+
+  def EmitDerivedSources(self, template, output_dir):
+    partitions = 20 # FIXME: this should be configurable.
+    sources_count = len(self._sources_list)
+    for i in range(0, partitions):
+      file_path = os.path.join(output_dir, 'DartDerivedSources%02i.cpp' % (i + 1))
+      includes_emitter = self._emitters.FileEmitter(file_path).Emit(template)
+      for source_file in self._sources_list[i::partitions]:
+        path = os.path.relpath(source_file, output_dir)
+        includes_emitter.Emit('#include "$PATH"\n', PATH=path)
+
+  def EmitResolver(self, template, output_dir):
+    file_path = os.path.join(output_dir, 'DartResolver.cpp')
+    includes_emitter, body_emitter = self._emitters.FileEmitter(file_path).Emit(template)
+    for header_file in self._headers_list:
+      path = os.path.relpath(header_file, output_dir)
+      includes_emitter.Emit('#include "$PATH"\n', PATH=path)
+      body_emitter.Emit(
+          '    if (Dart_NativeFunction func = $CLASS_NAME::resolver(name, argumentCount))\n'
+          '        return func;\n',
+          CLASS_NAME=os.path.splitext(os.path.basename(path))[0])
+
+
 def _GenerateCPPIncludes(includes):
   return ''.join(['#include %s\n' % include for include in sorted(includes)])
 
 def _FindInHierarchy(database, interface, test):
   if test(interface):
     return interface
   for parent in interface.parents:
     parent_name = parent.type.id
     if not database.HasInterface(parent.type.id):
       continue
     parent_interface = database.GetInterface(parent.type.id)
     parent_interface = _FindInHierarchy(database, parent_interface, test)
     if parent_interface:
       return parent_interface
 
 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)