class MakeMediaFeaturesWriter(json5_generator.Writer): default_metadata = { 'namespace': '', 'export': '', } filters = { 'symbol': media_feature_symbol.getMediaFeatureSymbolWithSuffix(''), 'to_macro_style': name_utilities.to_macro_style, 'upper_first_letter': name_utilities.upper_first_letter, } def __init__(self, json5_file_path): super(MakeMediaFeaturesWriter, self).__init__(json5_file_path) self._outputs = { ('MediaFeatures.h'): self.generate_header, } self._template_context = { 'entries': self.json5_file.name_dictionaries, } @template_expander.use_jinja('MediaFeatures.h.tmpl', filters=filters) def generate_header(self): return self._template_context if __name__ == '__main__': json5_generator.Maker(MakeMediaFeaturesWriter).main()
keyword for keyword in self._value_keywords if keyword['mode'] == mode ] @gperf.use_jinja_gperf_template( 'core/css/templates/css_value_keywords.cc.tmpl', ['-Q', 'CSSValueStringPool']) def generate_implementation(self): keyword_offsets = [] current_offset = 0 for keyword in self._value_keywords: keyword_offsets.append(current_offset) current_offset += len(keyword["name"].original) + 1 return { 'value_keywords': self._value_keywords, 'value_keyword_offsets': keyword_offsets, 'ua_sheet_mode_values_keywords': self._value_keywords_with_mode('UASheet'), 'quirks_mode_or_ua_sheet_mode_values_keywords': self._value_keywords_with_mode('QuirksOrUASheet'), 'gperf_path': self.gperf_path, } if __name__ == "__main__": json5_generator.Maker(CSSValueKeywordsWriter).main()
filters=filters) def generate_factory_implementation(self): return self._template_context def _interface(self, tag): if tag['interfaceName']: return tag['interfaceName'] name = tag['tokenized_name'].to_upper_camel_case() # FIXME: We shouldn't hard-code HTML here. if name == 'HTML': name = 'Html' return '%s%sElement' % (self.namespace, name) def _js_interface(self, tag): if tag['JSInterfaceName']: return tag['JSInterfaceName'] return self._interface(tag) def _has_js_interface(self, tag): return not tag['noConstructor'] and self._js_interface(tag) != ( '%sElement' % self.namespace) def _interface_header_dir(self, tag): if tag['interfaceHeaderDir']: return tag['interfaceHeaderDir'] return 'third_party/blink/renderer/core/' + self.namespace.lower() if __name__ == "__main__": json5_generator.Maker(MakeElementFactoryWriter).main()
yield "core/css/css_primitive_value_mappings.h" elif property_['converter'] == "CSSIdentifierValue": yield "core/css/css_identifier_value.h" else: yield "core/css/css_primitive_value_mappings.h" yield "core/css/resolver/style_builder_converter.h" if property_['font']: yield "core/css/resolver/font_builder.h" elif property_['svg']: yield "core/css/css_primitive_value_mappings.h" yield "core/style/computed_style.h" yield "core/style/svg_computed_style.h" else: yield "core/style/computed_style.h" if ('style_builder_template_args' in property_ and property_['style_builder_template_args'].get('modifier_type') in ['Width', 'Slice', 'Outset']): yield "core/css/properties/style_building_utils.h" if property_.get('style_builder_template') in [ 'animation', 'background_layer', 'counter', 'mask_layer', 'transition' ]: yield "core/css/css_value_list.h" if property_.get('style_builder_template') in ['counter']: yield "core/css/css_value_pair.h" yield "core/css/css_custom_ident_value.h" if __name__ == '__main__': json5_generator.Maker(CSSPropertiesWriter).main()
output_dir) self._tags = {} for entry in self.json5_file.name_dictionaries: self._tags[entry['name'].original] = entry['name'].original self._namespace = self.json5_file.metadata['namespace'].strip('"') basename = self._namespace.lower() + '_element_lookup_trie' self._outputs = { (basename + '.h'): self.generate_header, (basename + '.cc'): self.generate_implementation, } @template_expander.use_jinja('templates/element_lookup_trie.h.tmpl') def generate_header(self): return { 'input_files': self._input_files, 'namespace': self._namespace, } @template_expander.use_jinja('templates/element_lookup_trie.cc.tmpl', filters=filters) def generate_implementation(self): return { 'input_files': self._input_files, 'namespace': self._namespace, 'length_tries': trie_builder.trie_list_by_str_length(self._tags) } if __name__ == '__main__': json5_generator.Maker(ElementLookupTrieWriter).main()
class InternalRuntimeFlagsWriter(make_runtime_features.RuntimeFeatureWriter): def __init__(self, json5_file_path, output_dir): super(InternalRuntimeFlagsWriter, self).__init__(json5_file_path, output_dir) self._outputs = { 'internal_runtime_flags.idl': self.generate_idl, 'internal_runtime_flags.h': self.generate_header, } @template_expander.use_jinja('templates/internal_runtime_flags.idl.tmpl') def generate_idl(self): return { 'features': self._features, 'input_files': self._input_files, 'standard_features': self._standard_features, } @template_expander.use_jinja('templates/internal_runtime_flags.h.tmpl') def generate_header(self): return { 'features': self._features, 'feature_sets': self._feature_sets(), 'input_files': self._input_files, 'standard_features': self._standard_features, 'header_guard': self._header_guard, } if __name__ == '__main__': json5_generator.Maker(InternalRuntimeFlagsWriter).main()
# Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. import json5_generator import make_runtime_features import template_expander # We want exactly the same parsing as RuntimeFeatureWriter but generate # different files. class OriginTrialsWriter(make_runtime_features.BaseRuntimeFeatureWriter): file_basename = 'web_origin_trials' def __init__(self, json5_file_path, output_dir): super(OriginTrialsWriter, self).__init__(json5_file_path, output_dir) self._outputs = { (self.file_basename + '.cc'): self.generate_implementation, } @template_expander.use_jinja('templates/' + file_basename + '.cc.tmpl') def generate_implementation(self): return { 'features': self._features, 'origin_trial_features': self._origin_trial_features, 'input_files': self._input_files, } if __name__ == '__main__': json5_generator.Maker(OriginTrialsWriter).main()
("api_class value for " + property_['api_class'] + " should be None, True or a string") return property_['api_class'] @template_expander.use_jinja( 'core/css/properties/templates/CSSPropertyAPI.h.tmpl') def generate_property_api_header(self): return { 'input_files': self._input_files, 'api_classnames': self._api_classes, 'api_classes_by_property_id': self._api_classes_by_property_id, } @template_expander.use_jinja( 'core/css/properties/templates/CSSPropertyAPI.cpp.tmpl') def generate_property_api_implementation(self): return { 'input_files': self._input_files, 'api_classnames': self._api_classes, 'api_classes_by_property_id': self._api_classes_by_property_id, 'last_property_id': (self._first_enum_value + len(self._properties) - 1) } if __name__ == '__main__': json5_generator.Maker(CSSPropertyAPIWriter).main()
property_['longhands']) for longhand in property_['longhand_property_ids']: self._longhand_dictionary[longhand].append(property_) for longhands in self._longhand_dictionary.values(): # Sort first by number of longhands in decreasing order, then # alphabetically longhands.sort(key=lambda property_: (-len(property_[ 'longhand_property_ids']), property_['name'])) @template_expander.use_jinja( 'core/css/templates/style_property_shorthand.cc.tmpl') def generate_style_property_shorthand_cpp(self): return { 'input_files': self._input_files, 'properties': self._shorthands, 'longhands_dictionary': self._longhand_dictionary, } @template_expander.use_jinja( 'core/css/templates/style_property_shorthand.h.tmpl') def generate_style_property_shorthand_h(self): return { 'input_files': self._input_files, 'properties': self._shorthands, } if __name__ == '__main__': json5_generator.Maker(StylePropertyShorthandWriter).main()
@template_expander.use_jinja('templates/style_builder_functions.h.tmpl', filters=filters) def generate_style_builder_functions_h(self): return { 'input_files': self._input_files, 'properties': self._properties, } @template_expander.use_jinja('templates/style_builder_functions.cc.tmpl', filters=filters) def generate_style_builder_functions_cpp(self): return { 'input_files': self._input_files, 'properties': self._properties, 'properties_by_id': self._json5_properties.properties_by_id, } @template_expander.use_jinja('templates/style_builder.cc.tmpl', filters=filters) def generate_style_builder(self): return { 'input_files': self._input_files, 'properties': self._properties, 'properties_by_id': self._json5_properties.properties_by_id, } if __name__ == '__main__': json5_generator.Maker(StyleBuilderWriter).main()
namespace_uri, 'tags': self.tags_json5_file.name_dictionaries if self.tags_json5_file else [], 'this_include_path': qualified_header, 'use_namespace_for_attrs': use_namespace_for_attrs, } def _metadata(self, name): metadata = self.attrs_json5_file.metadata[name].strip('"') if self.tags_json5_file: assert metadata == self.tags_json5_file.metadata[name].strip( '"'), 'Both files must have the same %s.' % name return metadata @template_expander.use_jinja('templates/make_qualified_names.h.tmpl', filters=filters) def generate_header(self): return self._template_context @template_expander.use_jinja('templates/make_qualified_names.cc.tmpl', filters=filters) def generate_implementation(self): return self._template_context if __name__ == "__main__": json5_generator.Maker(MakeQualifiedNamesWriter).main()
namespace = self.json5_file.metadata['namespace'].strip('"') suffix = self.json5_file.metadata['suffix'].strip('"') export = self.json5_file.metadata['export'].strip('"') assert namespace, 'A namespace is required.' self._outputs = { (namespace + suffix + 'Names.h'): self.generate_header, (namespace + suffix + 'Names.cpp'): self.generate_implementation, } self._template_context = { 'namespace': namespace, 'suffix': suffix, 'export': export, 'entries': self.json5_file.name_dictionaries, 'in_files': self.json5_file.file_paths, } @template_expander.use_jinja("MakeNames.h.tmpl", filters=filters) def generate_header(self): return self._template_context @template_expander.use_jinja("MakeNames.cpp.tmpl", filters=filters) def generate_implementation(self): return self._template_context if __name__ == "__main__": json5_generator.Maker(MakeNamesWriter).main()
def get_attributes(properties): attributes = get_camel_cased_attributes(properties) + \ get_webkit_cased_attributes(properties) + \ get_dashed_attributes(properties) assert len(set(attributes)) == len(attributes), \ 'There should be no overlap between the attribute categories' return attributes class CSSStyleDeclarationAttributeIDLWriter(json5_generator.Writer): def __init__(self, json5_file_paths, output_dir): super(CSSStyleDeclarationAttributeIDLWriter, self).__init__([], output_dir) assert len(json5_file_paths) == 3,\ ('CSSStyleDeclarationAttributeIDLWriter requires 3 input json5 ' + 'files, got {}.'.format(len(json5_file_paths))) properties = css_properties.CSSProperties(json5_file_paths) self._attributes = get_attributes(properties.supported_properties) self._outputs = {} self._outputs[OUT_IDL] = self.generate_attributes_idl @template_expander.use_jinja('core/css/templates/%s.tmpl' % OUT_IDL) def generate_attributes_idl(self): return {'attributes': self._attributes} if __name__ == '__main__': json5_generator.Maker(CSSStyleDeclarationAttributeIDLWriter).main()
for offset, descriptor in enumerate(self._descriptors): descriptor['enum_value'] = first_descriptor_id + offset self._character_offsets.append(chars_used) chars_used += len(descriptor['name'].original) self._longest_name_length = max(len(descriptor['name'].original), len(descriptor['alias']), self._longest_name_length) @template_expander.use_jinja( 'core/css/parser/templates/at_rule_descriptors.h.tmpl') def generate_header(self): return { 'descriptors': self._descriptors, 'descriptors_count': self._descriptors_count } @gperf.use_jinja_gperf_template( 'core/css/parser/templates/at_rule_descriptors.cc.tmpl') def generate_implementation(self): return { 'descriptors': self._descriptors, 'descriptor_offsets': self._character_offsets, 'descriptors_count': len(self._descriptors), 'longest_name_length': self._longest_name_length, 'gperf_path': self.gperf_path } if __name__ == '__main__': json5_generator.Maker(AtRuleNamesWriter).main()
# Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. import sys import json5_generator import trie_builder import template_expander class UnitTrieWriter(json5_generator.Writer): def __init__(self, json5_file_paths): super(UnitTrieWriter, self).__init__(json5_file_paths) self._units = {entry['name']: entry['unit_type'] for entry in self.json5_file.name_dictionaries} self._outputs = { 'CSSPrimitiveValueUnitTrie.cpp': self.generate_implementation } @template_expander.use_jinja('templates/CSSPrimitiveValueUnitTrie.cpp.tmpl') def generate_implementation(self): return { 'input_files': self._input_files, 'length_tries': trie_builder.trie_list_by_str_length(self._units) } if __name__ == '__main__': json5_generator.Maker(UnitTrieWriter).main()
runtime_to_document_policy_map[dependency].append( feature['name']) self._outputs = { self.file_basename + '.cc': template_expander.use_jinja( 'templates/' + self.file_basename + '.cc.tmpl')(lambda: { 'header_guard': self.make_header_guard(self._relative_output_dir + self. file_basename + '.h'), 'input_files': self._input_files, 'feature_policy_features': feature_policy_features, 'document_policy_features': document_policy_features, 'fp_origin_trial_dependency_map': fp_origin_trial_dependency_map, 'dp_origin_trial_dependency_map': dp_origin_trial_dependency_map, 'runtime_to_feature_policy_map': runtime_to_feature_policy_map, 'runtime_to_document_policy_map': runtime_to_document_policy_map }), } if __name__ == '__main__': json5_generator.Maker(FeaturePolicyFeatureWriter).main()
'include_paths': self._include_paths, 'computed_style': self._root_group, 'diff_functions_map': self._diff_functions_map, } @template_expander.use_jinja('templates/ComputedStyleBase.cpp.tmpl', tests={ 'in': lambda a, b: a in b }) def generate_base_computed_style_cpp(self): return { 'input_files': self._input_files, 'properties': self._properties, 'enums': self._generated_enums, 'include_paths': self._include_paths, 'computed_style': self._root_group, 'diff_functions_map': self._diff_functions_map, } @template_expander.use_jinja('templates/ComputedStyleBaseConstants.h.tmpl') def generate_base_computed_style_constants(self): return { 'input_files': self._input_files, 'properties': self._properties, 'enums': self._generated_enums, } if __name__ == '__main__': json5_generator.Maker(ComputedStyleBaseWriter).main()
tag['js_interface'] = tag['JSInterfaceName'] elements.add(tag['js_interface']) for tag in tags: tag['multipleTagNames'] = (interface_counts[tag['interface']] > 1 or tag['interface'] == self.fallback_interface) @template_expander.use_jinja("templates/element_type_helpers.h.tmpl", filters=filters) def generate_helper_header(self): return self._template_context @template_expander.use_jinja("templates/element_type_helpers.cc.tmpl", filters=filters) def generate_helper_implementation(self): return self._template_context def _interface(self, tag): if tag['interfaceName']: return tag['interfaceName'] name = tag['name'].to_upper_camel_case() # FIXME: We shouldn't hard-code HTML here. if name == 'HTML': name = 'Html' return '%s%sElement' % (self.namespace, name) if __name__ == "__main__": json5_generator.Maker(MakeElementTypeHelpersWriter).main()
def _headers_header_includes(self, entries): includes = { 'third_party/blink/renderer/core/execution_context/execution_context.h', 'third_party/blink/renderer/core/frame/deprecation.h', 'third_party/blink/renderer/platform/instrumentation/use_counter.h', 'third_party/blink/renderer/platform/runtime_enabled_features.h', } includes.update(map(self._headers_header_include_path, entries)) return sorted([x for x in includes if x]) @template_expander.use_jinja('templates/event_factory.cc.tmpl', filters=filters) def generate_implementation(self): target_events = [ event for event in self.json5_file.name_dictionaries if (create_event_ignore_case_list(event['name'].original) or create_event_ignore_case_and_measure_list(event['name'].original)) ] return { 'include_header_paths': self._headers_header_includes(target_events), 'input_files': self._input_files, 'suffix': self.suffix, 'events': target_events, } if __name__ == "__main__": json5_generator.Maker(EventFactoryWriter).main()
def generate_implementation(self): return self._template_inputs() class RuntimeFeatureTestHelpersWriter(BaseRuntimeFeatureWriter): class_name = 'ScopedRuntimeEnabledFeatureForTest' file_basename = 'runtime_enabled_features_test_helpers' def __init__(self, json5_file_path, output_dir): super(RuntimeFeatureTestHelpersWriter, self).__init__(json5_file_path, output_dir) self._outputs = { ('testing/' + self.file_basename + '.h'): self.generate_header } def _template_inputs(self): return { 'features': self._features, 'input_files': self._input_files, 'header_guard': self._header_guard, } @template_expander.use_jinja('templates/' + file_basename + '.h.tmpl') def generate_header(self): return self._template_inputs() if __name__ == '__main__': json5_generator.Maker(RuntimeFeatureWriter).main() json5_generator.Maker(RuntimeFeatureTestHelpersWriter).main()
self.json5_file.name_dictionaries.sort(key=lambda entry: entry['name']) self._outputs = { ('InternalSettingsGenerated.h'): self.generate_header, ('InternalSettingsGenerated.cpp'): self.generate_implementation, ('InternalSettingsGenerated.idl'): self.generate_idl, } self._template_context = { 'settings': self.json5_file.name_dictionaries, } @template_expander.use_jinja('InternalSettingsGenerated.h.tmpl', filters=filters) def generate_header(self): return self._template_context @template_expander.use_jinja('InternalSettingsGenerated.cpp.tmpl', filters=filters) def generate_implementation(self): return self._template_context @template_expander.use_jinja('InternalSettingsGenerated.idl.tmpl', filters=filters) def generate_idl(self): return self._template_context if __name__ == '__main__': json5_generator.Maker(MakeInternalSettingsWriter).main()
for single_type in property_['typedom_types']: types.append(single_type) property_['typedom_types'] = types # Generate CSSValueID values from keywords. property_['keywordIDs'] = map(enum_key_for_css_keyword, property_['keywords']) self._outputs = { 'cssom_types.cc': self.generate_types, 'cssom_keywords.cc': self.generate_keywords, } @template_expander.use_jinja('core/css/templates/cssom_types.cc.tmpl') def generate_types(self): return { 'input_files': self._input_files, 'properties': self._properties, } @template_expander.use_jinja('core/css/templates/cssom_keywords.cc.tmpl') def generate_keywords(self): return { 'input_files': self._input_files, 'properties': self._properties, } if __name__ == '__main__': json5_generator.Maker(CSSOMTypesWriter).main()
filters = { 'lower_first': lower_first, } def __init__(self, json5_file_path): super(CSSPropertyMetadataWriter, self).__init__(json5_file_path) self._outputs = { 'CSSPropertyMetadata.cpp': self.generate_css_property_metadata_cpp } @template_expander.use_jinja('CSSPropertyMetadata.cpp.tmpl', filters=filters) def generate_css_property_metadata_cpp(self): return { 'properties_including_aliases': self._properties_including_aliases, 'switches': [ ('is_descriptor', 'isDescriptor'), ('is_property', 'isProperty'), ('interpolable', 'isInterpolableProperty'), ('inherited', 'isInheritedProperty'), ('supports_percentage', 'propertySupportsPercentage'), ], 'first_enum_value': self._first_enum_value, } if __name__ == '__main__': json5_generator.Maker(CSSPropertyMetadataWriter).main()
# found in the LICENSE file. import json5_generator import template_expander from make_document_policy_features_util import parse_default_value class DocumentPolicyFeatureWriter(json5_generator.Writer): file_basename = 'document_policy_features' def __init__(self, json5_file_path, output_dir): super(DocumentPolicyFeatureWriter, self).__init__(json5_file_path, output_dir) @template_expander.use_jinja('templates/' + self.file_basename + '.cc.tmpl') def generate_implementation(): return { 'input_files': self._input_files, 'features': self.json5_file.name_dictionaries, 'parse_default_value': parse_default_value } self._outputs = { self.file_basename + '.cc': generate_implementation, } if __name__ == '__main__': json5_generator.Maker(DocumentPolicyFeatureWriter).main()