| #!/usr/bin/env python |
| # Copyright (c) 2014 Apple 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 |
| # in the documentation and/or other materials provided with the |
| # distribution. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| # 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. |
| |
| import os.path |
| import re |
| import sys |
| import string |
| from string import Template |
| import optparse |
| import logging |
| from CodeGeneratorReplayInputsTemplates import Templates |
| |
| try: |
| import json |
| except ImportError: |
| import simplejson as json |
| |
| # Configuration values are first looked up in the framework configuration, |
| # and then in the global configuration if there is no framework-specific value. |
| GLOBAL_CONFIG = { |
| "baseFilename": "ReplayInputs", |
| "guardCondition": "ENABLE(WEB_REPLAY)", |
| "traitsFrameworkName": "JavaScriptCore", |
| |
| # These are formatted as ([allowed_frameworks], (framework, header_path)). |
| # The generator can figure out how to format the includes. |
| "headerIncludes": [ |
| (["WebCore"], |
| ("WebCore", "replay/EventLoopInput.h") |
| ), |
| (["JavaScriptCore", "WebCore"], |
| ("JavaScriptCore", "replay/EncodedValue.h") |
| ), |
| (["JavaScriptCore"], |
| ("JavaScriptCore", "replay/NondeterministicInput.h") |
| ), |
| (["JavaScriptCore", "WebCore"], |
| ("WTF", "wtf/TypeCasts.h") |
| ), |
| (["WebCore"], |
| ("WTF", "wtf/text/WTFString.h") |
| ), |
| |
| # Testing fixtures. |
| (["Test"], |
| ("WebCore", "platform/ExternalNamespaceHeaderIncludeDummy.h") |
| ), |
| (["Test"], |
| ("Test", "platform/InternalNamespaceHeaderIncludeDummy.h") |
| ) |
| ], |
| |
| "implIncludes": [ |
| (["WebCore"], |
| ("WebCore", "replay/SerializationMethods.h") |
| ), |
| (["WebCore", "JavaScriptCore"], |
| ("JavaScriptCore", "inspector/InspectorValues.h") |
| ), |
| (["WebCore", "JavaScriptCore"], |
| ("WTF", "wtf/NeverDestroyed.h") |
| ), |
| |
| # Testing fixtures. |
| (["Test"], |
| ("WebCore", "platform/ExternalNamespaceImplIncludeDummy.h") |
| ), |
| (["Test"], |
| ("Test", "platform/InternalNamespaceImplIncludeDummy.h") |
| ) |
| ], |
| } |
| |
| FRAMEWORK_CONFIG_MAP = { |
| "Global": { |
| "prefix": "", |
| "namespace": "" |
| }, |
| |
| "WTF": { |
| "prefix": "WTF", |
| "namespace": "WTF", |
| }, |
| "JavaScriptCore": { |
| "prefix": "JS", |
| "namespace": "JSC", |
| "exportMacro": "JS_EXPORT_PRIVATE", |
| }, |
| "WebCore": { |
| "prefix": "Web", |
| "namespace": "WebCore", |
| "exportMacro": "WEBCORE_EXPORT" |
| }, |
| # Used for bindings tests. |
| "Test": { |
| "prefix": "Test", |
| "namespace": "Test", |
| "exportMacro": "TEST_EXPORT_MACRO" |
| } |
| } |
| |
| # These settings are specific to an input queue. |
| QUEUE_CONFIG_MAP = { |
| "SCRIPT_MEMOIZED": { |
| "enumValue": "ScriptMemoizedData", |
| "baseClass": "NondeterministicInput<%s>", |
| }, |
| "LOADER_MEMOIZED": { |
| "enumValue": "LoaderMemoizedData", |
| "baseClass": "NondeterministicInput<%s>", |
| }, |
| "EVENT_LOOP": { |
| "enumValue": "EventLoopInput", |
| "baseClass": "EventLoopInput<%s>", |
| }, |
| } |
| |
| # Use a global logger, which normally only logs errors. |
| # It can be configured to log debug messages from the CLI. |
| logging.basicConfig(format='%(levelname)s: %(message)s', level=logging.ERROR) |
| log = logging.getLogger('global') |
| |
| |
| # Model classes, which transliterate JSON input. |
| class ParseException(Exception): |
| pass |
| |
| |
| class TypecheckException(Exception): |
| pass |
| |
| |
| class Framework: |
| def __init__(self, name): |
| self._settings = FRAMEWORK_CONFIG_MAP[name] |
| self.name = name |
| |
| def setting(self, key, default=''): |
| return self._settings.get(key, default) |
| |
| @staticmethod |
| def fromString(frameworkString): |
| if frameworkString == "Global": |
| return Frameworks.Global |
| |
| if frameworkString == "WTF": |
| return Frameworks.WTF |
| |
| if frameworkString == "JavaScriptCore": |
| return Frameworks.JavaScriptCore |
| |
| if frameworkString == "WebCore": |
| return Frameworks.WebCore |
| |
| if frameworkString == "Test": |
| return Frameworks.Test |
| |
| raise ParseException("Unknown framework: " + frameworkString) |
| |
| |
| class Frameworks: |
| Global = Framework("Global") |
| WTF = Framework("WTF") |
| JavaScriptCore = Framework("JavaScriptCore") |
| WebCore = Framework("WebCore") |
| Test = Framework("Test") |
| |
| |
| class InputQueue: |
| def __init__(self, settings): |
| self._settings = settings |
| |
| def setting(self, key, default=''): |
| return self._settings.get(key, default) |
| |
| @staticmethod |
| def fromString(queueString): |
| if queueString == "SCRIPT_MEMOIZED": |
| return InputQueues.SCRIPT_MEMOIZED |
| |
| if queueString == "LOADER_MEMOIZED": |
| return InputQueues.LOADER_MEMOIZED |
| |
| if queueString == "EVENT_LOOP": |
| return InputQueues.EVENT_LOOP |
| |
| raise ParseException("Unknown input queue: " + queueString) |
| |
| |
| class InputQueues: |
| SCRIPT_MEMOIZED = InputQueue(QUEUE_CONFIG_MAP["SCRIPT_MEMOIZED"]) |
| LOADER_MEMOIZED = InputQueue(QUEUE_CONFIG_MAP["LOADER_MEMOIZED"]) |
| EVENT_LOOP = InputQueue(QUEUE_CONFIG_MAP["EVENT_LOOP"]) |
| |
| |
| class Input: |
| def __init__(self, name, description, framework, queueString, flags, guard=None): |
| self.name = name |
| self.description = description |
| self.framework = framework |
| self.queue = InputQueue.fromString(queueString) |
| self._flags = flags |
| self.guard = guard |
| self.members = [] # names should be unique, but ordered. |
| |
| def setting(self, key, default=''): |
| if key in self._flags: |
| return True |
| |
| return self.queue.setting(key, default) |
| |
| |
| class InputMember: |
| def __init__(self, memberName, typeName, flags=[]): |
| self.memberName = memberName |
| self.typeName = typeName |
| self._flags = flags |
| |
| def has_flag(self, key, default=''): |
| return key in self._flags |
| |
| |
| class TypeMode: |
| def __init__(self, name): |
| self._name = name |
| |
| @staticmethod |
| def fromString(modeString): |
| modeString = modeString.upper() |
| if modeString == 'SCALAR': |
| return TypeModes.SCALAR |
| if modeString == 'HEAVY_SCALAR': |
| return TypeModes.HEAVY_SCALAR |
| if modeString == 'OWNED': |
| return TypeModes.OWNED |
| if modeString == 'SHARED': |
| return TypeModes.SHARED |
| if modeString == 'VECTOR': |
| return TypeModes.VECTOR |
| |
| raise ParseException("Unknown type mode: " + modeString) |
| |
| |
| class TypeModes: |
| # Copy for assignment and for getter |
| SCALAR = TypeMode("SCALAR") |
| # Copy for assignment, pass by reference for getter |
| HEAVY_SCALAR = TypeMode("HEAVY_SCALAR") |
| # Move for assignment, pass by reference for getter |
| OWNED = TypeMode("OWNED") |
| # Copy a RefPtr for assignment and getter |
| SHARED = TypeMode("SHARED") |
| # Move operator for assignment, pass by reference for getter |
| VECTOR = TypeMode("VECTOR") |
| |
| |
| class Type: |
| def __init__(self, name, mode, framework, header, enclosing_class, values, guard_values_map, underlying_storage, flags, guard=None): |
| self._name = name |
| self.mode = mode |
| self.framework = framework |
| self.header = header |
| self.enclosing_class = enclosing_class |
| self.values = values |
| self.guard_values_map = guard_values_map |
| self.underlying_storage = underlying_storage |
| self._flags = flags |
| self.guard = guard |
| |
| def __eq__(self, other): |
| return self.type_name() == other.type_name() and self.mode == other.mode |
| |
| def __hash__(self): |
| return self._name.__hash__() |
| |
| def has_flag(self, flagString): |
| return flagString in self._flags |
| |
| def is_struct(self): |
| return self.has_flag("STRUCT") |
| |
| def is_enum(self): |
| return self.has_flag("ENUM") |
| |
| def is_enum_class(self): |
| return self.has_flag("ENUM_CLASS") |
| |
| def declaration_kind(self): |
| if self.is_enum(): |
| return "enum" |
| elif self.is_enum_class(): |
| return "enum class" |
| elif self.is_struct(): |
| return "struct" |
| else: |
| return "class" |
| |
| def qualified_prefix(self): |
| components = [] |
| if self.framework != Frameworks.Global: |
| components.append(self.framework.setting('namespace')) |
| if self.enclosing_class is not None: |
| components.append(self.enclosing_class) |
| components.append("") |
| return "::".join(components) |
| |
| def type_name(self, qualified=False): |
| if qualified: |
| return "%s%s" % (self.qualified_prefix(), self._name) |
| elif self.enclosing_class is not None: |
| return "%s::%s" % (self.enclosing_class, self._name) |
| else: |
| return self._name |
| |
| def storage_type(self, qualified=False): |
| if self.mode == TypeModes.OWNED: |
| return "std::unique_ptr<%s>" % self.type_name(qualified) |
| elif self.mode == TypeModes.SHARED: |
| return "RefPtr<%s>" % self.type_name(qualified) |
| else: |
| return self.type_name(qualified) |
| |
| def borrow_type(self, qualified=False): |
| if self.mode == TypeModes.SCALAR: |
| return self.type_name(qualified) |
| elif self.mode == TypeModes.SHARED: |
| return "RefPtr<%s>" % self.type_name(qualified) |
| else: |
| return "const %s&" % self.type_name(qualified) |
| |
| def argument_type(self, qualified=False): |
| if self.mode == TypeModes.SHARED: |
| return "RefPtr<%s>&&" % self.type_name(qualified) |
| else: |
| return self.storage_type() |
| |
| def encoding_type_argument(self, qualified=False): |
| return self.type_name(qualified=qualified) |
| |
| |
| def check_for_required_properties(props, obj, what): |
| for prop in props: |
| if prop not in obj: |
| raise ParseException("When parsing %s, required property missing: %s" % (what, prop)) |
| |
| |
| class VectorType(Type): |
| def __init__(self, element_type): |
| self._element_type = element_type |
| self.mode = TypeModes.VECTOR |
| self.framework = element_type.framework |
| self.enclosing_class = None |
| |
| def has_flag(self): |
| return False |
| |
| def is_struct(self): |
| return False |
| |
| def is_enum(self): |
| return False |
| |
| def is_enum_class(self): |
| return False |
| |
| def qualified_prefix(self): |
| return "" |
| |
| def type_name(self, qualified=False): |
| return "Vector<%s>" % self._element_type.storage_type(qualified=qualified) |
| |
| def encoding_type_argument(self, qualified=False): |
| return "Vector<%s>" % self._element_type.type_name(qualified=qualified) |
| |
| def argument_type(self, qualified=False): |
| return self.type_name(qualified=qualified) + "&" |
| |
| |
| class InputsModel: |
| def __init__(self): |
| self.inputs = [] |
| self.types = [] |
| |
| # Types have associated frameworks and are in their namespace, but within the specification |
| # file types are in a flat namespace. Types with the same name are not allowed. |
| self.types_by_name = {} |
| self.inputs_by_name = {} |
| |
| def enum_types(self): |
| _enums = filter(lambda x: x.is_enum() or x.is_enum_class(), self.types) |
| return sorted(_enums, key=lambda _enum: _enum.type_name()) |
| |
| def get_type_for_member(self, member): |
| if member.has_flag("VECTOR"): |
| return VectorType(self.types_by_name.get(member.typeName)) |
| else: |
| return self.types_by_name.get(member.typeName) |
| |
| def parse_specification(self, json): |
| if 'types' in json: |
| if not isinstance(json['types'], dict): |
| raise ParseException("Malformed specification: types is not a dict of framework->type list") |
| |
| for framework_name, type_list in json['types'].iteritems(): |
| if not isinstance(type_list, list): |
| raise ParseException("Malformed specification: type list for framework %s is not a list" % framework_name) |
| |
| framework = Framework.fromString(framework_name) |
| for _type in type_list: |
| self.parse_type_with_framework(_type, framework) |
| |
| if 'inputs' in json: |
| if not isinstance(json['inputs'], dict): |
| raise ParseException("Malformed specification: inputs is not a dict of framework->input list") |
| |
| for framework_name, input_list in json['inputs'].iteritems(): |
| if not isinstance(input_list, list): |
| raise ParseException("Malformed specification: input list for framework %s is not a list" % framework_name) |
| |
| framework = Framework.fromString(framework_name) |
| for _input in input_list: |
| self.parse_input_with_framework(_input, framework) |
| |
| def parse_type_with_framework(self, json, framework): |
| check_for_required_properties(['name', 'mode'], json, 'type') |
| if framework is not Frameworks.Global: |
| check_for_required_properties(['header'], json, 'non-global type') |
| |
| type_name = json['name'] |
| type_mode = TypeMode.fromString(json['mode']) |
| header = json.get('header') |
| enclosing_class = json.get('enclosing_class') |
| enum_values = json.get('values') |
| guarded_enum_values = json.get('guarded_values', {}) |
| type_storage = json.get('storage') |
| type_flags = json.get('flags', []) |
| guard = json.get('guard', None) |
| _type = Type(type_name, type_mode, framework, header, enclosing_class, enum_values, guarded_enum_values, type_storage, type_flags, guard) |
| if _type.is_enum() or _type.is_enum_class(): |
| check_for_required_properties(['values'], json, 'enum') |
| if not isinstance(json['values'], list) or len(_type.values) == 0: |
| raise ParseException("Malformed specification: enum %s does not supply a list of values" % type_name) |
| |
| if _type.is_enum() and enclosing_class is None and type_storage is None: |
| raise ParseException("Could not parse enum %s: C-style enums not enclosed by a class must specify their storage type so they can be forward declared." % type_name) |
| |
| self.types.append(_type) |
| |
| def parse_input_with_framework(self, json, framework): |
| check_for_required_properties(['name', 'description', 'queue', 'members'], json, 'input') |
| _input = Input(json['name'], json['description'], framework, json['queue'], json.get('flags', []), json.get('guard')) |
| if isinstance(json['members'], list): |
| for member in json['members']: |
| check_for_required_properties(['name', 'type'], member, 'member') |
| _input.members.append(InputMember(member['name'], member['type'], member.get('flags', []))) |
| |
| self.inputs.append(_input) |
| |
| # Types cannot (yet) reference other types, so we can check references in one pass. |
| def resolve_types(self): |
| for _type in self.types: |
| self.typecheck_type(_type) |
| |
| for _input in self.inputs: |
| self.typecheck_input(_input) |
| |
| def typecheck_type(self, _type): |
| log.debug("typecheck type " + _type.type_name()) |
| |
| if _type.type_name() in self.types_by_name: |
| raise TypecheckException("Duplicate type with name: " + _type.type_name()) |
| |
| self.types_by_name[_type.type_name()] = _type |
| |
| def typecheck_input(self, _input): |
| log.debug("typecheck input " + _input.name) |
| |
| if _input.name in self.inputs_by_name: |
| raise TypecheckException("Duplicate input with name: " + _input.name) |
| |
| seen_members = {} |
| |
| for member in _input.members: |
| if member.memberName in seen_members: |
| raise TypecheckException("Duplicate input member with name: " + member.memberName) |
| |
| self.typecheck_input_member(member, _input) |
| seen_members[member.memberName] = member |
| |
| self.inputs_by_name[_input.name] = _input |
| |
| def typecheck_input_member(self, input_member, _input): |
| log.debug("typecheck member '%s' of '%s'" % (input_member.memberName, _input.name)) |
| |
| if not input_member.typeName in self.types_by_name: |
| raise TypecheckException("Unknown type '%s' referenced by member '%s' of input '%s'" % (input_member.typeName, input_member.memberName, _input.name)) |
| |
| |
| # A writer that only updates file if it actually changed. |
| class IncrementalFileWriter: |
| def __init__(self, filepath, force_output): |
| self._filepath = filepath |
| self._output = "" |
| self.force_output = force_output |
| |
| def write(self, text): |
| self._output += text |
| |
| def close(self): |
| text_changed = True |
| self._output = self._output.rstrip() + "\n" |
| |
| try: |
| read_file = open(self._filepath, "r") |
| old_text = read_file.read() |
| read_file.close() |
| text_changed = old_text != self._output |
| except: |
| # Ignore, just overwrite by default |
| pass |
| |
| if text_changed or self.force_output: |
| out_file = open(self._filepath, "w") |
| out_file.write(self._output) |
| out_file.close() |
| |
| |
| def wrap_with_guard(contents, condition=None): |
| if condition is None: |
| return contents |
| |
| return "\n".join([ |
| "#if %s" % condition, |
| contents, |
| "#endif // %s" % condition |
| ]) |
| |
| |
| class Generator: |
| def __init__(self, model, target_framework_name, input_filepath, output_prefix): |
| self._model = model |
| self.target_framework = Framework.fromString(target_framework_name) |
| self.traits_framework = Framework.fromString(self.setting('traitsFrameworkName')) |
| self._input_filepath = input_filepath |
| self._output_prefix = output_prefix |
| |
| def setting(self, key, default=''): |
| return self.target_framework.setting(key, GLOBAL_CONFIG.get(key, default)) |
| |
| def should_generate_item(self, item): |
| return item.framework is self.target_framework |
| |
| # This does not account for any filename mangling performed on behalf of the test harness. |
| def output_filename(self, extension=None): |
| components = [] |
| if len(self._output_prefix) > 0: |
| components.extend([self._output_prefix, '-']) |
| |
| components.extend([self.setting('prefix'), self.setting('baseFilename')]) |
| |
| if extension is not None: |
| components.extend(['.', extension]) |
| |
| return "".join(components) |
| |
| def write_output_files(self, _dir, force=False): |
| header_file = IncrementalFileWriter(os.path.join(_dir, self.output_filename('h')), force) |
| implementation_file = IncrementalFileWriter(os.path.join(_dir, self.output_filename('cpp')), force) |
| |
| header_file.write(self.generate_header()) |
| implementation_file.write(self.generate_implementation()) |
| |
| header_file.close() |
| implementation_file.close() |
| |
| def generate_header(self): |
| enums_to_generate = filter(self.should_generate_item, self._model.enum_types()) |
| inputs_to_generate = filter(self.should_generate_item, self._model.inputs) |
| |
| template_arguments = { |
| 'licenseBlock': self.generate_license(), |
| 'headerGuard': re.sub('[-./]', '_', self.output_filename() + ".h"), |
| 'filename': self.output_filename(), |
| 'guardCondition': self.setting('guardCondition'), |
| 'traitsNamespace': self.traits_framework.setting('namespace'), |
| 'inputsNamespace': self.target_framework.setting('namespace'), |
| 'includes': self.generate_includes(defaults=self.setting('headerIncludes')), |
| 'typeForwardDeclarations': self.generate_type_forward_declarations(), |
| 'inputForwardDeclarations': "\n".join([wrap_with_guard("class %s;", _input.guard) % _input.name for _input in inputs_to_generate]), |
| 'inputClassDeclarations': "\n\n".join([self.generate_class_declaration(_input) for _input in inputs_to_generate]), |
| 'inputTraitDeclarations': "\n\n".join([self.generate_input_trait_declaration(_input) for _input in inputs_to_generate]), |
| 'inputTypeTraitDeclarations': "\n\n".join([self.generate_input_type_trait_declaration(_input) for _input in inputs_to_generate]), |
| 'enumTraitDeclarations': "\n\n".join([wrap_with_guard(self.generate_enum_trait_declaration(_type), _type.guard) for _type in enums_to_generate]), |
| 'forEachMacro': self.generate_for_each_macro(), |
| } |
| |
| return Template(Templates.HeaderSkeleton).substitute(template_arguments) |
| |
| def generate_implementation(self): |
| enums_to_generate = filter(self.should_generate_item, self._model.enum_types()) |
| inputs_to_generate = filter(self.should_generate_item, self._model.inputs) |
| |
| template_arguments = { |
| 'licenseBlock': self.generate_license(), |
| 'filename': self.output_filename(), |
| 'guardCondition': self.setting('guardCondition'), |
| 'traitsNamespace': self.traits_framework.setting('namespace'), |
| 'inputsNamespace': self.target_framework.setting('namespace'), |
| 'includes': self.generate_includes(defaults=self.setting('implIncludes'), includes_for_types=True), |
| 'inputClassImplementations': "\n\n".join([self.generate_class_implementation(_input) for _input in inputs_to_generate]), |
| 'inputTraitImplementations': "\n\n".join([self.generate_input_trait_implementation(_input) for _input in inputs_to_generate]), |
| 'enumTraitImplementations': "\n\n".join([wrap_with_guard(self.generate_enum_trait_implementation(_type), _type.guard) for _type in enums_to_generate]), |
| } |
| |
| return Template(Templates.ImplementationSkeleton).substitute(template_arguments) |
| |
| def generate_license(self): |
| return Template(Templates.CopyrightBlock).substitute(None, inputFilename=os.path.basename(self._input_filepath)) |
| |
| def generate_includes(self, defaults=[], includes_for_types=False): |
| lines = set() |
| |
| for _type in self._model.types: |
| # Types in the "global" framework are implicitly declared and available in all namespaces. |
| if _type.framework is Frameworks.Global: |
| continue |
| # For RefCounted types, we reverse when to include the header so that the destructor can be |
| # used in the header file. |
| include_for_destructor = _type.mode is TypeModes.SHARED |
| # Enums within classes cannot be forward declared, so we include |
| # headers with the relevant class declaration. |
| include_for_enclosing_class = _type.enclosing_class is not None |
| # Include headers for types like URL and String which are copied, not owned or shared. |
| include_for_copyable_member = _type.mode is TypeModes.HEAVY_SCALAR |
| if (not includes_for_types) ^ (include_for_destructor or include_for_enclosing_class or include_for_copyable_member): |
| continue |
| |
| if self.target_framework != _type.framework: |
| lines.add("#include <%s>" % _type.header) |
| else: |
| lines.add("#include \"%s\"" % os.path.basename(_type.header)) |
| |
| for entry in defaults: |
| (allowed_framework_names, data) = entry |
| (framework_name, header_path) = data |
| |
| if self.target_framework.name not in allowed_framework_names: |
| continue |
| if self.target_framework.name != framework_name: |
| lines.add("#include <%s>" % header_path) |
| else: |
| lines.add("#include \"%s\"" % os.path.basename(header_path)) |
| |
| return "\n".join(sorted(list(lines))) |
| |
| def generate_type_forward_declarations(self): |
| lines = [] |
| |
| decls_by_framework = {} |
| frameworks = [Framework.fromString(s) for s in FRAMEWORK_CONFIG_MAP.keys() if s != Frameworks.Global.name] |
| for framework in frameworks: |
| decls_by_framework[framework] = [] |
| |
| for _type in self._model.types: |
| if _type.framework not in frameworks: |
| continue |
| if _type.enclosing_class is not None: |
| continue |
| if _type.mode == TypeModes.HEAVY_SCALAR: |
| continue |
| if _type.mode == TypeModes.SCALAR and not (_type.is_enum() or _type.is_enum_class()): |
| continue |
| if _type.is_enum(): |
| declaration = "enum %s : %s;" % (_type.type_name(), _type.underlying_storage) |
| else: |
| declaration = "%s %s;" % (_type.declaration_kind(), _type.type_name()) |
| decls_by_framework[_type.framework].append(declaration) |
| |
| # Declare all namespaces explicitly, even if it's the main namespace. |
| for framework in frameworks: |
| if len(decls_by_framework[framework]) == 0: |
| continue |
| |
| decls_by_framework[framework].sort() |
| lines.append("namespace %s {" % framework.setting('namespace')) |
| lines.extend(decls_by_framework[framework]) |
| lines.append("}") |
| lines.append("") |
| |
| return "\n".join(lines) |
| |
| def generate_class_declaration(self, _input): |
| extra_declarations = [] |
| if _input.queue == InputQueues.EVENT_LOOP: |
| extra_declarations.extend([ |
| "", |
| " // EventLoopInput API", |
| " virtual void dispatch(ReplayController&) override final;", |
| ]) |
| |
| if _input.setting('CREATE_FROM_PAGE'): |
| extra_declarations.extend([ |
| " static std::unique_ptr<%s> createFromPage(const Page&);" % _input.name |
| ]) |
| |
| member_getters = [self.generate_input_member_getter(_member) for _member in _input.members] |
| |
| member_declarations = [self.generate_input_member_declaration(_member) for _member in _input.members] |
| if len(member_declarations) > 0: |
| member_declarations.insert(0, "private:") |
| |
| template_arguments = { |
| 'inputConstructor': self.generate_input_constructor_declaration(_input), |
| 'inputDestructor': self.generate_input_destructor_declaration(_input), |
| 'inputName': _input.name, |
| 'inputQueue': _input.setting('enumValue'), |
| 'baseClass': _input.setting('baseClass') % _input.name, |
| 'extraDeclarations': "\n".join(extra_declarations), |
| 'memberGetters': "\n".join(member_getters), |
| 'memberDeclarations': "\n".join(member_declarations), |
| } |
| |
| return wrap_with_guard(Template(Templates.InputClassDeclaration).substitute(template_arguments), _input.guard) |
| |
| def generate_input_constructor_declaration(self, _input): |
| formals_list = self.generate_constructor_formals_list(_input) |
| terms = [] |
| if self.setting('exportMacro'): |
| terms.append(self.setting('exportMacro')) |
| terms.append("%s(%s)" % (_input.name, formals_list)) |
| return " %s;" % " ".join(terms) |
| |
| def generate_input_destructor_declaration(self, _input): |
| return " virtual ~%s();" % _input.name |
| |
| def generate_input_member_getter(self, _member): |
| member_type = self._model.get_type_for_member(_member) |
| return " %s %s() const { return %s; }" % (member_type.borrow_type(), _member.memberName, self.generate_member_borrow_expression(_member)) |
| |
| def generate_input_member_declaration(self, _member): |
| member_type = self._model.get_type_for_member(_member) |
| return " %s m_%s;" % (member_type.storage_type(), _member.memberName) |
| |
| def generate_input_member_tuples(self, _input): |
| return [(_member, self._model.get_type_for_member(_member)) for _member in _input.members] |
| |
| def qualified_input_name(self, _input, forceQualified=False): |
| if forceQualified or self.target_framework != self.traits_framework: |
| return "%s::%s" % (self.target_framework.setting('namespace'), _input.name) |
| else: |
| return _input.name |
| |
| def generate_input_trait_declaration(self, _input): |
| decl_type = ['struct'] |
| if len(self.setting('exportMacro')) > 0: |
| decl_type.append(self.setting('exportMacro')) |
| |
| template_arguments = { |
| 'structOrClass': " ".join(decl_type), |
| 'queueType': _input.queue.setting('enumValue'), |
| 'qualifiedInputName': self.qualified_input_name(_input), |
| } |
| |
| return wrap_with_guard(Template(Templates.InputTraitsDeclaration).substitute(template_arguments), _input.guard) |
| |
| def generate_input_type_trait_declaration(self, _input): |
| template_arguments = { |
| 'qualifiedInputName': self.qualified_input_name(_input, forceQualified=True), |
| } |
| |
| return wrap_with_guard(Template(Templates.InputTypeTraitsDeclaration).substitute(template_arguments), _input.guard) |
| |
| def generate_enum_trait_declaration(self, _type): |
| decl_type = ['struct'] |
| if len(self.setting('exportMacro')) > 0: |
| decl_type.append(self.setting('exportMacro')) |
| |
| should_qualify_type = _type.framework != self.traits_framework |
| template = Templates.EnumTraitDeclaration if _type.is_enum() else Templates.EnumClassTraitDeclaration |
| template_arguments = { |
| 'encodingTypeArgument': _type.encoding_type_argument(qualified=should_qualify_type), |
| 'enumType': _type.type_name(qualified=should_qualify_type), |
| 'structOrClass': " ".join(decl_type) |
| } |
| return Template(template).substitute(template_arguments) |
| |
| def generate_for_each_macro(self): |
| inputs_to_generate = filter(self.should_generate_item, self._model.inputs) |
| |
| macro_name = "%s_REPLAY_INPUT_NAMES_FOR_EACH" % self.setting('prefix').upper() |
| lines = [] |
| lines.append("#define %s(macro) \\" % macro_name) |
| lines.extend([" macro(%s) \\" % _input.name for _input in inputs_to_generate]) |
| lines.append(" \\") |
| lines.append("// end of %s" % macro_name) |
| return "\n".join(lines) |
| |
| def generate_class_implementation(self, _input): |
| template_arguments = { |
| 'inputName': _input.name, |
| 'inputsNamespace': self.target_framework.setting('namespace'), |
| 'initializerList': self.generate_constructor_initializer_list(_input), |
| 'constructorFormalsList': self.generate_constructor_formals_list(_input), |
| } |
| |
| return wrap_with_guard(Template(Templates.InputClassImplementation).substitute(template_arguments), _input.guard) |
| |
| def generate_enum_trait_implementation(self, _type): |
| should_qualify_type = _type.framework != self.traits_framework |
| prefix_components = [] |
| if should_qualify_type: |
| prefix_components.append(_type.framework.setting('namespace')) |
| if _type.is_enum() and _type.enclosing_class is not None: |
| prefix_components.append(_type.enclosing_class) |
| elif _type.is_enum_class(): |
| prefix_components.append(_type.type_name(qualified=False)) |
| prefix_components.append("") |
| enum_prefix = "::".join(prefix_components) |
| encodeLines = [] |
| |
| if _type.is_enum(): |
| encode_template = Templates.EnumEncodeCase |
| decode_template = Templates.EnumDecodeCase |
| enum_trait_template = Templates.EnumTraitImplementation |
| else: |
| encode_template = Templates.EnumClassEncodeCase |
| decode_template = Templates.EnumClassDecodeCase |
| enum_trait_template = Templates.EnumClassTraitImplementation |
| |
| # Generate body for encode. |
| for _value in _type.values: |
| template_arguments = { |
| 'enumStringValue': _value, |
| 'qualifiedEnumValue': "%s%s" % (enum_prefix, _value), |
| } |
| encodeLines.append(Template(encode_template).substitute(template_arguments)) |
| |
| for guard, guard_values in _type.guard_values_map.iteritems(): |
| guardedLines = [] |
| for guard_value in guard_values: |
| template_arguments = { |
| 'enumStringValue': guard_value, |
| 'qualifiedEnumValue': "%s%s" % (enum_prefix, guard_value), |
| } |
| guardedLines.append(Template(encode_template).substitute(template_arguments)) |
| encodeLines.append(wrap_with_guard("\n".join(guardedLines), guard)) |
| |
| # Generate body for decode. |
| decodeLines = [] |
| for i, _value in enumerate(_type.values): |
| |
| template_arguments = { |
| 'branchKeyword': "else if" if i > 0 else "if", |
| 'enumStringValue': _value, |
| 'qualifiedEnumValue': "%s%s" % (enum_prefix, _value), |
| 'qualifiedEnumName': _type.type_name(qualified=should_qualify_type) |
| } |
| decodeLines.append(Template(decode_template).substitute(template_arguments)) |
| |
| for guard, guard_values in _type.guard_values_map.iteritems(): |
| guardedLines = [] |
| for i, guard_value in enumerate(guard_values): |
| template_arguments = { |
| 'branchKeyword': "else if" if i > 0 else "if", |
| 'enumStringValue': guard_value, |
| 'qualifiedEnumValue': "%s%s" % (enum_prefix, guard_value), |
| 'qualifiedEnumName': _type.type_name(qualified=should_qualify_type) |
| } |
| guardedLines.append(Template(decode_template).substitute(template_arguments)) |
| decodeLines.append(wrap_with_guard("\n".join(guardedLines), guard)) |
| |
| template_arguments = { |
| 'encodingTypeArgument': _type.encoding_type_argument(qualified=should_qualify_type), |
| 'enumType': _type.type_name(qualified=should_qualify_type), |
| 'encodeCases': "\n".join(encodeLines), |
| 'decodeCases': "\n".join(decodeLines) |
| } |
| |
| return Template(enum_trait_template).substitute(template_arguments) |
| |
| def generate_input_trait_implementation(self, _input): |
| template_arguments = { |
| 'inputsNamespace': self.target_framework.setting('namespace'), |
| 'inputNameStringLiteral': '"%s"' % _input.name, |
| 'qualifiedInputName': self.qualified_input_name(_input), |
| 'constructorArguments': self.generate_constructor_arguments_list(_input), |
| 'constructorFormalsList': self.generate_constructor_formals_list(_input), |
| 'encodeSteps': self.generate_input_encode_implementation(_input), |
| 'decodeSteps': self.generate_input_decode_implementation(_input), |
| } |
| return wrap_with_guard(Template(Templates.InputTraitsImplementation).substitute(template_arguments), _input.guard) |
| |
| def generate_input_encode_implementation(self, _input): |
| steps = [] |
| for (_member, _type) in self.generate_input_member_tuples(_input): |
| should_qualify_type = _type.framework != self.traits_framework |
| put_method = "put<%s>" % _type.encoding_type_argument(qualified=should_qualify_type) |
| |
| steps.extend([ |
| " encodedValue.%s(ASCIILiteral(\"%s\"), input.%s());" % (put_method, _member.memberName, _member.memberName) |
| ]) |
| |
| if len(steps) == 0: |
| steps.extend([ |
| " UNUSED_PARAM(encodedValue);", |
| " UNUSED_PARAM(input);", |
| ]) |
| |
| return "\n".join(steps) |
| |
| def generate_input_decode_implementation(self, _input): |
| steps = [] |
| for (_member, _type) in self.generate_input_member_tuples(_input): |
| should_qualify_type = _type.framework != self.traits_framework |
| get_method = "get<%s>" % _type.encoding_type_argument(qualified=should_qualify_type) |
| |
| lines = [ |
| " %s %s;" % (_type.storage_type(qualified=should_qualify_type), _member.memberName), |
| " if (!encodedValue.%s(ASCIILiteral(\"%s\"), %s))" % (get_method, _member.memberName, _member.memberName), |
| " return false;", |
| "" |
| ] |
| |
| steps.append("\n".join(lines)) |
| |
| if len(steps) == 0: |
| steps.extend([ |
| " UNUSED_PARAM(encodedValue);", |
| ]) |
| |
| return "\n".join(steps) |
| |
| def generate_constructor_initializer_list(self, _input): |
| initializers = [] |
| initializers.append(" : %s()" % (_input.setting('baseClass') % _input.name)) |
| for _member in _input.members: |
| initializers.append(" , m_%s(%s)" % (_member.memberName, self.generate_member_move_expression(_member))) |
| |
| return "\n".join(initializers) |
| |
| def generate_constructor_formals_list(self, _input): |
| member_tuples = self.generate_input_member_tuples(_input) |
| return ", ".join(["%s %s" % (_type.argument_type(), _member.memberName) for (_member, _type) in member_tuples]) |
| |
| def generate_member_borrow_expression(self, _member): |
| _type = self._model.get_type_for_member(_member) |
| expression = "m_%s" % _member.memberName |
| if _type.mode == TypeModes.OWNED: |
| expression = "*" + expression |
| |
| return expression |
| |
| def generate_member_move_expression(self, _member): |
| _type = self._model.get_type_for_member(_member) |
| if _type.mode in [TypeModes.OWNED, TypeModes.SHARED]: |
| return "WTF::move(%s)" % _member.memberName |
| else: |
| return _member.memberName |
| |
| def generate_constructor_arguments_list(self, _input): |
| return ", ".join([self.generate_member_move_expression(_member) for _member in _input.members]) |
| |
| |
| def generate_from_specifications(input_filepaths=[], output_prefix="", output_dirpath=None, framework_name=None, force_output=False): |
| |
| if not framework_name in FRAMEWORK_CONFIG_MAP: |
| raise ParseException("Unknown or unsupported framework name supplied: " + framework_name) |
| |
| if len(input_filepaths) == 0: |
| raise ParseException("Must provide at least one specification file, none were provided.") |
| |
| def parse_json_from_file(input_filepath): |
| try: |
| with open(input_filepath, "r") as input_file: |
| return json.load(input_file) |
| except ValueError as e: |
| raise Exception("Error parsing valid JSON in file: " + input_filepath) |
| |
| specifications = map(parse_json_from_file, input_filepaths) |
| |
| model = InputsModel() |
| for spec in specifications: |
| model.parse_specification(spec) |
| |
| model.resolve_types() |
| generator = Generator(model, framework_name, input_filepaths[0], output_prefix) |
| |
| generator.write_output_files(output_dirpath, force_output) |
| |
| |
| if __name__ == '__main__': |
| allowed_framework_names = FRAMEWORK_CONFIG_MAP.keys() |
| |
| cli_parser = optparse.OptionParser(usage="usage: %prog [options] <Inputs.json> [, <MoreInputs.json> ]") |
| cli_parser.add_option("-o", "--outputDir", help="Directory where generated files should be written.") |
| cli_parser.add_option("--framework", type="choice", choices=allowed_framework_names, help="The framework these inputs belong to.") # JavaScriptCore, WebCore |
| cli_parser.add_option("--force", action="store_true", help="Force output of generated scripts, even if nothing changed.") |
| cli_parser.add_option("-v", "--debug", action="store_true", help="Log extra output for debugging the generator itself.") |
| cli_parser.add_option("-t", "--test", action="store_true", help="Enable test mode. Use unique output filenames created by prepending the input filename.") |
| |
| options = None |
| |
| arg_options, arg_values = cli_parser.parse_args() |
| |
| if not arg_options.outputDir: |
| raise ParseException("Missing output directory") |
| |
| if arg_options.debug: |
| log.setLevel(logging.DEBUG) |
| |
| options = { |
| 'input_filepaths': arg_values, |
| 'output_dirpath': arg_options.outputDir, |
| 'output_prefix': os.path.basename(arg_values[0]) if arg_options.test else "", |
| 'framework_name': arg_options.framework, |
| 'force_output': arg_options.force |
| } |
| |
| try: |
| generate_from_specifications(**options) |
| except (ParseException, TypecheckException) as e: |
| if arg_options.test: |
| log.error(e.message) |
| else: |
| raise e # Force the build to fail. |
