Draft implementation of c++ bindings generation.

client/dom/scripts/dartgenerator.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 generates Dart APIs from the IDL database."""
 
 import emitter
 import idlnode
 import logging
@@ skipping 2059 matching lines @@
 
 class NativeImplementationSystem(System):
 
   def __init__(self, templates, database, emitters, auxiliary_dir, output_dir):
     super(NativeImplementationSystem, self).__init__(
         templates, database, emitters, output_dir)
 
     self._auxiliary_dir = auxiliary_dir
     self._dom_public_files = []
     self._dom_impl_files = []
+    self._cpp_header_files = []
+    self._cpp_impl_files = []
 
   def InterfaceGenerator(self,
                          interface,
                          common_prefix,
                          super_interface_name,
                          source_filter):
     interface_name = interface.id
 
     dart_interface_path = self._FilePathForDartInterface(interface_name)
     self._dom_public_files.append(dart_interface_path)
 
     dart_impl_path = self._FilePathForDartImplementation(interface_name)
     self._dom_impl_files.append(dart_impl_path)
 
+    cpp_header_path = os.path.join(self._output_dir, 'cpp',
+        'Dart%s.h' % interface_name)
+    self._cpp_header_files.append(cpp_header_path)
+
+    cpp_impl_path = os.path.join(self._output_dir, 'cpp',

[antonm, 2012/02/03 14:03:06]

nit: maybe introduce a helper a la
_FilePathForDartInterface/_FilePathForDartImplementation and for C++ files?

[podivilov, 2012/02/06 13:24:36]

Done.

+        'Dart%s.cpp' % interface_name)
+    self._cpp_impl_files.append(cpp_impl_path)
+
     return NativeImplementationGenerator(interface, super_interface_name,
         self._emitters.FileEmitter(dart_impl_path),
+        self._emitters.FileEmitter(cpp_header_path),
+        self._emitters.FileEmitter(cpp_impl_path),
         self._BaseDefines(interface),
         self._templates)
 
   def ProcessCallback(self, interface, info):
     self._dom_public_files.append(self._FilePathForDartInterface(interface.id))
 
   def GenerateLibraries(self, lib_dir):
     auxiliary_dir = os.path.relpath(self._auxiliary_dir, self._output_dir)
 
     # Generate dom_public.dart.
@@ skipping 15 matching lines @@
     dom_impl_imports_emitter = emitter.Emitter()
     for file in self._dom_impl_files:
         path = os.path.relpath(file, os.path.dirname(dom_impl_path))
         dom_impl_imports_emitter.Emit('#source("$PATH");\n', PATH=path)
 
     dom_impl_emitter = self._emitters.FileEmitter(dom_impl_path)
     dom_impl_emitter.Emit(self._templates.Load('dom_impl.darttemplate'),
         AUXILIARY_DIR=auxiliary_dir,
         SOURCES=dom_impl_imports_emitter.Fragments())
 
+    # Generate DartDerivedSourcesAll.cpp

[antonm, 2012/02/03 14:03:06]

nit: missing trailing dot.

[podivilov, 2012/02/06 13:24:36]

Done.

+    cpp_all_in_one_path = os.path.join(self._output_dir,
+        'DartDerivedSourcesAll.cpp')
+
+    includes_emitter = emitter.Emitter()
+    for file in self._cpp_impl_files:
+        path = os.path.relpath(file, os.path.dirname(cpp_all_in_one_path))

[antonm, 2012/02/03 14:03:06]

nit: two-space indent for control flow.

[podivilov, 2012/02/06 13:24:36]

Done.

+        includes_emitter.Emit('#include "$PATH"\n', PATH=path)

[antonm, 2012/02/03 14:03:06]

what about ENABLE_ features?  Do you have filters before?

[podivilov, 2012/02/06 13:24:36]

Disabled interfaces and operations are removed by fremontcutbuilder.py

+
+    cpp_all_in_one_emitter = self._emitters.FileEmitter(cpp_all_in_one_path)
+    cpp_all_in_one_emitter.Emit(
+        self._templates.Load('cpp_all_in_one.template'),

[sra1, 2012/02/03 21:30:49]

Instead of using Fragments to build and substitute a substring, use the 'holes'
feature to write directly to a substring.

The above ~10 lines would be done 'top-down' instead of 'bottom-up'

1. Change template to have a hole: $!INCLUDES

2. Work top-down:
cpp_all_in_one_emitter = ...

# Emit template and collect sub-emitters
includes_emitter = cpp_all_in_one_emitter.Emit(
  self._templates.Load('cpp_all_in_one.template'))

# Use sub-emitters
for filename in self._cpp_impl_files:
  path = ...
  includes_emitter.Emit('#include ...', PATH=...)

There is a comment in emitter.py that might add more detail about the mechanism.

[podivilov, 2012/02/06 13:24:36]

Not using template holes was a conscious decision actually. Consider generating
a list of c++ inclusions: you need to maintain a unique list of files while
generating operations, then emit it in lex order. When going top-down, you are
obliged to create a useless hole and emitter for it. Also, I think the code is
easier to understand and maintain when it uses only one type of template
parameters instead of two.

+        INCLUDES=includes_emitter.Fragments())

[antonm, 2012/02/03 14:03:06]

just curious, I don't know if the templating system supports it: in many other
template systems, I'd rather have a loop to generate includes in template itself
and pass only a list of files to include into a template.  Something like:

%for $include in $INCLUDES
#include "$include"
%endfor

[sra1, 2012/02/03 21:30:49]

Lets spend a few minutes talking about the templates in our next meeting.  It
currently does not support control flow.
I don't really want to add control flow, since that requires building a lot of
machinery.

+
+    # 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:

[antonm, 2012/02/03 14:03:06]

file is a synonym for open in Python and it's usually recommended not to use it.

[podivilov, 2012/02/06 13:24:36]

Done.

+        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'

[antonm, 2012/02/03 14:03:06]

multiline literal?

[podivilov, 2012/02/06 13:24:36]

Multiline literals break indentation rules and make the code hard to read. I
suggest that we stay with single line strings for code generation.

+            '        return func;\n',
+            CLASS_NAME=os.path.splitext(os.path.basename(path))[0])

[antonm, 2012/02/03 14:03:06]

hrr, do not we have it stored somewhere already?

+
+    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())

[sra1, 2012/02/03 21:30:49]

See above comment about using 'holes'.

Start resolver code with:

(includes_emitter, resolver_body_emitter) = cpp_resolver_emitter.Emit(
   self._templates.Load('cpp_resolver.template'))

Python gives you a error if the number of holes does not match the tuple length.

+
   def Finish(self):
     pass
 
   def _FilePathForDartInterface(self, interface_name):
     return os.path.join(self._output_dir, 'src', 'interface',
                         '%s.dart' % interface_name)
 
   def _FilePathForDartImplementation(self, interface_name):
     return os.path.join(self._output_dir, 'dart',
                         '%sImplementation.dart' % interface_name)
 
 
 class NativeImplementationGenerator(WrappingInterfaceGenerator):
   """Generates Dart implementation for one DOM IDL interface."""
 
-  def __init__(self, interface, super_interface, dart_impl_emitter,
+  def __init__(self, interface, super_interface,
+               dart_impl_emitter, cpp_header_emitter, cpp_impl_emitter,
                base_members, templates):
-    """Generates Dart code for the given interface.
+    """Generates Dart and c++ 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.
       super_interface: A string or None, the name of the common interface that
          this interface implements, if any.
       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.
     """
     self._interface = interface
     self._super_interface = super_interface
     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
 
   def StartInterface(self):
     self._class_name = self._ImplClassName(self._interface.id)
     self._members_emitter = emitter.Emitter()
 
