class IdlCompiler(object):
"""Abstract Base Class for IDL compilers.
In concrete classes:
* self.code_generator must be set, implementing generate_code()
(returning a list of output code), and
* compile_file() must be implemented (handling output filenames).
"""
__metaclass__ = abc.ABCMeta
def __init__(self,
output_directory,
code_generator=None,
interfaces_info=None,
interfaces_info_filename='',
only_if_changed=False):
"""
Args:
interfaces_info:
interfaces_info dict
(avoids auxiliary file in run-bindings-tests)
interfaces_info_file: filename of pickled interfaces_info
"""
self.code_generator = code_generator
if interfaces_info_filename:
with open(interfaces_info_filename) as interfaces_info_file:
interfaces_info = pickle.load(interfaces_info_file)
self.interfaces_info = interfaces_info
self.only_if_changed = only_if_changed
self.output_directory = output_directory
self.reader = IdlReader(interfaces_info, output_directory)
def compile_and_write(self, idl_filename, output_filenames):
interface_name = idl_filename_to_interface_name(idl_filename)
idl_pickle_filename = os.path.join(
self.output_directory, '%s_globals.pickle' % interface_name)
definitions = self.reader.read_idl_definitions(idl_filename)
output_code_list = self.code_generator.generate_code(
definitions, interface_name, idl_filename, idl_pickle_filename,
self.only_if_changed)
for output_code, output_filename in zip(output_code_list,
output_filenames):
write_file(output_code, output_filename, self.only_if_changed)
def generate_global_and_write(self, global_entries, output_filenames):
output_code_list = self.code_generator.generate_globals(global_entries)
for output_code, output_filename in zip(output_code_list,
output_filenames):
write_file(output_code, output_filename, self.only_if_changed)
def generate_dart_blink_and_write(self, global_entries, output_filename):
output_code = self.code_generator.generate_dart_blink(global_entries)
write_file(output_code, output_filename, self.only_if_changed)
@abc.abstractmethod
def compile_file(self, idl_filename):
pass
class IdlCompiler(object):
"""Abstract Base Class for IDL compilers.
In concrete classes:
* self.code_generator must be set, implementing generate_code()
(returning a list of output code), and
* compile_file() must be implemented (handling output filenames).
"""
__metaclass__ = abc.ABCMeta
def __init__(self, output_directory, code_generator=None,
interfaces_info=None, interfaces_info_filename='',
only_if_changed=False):
"""
Args:
interfaces_info:
interfaces_info dict
(avoids auxiliary file in run-bindings-tests)
interfaces_info_file: filename of pickled interfaces_info
"""
self.code_generator = code_generator
if interfaces_info_filename:
with open(interfaces_info_filename) as interfaces_info_file:
interfaces_info = pickle.load(interfaces_info_file)
self.interfaces_info = interfaces_info
self.only_if_changed = only_if_changed
self.output_directory = output_directory
self.reader = IdlReader(interfaces_info, output_directory)
def compile_and_write(self, idl_filename, output_filenames):
interface_name = idl_filename_to_interface_name(idl_filename)
idl_pickle_filename = os.path.join(self.output_directory,
'%s_globals.pickle' % interface_name)
definitions = self.reader.read_idl_definitions(idl_filename)
output_code_list = self.code_generator.generate_code(definitions,
interface_name,
idl_filename,
idl_pickle_filename,
self.only_if_changed)
for output_code, output_filename in zip(output_code_list, output_filenames):
write_file(output_code, output_filename, self.only_if_changed)
def generate_global_and_write(self, global_entries, output_filenames):
output_code_list = self.code_generator.generate_globals(global_entries)
for output_code, output_filename in zip(output_code_list, output_filenames):
write_file(output_code, output_filename, self.only_if_changed)
def generate_dart_blink_and_write(self, global_entries, output_filename):
output_code = self.code_generator.generate_dart_blink(global_entries)
write_file(output_code, output_filename, self.only_if_changed)
@abc.abstractmethod
def compile_file(self, idl_filename):
pass
class IdlCompiler(object):
"""Abstract Base Class for IDL compilers.
In concrete classes:
* self.code_generator must be set, implementing generate_code()
(returning a list of output code), and
* compile_file() must be implemented (handling output filenames).
"""
__metaclass__ = abc.ABCMeta
def __init__(self,
output_directory,
cache_directory=None,
code_generator=None,
info_provider=None,
only_if_changed=False,
target_component=None):
"""
Args:
output_directory: directory to put output files.
cache_directory: directory which contains PLY caches.
code_generator: code generator to be used.
info_provider: component-specific information provider.
only_if_changed: True when the compiler should only write output files
when the contents are changed.
target_component: component to be processed.
"""
self.cache_directory = cache_directory
self.code_generator = code_generator
self.info_provider = info_provider
self.only_if_changed = only_if_changed
self.output_directory = output_directory
self.target_component = target_component
self.reader = IdlReader(info_provider.interfaces_info, cache_directory)
def compile_and_write(self, idl_filename):
interface_name = idl_filename_to_interface_name(idl_filename)
definitions = self.reader.read_idl_definitions(idl_filename)
target_component = self.target_component or idl_filename_to_component(
idl_filename)
target_definitions = definitions[target_component]
output_code_list = self.code_generator.generate_code(
target_definitions, interface_name)
for output_path, output_code in output_code_list:
write_file(output_code, output_path, self.only_if_changed)
@abc.abstractmethod
def compile_file(self, idl_filename):
pass
class IdlCompiler(object):
"""Abstract Base Class for IDL compilers.
In concrete classes:
* self.code_generator must be set, implementing generate_code()
(returning a list of output code), and
* compile_file() must be implemented (handling output filenames).
"""
__metaclass__ = abc.ABCMeta
def __init__(self,
output_directory,
cache_directory='',
code_generator=None,
interfaces_info=None,
interfaces_info_filename='',
only_if_changed=False):
"""
Args:
interfaces_info:
interfaces_info dict
(avoids auxiliary file in run-bindings-tests)
interfaces_info_file: filename of pickled interfaces_info
"""
cache_directory = cache_directory or output_directory
self.cache_directory = cache_directory
self.code_generator = code_generator
if interfaces_info_filename:
with open(interfaces_info_filename) as interfaces_info_file:
interfaces_info = pickle.load(interfaces_info_file)
self.interfaces_info = interfaces_info
self.only_if_changed = only_if_changed
self.output_directory = output_directory
self.reader = IdlReader(interfaces_info, cache_directory)
def compile_and_write(self, idl_filename):
interface_name = idl_filename_to_interface_name(idl_filename)
component = idl_filename_to_component(idl_filename)
definitions = self.reader.read_idl_definitions(idl_filename)
output_code_list = self.code_generator.generate_code(
definitions[component], interface_name)
for output_path, output_code in output_code_list:
write_file(output_code, output_path, self.only_if_changed)
@abc.abstractmethod
def compile_file(self, idl_filename):
pass
class IdlCompiler(object):
"""The IDL Compiler.
"""
__metaclass__ = abc.ABCMeta
def __init__(self,
output_directory,
cache_directory=None,
code_generator_class=None,
snake_case_generated_files=False,
info_provider=None,
target_component=None):
"""
Args:
output_directory: directory to put output files.
cache_directory: directory which contains PLY caches.
code_generator_class: code generator class to be used.
info_provider: component-specific information provider.
target_component: component to be processed.
"""
self.cache_directory = cache_directory
self.info_provider = info_provider
self.output_directory = output_directory
self.target_component = target_component
self.reader = IdlReader(info_provider.interfaces_info, cache_directory)
self.code_generator = code_generator_class(self.info_provider,
self.cache_directory,
self.output_directory,
snake_case_generated_files)
def compile_and_write(self, idl_filename):
definitions = self.reader.read_idl_definitions(idl_filename)
target_definitions = definitions[self.target_component]
interface_name = target_definitions.first_name
output_code_list = self.code_generator.generate_code(
target_definitions, interface_name)
# Generator may choose to omit the file.
if output_code_list is None:
return
for output_path, output_code in output_code_list:
write_file(output_code, output_path)
def compile_file(self, idl_filename):
self.compile_and_write(idl_filename)
class IdlCompiler(object):
"""Abstract Base Class for IDL compilers.
In concrete classes:
* self.code_generator must be set, implementing generate_code()
(returning a list of output code), and
* compile_file() must be implemented (handling output filenames).
"""
__metaclass__ = abc.ABCMeta
def __init__(self, output_directory, cache_directory=None,
code_generator=None, interfaces_info=None,
interfaces_info_filename='', only_if_changed=False,
target_component=None):
"""
Args:
interfaces_info:
interfaces_info dict
(avoids auxiliary file in run-bindings-tests)
interfaces_info_file: filename of pickled interfaces_info
"""
self.cache_directory = cache_directory
self.code_generator = code_generator
if interfaces_info_filename:
with open(interfaces_info_filename) as interfaces_info_file:
interfaces_info = pickle.load(interfaces_info_file)
self.interfaces_info = interfaces_info
self.only_if_changed = only_if_changed
self.output_directory = output_directory
self.target_component = target_component
self.reader = IdlReader(interfaces_info, cache_directory)
def compile_and_write(self, idl_filename):
interface_name = idl_filename_to_interface_name(idl_filename)
definitions = self.reader.read_idl_definitions(idl_filename)
target_component = self.target_component or idl_filename_to_component(idl_filename)
target_definitions = definitions[target_component]
output_code_list = self.code_generator.generate_code(
target_definitions, interface_name)
for output_path, output_code in output_code_list:
write_file(output_code, output_path, self.only_if_changed)
@abc.abstractmethod
def compile_file(self, idl_filename):
pass
class IdlCompiler(object):
"""Abstract Base Class for IDL compilers.
In concrete classes:
* self.code_generator must be set, implementing generate_code()
(returning a list of output code), and
* compile_file() must be implemented (handling output filenames).
"""
__metaclass__ = abc.ABCMeta
def __init__(self, output_directory, cache_directory=None,
code_generator=None, info_provider=None,
only_if_changed=False, target_component=None):
"""
Args:
output_directory: directory to put output files.
cache_directory: directory which contains PLY caches.
code_generator: code generator to be used.
info_provider: component-specific information provider.
only_if_changed: True when the compiler should only write output files
when the contents are changed.
target_component: component to be processed.
"""
self.cache_directory = cache_directory
self.code_generator = code_generator
self.info_provider = info_provider
self.only_if_changed = only_if_changed
self.output_directory = output_directory
self.target_component = target_component
self.reader = IdlReader(info_provider.interfaces_info, cache_directory)
def compile_and_write(self, idl_filename):
interface_name = idl_filename_to_interface_name(idl_filename)
definitions = self.reader.read_idl_definitions(idl_filename)
target_component = self.target_component or idl_filename_to_component(idl_filename)
target_definitions = definitions[target_component]
output_code_list = self.code_generator.generate_code(
target_definitions, interface_name)
for output_path, output_code in output_code_list:
write_file(output_code, output_path, self.only_if_changed)
@abc.abstractmethod
def compile_file(self, idl_filename):
pass
class IdlCompiler(object):
"""Abstract Base Class for IDL compilers.
In concrete classes:
* self.code_generator must be set, implementing generate_code()
(returning a list of output code), and
* compile_file() must be implemented (handling output filenames).
"""
__metaclass__ = abc.ABCMeta
def __init__(self,
output_directory,
code_generator=None,
interfaces_info=None,
interfaces_info_filename='',
only_if_changed=False):
"""
Args:
interfaces_info:
interfaces_info dict
(avoids auxiliary file in run-bindings-tests)
interfaces_info_file: filename of pickled interfaces_info
"""
self.code_generator = code_generator
if interfaces_info_filename:
with open(interfaces_info_filename) as interfaces_info_file:
interfaces_info = pickle.load(interfaces_info_file)
self.interfaces_info = interfaces_info
self.only_if_changed = only_if_changed
self.output_directory = output_directory
self.reader = IdlReader(interfaces_info, output_directory, True)
def compile_and_write(self, idl_filename, output_filenames):
# Only compile the IDL file and return the AST.
definitions = self.reader.read_idl_definitions(idl_filename)
return definitions
def generate_global_and_write(self, output_filenames):
pass
@abc.abstractmethod
def compile_file(self, idl_filename):
pass
class IdlCompiler(object):
"""The IDL Compiler.
"""
__metaclass__ = abc.ABCMeta
def __init__(self, output_directory, cache_directory=None,
code_generator_class=None, info_provider=None,
target_component=None):
"""
Args:
output_directory: directory to put output files.
cache_directory: directory which contains PLY caches.
code_generator_class: code generator class to be used.
info_provider: component-specific information provider.
target_component: component to be processed.
"""
self.cache_directory = cache_directory
self.info_provider = info_provider
self.output_directory = output_directory
self.target_component = target_component
self.reader = IdlReader(info_provider.interfaces_info, cache_directory)
self.code_generator = code_generator_class(self.info_provider,
self.cache_directory,
self.output_directory)
def compile_and_write(self, idl_filename):
interface_name = idl_filename_to_interface_name(idl_filename)
definitions = self.reader.read_idl_definitions(idl_filename)
target_definitions = definitions[self.target_component]
output_code_list = self.code_generator.generate_code(
target_definitions, interface_name)
# Generator may choose to omit the file.
if output_code_list is None:
return
for output_path, output_code in output_code_list:
write_file(output_code, output_path)
def compile_file(self, idl_filename):
self.compile_and_write(idl_filename)
class IdlCompiler(object):
"""Abstract Base Class for IDL compilers.
In concrete classes:
* self.code_generator must be set, implementing generate_code()
(returning a list of output code), and
* compile_file() must be implemented (handling output filenames).
"""
__metaclass__ = abc.ABCMeta
def __init__(self, output_directory, code_generator=None,
interfaces_info=None, interfaces_info_filename='',
only_if_changed=False):
"""
Args:
interfaces_info:
interfaces_info dict
(avoids auxiliary file in run-bindings-tests)
interfaces_info_file: filename of pickled interfaces_info
"""
self.code_generator = code_generator
if interfaces_info_filename:
with open(interfaces_info_filename) as interfaces_info_file:
interfaces_info = pickle.load(interfaces_info_file)
self.interfaces_info = interfaces_info
self.only_if_changed = only_if_changed
self.output_directory = output_directory
self.reader = IdlReader(interfaces_info, output_directory, True)
def compile_and_write(self, idl_filename, output_filenames):
# Only compile the IDL file and return the AST.
definitions = self.reader.read_idl_definitions(idl_filename)
return definitions
def generate_global_and_write(self, output_filenames):
pass
@abc.abstractmethod
def compile_file(self, idl_filename):
pass
class ExternalReferenceTableGenerator(object):
def __init__(self, opts, info_provider):
self._opts = opts
self._info_provider = info_provider
self._reader = IdlReader(info_provider.interfaces_info, opts.cache_dir)
self._interface_contexts = {}
self._include_files = set(INCLUDES)
v8_types.set_component_dirs(
info_provider.interfaces_info['component_dirs'])
# Creates a Jinja context from an IDL file.
def process_idl_file(self, idl_filename):
definitions = self._reader.read_idl_definitions(idl_filename)
for component in definitions:
target_definitions = definitions[component]
interfaces = target_definitions.interfaces
first_name = target_definitions.first_name
if first_name in interfaces.keys():
interface = interfaces[first_name]
self._process_interface(interface, component, interfaces)
# Creates a Jinja context from an interface. Some interfaces are not used
# in V8 context snapshot, so we can skip them.
def _process_interface(self, interface, component, interfaces):
def has_impl(interface):
# Non legacy callback interface does not provide V8 callbacks.
if interface.is_callback:
return len(interface.constants) > 0
if 'RuntimeEnabled' in interface.extended_attributes:
return False
if 'Exposed' not in interface.extended_attributes:
return True
return any(
exposure.exposed == 'Window'
and exposure.runtime_enabled is None
for exposure in interface.extended_attributes['Exposed'])
if not has_impl(interface):
return
context_builder = InterfaceTemplateContextBuilder(
self._opts, self._info_provider)
context = context_builder.create_interface_context(
interface, component, interfaces)
name = '%s%s' % (interface.name,
'Partial' if interface.is_partial else '')
self._interface_contexts[name] = context
# Do not include unnecessary header files.
if not context['attributes'] and not context['named_property_setter']:
return
include_file = 'third_party/blink/renderer/bindings/%s/v8/%s.h' % (
component, utilities.to_snake_case(context['v8_class']))
self._include_files.add(include_file)
# Gathers all interface-dependent information and returns as a Jinja template context.
def _create_template_context(self):
interfaces = []
for name in sorted(self._interface_contexts):
interfaces.append(self._interface_contexts[name])
header_path = 'third_party/blink/renderer/bindings/modules/v8/v8_context_snapshot_external_references.h'
include_files = list(self._include_files)
return {
'class': 'V8ContextSnapshotExternalReferences',
'interfaces': interfaces,
'include_files': sorted(include_files),
'this_include_header_path': header_path,
'code_generator': os.path.basename(__file__),
'jinja_template_filename': TEMPLATE_FILE
}
# Applies a Jinja template on a context and generates a C++ code.
def generate(self):
jinja_env = initialize_jinja_env(self._opts.cache_dir)
context = self._create_template_context()
cpp_template = jinja_env.get_template(TEMPLATE_FILE)
cpp_text = cpp_template.render(context)
return cpp_text
class ExternalReferenceTableGenerator(object):
def __init__(self, opts, info_provider):
self._opts = opts
self._info_provider = info_provider
self._reader = IdlReader(info_provider.interfaces_info, opts.cache_dir)
self._interface_contexts = {}
self._include_files = set(INCLUDES)
v8_types.set_component_dirs(
info_provider.interfaces_info['component_dirs'])
# Creates a Jinja context from an IDL file.
def process_idl_file(self, idl_filename):
definitions = self._reader.read_idl_definitions(idl_filename)
for component in definitions:
target_definitions = definitions[component]
interfaces = target_definitions.interfaces
first_name = target_definitions.first_name
if first_name in interfaces.keys():
interface = interfaces[first_name]
self._process_interface(interface, component, interfaces)
# Creates a Jinja context from an interface. Some interfaces are not used
# in V8 context snapshot, so we can skip them.
def _process_interface(self, interface, component, interfaces):
def has_impl(interface):
if interface.name in WHITE_LIST_INTERFACES:
return True
# Non legacy callback interface does not provide V8 callbacks.
if interface.is_callback:
return len(interface.constants) > 0
if 'RuntimeEnabled' in interface.extended_attributes:
return False
return True
if not has_impl(interface):
return
context_builder = InterfaceTemplateContextBuilder(
self._opts, self._info_provider)
context = context_builder.create_interface_context(
interface, interfaces)
name = '%s%s' % (interface.name,
'Partial' if interface.is_partial else '')
self._interface_contexts[name] = context
if self._opts.snake_case_generated_files:
include_file = 'bindings/%s/v8/%s.h' % (
component, utilities.to_snake_case(context['v8_name']))
else:
include_file = 'bindings/%s/v8/%s.h' % (component,
context['v8_name'])
self._include_files.add(include_file)
# Gathers all interface-dependent information and returns as a Jinja template context.
def _create_template_context(self):
interfaces = []
for name in sorted(self._interface_contexts):
interfaces.append(self._interface_contexts[name])
header_name = 'V8ContextSnapshotExternalReferences.h'
if self._opts.snake_case_generated_files:
header_name = 'v8_context_snapshot_external_references.h'
include_files = list(self._include_files)
# TODO(tkent): Update INCLUDES after the great mv, and remove the
# following block. crbug.com/760462
if self._opts.snake_case_generated_files:
include_files = []
for include in self._include_files:
dirname, basename = posixpath.split(include)
name, ext = posixpath.splitext(basename)
include_files.append(
posixpath.join(dirname,
utilities.to_snake_case(name) + ext))
return {
'class': 'V8ContextSnapshotExternalReferences',
'interfaces': interfaces,
'include_files': sorted(include_files),
'this_include_header_name': header_name,
'code_generator': os.path.basename(__file__),
'jinja_template_filename': TEMPLATE_FILE
}
# Applies a Jinja template on a context and generates a C++ code.
def generate(self):
jinja_env = initialize_jinja_env(self._opts.cache_dir)
context = self._create_template_context()
cpp_template = jinja_env.get_template(TEMPLATE_FILE)
cpp_text = cpp_template.render(context)
return cpp_text
class ExternalReferenceTableGenerator(object):
def __init__(self, opts, info_provider):
self._opts = opts
self._info_provider = info_provider
self._reader = IdlReader(
info_provider.interfaces_info, opts.cache_dir)
self._interface_contexts = {}
self._include_files = set(INCLUDES)
v8_types.set_component_dirs(info_provider.interfaces_info['component_dirs'])
# Creates a Jinja context from an IDL file.
def process_idl_file(self, idl_filename):
definitions = self._reader.read_idl_definitions(idl_filename)
base_name, _ = os.path.splitext(os.path.basename(idl_filename))
for component in definitions:
target_definitions = definitions[component]
interfaces = target_definitions.interfaces
if base_name in interfaces.keys():
interface = interfaces[base_name]
self._process_interface(interface, component, interfaces)
# Creates a Jinja context from an interface. Some interfaces are not used
# in V8 context snapshot, so we can skip them.
def _process_interface(self, interface, component, interfaces):
def has_impl(interface):
if interface.name in WHITE_LIST_INTERFACES:
return True
# Non legacy callback interface does not provide V8 callbacks.
if interface.is_callback:
return len(interface.constants) > 0
if 'RuntimeEnabled' in interface.extended_attributes:
return False
return True
if not has_impl(interface):
return
context_builder = InterfaceTemplateContextBuilder(self._opts, self._info_provider)
context = context_builder.create_interface_context(interface, interfaces)
name = '%s%s' % (interface.name, 'Partial' if interface.is_partial else '')
self._interface_contexts[name] = context
include_file = 'bindings/%s/v8/%s.h' % (component, context['v8_name'])
self._include_files.add(include_file)
# Gathers all interface-dependent information and returns as a Jinja template context.
def _create_template_context(self):
interfaces = []
for name in sorted(self._interface_contexts):
interfaces.append(self._interface_contexts[name])
return {
'class': 'V8ContextSnapshotExternalReferences',
'interfaces': interfaces,
'include_files': sorted(list(self._include_files)),
}
# Applies a Jinja template on a context and generates a C++ code.
def generate(self):
jinja_env = initialize_jinja_env(self._opts.cache_dir)
context = self._create_template_context()
cpp_template = jinja_env.get_template(TEMPLATE_FILE)
cpp_text = cpp_template.render(context)
return cpp_text
