Generate binding code for VoidCallback.idl with code generator in python

Source/bindings/scripts/code_generator_v8.py

 # Copyright (C) 2013 Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 # copyright notice, this list of conditions and the following disclaimer
@@ skipping 12 matching lines @@
 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 """Generate Blink V8 bindings (.h and .cpp files).
 
 Input: An object of class IdlDefinitions, containing an IDL interface X
 Output: V8X.h and V8X.cpp
-
-FIXME: Currently a stub, as part of landing the parser and code generator
-incrementally. Only implements generation of dummy .cpp and .h files.
 """
 
-import os.path
+import os
+import posixpath
+import re
+import sys
+
+import idl_definitions
+
+# jinja2 is in chromium's third_party directory.
+module_path, module_name = os.path.split(__file__)
+third_party = os.path.join(module_path, os.pardir, os.pardir, os.pardir, os.pardir)
+sys.path.append(third_party)
+import jinja2
+
+
+def apply_template(path_to_template, contents):
+    dirname, basename = os.path.split(path_to_template)
+    jinja_env = jinja2.Environment(trim_blocks=True, loader=jinja2.FileSystemLoader([dirname]))
+    template = jinja_env.get_template(basename)
+    return template.render(contents)
+
+
+def v8_class_name(interface):
+    return 'V8' + interface.name
+
+
+def cpp_type(data_type):
+    """Returns the cpp type corresponding to the IDL type."""
+    if data_type == 'boolean':
+        return 'bool'
+    raise Exception('Not supported')
+
+
+def callback_argument_declaration(operation):
+    arguments = ['%s %s' % (cpp_type(argument.data_type), argument.name) for argument in operation.arguments]
+    return ', '.join(arguments)
+
+
+class CodeGeneratorV8:
+    def __init__(self, definitions, interface_name, output_directory, idl_directories, verbose=False):
+        if interface_name not in definitions.interfaces:
+            raise Exception('%s not in IDL definitions' % interface_name)
+        self.idl_definitions = definitions
+        self.interface_name = interface_name
+        self.idl_directories = idl_directories
+        self.output_directory = output_directory
+        self.verbose = verbose
+        self.interface = self.idl_definitions.interfaces[self.interface_name]
+
+    def cpp_class_header_filename(self):
+        """Returns relative path from bindings/ of webcore header of the interface"""
+        # FIXME: parser will prepare posix form relative path from Source/bindings in IdlInterface.file_name
+        idl_filename = self.idl_definitions.file_name
+        idl_rel_path_local = os.path.relpath(idl_filename)
+        idl_rel_path_posix = idl_rel_path_local.replace(os.path.sep, posixpath.sep)
+
+        idl_dir_posix = posixpath.join('bindings', posixpath.dirname(idl_rel_path_posix))
+        return posixpath.join(idl_dir_posix, self.interface.name + '.h')
+
+    def generate_header_and_cpp(self):
+        if self.interface.is_callback:
+            template_contents = {}
+            template_contents.update(self.generate_callback_interface())
+            header_file_text = apply_template('templates/callback.h', template_contents)
+            cpp_file_text = apply_template('templates/callback.cpp', template_contents)
+        else:
+            # FIXME: Implement.
+            header_file_text = ""
+            cpp_file_text = ""
+        self.write_generated_code(header_file_text, cpp_file_text)
+
+    def write_generated_code(self, header_file_text, cpp_file_text):
+        header_filename = os.path.join(self.output_directory, v8_class_name(self.interface) + '.h')
+        with open(header_filename, 'w') as header_file:
+            header_file.write(header_file_text)
+        cpp_filename = os.path.join(self.output_directory, v8_class_name(self.interface) + '.cpp')
+        with open(cpp_filename, 'w') as cpp_file:
+            cpp_file.write(cpp_file_text)
+
+    def generate_callback_interface(self):
+        methods = []
+        cpp_includes = set([
+            'core/dom/ScriptExecutionContext.h',
+            'bindings/v8/V8Binding.h',
+            'bindings/v8/V8Callback.h',
+            'wtf/Assertions.h',
+        ])
+        header_includes = set([
+            'bindings/v8/ActiveDOMCallback.h',
+            'bindings/v8/DOMWrapperWorld.h',
+            'bindings/v8/ScopedPersistent.h',
+        ])
+        header_includes.add(self.cpp_class_header_filename())
+        for operation in self.interface.operations:
+            method = {}
+            if 'Custom' not in operation.extended_attributes:
+                if operation.data_type != 'boolean':
+                    raise Exception("We don't yet support callbacks that return non-boolean values.")
+                if len(operation.arguments):
+                    raise Exception('Not supported')
+                method = {

[haraken, 2013/07/26 10:15:48]

You might want to set 'method.arguments': []

+                    'return_type': cpp_type(operation.data_type),
+                    'name': operation.name,
+                    'parameter_declaration': callback_argument_declaration(operation),

[haraken, 2013/07/26 10:15:48]

parameter_declaration => argument_declaration

+                    'custom': None,
+                }
+            methods.append(method)
+        template_contents = {
+            'cpp_class_name': self.interface.name,
+            'v8_class_name': v8_class_name(self.interface),
+            'cpp_includes': sorted(list(cpp_includes)),
+            'header_includes': sorted(list(header_includes)),
+            'methods': methods,
+        }
+        return template_contents
 
 
 def generate_dummy_header_and_cpp(target_interface_name, output_directory):

[haraken, 2013/07/26 10:15:48]

You can put this method inside the CodeGeneratorV8 class.

     header_basename = 'V8%s.h' % target_interface_name
     cpp_basename = 'V8%s.cpp' % target_interface_name
     header_fullname = os.path.join(output_directory, header_basename)
     cpp_fullname = os.path.join(output_directory, cpp_basename)
     contents = """/*
     This file is generated just to tell build scripts that {header_basename} and
     {cpp_basename} are created for {target_interface_name}.idl, and thus
     prevent the build scripts from trying to generate {header_basename} and
     {cpp_basename} at every build. This file must not be tried to compile.
 */
 """.format(**locals())
     with open(header_fullname, 'w') as header_file:
         header_file.write(contents)
     with open(cpp_fullname, 'w') as cpp_file:
         cpp_file.write(contents)