| # Copyright 2014 Google Inc. All Rights Reserved. |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| """Generate Cobalt bindings (.h and .cpp files). |
| |
| Based on and borrows heavily from code_generator_v8.py which is used as part |
| of the bindings generation pipeline in Blink. |
| """ |
| |
| import abc |
| from datetime import date |
| import os |
| import sys |
| |
| # Add blink's binding scripts to the path, so we can import |
| module_path, module_filename = os.path.split(os.path.realpath(__file__)) |
| blink_script_dir = os.path.normpath(os.path.join( |
| module_path, os.pardir, os.pardir, 'third_party', 'blink', 'Source')) |
| sys.path.append(blink_script_dir) |
| |
| from bindings.scripts.code_generator_v8 import CodeGeneratorBase # pylint: disable=g-import-not-at-top |
| from bindings.scripts.idl_types import IdlType |
| from bindings.scripts.idl_types import inherits_interface |
| import contexts |
| import jinja2 |
| from name_conversion import convert_to_cobalt_name |
| from name_conversion import get_interface_name |
| |
| module_path, module_filename = os.path.split(os.path.realpath(__file__)) |
| |
| # Track the cobalt directory, so we can use it for building relative paths. |
| cobalt_dir = os.path.normpath(os.path.join(module_path, os.pardir)) |
| |
| SHARED_TEMPLATES_DIR = os.path.abspath(os.path.join(module_path, 'templates')) |
| |
| |
| def initialize_jinja_env(cache_dir, templates_dir): |
| """Initialize the Jinja2 environment.""" |
| assert os.path.isabs(templates_dir) |
| assert os.path.isabs(SHARED_TEMPLATES_DIR) |
| jinja_env = jinja2.Environment( |
| loader=jinja2.FileSystemLoader([templates_dir, SHARED_TEMPLATES_DIR]), |
| extensions=['jinja2.ext.do'], # do statement |
| # Bytecode cache is not concurrency-safe unless pre-cached: |
| # if pre-cached this is read-only, but writing creates a race condition. |
| bytecode_cache=jinja2.FileSystemBytecodeCache(cache_dir), |
| keep_trailing_newline=True, # newline-terminate generated files |
| lstrip_blocks=True, # so can indent control flow tags |
| trim_blocks=True) |
| return jinja_env |
| |
| |
| def normalize_slashes(path): |
| if os.path.sep == '\\': |
| return path.replace('\\', '/') |
| else: |
| return path |
| |
| |
| def get_implementation_header_path(interface_info): |
| """Get the path to the implementation header file. |
| |
| The interface file must be under cobalt/... |
| |
| Args: |
| interface_info: (dict) Contains the information about an interface |
| defined in an IDL, as generated by blink's |
| compute_interfaces_info_individual.py script |
| Returns: |
| (str) The path to the corresponding implementation header file, starting |
| with the 'cobalt' directory. |
| """ |
| implementation_header_absdir, filename = os.path.split(interface_info[ |
| 'full_path']) |
| |
| implementation_header_reldir = os.path.relpath(implementation_header_absdir, |
| cobalt_dir) |
| assert not os.path.isabs(implementation_header_reldir) |
| assert os.pardir not in implementation_header_reldir.split(os.sep) |
| |
| root, _ = os.path.splitext(filename) |
| header_filename = convert_to_cobalt_name(root) + '.h' |
| return normalize_slashes(os.path.join('cobalt', implementation_header_reldir, |
| header_filename)) |
| |
| |
| def is_global_interface(interface): |
| return (('PrimaryGlobal' in interface.extended_attributes) or |
| ('Global' in interface.extended_attributes)) |
| |
| |
| def get_indexed_special_operation(interface, special): |
| special_operations = list( |
| operation for operation in interface.operations |
| if (special in operation.specials and operation.arguments and str( |
| operation.arguments[0].idl_type) == 'unsigned long')) |
| assert len(special_operations) <= 1, ( |
| 'Multiple indexed %ss defined on interface: %s' % |
| (special, interface.name)) |
| return special_operations[0] if len(special_operations) else None |
| |
| |
| def get_indexed_property_getter(interface): |
| getter_operation = get_indexed_special_operation(interface, 'getter') |
| assert not getter_operation or len(getter_operation.arguments) == 1 |
| return getter_operation |
| |
| |
| def get_indexed_property_setter(interface): |
| setter_operation = get_indexed_special_operation(interface, 'setter') |
| assert not setter_operation or len(setter_operation.arguments) == 2 |
| return setter_operation |
| |
| |
| def get_named_special_operation(interface, special): |
| special_operations = list( |
| operation for operation in interface.operations |
| if (special in operation.specials and operation.arguments and str( |
| operation.arguments[0].idl_type) == 'DOMString')) |
| assert len(special_operations) <= 1, ( |
| 'Multiple named %ss defined on interface: %s' % (special, interface.name)) |
| return special_operations[0] if len(special_operations) else None |
| |
| |
| def get_named_property_getter(interface): |
| getter_operation = get_named_special_operation(interface, 'getter') |
| assert not getter_operation or len(getter_operation.arguments) == 1 |
| return getter_operation |
| |
| |
| def get_named_property_setter(interface): |
| setter_operation = get_named_special_operation(interface, 'setter') |
| assert not setter_operation or len(setter_operation.arguments) == 2 |
| return setter_operation |
| |
| |
| def get_named_property_deleter(interface): |
| deleter_operation = get_named_special_operation(interface, 'deleter') |
| assert not deleter_operation or len(deleter_operation.arguments) == 1 |
| return deleter_operation |
| |
| |
| def get_interface_type_names_from_idl_types(idl_type_list): |
| for idl_type in idl_type_list: |
| if idl_type: |
| if idl_type.is_interface_type: |
| yield get_interface_name(idl_type) |
| elif idl_type.is_union_type: |
| for interface_name in get_interface_type_names_from_idl_types( |
| idl_type.member_types): |
| yield interface_name |
| |
| |
| def get_interface_type_names_from_typed_objects(typed_object_list): |
| for typed_object in typed_object_list: |
| for interface_name in get_interface_type_names_from_idl_types( |
| [typed_object.idl_type]): |
| yield interface_name |
| |
| if hasattr(typed_object, 'arguments'): |
| for interface_name in get_interface_type_names_from_typed_objects( |
| typed_object.arguments): |
| yield interface_name |
| |
| |
| def split_unsupported_properties(context_list): |
| supported = [] |
| unsupported = [] |
| for context in context_list: |
| if context['unsupported']: |
| unsupported.append(context['idl_name']) |
| else: |
| supported.append(context) |
| return supported, unsupported |
| |
| |
| class CodeGeneratorCobalt(CodeGeneratorBase): |
| """Abstract Base code generator class for Cobalt. |
| |
| Concrete classes will provide an implementation for generating bindings for a |
| specific JavaScript engine implementation. |
| """ |
| __metaclass__ = abc.ABCMeta |
| |
| def __init__(self, interfaces_info, templates_dir, cache_dir, output_dir): |
| CodeGeneratorBase.__init__(self, interfaces_info, cache_dir, output_dir) |
| # CodeGeneratorBase inititalizes this with the v8 template path, so |
| # reinitialize it with cobalt's template path |
| |
| # Whether the path is absolute or relative affects the cache file name. Use |
| # the absolute path to ensure that we use the same path as was used when the |
| # cache was prepopulated. |
| self.jinja_env = initialize_jinja_env(cache_dir, |
| os.path.abspath(templates_dir)) |
| |
| @abc.abstractproperty |
| def generated_file_prefix(self): |
| """The prefix to prepend to all generated source files.""" |
| pass |
| |
| @abc.abstractproperty |
| def expression_generator(self): |
| """An instance that implements the ExpressionGenerator class.""" |
| pass |
| |
| def wrapper_class_from_interface_name(self, interface_name): |
| return self.generated_file_prefix + interface_name |
| |
| def wrapper_header_from_interface_name(self, interface_name): |
| attribute_wrapper_class = self.wrapper_class_from_interface_name( |
| interface_name) |
| return normalize_slashes(attribute_wrapper_class + '.h') |
| |
| def output_paths(self, class_name): |
| """Construct the filenames for a generated source file. |
| |
| Construct the header and cc source file paths based on the |
| name of the generated class. |
| |
| Args: |
| class_name: A string that is the name of the interface as defined |
| in the IDL |
| |
| Returns: |
| (str, str): A tuple of two strings representing the full path of |
| the (.h, .cpp) file that will be generated for this interface |
| """ |
| |
| header_path = os.path.join(self.output_dir, class_name + '.h') |
| cc_path = os.path.join(self.output_dir, class_name + '.cc') |
| return header_path, cc_path |
| |
| def render_template(self, header_template_filename, cc_template_filename, |
| template_context): |
| header_template = self.jinja_env.get_template(header_template_filename) |
| cc_template = self.jinja_env.get_template(cc_template_filename) |
| # Make sure extension is .py, not .pyc or .pyo, so doesn't depend on caching |
| module_path_pyname = os.path.join( |
| module_path, os.path.splitext(module_filename)[0] + '.py') |
| # Ensure that posix forward slashes are used |
| template_context['code_generator'] = normalize_slashes(os.path.relpath( |
| module_path_pyname, cobalt_dir)) |
| template_context['header_template_path'] = normalize_slashes( |
| os.path.relpath(header_template.filename, cobalt_dir)) |
| template_context['cc_template_path'] = normalize_slashes(os.path.relpath( |
| cc_template.filename, cobalt_dir)) |
| header_text = header_template.render(template_context) |
| cc_text = cc_template.render(template_context) |
| return header_text, cc_text |
| |
| def generate_code_internal(self, definitions, definition_name): |
| if definition_name in definitions.interfaces: |
| return self.generate_interface_code( |
| definitions, definition_name, definitions.interfaces[definition_name]) |
| if definition_name in definitions.dictionaries: |
| return self.generate_dictionary_code( |
| definitions, definition_name, |
| definitions.dictionaries[definition_name]) |
| raise ValueError('%s is not in IDL definitions' % definition_name) |
| |
| def generate_interface_code(self, definitions, interface_name, interface): |
| interface_info = self.interfaces_info[interface_name] |
| # Select appropriate Jinja template and contents function |
| if interface.is_callback: |
| header_template_filename = 'callback-interface.h.template' |
| cpp_template_filename = 'callback-interface.cc.template' |
| elif interface.is_partial: |
| raise NotImplementedError('Partial interfaces not implemented') |
| else: |
| header_template_filename = 'interface.h.template' |
| cpp_template_filename = 'interface.cc.template' |
| |
| template_context = self.build_interface_context(interface, interface_info, |
| definitions) |
| header_text, cc_text = self.render_template(header_template_filename, |
| cpp_template_filename, |
| template_context) |
| header_path, cc_path = self.output_paths(template_context['binding_class']) |
| return ((header_path, header_text), |
| (cc_path, cc_text),) |
| |
| def generate_dictionary_code(self, definitions, dictionary_name, dictionary): |
| raise NotImplementedError('Dictionaries not implemented') |
| |
| def get_interface_components(self, idl_type_name): |
| """Get the interface's namespace as a list of namespace components.""" |
| idl_filename = self.interfaces_info[idl_type_name].get('full_path') |
| # Get the IDL filename relative to the cobalt directory, and split the |
| # directory to get the list of namespace components. |
| idl_filename = os.path.relpath(idl_filename, cobalt_dir) |
| components = os.path.dirname(idl_filename).split(os.sep) |
| return components |
| |
| def referenced_interface_contexts(self, interface_name): |
| """Yields information for including and declaring this interface's classes. |
| |
| Args: |
| interface_name: The name of the interface. |
| Yields: |
| dict with the following keys: |
| fully_qualified_name: Fully qualified name of the class. |
| include: Path to the header that defines the class. |
| conditional: Symbol on which this interface is conditional compiled. |
| is_callback_interface: True iff this is a callback interface. |
| """ |
| |
| conditional = self.interfaces_info[interface_name]['conditional'] |
| namespace = '::'.join(self.get_interface_components(interface_name)) |
| full_name = 'cobalt::%s::%s' % (namespace, interface_name) |
| |
| # Information about the Cobalt implementation class. |
| yield { |
| 'fully_qualified_name': full_name, |
| 'include': get_implementation_header_path(self.interfaces_info[ |
| interface_name]), |
| 'conditional': conditional, |
| 'is_callback_interface': interface_name in IdlType.callback_interfaces, |
| } |
| yield { |
| 'fully_qualified_name': 'cobalt::%s::%s' % ( |
| namespace, self.wrapper_class_from_interface_name(interface_name)), |
| 'include': self.wrapper_header_from_interface_name(interface_name), |
| 'conditional': conditional, |
| 'is_callback_interface': interface_name in IdlType.callback_interfaces, |
| } |
| |
| def build_interface_context(self, interface, interface_info, definitions): |
| wrapper_class_name = self.wrapper_class_from_interface_name(interface.name) |
| header, _ = self.output_paths(wrapper_class_name) |
| generated_header_relative_path = os.path.relpath(header, self.output_dir) |
| assert not os.path.isabs(generated_header_relative_path) |
| assert os.pardir not in generated_header_relative_path.split(os.sep) |
| |
| interface_components = ( |
| self.get_interface_components(interface.idl_type.name)) |
| context = { |
| # Parameters used for template rendering. |
| 'today': date.today(), |
| 'binding_class': wrapper_class_name, |
| 'fully_qualified_binding_class': ( |
| '::'.join(interface_components + [wrapper_class_name])), |
| 'header_file': normalize_slashes(generated_header_relative_path), |
| 'impl_class': interface.name, |
| 'fully_qualified_impl_class': ( |
| '::'.join(interface_components + [interface.name])), |
| 'interface_name': interface.name, |
| 'is_event_interface': inherits_interface(interface.name, 'Event'), |
| 'is_global_interface': is_global_interface(interface), |
| 'has_interface_object': |
| ('NoInterfaceObject' not in interface.extended_attributes), |
| 'conditional': interface.extended_attributes.get('Conditional', None), |
| 'add_opaque_roots': interface.extended_attributes.get('AddOpaqueRoots', |
| None), |
| 'get_opaque_root': interface.extended_attributes.get('GetOpaqueRoot', |
| None), |
| } |
| if is_global_interface(interface): |
| # Global interface references all interfaces. |
| referenced_interface_names = set( |
| interface_name |
| for interface_name in self.interfaces_info['all_interfaces'] |
| if not self.interfaces_info[interface_name]['unsupported'] and |
| not self.interfaces_info[interface_name]['is_callback_interface']) |
| referenced_interface_names.update(IdlType.callback_interfaces) |
| else: |
| # Build the set of referenced interfaces from this interface's members. |
| referenced_interface_names = set() |
| referenced_interface_names.update( |
| get_interface_type_names_from_typed_objects(interface.attributes)) |
| referenced_interface_names.update( |
| get_interface_type_names_from_typed_objects(interface.operations)) |
| referenced_interface_names.update( |
| get_interface_type_names_from_typed_objects(interface.constructors)) |
| referenced_interface_names.update( |
| get_interface_type_names_from_typed_objects( |
| definitions.callback_functions.values())) |
| |
| # Build the set of #includes in the header file. Try to keep this small |
| # to avoid circular dependency problems. |
| header_includes = set() |
| if interface.parent: |
| header_includes.add(self.wrapper_header_from_interface_name( |
| interface.parent)) |
| header_includes.add(get_implementation_header_path(interface_info)) |
| |
| attributes = [contexts.attribute_context(interface, attribute, definitions) |
| for attribute in interface.attributes] |
| constructor = contexts.get_constructor_context(self.expression_generator, |
| interface) |
| methods = contexts.get_method_contexts(self.expression_generator, interface) |
| constants = [contexts.constant_context(c) for c in interface.constants] |
| |
| # Get a list of all the unsupported property names, and remove the |
| # unsupported ones from their respective lists |
| attributes, unsupported_attribute_names = split_unsupported_properties( |
| attributes) |
| methods, unsupported_method_names = split_unsupported_properties(methods) |
| constants, unsupported_constant_names = split_unsupported_properties( |
| constants) |
| |
| # Build a set of all interfaces referenced by this interface. |
| referenced_interfaces = {} |
| for interface_name in referenced_interface_names: |
| # Get information for classes related to this interface. |
| for referenced_interface_context in self.referenced_interface_contexts( |
| interface_name): |
| # Store it in the dictionary using fully_qualified_name as the key so |
| # we can avoid duplicates |
| key = referenced_interface_context['fully_qualified_name'] |
| referenced_interfaces[key] = referenced_interface_context |
| # Now that we have all the referenced interfaces at most once, just get |
| # the values(), since the key is duplicated there and we no longer need |
| # to lookup by name. |
| referenced_interfaces = referenced_interfaces.values() |
| |
| all_interfaces = [] |
| for interface_name in referenced_interface_names: |
| if interface_name not in IdlType.callback_interfaces and not ( |
| self.interfaces_info[interface_name]['unsupported']): |
| all_interfaces.append({ |
| 'name': interface_name, |
| 'conditional': self.interfaces_info[interface_name]['conditional'], |
| }) |
| |
| context['implementation_includes'] = sorted( |
| (interface['include'] for interface in referenced_interfaces)) |
| context['header_includes'] = sorted(header_includes) |
| context['attributes'] = [a for a in attributes if not a['is_static']] |
| context['static_attributes'] = [a for a in attributes if a['is_static']] |
| context['constants'] = constants |
| context['constructor'] = constructor |
| context['named_constructor'] = interface.extended_attributes.get( |
| 'NamedConstructor', None) |
| context['interface'] = interface |
| context['operations'] = [m for m in methods if not m['is_static']] |
| context['static_operations'] = [m for m in methods if m['is_static']] |
| context['unsupported_interface_properties'] = set( |
| unsupported_attribute_names + unsupported_method_names + |
| unsupported_constant_names) |
| context['unsupported_constructor_properties'] = set( |
| unsupported_constant_names) |
| if interface.parent: |
| context['parent_interface'] = ( |
| '::'.join(self.get_interface_components(interface.parent)) + '::%s' % |
| self.wrapper_class_from_interface_name(interface.parent)) |
| context['is_exception_interface'] = interface.is_exception |
| context['components'] = self.get_interface_components( |
| interface.idl_type.name) |
| context['forward_declarations'] = sorted( |
| referenced_interfaces, |
| key=lambda x: x['fully_qualified_name']) |
| context['all_interfaces'] = sorted(all_interfaces, key=lambda x: x['name']) |
| context['callback_functions'] = definitions.callback_functions.values() |
| context['enumerations'] = [ |
| contexts.enumeration_context(enumeration) |
| for enumeration in definitions.enumerations.values() |
| ] |
| |
| context['stringifier'] = contexts.stringifier_context(interface) |
| context['indexed_property_getter'] = contexts.special_method_context( |
| interface, get_indexed_property_getter(interface)) |
| context['indexed_property_setter'] = contexts.special_method_context( |
| interface, get_indexed_property_setter(interface)) |
| context['named_property_getter'] = contexts.special_method_context( |
| interface, get_named_property_getter(interface)) |
| context['named_property_setter'] = contexts.special_method_context( |
| interface, get_named_property_setter(interface)) |
| context['named_property_deleter'] = contexts.special_method_context( |
| interface, get_named_property_deleter(interface)) |
| |
| context['supports_indexed_properties'] = ( |
| context['indexed_property_getter'] or |
| context['indexed_property_setter']) |
| context['supports_named_properties'] = (context['named_property_setter'] or |
| context['named_property_getter'] or |
| context['named_property_deleter']) |
| |
| return context |
| |
| ################################################################################ |
| |
| |
| def main(argv): |
| # If file itself executed, cache templates |
| try: |
| cache_dir = argv[1] |
| templates_dir = argv[2] |
| dummy_filename = argv[3] |
| except IndexError: |
| print 'Usage: %s CACHE_DIR TEMPLATES_DIR DUMMY_FILENAME' % argv[0] |
| return 1 |
| |
| # Cache templates. |
| # Whether the path is absolute or relative affects the cache file name. Use |
| # the absolute path to ensure that the same path is used when we populate the |
| # cache here and when it's read during code generation. |
| jinja_env = initialize_jinja_env(cache_dir, os.path.abspath(templates_dir)) |
| template_filenames = [ |
| filename |
| for filename in os.listdir(templates_dir) |
| # Skip .svn, directories, etc. |
| if filename.endswith(('.template')) |
| ] |
| assert template_filenames, 'Expected at least one template to be cached.' |
| shared_template_filenames = [ |
| filename |
| for filename in os.listdir(SHARED_TEMPLATES_DIR) |
| # Skip .svn, directories, etc. |
| if filename.endswith(('.template')) |
| ] |
| for template_filename in template_filenames + shared_template_filenames: |
| jinja_env.get_template(template_filename) |
| |
| # Create a dummy file as output for the build system, |
| # since filenames of individual cache files are unpredictable and opaque |
| # (they are hashes of the template path, which varies based on environment) |
| with open(dummy_filename, 'w') as dummy_file: |
| pass # |open| creates or touches the file |
| |
| |
| if __name__ == '__main__': |
| sys.exit(main(sys.argv)) |