-  def _ImplClassName(self, type_name):
-    return type_name + 'Implementation'
+  def _ImplClassName(self, interface_name):
+    return interface_name + 'Implementation'
 
   def FinishInterface(self):
-    interface = self._interface
-    interface_name = interface.id
-
-    base = self._BaseClassName(interface)
+    base = self._BaseClassName(self._interface)
     self._dart_impl_emitter.Emit(
         self._templates.Load('dart_implementation.darttemplate'),
-        CLASS=self._class_name, BASE=base, INTERFACE=interface_name,
+        CLASS=self._class_name, BASE=base, INTERFACE=self._interface.id,
         MEMBERS=self._members_emitter.Fragments())
 
+    self._cpp_header_emitter.Emit(
+        self._templates.Load('cpp_header.template'),
+        INTERFACE=self._interface.id)
+
+    self._cpp_impl_emitter.Emit(
+        self._templates.Load('cpp_implementation.template'),
+        INTERFACE=self._interface.id)
+
   def AddGetter(self, attr):
     self._members_emitter.Emit(
         '\n'
         '  $TYPE get $NAME() native "$(INTERFACE)_$(NAME)_Getter";\n',
         NAME=attr.id, TYPE=attr.type.id, INTERFACE=self._interface.id)
 
   def AddSetter(self, attr):
     self._members_emitter.Emit(
         '\n'
         '  void set $NAME($TYPE) native "$(INTERFACE)_$(NAME)_Setter";\n',
@@ skipping 81 matching lines @@
                    INDENT=indent,
                    NATIVENAME=native_name,
                    ARGS=argument_expressions)
 
     self._members_emitter.Emit('  $TYPE $NATIVE_NAME($PARAMS) native '
                                '"$(INTERFACE)$(NATIVE_NAME)_Callback";\n',
                                NATIVE_NAME=native_name,
                                TYPE=info.type_name,
                                PARAMS=', '.join(arg_names),
                                INTERFACE=self._interface.id)