1 files changed, 549 insertions, 0 deletions
diff --git a/deps/v8/build/fuchsia/fidlgen_js/fidl.py b/deps/v8/build/fuchsia/fidlgen_js/fidl.py
new file mode 100644
index 0000000000..6f8b99f441
--- /dev/null
+++ b/deps/v8/build/fuchsia/fidlgen_js/fidl.py
@@ -0,0 +1,549 @@
+# Copyright 2018 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.
+
+# This was generated (and can be regenerated) by pasting
+# zircon/system/host/fidl/schema.json from Fuchsia into
+# https://app.quicktype.io and choosing Python 2.7 output. The only manual
+# change is to modify the import path for Enum.
+
+from third_party.enum34 import Enum
+
+
+def from_str(x):
+    assert isinstance(x, (str, unicode))
+    return x
+
+
+def from_int(x):
+    assert isinstance(x, int) and not isinstance(x, bool)
+    return x
+
+
+def from_none(x):
+    assert x is None
+    return x
+
+
+def from_union(fs, x):
+    for f in fs:
+        try:
+            return f(x)
+        except:
+            pass
+    assert False
+
+
+def from_bool(x):
+    assert isinstance(x, bool)
+    return x
+
+
+def to_class(c, x):
+    assert isinstance(x, c)
+    return x.to_dict()
+
+
+def to_enum(c, x):
+    assert isinstance(x, c)
+    return x.value
+
+
+def from_list(f, x):
+    assert isinstance(x, list)
+    return [f(y) for y in x]
+
+
+def from_dict(f, x):
+    assert isinstance(x, dict)
+    return { k: f(v) for (k, v) in x.items() }
+
+
+class Attribute:
+    def __init__(self, name, value):
+        self.name = name
+        self.value = value
+
+    @staticmethod
+    def from_dict(obj):
+        assert isinstance(obj, dict)
+        name = from_str(obj.get(u"name"))
+        value = from_str(obj.get(u"value"))
+        return Attribute(name, value)
+
+    def to_dict(self):
+        result = {}
+        result[u"name"] = from_str(self.name)
+        result[u"value"] = from_str(self.value)
+        return result
+
+
+class TypeKind(Enum):
+    ARRAY = u"array"
+    HANDLE = u"handle"
+    IDENTIFIER = u"identifier"
+    PRIMITIVE = u"primitive"
+    REQUEST = u"request"
+    STRING = u"string"
+    VECTOR = u"vector"
+
+
+class TypeClass:
+    def __init__(self, element_count, element_type, kind, maybe_element_count, nullable, subtype, identifier):
+        self.element_count = element_count
+        self.element_type = element_type
+        self.kind = kind
+        self.maybe_element_count = maybe_element_count
+        self.nullable = nullable
+        self.subtype = subtype
+        self.identifier = identifier
+
+    @staticmethod
+    def from_dict(obj):
+        assert isinstance(obj, dict)
+        element_count = from_union([from_int, from_none], obj.get(u"element_count"))
+        element_type = from_union([TypeClass.from_dict, from_none], obj.get(u"element_type"))
+        kind = TypeKind(obj.get(u"kind"))
+        maybe_element_count = from_union([from_int, from_none], obj.get(u"maybe_element_count"))
+        nullable = from_union([from_bool, from_none], obj.get(u"nullable"))
+        subtype = from_union([from_str, from_none], obj.get(u"subtype"))
+        identifier = from_union([from_str, from_none], obj.get(u"identifier"))
+        return TypeClass(element_count, element_type, kind, maybe_element_count, nullable, subtype, identifier)
+
+    def to_dict(self):
+        result = {}
+        result[u"element_count"] = from_union([from_int, from_none], self.element_count)
+        result[u"element_type"] = from_union([lambda x: to_class(TypeClass, x), from_none], self.element_type)
+        result[u"kind"] = to_enum(TypeKind, self.kind)
+        result[u"maybe_element_count"] = from_union([from_int, from_none], self.maybe_element_count)
+        result[u"nullable"] = from_union([from_bool, from_none], self.nullable)
+        result[u"subtype"] = from_union([from_str, from_none], self.subtype)
+        result[u"identifier"] = from_union([from_str, from_none], self.identifier)
+        return result
+
+
+class ConstantKind(Enum):
+    IDENTIFIER = u"identifier"
+    LITERAL = u"literal"
+
+
+class LiteralKind(Enum):
+    DEFAULT = u"default"
+    FALSE = u"false"
+    NUMERIC = u"numeric"
+    STRING = u"string"
+    TRUE = u"true"
+
+
+class Literal:
+    def __init__(self, kind, value):
+        self.kind = kind
+        self.value = value
+
+    @staticmethod
+    def from_dict(obj):
+        assert isinstance(obj, dict)
+        kind = LiteralKind(obj.get(u"kind"))
+        value = from_union([from_str, from_none], obj.get(u"value"))
+        return Literal(kind, value)
+
+    def to_dict(self):
+        result = {}
+        result[u"kind"] = to_enum(LiteralKind, self.kind)
+        result[u"value"] = from_union([from_str, from_none], self.value)
+        return result
+
+
+class Constant:
+    def __init__(self, identifier, kind, literal):
+        self.identifier = identifier
+        self.kind = kind
+        self.literal = literal
+
+    @staticmethod
+    def from_dict(obj):
+        assert isinstance(obj, dict)
+        identifier = from_union([from_str, from_none], obj.get(u"identifier"))
+        kind = ConstantKind(obj.get(u"kind"))
+        literal = from_union([Literal.from_dict, from_none], obj.get(u"literal"))
+        return Constant(identifier, kind, literal)
+
+    def to_dict(self):
+        result = {}
+        result[u"identifier"] = from_union([from_str, from_none], self.identifier)
+        result[u"kind"] = to_enum(ConstantKind, self.kind)
+        result[u"literal"] = from_union([lambda x: to_class(Literal, x), from_none], self.literal)
+        return result
+
+
+class Const:
+    def __init__(self, maybe_attributes, name, type, value):
+        self.maybe_attributes = maybe_attributes
+        self.name = name
+        self.type = type
+        self.value = value
+
+    @staticmethod
+    def from_dict(obj):
+        assert isinstance(obj, dict)
+        maybe_attributes = from_union([lambda x: from_list(Attribute.from_dict, x), from_none], obj.get(u"maybe_attributes"))
+        name = from_str(obj.get(u"name"))
+        type = TypeClass.from_dict(obj.get(u"type"))
+        value = Constant.from_dict(obj.get(u"value"))
+        return Const(maybe_attributes, name, type, value)
+
+    def to_dict(self):
+        result = {}
+        result[u"maybe_attributes"] = from_union([lambda x: from_list(lambda x: to_class(Attribute, x), x), from_none], self.maybe_attributes)
+        result[u"name"] = from_str(self.name)
+        result[u"type"] = to_class(TypeClass, self.type)
+        result[u"value"] = to_class(Constant, self.value)
+        return result
+
+
+class DeclarationsMap(Enum):
+    CONST = u"const"
+    ENUM = u"enum"
+    INTERFACE = u"interface"
+    STRUCT = u"struct"
+    UNION = u"union"
+
+
+class EnumMember:
+    def __init__(self, name, value):
+        self.name = name
+        self.value = value
+
+    @staticmethod
+    def from_dict(obj):
+        assert isinstance(obj, dict)
+        name = from_str(obj.get(u"name"))
+        value = Constant.from_dict(obj.get(u"value"))
+        return EnumMember(name, value)
+
+    def to_dict(self):
+        result = {}
+        result[u"name"] = from_str(self.name)
+        result[u"value"] = to_class(Constant, self.value)
+        return result
+
+
+class IntegerType(Enum):
+    INT16 = u"int16"
+    INT32 = u"int32"
+    INT64 = u"int64"
+    INT8 = u"int8"
+    UINT16 = u"uint16"
+    UINT32 = u"uint32"
+    UINT64 = u"uint64"
+    UINT8 = u"uint8"
+
+
+class EnumDeclarationElement:
+    def __init__(self, maybe_attributes, members, name, type):
+        self.maybe_attributes = maybe_attributes
+        self.members = members
+        self.name = name
+        self.type = type
+
+    @staticmethod
+    def from_dict(obj):
+        assert isinstance(obj, dict)
+        maybe_attributes = from_union([lambda x: from_list(Attribute.from_dict, x), from_none], obj.get(u"maybe_attributes"))
+        members = from_list(EnumMember.from_dict, obj.get(u"members"))
+        name = from_str(obj.get(u"name"))
+        type = IntegerType(obj.get(u"type"))
+        return EnumDeclarationElement(maybe_attributes, members, name, type)
+
+    def to_dict(self):
+        result = {}
+        result[u"maybe_attributes"] = from_union([lambda x: from_list(lambda x: to_class(Attribute, x), x), from_none], self.maybe_attributes)
+        result[u"members"] = from_list(lambda x: to_class(EnumMember, x), self.members)
+        result[u"name"] = from_str(self.name)
+        result[u"type"] = to_enum(IntegerType, self.type)
+        return result
+
+
+class InterfaceMethodParameter:
+    def __init__(self, alignment, name, offset, size, type):
+        self.alignment = alignment
+        self.name = name
+        self.offset = offset
+        self.size = size
+        self.type = type
+
+    @staticmethod
+    def from_dict(obj):
+        assert isinstance(obj, dict)
+        alignment = from_int(obj.get(u"alignment"))
+        name = from_str(obj.get(u"name"))
+        offset = from_int(obj.get(u"offset"))
+        size = from_int(obj.get(u"size"))
+        type = TypeClass.from_dict(obj.get(u"type"))
+        return InterfaceMethodParameter(alignment, name, offset, size, type)
+
+    def to_dict(self):
+        result = {}
+        result[u"alignment"] = from_int(self.alignment)
+        result[u"name"] = from_str(self.name)
+        result[u"offset"] = from_int(self.offset)
+        result[u"size"] = from_int(self.size)
+        result[u"type"] = to_class(TypeClass, self.type)
+        return result
+
+
+class InterfaceMethod:
+    def __init__(self, has_request, has_response, maybe_attributes, maybe_request, maybe_request_alignment, maybe_request_size, maybe_response, maybe_response_alignment, maybe_response_size, name, ordinal):
+        self.has_request = has_request
+        self.has_response = has_response
+        self.maybe_attributes = maybe_attributes
+        self.maybe_request = maybe_request
+        self.maybe_request_alignment = maybe_request_alignment
+        self.maybe_request_size = maybe_request_size
+        self.maybe_response = maybe_response
+        self.maybe_response_alignment = maybe_response_alignment
+        self.maybe_response_size = maybe_response_size
+        self.name = name
+        self.ordinal = ordinal
+
+    @staticmethod
+    def from_dict(obj):
+        assert isinstance(obj, dict)
+        has_request = from_bool(obj.get(u"has_request"))
+        has_response = from_bool(obj.get(u"has_response"))
+        maybe_attributes = from_union([lambda x: from_list(Attribute.from_dict, x), from_none], obj.get(u"maybe_attributes"))
+        maybe_request = from_union([lambda x: from_list(InterfaceMethodParameter.from_dict, x), from_none], obj.get(u"maybe_request"))
+        maybe_request_alignment = from_union([from_int, from_none], obj.get(u"maybe_request_alignment"))
+        maybe_request_size = from_union([from_int, from_none], obj.get(u"maybe_request_size"))
+        maybe_response = from_union([lambda x: from_list(InterfaceMethodParameter.from_dict, x), from_none], obj.get(u"maybe_response"))
+        maybe_response_alignment = from_union([from_int, from_none], obj.get(u"maybe_response_alignment"))
+        maybe_response_size = from_union([from_int, from_none], obj.get(u"maybe_response_size"))
+        name = from_str(obj.get(u"name"))
+        ordinal = from_int(obj.get(u"ordinal"))
+        return InterfaceMethod(has_request, has_response, maybe_attributes, maybe_request, maybe_request_alignment, maybe_request_size, maybe_response, maybe_response_alignment, maybe_response_size, name, ordinal)
+
+    def to_dict(self):
+        result = {}
+        result[u"has_request"] = from_bool(self.has_request)
+        result[u"has_response"] = from_bool(self.has_response)
+        result[u"maybe_attributes"] = from_union([lambda x: from_list(lambda x: to_class(Attribute, x), x), from_none], self.maybe_attributes)
+        result[u"maybe_request"] = from_union([lambda x: from_list(lambda x: to_class(InterfaceMethodParameter, x), x), from_none], self.maybe_request)
+        result[u"maybe_request_alignment"] = from_union([from_int, from_none], self.maybe_request_alignment)
+        result[u"maybe_request_size"] = from_union([from_int, from_none], self.maybe_request_size)
+        result[u"maybe_response"] = from_union([lambda x: from_list(lambda x: to_class(InterfaceMethodParameter, x), x), from_none], self.maybe_response)
+        result[u"maybe_response_alignment"] = from_union([from_int, from_none], self.maybe_response_alignment)
+        result[u"maybe_response_size"] = from_union([from_int, from_none], self.maybe_response_size)
+        result[u"name"] = from_str(self.name)
+        result[u"ordinal"] = from_int(self.ordinal)
+        return result
+
+
+class Interface:
+    def __init__(self, maybe_attributes, methods, name):
+        self.maybe_attributes = maybe_attributes
+        self.methods = methods
+        self.name = name
+
+    @staticmethod
+    def from_dict(obj):
+        assert isinstance(obj, dict)
+        maybe_attributes = from_union([lambda x: from_list(Attribute.from_dict, x), from_none], obj.get(u"maybe_attributes"))
+        methods = from_list(InterfaceMethod.from_dict, obj.get(u"methods"))
+        name = from_str(obj.get(u"name"))
+        return Interface(maybe_attributes, methods, name)
+
+    def to_dict(self):
+        result = {}
+        result[u"maybe_attributes"] = from_union([lambda x: from_list(lambda x: to_class(Attribute, x), x), from_none], self.maybe_attributes)
+        result[u"methods"] = from_list(lambda x: to_class(InterfaceMethod, x), self.methods)
+        result[u"name"] = from_str(self.name)
+        return result
+
+
+class Library:
+    def __init__(self, declarations, name):
+        self.declarations = declarations
+        self.name = name
+
+    @staticmethod
+    def from_dict(obj):
+        assert isinstance(obj, dict)
+        declarations = from_dict(DeclarationsMap, obj.get(u"declarations"))
+        name = from_str(obj.get(u"name"))
+        return Library(declarations, name)
+
+    def to_dict(self):
+        result = {}
+        result[u"declarations"] = from_dict(lambda x: to_enum(DeclarationsMap, x), self.declarations)
+        result[u"name"] = from_str(self.name)
+        return result
+
+
+class StructMember:
+    def __init__(self, alignment, maybe_default_value, name, offset, size, type):
+        self.alignment = alignment
+        self.maybe_default_value = maybe_default_value
+        self.name = name
+        self.offset = offset
+        self.size = size
+        self.type = type
+
+    @staticmethod
+    def from_dict(obj):
+        assert isinstance(obj, dict)
+        alignment = from_int(obj.get(u"alignment"))
+        maybe_default_value = from_union([Constant.from_dict, from_none], obj.get(u"maybe_default_value"))
+        name = from_str(obj.get(u"name"))
+        offset = from_int(obj.get(u"offset"))
+        size = from_int(obj.get(u"size"))
+        type = TypeClass.from_dict(obj.get(u"type"))
+        return StructMember(alignment, maybe_default_value, name, offset, size, type)
+
+    def to_dict(self):
+        result = {}
+        result[u"alignment"] = from_int(self.alignment)
+        result[u"maybe_default_value"] = from_union([lambda x: to_class(Constant, x), from_none], self.maybe_default_value)
+        result[u"name"] = from_str(self.name)
+        result[u"offset"] = from_int(self.offset)
+        result[u"size"] = from_int(self.size)
+        result[u"type"] = to_class(TypeClass, self.type)
+        return result
+
+
+class Struct:
+    def __init__(self, max_handles, maybe_attributes, members, name, size):
+        self.max_handles = max_handles
+        self.maybe_attributes = maybe_attributes
+        self.members = members
+        self.name = name
+        self.size = size
+
+    @staticmethod
+    def from_dict(obj):
+        assert isinstance(obj, dict)
+        max_handles = from_union([from_int, from_none], obj.get(u"max_handles"))
+        maybe_attributes = from_union([lambda x: from_list(Attribute.from_dict, x), from_none], obj.get(u"maybe_attributes"))
+        members = from_list(StructMember.from_dict, obj.get(u"members"))
+        name = from_str(obj.get(u"name"))
+        size = from_int(obj.get(u"size"))
+        return Struct(max_handles, maybe_attributes, members, name, size)
+
+    def to_dict(self):
+        result = {}
+        result[u"max_handles"] = from_union([from_int, from_none], self.max_handles)
+        result[u"maybe_attributes"] = from_union([lambda x: from_list(lambda x: to_class(Attribute, x), x), from_none], self.maybe_attributes)
+        result[u"members"] = from_list(lambda x: to_class(StructMember, x), self.members)
+        result[u"name"] = from_str(self.name)
+        result[u"size"] = from_int(self.size)
+        return result
+
+
+class UnionMember:
+    def __init__(self, alignment, name, offset, size, type):
+        self.alignment = alignment
+        self.name = name
+        self.offset = offset
+        self.size = size
+        self.type = type
+
+    @staticmethod
+    def from_dict(obj):
+        assert isinstance(obj, dict)
+        alignment = from_int(obj.get(u"alignment"))
+        name = from_str(obj.get(u"name"))
+        offset = from_int(obj.get(u"offset"))
+        size = from_int(obj.get(u"size"))
+        type = TypeClass.from_dict(obj.get(u"type"))
+        return UnionMember(alignment, name, offset, size, type)
+
+    def to_dict(self):
+        result = {}
+        result[u"alignment"] = from_int(self.alignment)
+        result[u"name"] = from_str(self.name)
+        result[u"offset"] = from_int(self.offset)
+        result[u"size"] = from_int(self.size)
+        result[u"type"] = to_class(TypeClass, self.type)
+        return result
+
+
+class UnionDeclarationElement:
+    def __init__(self, alignment, max_handles, maybe_attributes, members, name, size):
+        self.alignment = alignment
+        self.max_handles = max_handles
+        self.maybe_attributes = maybe_attributes
+        self.members = members
+        self.name = name
+        self.size = size
+
+    @staticmethod
+    def from_dict(obj):
+        assert isinstance(obj, dict)
+        alignment = from_int(obj.get(u"alignment"))
+        max_handles = from_union([from_int, from_none], obj.get(u"max_handles"))
+        maybe_attributes = from_union([lambda x: from_list(Attribute.from_dict, x), from_none], obj.get(u"maybe_attributes"))
+        members = from_list(UnionMember.from_dict, obj.get(u"members"))
+        name = from_str(obj.get(u"name"))
+        size = from_int(obj.get(u"size"))
+        return UnionDeclarationElement(alignment, max_handles, maybe_attributes, members, name, size)
+
+    def to_dict(self):
+        result = {}
+        result[u"alignment"] = from_int(self.alignment)
+        result[u"max_handles"] = from_union([from_int, from_none], self.max_handles)
+        result[u"maybe_attributes"] = from_union([lambda x: from_list(lambda x: to_class(Attribute, x), x), from_none], self.maybe_attributes)
+        result[u"members"] = from_list(lambda x: to_class(UnionMember, x), self.members)
+        result[u"name"] = from_str(self.name)
+        result[u"size"] = from_int(self.size)
+        return result
+
+
+class Fidl:
+    def __init__(self, const_declarations, declaration_order, declarations, enum_declarations, interface_declarations, library_dependencies, name, struct_declarations, union_declarations, version):
+        self.const_declarations = const_declarations
+        self.declaration_order = declaration_order
+        self.declarations = declarations
+        self.enum_declarations = enum_declarations
+        self.interface_declarations = interface_declarations
+        self.library_dependencies = library_dependencies
+        self.name = name
+        self.struct_declarations = struct_declarations
+        self.union_declarations = union_declarations
+        self.version = version
+
+    @staticmethod
+    def from_dict(obj):
+        assert isinstance(obj, dict)
+        const_declarations = from_list(Const.from_dict, obj.get(u"const_declarations"))
+        declaration_order = from_list(from_str, obj.get(u"declaration_order"))
+        declarations = from_dict(DeclarationsMap, obj.get(u"declarations"))
+        enum_declarations = from_list(EnumDeclarationElement.from_dict, obj.get(u"enum_declarations"))
+        interface_declarations = from_list(Interface.from_dict, obj.get(u"interface_declarations"))
+        library_dependencies = from_list(Library.from_dict, obj.get(u"library_dependencies"))
+        name = from_str(obj.get(u"name"))
+        struct_declarations = from_list(Struct.from_dict, obj.get(u"struct_declarations"))
+        union_declarations = from_list(UnionDeclarationElement.from_dict, obj.get(u"union_declarations"))
+        version = from_str(obj.get(u"version"))
+        return Fidl(const_declarations, declaration_order, declarations, enum_declarations, interface_declarations, library_dependencies, name, struct_declarations, union_declarations, version)
+
+    def to_dict(self):
+        result = {}
+        result[u"const_declarations"] = from_list(lambda x: to_class(Const, x), self.const_declarations)
+        result[u"declaration_order"] = from_list(from_str, self.declaration_order)
+        result[u"declarations"] = from_dict(lambda x: to_enum(DeclarationsMap, x), self.declarations)
+        result[u"enum_declarations"] = from_list(lambda x: to_class(EnumDeclarationElement, x), self.enum_declarations)
+        result[u"interface_declarations"] = from_list(lambda x: to_class(Interface, x), self.interface_declarations)
+        result[u"library_dependencies"] = from_list(lambda x: to_class(Library, x), self.library_dependencies)
+        result[u"name"] = from_str(self.name)
+        result[u"struct_declarations"] = from_list(lambda x: to_class(Struct, x), self.struct_declarations)
+        result[u"union_declarations"] = from_list(lambda x: to_class(UnionDeclarationElement, x), self.union_declarations)
+        result[u"version"] = from_str(self.version)
+        return result
+
+
+def fidl_from_dict(s):
+    return Fidl.from_dict(s)
+
+
+def fidl_to_dict(x):
+    return to_class(Fidl, x)
+