aeead07cdf
This information is necessary, as the interface could be implemented by a JS object. In this case, xptcall needs to know the signature of the method in order to properly process arguments and clean up the stack even if the method cannot be implemented in JS, and will just return an error. This change means that values with the TD_VOID type will once again be generated and included in xptdata.cpp, however support for processing this type was never removed from xptcall, and all functions which use it should early return from CallMethod due to IsReflectable returning false. Without this information it is likely that calling one of these methods will cause crashes, especially on platforms like 32-bit windows which pass all arguments on the stack. XPT type information for non-reflectable methods are still omitted for builtinclass interfaces, as they can never receive an XPCWrappedJS so do not need the information available. Differential Revision: https://phabricator.services.mozilla.com/D207802
300 lines
9.4 KiB
Python
300 lines
9.4 KiB
Python
#!/usr/bin/env python
|
|
# jsonxpt.py - Generate json XPT typelib files from IDL.
|
|
#
|
|
# This Source Code Form is subject to the terms of the Mozilla Public
|
|
# License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
|
|
"""Generate a json XPT typelib for an IDL file"""
|
|
|
|
import itertools
|
|
import json
|
|
|
|
from xpidl import xpidl
|
|
|
|
# A map of xpidl.py types to xpt enum variants
|
|
TypeMap = {
|
|
# builtins
|
|
"boolean": "TD_BOOL",
|
|
"void": "TD_VOID",
|
|
"int8_t": "TD_INT8",
|
|
"int16_t": "TD_INT16",
|
|
"int32_t": "TD_INT32",
|
|
"int64_t": "TD_INT64",
|
|
"uint8_t": "TD_UINT8",
|
|
"uint16_t": "TD_UINT16",
|
|
"uint32_t": "TD_UINT32",
|
|
"uint64_t": "TD_UINT64",
|
|
"nsresult": "TD_UINT32",
|
|
"float": "TD_FLOAT",
|
|
"double": "TD_DOUBLE",
|
|
"char": "TD_CHAR",
|
|
"string": "TD_PSTRING",
|
|
"wchar": "TD_WCHAR",
|
|
"wstring": "TD_PWSTRING",
|
|
"char16_t": "TD_UINT16",
|
|
# special types
|
|
"nsid": "TD_NSID",
|
|
"astring": "TD_ASTRING",
|
|
"utf8string": "TD_UTF8STRING",
|
|
"cstring": "TD_CSTRING",
|
|
"jsval": "TD_JSVAL",
|
|
"promise": "TD_PROMISE",
|
|
}
|
|
|
|
|
|
def flags(*flags):
|
|
return [flag for flag, cond in flags if cond]
|
|
|
|
|
|
def get_type(type, calltype, iid_is=None, size_is=None, needs_scriptable=None):
|
|
while isinstance(type, xpidl.Typedef):
|
|
type = type.realtype
|
|
|
|
if isinstance(type, xpidl.Builtin):
|
|
ret = {"tag": TypeMap[type.name]}
|
|
if type.name in ["string", "wstring"] and size_is is not None:
|
|
ret["tag"] += "_SIZE_IS"
|
|
ret["size_is"] = size_is
|
|
return ret
|
|
|
|
if isinstance(type, xpidl.Array):
|
|
# NB: For a Array<T> we pass down the iid_is to get the type of T.
|
|
# This allows Arrays of InterfaceIs types to work.
|
|
return {
|
|
"tag": "TD_ARRAY",
|
|
"element": get_type(type.type, calltype, iid_is, None, needs_scriptable),
|
|
}
|
|
|
|
if isinstance(type, xpidl.LegacyArray):
|
|
# NB: For a Legacy [array] T we pass down iid_is to get the type of T.
|
|
# This allows [array] of InterfaceIs types to work.
|
|
return {
|
|
"tag": "TD_LEGACY_ARRAY",
|
|
"size_is": size_is,
|
|
"element": get_type(type.type, calltype, iid_is, None, needs_scriptable),
|
|
}
|
|
|
|
if isinstance(type, xpidl.Interface) or isinstance(type, xpidl.Forward):
|
|
if isinstance(needs_scriptable, set):
|
|
needs_scriptable.add(type.name)
|
|
return {
|
|
"tag": "TD_INTERFACE_TYPE",
|
|
"name": type.name,
|
|
}
|
|
|
|
if isinstance(type, xpidl.WebIDL):
|
|
return {
|
|
"tag": "TD_DOMOBJECT",
|
|
"name": type.name,
|
|
"native": type.native,
|
|
"headerFile": type.headerFile,
|
|
}
|
|
|
|
if isinstance(type, xpidl.Native):
|
|
if type.specialtype == "nsid" and type.isPtr(calltype):
|
|
return {"tag": "TD_NSIDPTR"}
|
|
elif type.specialtype:
|
|
return {"tag": TypeMap[type.specialtype]}
|
|
elif iid_is is not None:
|
|
return {
|
|
"tag": "TD_INTERFACE_IS_TYPE",
|
|
"iid_is": iid_is,
|
|
}
|
|
else:
|
|
return {"tag": "TD_VOID"}
|
|
|
|
if isinstance(type, xpidl.CEnum):
|
|
# As far as XPConnect is concerned, cenums are just unsigned integers.
|
|
return {"tag": "TD_UINT%d" % type.width}
|
|
|
|
raise Exception("Unknown type!")
|
|
|
|
|
|
def mk_param(type, in_=0, out=0, optional=0):
|
|
return {
|
|
"type": type,
|
|
"flags": flags(
|
|
("in", in_),
|
|
("out", out),
|
|
("optional", optional),
|
|
),
|
|
}
|
|
|
|
|
|
def mk_method(method, params, getter=0, setter=0, optargc=0, hasretval=0, symbol=0):
|
|
return {
|
|
"name": method.name,
|
|
# NOTE: We don't include any return value information here, as we'll
|
|
# never call the methods if they're marked notxpcom, and all xpcom
|
|
# methods return the same type (nsresult).
|
|
# XXX: If we ever use these files for other purposes than xptcodegen we
|
|
# may want to write that info.
|
|
"params": params,
|
|
"flags": flags(
|
|
("getter", getter),
|
|
("setter", setter),
|
|
("hidden", not method.isScriptable()),
|
|
("optargc", optargc),
|
|
("jscontext", method.implicit_jscontext),
|
|
("hasretval", hasretval),
|
|
("symbol", method.symbol),
|
|
),
|
|
}
|
|
|
|
|
|
def attr_param_idx(p, m, attr):
|
|
attr_val = getattr(p, attr, None)
|
|
if not attr_val:
|
|
return None
|
|
for i, param in enumerate(m.params):
|
|
if param.name == attr_val:
|
|
return i
|
|
raise Exception(f"Need parameter named '{attr_val}' for attribute '{attr}'")
|
|
|
|
|
|
def build_interface(iface):
|
|
if iface.namemap is None:
|
|
raise Exception("Interface was not resolved.")
|
|
|
|
assert (
|
|
iface.attributes.scriptable
|
|
), "Don't generate XPT info for non-scriptable interfaces"
|
|
|
|
# State used while building an interface
|
|
consts = []
|
|
methods = []
|
|
|
|
# Interfaces referenced from scriptable members need to be [scriptable].
|
|
needs_scriptable = set()
|
|
|
|
def build_const(c):
|
|
consts.append(
|
|
{
|
|
"name": c.name,
|
|
"type": get_type(c.basetype, ""),
|
|
"value": c.getValue(), # All of our consts are numbers
|
|
}
|
|
)
|
|
|
|
def build_cenum(b):
|
|
for var in b.variants:
|
|
consts.append(
|
|
{
|
|
"name": var.name,
|
|
"type": get_type(b, "in"),
|
|
"value": var.value,
|
|
}
|
|
)
|
|
|
|
def build_method(m, needs_scriptable=None):
|
|
params = []
|
|
for p in m.params:
|
|
params.append(
|
|
mk_param(
|
|
get_type(
|
|
p.realtype,
|
|
p.paramtype,
|
|
iid_is=attr_param_idx(p, m, "iid_is"),
|
|
size_is=attr_param_idx(p, m, "size_is"),
|
|
needs_scriptable=needs_scriptable,
|
|
),
|
|
in_=p.paramtype.count("in"),
|
|
out=p.paramtype.count("out"),
|
|
optional=p.optional,
|
|
)
|
|
)
|
|
|
|
hasretval = len(m.params) > 0 and m.params[-1].retval
|
|
if not m.notxpcom and m.realtype.name != "void":
|
|
hasretval = True
|
|
type = get_type(m.realtype, "out", needs_scriptable=needs_scriptable)
|
|
params.append(mk_param(type, out=1))
|
|
|
|
methods.append(
|
|
mk_method(m, params, optargc=m.optional_argc, hasretval=hasretval)
|
|
)
|
|
|
|
def build_attr(a, needs_scriptable=None):
|
|
assert a.realtype.name != "void"
|
|
|
|
# Write the getter
|
|
getter_params = []
|
|
if not a.notxpcom:
|
|
type = get_type(a.realtype, "out", needs_scriptable=needs_scriptable)
|
|
getter_params.append(mk_param(type, out=1))
|
|
|
|
methods.append(mk_method(a, getter_params, getter=1, hasretval=1))
|
|
|
|
# And maybe the setter
|
|
if not a.readonly:
|
|
type = get_type(a.realtype, "in", needs_scriptable=needs_scriptable)
|
|
methods.append(mk_method(a, [mk_param(type, in_=1)], setter=1))
|
|
|
|
for member in iface.members:
|
|
if isinstance(member, xpidl.ConstMember):
|
|
build_const(member)
|
|
elif isinstance(member, xpidl.Attribute):
|
|
build_attr(member, member.isScriptable() and needs_scriptable)
|
|
elif isinstance(member, xpidl.Method):
|
|
build_method(member, member.isScriptable() and needs_scriptable)
|
|
elif isinstance(member, xpidl.CEnum):
|
|
build_cenum(member)
|
|
elif isinstance(member, xpidl.CDATA):
|
|
pass
|
|
else:
|
|
raise Exception("Unexpected interface member: %s" % member)
|
|
|
|
for ref in set(needs_scriptable):
|
|
p = iface.idl.getName(xpidl.TypeId(ref), None)
|
|
if isinstance(p, xpidl.Interface):
|
|
needs_scriptable.remove(ref)
|
|
if not p.attributes.scriptable:
|
|
raise Exception(
|
|
f"Scriptable member in {iface.name} references non-scriptable {ref}. "
|
|
"The interface must be marked as [scriptable], "
|
|
"or the referencing member with [noscript]."
|
|
)
|
|
|
|
return {
|
|
"name": iface.name,
|
|
"uuid": iface.attributes.uuid,
|
|
"methods": methods,
|
|
"consts": consts,
|
|
"parent": iface.base,
|
|
"needs_scriptable": sorted(needs_scriptable),
|
|
"flags": flags(
|
|
("function", iface.attributes.function),
|
|
("builtinclass", iface.attributes.builtinclass),
|
|
("main_process_only", iface.attributes.main_process_scriptable_only),
|
|
),
|
|
}
|
|
|
|
|
|
# These functions are the public interface of this module. They are very simple
|
|
# functions, but are exported so that if we need to do something more
|
|
# complex in them in the future we can.
|
|
|
|
|
|
def build_typelib(idl):
|
|
"""Given a parsed IDL file, generate and return the typelib"""
|
|
return [
|
|
build_interface(p)
|
|
for p in idl.productions
|
|
if p.kind == "interface" and p.attributes.scriptable
|
|
]
|
|
|
|
|
|
def link(typelibs):
|
|
"""Link a list of typelibs together into a single typelib"""
|
|
linked = list(itertools.chain.from_iterable(typelibs))
|
|
assert len(set(iface["name"] for iface in linked)) == len(
|
|
linked
|
|
), "Multiple typelibs containing the same interface were linked together"
|
|
return linked
|
|
|
|
|
|
def write(typelib, fd):
|
|
"""Write typelib into fd"""
|
|
json.dump(typelib, fd, indent=2, sort_keys=True)
|