| # Copyright 2016 The Chromium Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| # pylint: disable=import-error,print-statement,relative-import |
| """Plumbing for a Jinja-based code generator, including CodeGeneratorBase, a base class for all generators.""" |
| |
| from __future__ import print_function |
| |
| import os |
| import posixpath |
| import re |
| import sys |
| |
| from idl_types import set_ancestors, IdlType |
| from itertools import groupby |
| from v8_globals import includes |
| from v8_interface import constant_filters |
| from v8_types import set_component_dirs |
| from v8_methods import method_filters |
| from v8_utilities import capitalize |
| from utilities import (idl_filename_to_component, |
| is_valid_component_dependency, format_remove_duplicates, |
| format_blink_cpp_source_code, to_snake_case, |
| normalize_path) |
| import v8_utilities |
| |
| # Path handling for libraries and templates |
| # Paths have to be normalized because Jinja uses the exact template path to |
| # determine the hash used in the cache filename, and we need a pre-caching step |
| # to be concurrency-safe. Use absolute path because __file__ is absolute if |
| # module is imported, and relative if executed directly. |
| # If paths differ between pre-caching and individual file compilation, the cache |
| # is regenerated, which causes a race condition and breaks concurrent build, |
| # since some compile processes will try to read the partially written cache. |
| MODULE_PATH, _ = os.path.split(os.path.realpath(__file__)) |
| THIRD_PARTY_DIR = os.path.normpath( |
| os.path.join(MODULE_PATH, os.pardir, os.pardir, os.pardir, os.pardir)) |
| TEMPLATES_DIR = os.path.normpath( |
| os.path.join(MODULE_PATH, os.pardir, 'templates')) |
| |
| # jinja2 is in chromium's third_party directory. |
| # Insert at 1 so at front to override system libraries, and |
| # after path[0] == invoking script dir |
| sys.path.insert(1, THIRD_PARTY_DIR) |
| import jinja2 |
| from jinja2.filters import make_attrgetter, environmentfilter |
| |
| |
| def generate_indented_conditional(code, conditional): |
| # Indent if statement to level of original code |
| indent = re.match(' *', code).group(0) |
| return ('%sif (%s) {\n' % (indent, conditional) + |
| ' %s\n' % '\n '.join(code.splitlines()) + '%s}\n' % indent) |
| |
| |
| # [Exposed] |
| def exposed_if(code, exposed_test): |
| if not exposed_test: |
| return code |
| return generate_indented_conditional( |
| code, 'execution_context && (%s)' % exposed_test) |
| |
| |
| # [SecureContext] |
| def secure_context_if(code, secure_context_test): |
| if secure_context_test is None: |
| return code |
| return generate_indented_conditional(code, secure_context_test) |
| |
| |
| # [RuntimeEnabled] |
| def origin_trial_enabled_if(code, |
| origin_trial_feature_name, |
| execution_context=None): |
| if not origin_trial_feature_name: |
| return code |
| |
| function = v8_utilities.origin_trial_function_call( |
| origin_trial_feature_name, execution_context) |
| return generate_indented_conditional(code, function) |
| |
| |
| # [RuntimeEnabled] |
| def runtime_enabled_if(code, name): |
| if not name: |
| return code |
| |
| function = v8_utilities.runtime_enabled_function(name) |
| return generate_indented_conditional(code, function) |
| |
| |
| @environmentfilter |
| def do_stringify_key_group_by(environment, value, attribute): |
| expr = make_attrgetter(environment, attribute) |
| key = lambda item: '' if expr(item) is None else str(expr(item)) |
| return groupby(sorted(value, key=key), expr) |
| |
| |
| def initialize_jinja_env(cache_dir): |
| jinja_env = jinja2.Environment( |
| loader=jinja2.FileSystemLoader(TEMPLATES_DIR), |
| # 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) |
| jinja_env.filters.update({ |
| 'blink_capitalize': |
| capitalize, |
| 'exposed': |
| exposed_if, |
| 'format_blink_cpp_source_code': |
| format_blink_cpp_source_code, |
| 'format_remove_duplicates': |
| format_remove_duplicates, |
| 'origin_trial_enabled': |
| origin_trial_enabled_if, |
| 'runtime_enabled': |
| runtime_enabled_if, |
| 'runtime_enabled_function': |
| v8_utilities.runtime_enabled_function, |
| 'secure_context': |
| secure_context_if |
| }) |
| jinja_env.filters.update(constant_filters()) |
| jinja_env.filters.update(method_filters()) |
| jinja_env.filters["stringifykeygroupby"] = do_stringify_key_group_by |
| return jinja_env |
| |
| |
| _BLINK_RELATIVE_PATH_PREFIXES = ('bindings/', 'core/', 'modules/', 'platform/') |
| |
| |
| def normalize_and_sort_includes(include_paths): |
| normalized_include_paths = set() |
| for include_path in include_paths: |
| match = re.search(r'/gen/(third_party/blink/.*)$', |
| posixpath.abspath(include_path)) |
| if match: |
| include_path = match.group(1) |
| elif include_path.startswith(_BLINK_RELATIVE_PATH_PREFIXES): |
| include_path = 'third_party/blink/renderer/' + include_path |
| normalized_include_paths.add(include_path) |
| return sorted(normalized_include_paths) |
| |
| |
| def render_template(template, context): |
| filename = str(template.filename) |
| filename = filename[filename.rfind('third_party'):] |
| filename = normalize_path(filename) |
| |
| context['jinja_template_filename'] = filename |
| return template.render(context) |
| |
| |
| class CodeGeneratorBase(object): |
| """Base class for jinja-powered jinja template generation. |
| """ |
| |
| def __init__(self, generator_name, info_provider, cache_dir, output_dir): |
| self.generator_name = generator_name |
| self.info_provider = info_provider |
| self.jinja_env = initialize_jinja_env(cache_dir) |
| self.output_dir = output_dir |
| self.set_global_type_info() |
| |
| def should_generate_code(self, definitions): |
| return definitions.interfaces or definitions.dictionaries |
| |
| def set_global_type_info(self): |
| interfaces_info = self.info_provider.interfaces_info |
| set_ancestors(interfaces_info['ancestors']) |
| IdlType.set_callback_interfaces(interfaces_info['callback_interfaces']) |
| IdlType.set_dictionaries(interfaces_info['dictionaries']) |
| IdlType.set_enums(self.info_provider.enumerations) |
| IdlType.set_callback_functions(self.info_provider.callback_functions) |
| IdlType.set_implemented_as_interfaces( |
| interfaces_info['implemented_as_interfaces']) |
| IdlType.set_garbage_collected_types( |
| interfaces_info['garbage_collected_interfaces']) |
| IdlType.set_garbage_collected_types(interfaces_info['dictionaries']) |
| set_component_dirs(interfaces_info['component_dirs']) |
| |
| def render_templates(self, |
| include_paths, |
| header_template, |
| cpp_template, |
| context, |
| component=None): |
| context['code_generator'] = self.generator_name |
| |
| # Add includes for any dependencies |
| for include_path in include_paths: |
| if component: |
| dependency = idl_filename_to_component(include_path) |
| assert is_valid_component_dependency(component, dependency) |
| includes.add(include_path) |
| |
| cpp_includes = set(context.get('cpp_includes', [])) |
| context['cpp_includes'] = normalize_and_sort_includes(cpp_includes |
| | includes) |
| context['header_includes'] = normalize_and_sort_includes( |
| context['header_includes']) |
| |
| header_text = render_template(header_template, context) |
| cpp_text = render_template(cpp_template, context) |
| return header_text, cpp_text |
| |
| def generate_code(self, definitions, definition_name): |
| """Invokes code generation. The [definitions] argument is a list of definitions, |
| and the [definition_name] is the name of the definition |
| """ |
| # This should be implemented in subclasses. |
| raise NotImplementedError() |
| |
| def normalize_this_header_path(self, header_path): |
| header_path = normalize_path(header_path) |
| match = re.search('(third_party/blink/.*)$', header_path) |
| assert match, 'Unkown style of path to output: ' + header_path |
| return match.group(1) |
| |
| |
| def main(argv): |
| # If file itself executed, cache templates |
| try: |
| cache_dir = argv[1] |
| dummy_filename = argv[2] |
| except IndexError: |
| print('Usage: %s CACHE_DIR DUMMY_FILENAME' % argv[0]) |
| return 1 |
| |
| # Cache templates |
| jinja_env = initialize_jinja_env(cache_dir) |
| template_filenames = [ |
| filename for filename in os.listdir(TEMPLATES_DIR) |
| # Skip .svn, directories, etc. |
| if filename.endswith(('.tmpl', '.txt')) |
| ] |
| for template_filename in 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)) |
