Source code
Revision control
Copy as Markdown
Other Tools
# 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,
# Common codegen classes.
import functools
import math
from operator import attrgetter
import os
import re
import string
import textwrap
from Configuration import (
Configuration,
Descriptor,
MemberIsLegacyUnforgeable,
NoSuchDescriptorError,
getAllTypes,
getTypesFromCallback,
getTypesFromDescriptor,
getTypesFromDictionary,
)
from perfecthash import PerfectHash
from WebIDL import (
BuiltinTypes,
IDLAttribute,
IDLBuiltinType,
IDLDefaultDictionaryValue,
IDLDictionary,
IDLEmptySequenceValue,
IDLInterfaceMember,
IDLNullValue,
IDLSequenceType,
IDLType,
IDLTypedef,
IDLUndefinedValue,
)
AUTOGENERATED_WARNING_COMMENT = (
"/* THIS FILE IS AUTOGENERATED BY Codegen.py - DO NOT EDIT */\n\n"
)
AUTOGENERATED_WITH_SOURCE_WARNING_COMMENT = (
"/* THIS FILE IS AUTOGENERATED FROM %s BY Codegen.py - DO NOT EDIT */\n\n"
)
FINALIZE_HOOK_NAME = "_finalize"
CONSTRUCT_HOOK_NAME = "_constructor"
LEGACYCALLER_HOOK_NAME = "_legacycaller"
RESOLVE_HOOK_NAME = "_resolve"
MAY_RESOLVE_HOOK_NAME = "_mayResolve"
NEW_ENUMERATE_HOOK_NAME = "_newEnumerate"
INSTANCE_RESERVED_SLOTS = 1
# If you have to change this list (which you shouldn't!), make sure it
# continues to match the list in test_Object.prototype_props.html
JS_OBJECT_PROTOTYPE_PROPERTIES = [
"constructor",
"toString",
"toLocaleString",
"valueOf",
"hasOwnProperty",
"isPrototypeOf",
"propertyIsEnumerable",
"__defineGetter__",
"__defineSetter__",
"__lookupGetter__",
"__lookupSetter__",
"__proto__",
]
def reservedSlot(slotIndex, forXray):
base = "DOM_EXPANDO_RESERVED_SLOTS" if forXray else "DOM_INSTANCE_RESERVED_SLOTS"
return "(%s + %d)" % (base, slotIndex)
def getSlotIndex(member, descriptor):
slotIndex = member.slotIndices[descriptor.interface.identifier.name]
return slotIndex[0] if isinstance(slotIndex, tuple) else slotIndex
def memberReservedSlot(member, descriptor):
return reservedSlot(getSlotIndex(member, descriptor), False)
def memberXrayExpandoReservedSlot(member, descriptor):
return reservedSlot(getSlotIndex(member, descriptor), True)
def getReservedSlotFunc(descriptor, mayBeXray=False):
# Try to use js::GetProxyReservedSlot or JS::GetNativeObjectReservedSlot
# instead of the generic JS::GetReservedSlot to avoid a branch and reduce
# binary size.
#
# If mayBeXray is True, the object may be either the descriptor's reflector
# or an Xray expando (always a native object).
if descriptor.concrete and descriptor.proxy:
if mayBeXray:
return "JS::GetReservedSlot"
return "js::GetProxyReservedSlot"
return "JS::GetNativeObjectReservedSlot"
def setReservedSlotFunc(descriptor, mayBeXray=False):
# Try to use js::SetProxyReservedSlot or JS::SetNativeObjectReservedSlot
# instead of the generic JS::SetReservedSlot to avoid a branch and reduce
# binary size.
#
# If mayBeXray is True, the object may be either the descriptor's reflector
# or an Xray expando (always a native object).
if descriptor.concrete and descriptor.proxy:
if mayBeXray:
return "JS::SetReservedSlot"
return "js::SetProxyReservedSlot"
return "JS::SetNativeObjectReservedSlot"
def mayUseXrayExpandoSlots(descriptor, attr):
assert not attr.getExtendedAttribute("NewObject")
# For attributes whose type is a Gecko interface we always use
# slots on the reflector for caching. Also, for interfaces that
# don't want Xrays we obviously never use the Xray expando slot.
return descriptor.wantsXrays and not attr.type.isGeckoInterface()
def reflectedHTMLAttributesArrayIndex(descriptor, attr):
slots = attr.slotIndices[descriptor.interface.identifier.name]
return slots[1]
def getReflectedHTMLAttributesIface(descriptor):
iface = descriptor.interface
while iface:
if iface.reflectedHTMLAttributesReturningFrozenArray:
return iface
iface = iface.parent
return None
def toStringBool(arg):
"""
Converts IDL/Python Boolean (True/False) to C++ Boolean (true/false)
"""
return str(not not arg).lower()
def toBindingNamespace(arg):
return arg + "_Binding"
def isTypeCopyConstructible(type):
# Nullable and sequence stuff doesn't affect copy-constructibility
type = type.unroll()
return (
type.isUndefined()
or type.isPrimitive()
or type.isString()
or type.isEnum()
or (type.isUnion() and CGUnionStruct.isUnionCopyConstructible(type))
or (
type.isDictionary()
and CGDictionary.isDictionaryCopyConstructible(type.inner)
)
or
# Interface types are only copy-constructible if they're Gecko
# interfaces. SpiderMonkey interfaces are not copy-constructible
# because of rooting issues.
(type.isInterface() and type.isGeckoInterface())
)
class CycleCollectionUnsupported(TypeError):
def __init__(self, message):
TypeError.__init__(self, message)
def idlTypeNeedsCycleCollection(type):
type = type.unroll() # Takes care of sequences and nullables
if (
(type.isPrimitive() and type.tag() in builtinNames)
or type.isUndefined()
or type.isEnum()
or type.isString()
or type.isAny()
or type.isObject()
or type.isSpiderMonkeyInterface()
):
return False
elif type.isCallback() or type.isPromise() or type.isGeckoInterface():
return True
elif type.isUnion():
return any(idlTypeNeedsCycleCollection(t) for t in type.flatMemberTypes)
elif type.isRecord():
if idlTypeNeedsCycleCollection(type.inner):
raise CycleCollectionUnsupported(
"Cycle collection for type %s is not supported" % type
)
return False
elif type.isDictionary():
return CGDictionary.dictionaryNeedsCycleCollection(type.inner)
else:
raise CycleCollectionUnsupported(
"Don't know whether to cycle-collect type %s" % type
)
def idlTypeNeedsCallContext(type, descriptor=None, allowTreatNonCallableAsNull=False):
"""
Returns whether the given type needs error reporting via a
BindingCallContext for JS-to-C++ conversions. This will happen when the
conversion can throw an exception due to logic in the IDL spec or
Gecko-specific security checks. In particular, a type needs a
BindingCallContext if and only if the JS-to-C++ conversion for that type can
end up calling ThrowErrorMessage.
For some types this depends on the descriptor (e.g. because we do certain
checks only for some kinds of interfaces).
The allowTreatNonCallableAsNull optimization is there so we can avoid
generating an unnecessary BindingCallContext for all the event handler
attribute setters.
"""
while True:
if type.isSequence():
# Sequences can always throw "not an object"
return True
if type.nullable():
# treatNonObjectAsNull() and treatNonCallableAsNull() are
# only sane things to test on nullable types, so do that now.
if (
allowTreatNonCallableAsNull
and type.isCallback()
and (type.treatNonObjectAsNull() or type.treatNonCallableAsNull())
):
# This can't throw. so never needs a method description.
return False
type = type.inner
else:
break
if type.isUndefined():
# Clearly doesn't need a method description; we can only get here from
# CGHeaders trying to decide whether to include the method description
# header.
return False
# The float check needs to come before the isPrimitive() check,
# because floats are primitives too.
if type.isFloat():
# Floats can throw if restricted.
return not type.isUnrestricted()
if type.isPrimitive() and type.tag() in builtinNames:
# Numbers can throw if enforcing range.
return type.hasEnforceRange()
if type.isEnum():
# Can throw on invalid value.
return True
if type.isString():
# Can throw if it's a ByteString
return type.isByteString()
if type.isAny():
# JS-implemented interfaces do extra security checks so need a
# method description here. If we have no descriptor, this
# might be JS-implemented thing, so it will do the security
# check and we need the method description.
return not descriptor or descriptor.interface.isJSImplemented()
if type.isPromise():
# JS-to-Promise conversion won't cause us to throw any
# specific exceptions, so does not need a method description.
return False
if (
type.isObject()
or type.isInterface()
or type.isCallback()
or type.isDictionary()
or type.isRecord()
or type.isObservableArray()
):
# These can all throw if a primitive is passed in, at the very least.
# There are some rare cases when we know we have an object, but those
# are not worth the complexity of optimizing for.
#
# Note that we checked the [LegacyTreatNonObjectAsNull] case already when
# unwrapping nullables.
return True
if type.isUnion():
# Can throw if a type not in the union is passed in.
return True
raise TypeError("Don't know whether type '%s' needs a method description" % type)
# TryPreserveWrapper uses the addProperty hook to preserve the wrapper of
# non-nsISupports cycle collected objects, so if wantsPreservedWrapper is changed
# to not cover that case then TryPreserveWrapper will need to be changed.
def wantsPreservedWrapper(desc):
return desc.concrete and desc.wrapperCache and not desc.isGlobal()
def wantsGetWrapperCache(desc):
return (
desc.concrete and desc.wrapperCache and not desc.isGlobal() and not desc.proxy
)
def indent(s, indentLevel=2):
"""
Indent C++ code.
Weird secret feature: this doesn't indent lines that start with # (such as
#include lines or #ifdef/#endif).
"""
# We'll want to insert the indent at the beginnings of lines, but we
# don't want to indent empty lines.
padding = indentLevel * " "
return "\n".join(
[
(padding + line) if line and line[0] != "#" else line
for line in s.split("\n")
]
)
# dedent() and fill() are often called on the same string multiple
# times. We want to memoize their return values so we don't keep
# recomputing them all the time.
def memoize(fn):
"""
Decorator to memoize a function of one argument. The cache just
grows without bound.
"""
cache = {}
@functools.wraps(fn)
def wrapper(arg):
retval = cache.get(arg)
if retval is None:
retval = cache[arg] = fn(arg)
return retval
return wrapper
@memoize
def dedent(s):
"""
Remove all leading whitespace from s, and remove a blank line
at the beginning.
"""
if s.startswith("\n"):
s = s[1:]
return textwrap.dedent(s)
# This works by transforming the fill()-template to an equivalent
# string.Template.
fill_multiline_substitution_re = re.compile(r"( *)\$\*{(\w+)}(\n)?")
find_substitutions = re.compile(r"\${")
@memoize
def compile_fill_template(template):
"""
Helper function for fill(). Given the template string passed to fill(),
do the reusable part of template processing and return a pair (t,
argModList) that can be used every time fill() is called with that
template argument.
argsModList is list of tuples that represent modifications to be
made to args. Each modification has, in order: i) the arg name,
ii) the modified name, iii) the indent depth.
"""
t = dedent(template)
assert t.endswith("\n") or "\n" not in t
argModList = []
def replace(match):
"""
Replaces a line like ' $*{xyz}\n' with '${xyz_n}',
where n is the indent depth, and add a corresponding entry to
argModList.
Note that this needs to close over argModList, so it has to be
defined inside compile_fill_template().
"""
indentation, name, nl = match.groups()
depth = len(indentation)
# Check that $*{xyz} appears by itself on a line.
prev = match.string[: match.start()]
if (prev and not prev.endswith("\n")) or nl is None:
raise ValueError(
"Invalid fill() template: $*{%s} must appear by itself on a line" % name
)
# Now replace this whole line of template with the indented equivalent.
modified_name = name + "_" + str(depth)
argModList.append((name, modified_name, depth))
return "${" + modified_name + "}"
t = re.sub(fill_multiline_substitution_re, replace, t)
if not re.search(find_substitutions, t):
raise TypeError("Using fill() when dedent() would do.")
return (string.Template(t), argModList)
def fill(template, **args):
"""
Convenience function for filling in a multiline template.
`fill(template, name1=v1, name2=v2)` is a lot like
`string.Template(template).substitute({"name1": v1, "name2": v2})`.
However, it's shorter, and has a few nice features:
* If `template` is indented, fill() automatically dedents it!
This makes code using fill() with Python's multiline strings
much nicer to look at.
* If `template` starts with a blank line, fill() strips it off.
(Again, convenient with multiline strings.)
* fill() recognizes a special kind of substitution
of the form `$*{name}`.
Use this to paste in, and automatically indent, multiple lines.
(Mnemonic: The `*` is for "multiple lines").
A `$*` substitution must appear by itself on a line, with optional
preceding indentation (spaces only). The whole line is replaced by the
corresponding keyword argument, indented appropriately. If the
argument is an empty string, no output is generated, not even a blank
line.
"""
t, argModList = compile_fill_template(template)
# Now apply argModList to args
for name, modified_name, depth in argModList:
if not (args[name] == "" or args[name].endswith("\n")):
raise ValueError(
"Argument %s with value %r is missing a newline" % (name, args[name])
)
args[modified_name] = indent(args[name], depth)
return t.substitute(args)
class CGThing:
"""
Abstract base class for things that spit out code.
"""
def __init__(self):
pass # Nothing for now
def declare(self):
"""Produce code for a header file."""
assert False # Override me!
def define(self):
"""Produce code for a cpp file."""
assert False # Override me!
def forward_declare(self):
"""Produce code for a header file."""
return "" # This can be skipped for most of the classes
def deps(self):
"""Produce the deps for a pp file"""
assert False # Override me!
class CGStringTable(CGThing):
"""
Generate a function accessor for a WebIDL string table, using the existing
concatenated names string and mapping indexes to offsets in that string:
const char *accessorName(unsigned int index) {
static const uint16_t offsets = { ... };
return BindingName(offsets[index]);
}
This is more efficient than the more natural:
const char *table[] = {
...
};
The uint16_t offsets are smaller than the pointer equivalents, and the
concatenated string requires no runtime relocations.
"""
def __init__(self, accessorName, strings, static=False):
CGThing.__init__(self)
self.accessorName = accessorName
self.strings = strings
self.static = static
def declare(self):
if self.static:
return ""
return "const char *%s(unsigned int aIndex);\n" % self.accessorName
def define(self):
offsets = []
for s in self.strings:
offsets.append(BindingNamesOffsetEnum(s))
return fill(
"""
${static}const char *${name}(unsigned int aIndex)
{
static const BindingNamesOffset offsets[] = {
$*{offsets}
};
return BindingName(offsets[aIndex]);
}
""",
static="static " if self.static else "",
name=self.accessorName,
offsets="".join("BindingNamesOffset::%s,\n" % o for o in offsets),
)
class CGNativePropertyHooks(CGThing):
"""
Generate a NativePropertyHooks for a given descriptor
"""
def __init__(self, descriptor, properties):
CGThing.__init__(self)
assert descriptor.wantsXrays
self.descriptor = descriptor
self.properties = properties
def declare(self):
return ""
def define(self):
if (
self.descriptor.concrete
and self.descriptor.proxy
and not self.descriptor.isMaybeCrossOriginObject()
):
if self.descriptor.needsXrayNamedDeleterHook():
deleteNamedProperty = "DeleteNamedProperty"
else:
deleteNamedProperty = "nullptr"
namedOrIndexed = fill(
"""
const NativeNamedOrIndexedPropertyHooks sNativeNamedOrIndexedPropertyHooks = {
binding_detail::ResolveOwnProperty,
binding_detail::EnumerateOwnProperties,
${deleteNamedProperty}
};
""",
deleteNamedProperty=deleteNamedProperty,
)
namedOrIndexedPointer = "&sNativeNamedOrIndexedPropertyHooks"
elif self.descriptor.needsXrayResolveHooks():
namedOrIndexed = dedent(
"""
const NativeNamedOrIndexedPropertyHooks sNativeNamedOrIndexedPropertyHooks = {
ResolveOwnPropertyViaResolve,
EnumerateOwnPropertiesViaGetOwnPropertyNames,
nullptr
};
"""
)
namedOrIndexedPointer = "&sNativeNamedOrIndexedPropertyHooks"
else:
namedOrIndexed = ""
namedOrIndexedPointer = "nullptr"
if self.properties.hasNonChromeOnly():
regular = "sNativeProperties.Upcast()"
else:
regular = "nullptr"
if self.properties.hasChromeOnly():
chrome = "sChromeOnlyNativeProperties.Upcast()"
else:
chrome = "nullptr"
constructorID = "constructors::id::"
if self.descriptor.interface.hasInterfaceObject():
constructorID += self.descriptor.name
else:
constructorID += "_ID_Count"
prototypeID = "prototypes::id::"
if self.descriptor.interface.hasInterfacePrototypeObject():
prototypeID += self.descriptor.name
else:
prototypeID += "_ID_Count"
if self.descriptor.wantsXrayExpandoClass:
expandoClass = "&sXrayExpandoObjectClass"
else:
expandoClass = "&DefaultXrayExpandoObjectClass"
return namedOrIndexed + fill(
"""
bool sNativePropertiesInited = false;
const NativePropertyHooks sNativePropertyHooks = {
${namedOrIndexedPointer},
{ ${regular}, ${chrome}, &sNativePropertiesInited },
${prototypeID},
${constructorID},
${expandoClass}
};
""",
namedOrIndexedPointer=namedOrIndexedPointer,
regular=regular,
chrome=chrome,
prototypeID=prototypeID,
constructorID=constructorID,
expandoClass=expandoClass,
)
def NativePropertyHooks(descriptor):
return (
"&sEmptyNativePropertyHooks"
if not descriptor.wantsXrays
else "&sNativePropertyHooks"
)
def DOMClass(descriptor):
protoList = ["prototypes::id::" + proto for proto in descriptor.prototypeNameChain]
# Pad out the list to the right length with _ID_Count so we
# guarantee that all the lists are the same length. _ID_Count
# is never the ID of any prototype, so it's safe to use as
# padding.
protoList.extend(
["prototypes::id::_ID_Count"]
* (descriptor.config.maxProtoChainLength - len(protoList))
)
if descriptor.interface.isSerializable():
serializer = "Serialize"
else:
serializer = "nullptr"
if wantsGetWrapperCache(descriptor):
wrapperCacheGetter = (
"NativeTypeHelpers<%s>::GetWrapperCache" % descriptor.nativeType
)
else:
wrapperCacheGetter = "nullptr"
if descriptor.hasOrdinaryObjectPrototype():
getProto = "JS::GetRealmObjectPrototypeHandle"
else:
getProto = "GetProtoObjectHandle"
return fill(
"""
{ ${protoChain} },
std::is_base_of_v<nsISupports, ${nativeType}>,
${hooks},
${getProto},
GetCCParticipant<${nativeType}>::Get(),
${serializer},
${wrapperCacheGetter}
""",
protoChain=", ".join(protoList),
nativeType=descriptor.nativeType,
hooks=NativePropertyHooks(descriptor),
serializer=serializer,
wrapperCacheGetter=wrapperCacheGetter,
getProto=getProto,
)
def InstanceReservedSlots(descriptor):
slots = INSTANCE_RESERVED_SLOTS + descriptor.interface.totalMembersInSlots
if descriptor.isMaybeCrossOriginObject():
# We need a slot for the cross-origin holder too.
if descriptor.interface.hasChildInterfaces():
raise TypeError(
"We don't support non-leaf cross-origin interfaces "
"like %s" % descriptor.interface.identifier.name
)
slots += 1
return slots
class CGDOMJSClass(CGThing):
"""
Generate a DOMJSClass for a given descriptor
"""
def __init__(self, descriptor):
CGThing.__init__(self)
self.descriptor = descriptor
def declare(self):
return ""
def define(self):
callHook = (
LEGACYCALLER_HOOK_NAME
if self.descriptor.operations["LegacyCaller"]
else "nullptr"
)
if self.descriptor.wrapperCache:
classExtension = (
"&NativeTypeHelpers<%s>::sClassExtension" % self.descriptor.nativeType
)
else:
classExtension = "JS_NULL_CLASS_EXT"
slotCount = InstanceReservedSlots(self.descriptor)
classFlags = "JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE | "
if self.descriptor.isGlobal():
classFlags += (
"JSCLASS_DOM_GLOBAL | JSCLASS_GLOBAL_FLAGS_WITH_SLOTS(DOM_GLOBAL_SLOTS)"
)
traceHook = "JS_GlobalObjectTraceHook"
reservedSlots = "JSCLASS_GLOBAL_APPLICATION_SLOTS"
else:
classFlags += "JSCLASS_HAS_RESERVED_SLOTS(%d)" % slotCount
iface = getReflectedHTMLAttributesIface(self.descriptor)
if iface:
traceHook = (
"%s::ReflectedHTMLAttributeSlots::Trace"
% toBindingNamespace(iface.identifier.name)
)
else:
traceHook = "nullptr"
reservedSlots = slotCount
if self.descriptor.interface.hasProbablyShortLivingWrapper():
if not self.descriptor.wrapperCache:
raise TypeError(
"Need a wrapper cache to support nursery "
"allocation of DOM objects"
)
classFlags += " | JSCLASS_SKIP_NURSERY_FINALIZE"
if wantsPreservedWrapper(self.descriptor):
classFlags += " | JSCLASS_PRESERVES_WRAPPER"
if self.descriptor.interface.getExtendedAttribute("NeedResolve"):
resolveHook = RESOLVE_HOOK_NAME
mayResolveHook = MAY_RESOLVE_HOOK_NAME
newEnumerateHook = NEW_ENUMERATE_HOOK_NAME
elif self.descriptor.isGlobal():
resolveHook = "mozilla::dom::ResolveGlobal"
mayResolveHook = "mozilla::dom::MayResolveGlobal"
newEnumerateHook = "mozilla::dom::EnumerateGlobal"
else:
resolveHook = "nullptr"
mayResolveHook = "nullptr"
newEnumerateHook = "nullptr"
return fill(
"""
static const JSClassOps sClassOps = {
nullptr, /* addProperty */
nullptr, /* delProperty */
nullptr, /* enumerate */
${newEnumerate}, /* newEnumerate */
${resolve}, /* resolve */
${mayResolve}, /* mayResolve */
${finalize}, /* finalize */
${call}, /* call */
nullptr, /* construct */
${trace}, /* trace */
};
static const DOMJSClass sClass = {
{ "${name}",
${flags},
&sClassOps,
JS_NULL_CLASS_SPEC,
${classExtension},
JS_NULL_OBJECT_OPS
},
$*{descriptor}
};
static_assert(${instanceReservedSlots} == DOM_INSTANCE_RESERVED_SLOTS,
"Must have the right minimal number of reserved slots.");
static_assert(${reservedSlots} >= ${slotCount},
"Must have enough reserved slots.");
""",
name=self.descriptor.interface.getClassName(),
flags=classFlags,
newEnumerate=newEnumerateHook,
resolve=resolveHook,
mayResolve=mayResolveHook,
finalize=FINALIZE_HOOK_NAME,
call=callHook,
trace=traceHook,
classExtension=classExtension,
descriptor=DOMClass(self.descriptor),
instanceReservedSlots=INSTANCE_RESERVED_SLOTS,
reservedSlots=reservedSlots,
slotCount=slotCount,
)
class CGDOMProxyJSClass(CGThing):
"""
Generate a DOMJSClass for a given proxy descriptor
"""
def __init__(self, descriptor):
CGThing.__init__(self)
self.descriptor = descriptor
def declare(self):
return ""
def define(self):
slotCount = InstanceReservedSlots(self.descriptor)
# We need one reserved slot (DOM_OBJECT_SLOT).
flags = ["JSCLASS_IS_DOMJSCLASS", "JSCLASS_HAS_RESERVED_SLOTS(%d)" % slotCount]
# We don't use an IDL annotation for JSCLASS_EMULATES_UNDEFINED because
# we don't want people ever adding that to any interface other than
# HTMLAllCollection. So just hardcode it here.
if self.descriptor.interface.identifier.name == "HTMLAllCollection":
flags.append("JSCLASS_EMULATES_UNDEFINED")
return fill(
"""
static const DOMJSClass sClass = {
PROXY_CLASS_DEF("${name}",
${flags}),
$*{descriptor}
};
""",
name=self.descriptor.interface.identifier.name,
flags=" | ".join(flags),
descriptor=DOMClass(self.descriptor),
)
class CGXrayExpandoJSClass(CGThing):
"""
Generate a JSClass for an Xray expando object. This is only
needed if we have members in slots (for [Cached] or [StoreInSlot]
stuff).
"""
def __init__(self, descriptor):
assert descriptor.interface.totalMembersInSlots != 0
assert descriptor.wantsXrays
assert descriptor.wantsXrayExpandoClass
CGThing.__init__(self)
self.descriptor = descriptor
def declare(self):
return ""
def define(self):
iface = getReflectedHTMLAttributesIface(self.descriptor)
if iface:
ops = (
"&%s::ReflectedHTMLAttributeSlots::sXrayExpandoObjectClassOps"
% toBindingNamespace(iface.identifier.name)
)
else:
ops = "&xpc::XrayExpandoObjectClassOps"
return fill(
"""
// This may allocate too many slots, because we only really need
// slots for our non-interface-typed members that we cache. But
// allocating slots only for those would make the slot index
// computations much more complicated, so let's do this the simple
// way for now.
DEFINE_XRAY_EXPANDO_CLASS_WITH_OPS(static, sXrayExpandoObjectClass, ${memberSlots},
${ops});
""",
memberSlots=self.descriptor.interface.totalMembersInSlots,
ops=ops,
)
def PrototypeIDAndDepth(descriptor):
prototypeID = "prototypes::id::"
if descriptor.interface.hasInterfacePrototypeObject():
prototypeID += descriptor.interface.identifier.name
depth = "PrototypeTraits<%s>::Depth" % prototypeID
else:
prototypeID += "_ID_Count"
depth = "0"
return (prototypeID, depth)
def InterfacePrototypeObjectProtoGetter(descriptor):
"""
Returns a tuple with two elements:
1) The name of the function to call to get the prototype to use for the
interface prototype object as a JSObject*.
2) The name of the function to call to get the prototype to use for the
interface prototype object as a JS::Handle<JSObject*> or None if no
such function exists.
"""
parentProtoName = descriptor.parentPrototypeName
if descriptor.hasNamedPropertiesObject:
protoGetter = "GetNamedPropertiesObject"
protoHandleGetter = None
elif parentProtoName is None:
protoHandleGetter = None
if descriptor.interface.getExtendedAttribute("ExceptionClass"):
protoGetter = "JS::GetRealmErrorPrototype"
elif descriptor.interface.isIteratorInterface():
protoGetter = "JS::GetRealmIteratorPrototype"
elif descriptor.interface.isAsyncIteratorInterface():
protoGetter = "JS::GetRealmAsyncIteratorPrototype"
else:
protoGetter = "JS::GetRealmObjectPrototype"
protoHandleGetter = "JS::GetRealmObjectPrototypeHandle"
else:
prefix = toBindingNamespace(parentProtoName)
protoGetter = prefix + "::GetProtoObject"
protoHandleGetter = prefix + "::GetProtoObjectHandle"
return (protoGetter, protoHandleGetter)
class CGPrototypeJSClass(CGThing):
def __init__(self, descriptor, properties):
CGThing.__init__(self)
self.descriptor = descriptor
self.properties = properties
def declare(self):
# We're purely for internal consumption
return ""
def define(self):
prototypeID, depth = PrototypeIDAndDepth(self.descriptor)
slotCount = "DOM_INTERFACE_PROTO_SLOTS_BASE"
# Globals handle unforgeables directly in Wrap() instead of
# via a holder.
if (
self.descriptor.hasLegacyUnforgeableMembers
and not self.descriptor.isGlobal()
):
slotCount += (
" + 1 /* slot for the JSObject holding the unforgeable properties */"
)
(protoGetter, _) = InterfacePrototypeObjectProtoGetter(self.descriptor)
type = (
"eGlobalInterfacePrototype"
if self.descriptor.isGlobal()
else "eInterfacePrototype"
)
return fill(
"""
static const DOMIfaceAndProtoJSClass sPrototypeClass = {
{
"${name}Prototype",
JSCLASS_IS_DOMIFACEANDPROTOJSCLASS | JSCLASS_HAS_RESERVED_SLOTS(${slotCount}),
JS_NULL_CLASS_OPS,
JS_NULL_CLASS_SPEC,
JS_NULL_CLASS_EXT,
JS_NULL_OBJECT_OPS
},
${type},
${prototypeID},
${depth},
${hooks},
${protoGetter}
};
""",
name=self.descriptor.interface.getClassName(),
slotCount=slotCount,
type=type,
hooks=NativePropertyHooks(self.descriptor),
prototypeID=prototypeID,
depth=depth,
protoGetter=protoGetter,
)
def InterfaceObjectProtoGetter(descriptor):
"""
Returns the name of the function to call to get the prototype to use for the
interface object's prototype as a JS::Handle<JSObject*>.
"""
assert not descriptor.interface.isNamespace()
parentInterface = descriptor.interface.parent
if parentInterface:
parentIfaceName = parentInterface.identifier.name
parentDesc = descriptor.getDescriptor(parentIfaceName)
prefix = toBindingNamespace(parentDesc.name)
protoHandleGetter = prefix + "::GetConstructorObjectHandle"
else:
protoHandleGetter = "JS::GetRealmFunctionPrototypeHandle"
return protoHandleGetter
class CGNamespaceObjectJSClass(CGThing):
def __init__(self, descriptor):
CGThing.__init__(self)
self.descriptor = descriptor
def declare(self):
# We're purely for internal consumption
return ""
def define(self):
classString = self.descriptor.interface.getExtendedAttribute("ClassString")
if classString is None:
classString = self.descriptor.interface.identifier.name
else:
classString = classString[0]
return fill(
"""
static const DOMIfaceAndProtoJSClass sNamespaceObjectClass = {
{
"${classString}",
JSCLASS_IS_DOMIFACEANDPROTOJSCLASS,
JS_NULL_CLASS_OPS,
JS_NULL_CLASS_SPEC,
JS_NULL_CLASS_EXT,
JS_NULL_OBJECT_OPS
},
eNamespace,
prototypes::id::_ID_Count,
0,
${hooks},
// This isn't strictly following the spec (see
// but should be ok for Xrays.
JS::GetRealmObjectPrototype
};
""",
classString=classString,
hooks=NativePropertyHooks(self.descriptor),
)
class CGInterfaceObjectInfo(CGThing):
def __init__(self, descriptor):
CGThing.__init__(self)
self.descriptor = descriptor
def declare(self):
# We're purely for internal consumption
return ""
def define(self):
if self.descriptor.interface.ctor():
ctorname = CONSTRUCT_HOOK_NAME
constructorArgs = methodLength(self.descriptor.interface.ctor())
else:
ctorname = "ThrowingConstructor"
constructorArgs = 0
constructorName = self.descriptor.interface.getClassName()
wantsIsInstance = self.descriptor.interface.hasInterfacePrototypeObject()
prototypeID, depth = PrototypeIDAndDepth(self.descriptor)
protoHandleGetter = InterfaceObjectProtoGetter(self.descriptor)
return fill(
"""
static const DOMInterfaceInfo sInterfaceObjectInfo = {
{ ${ctorname}, ${hooks} },
${protoHandleGetter},
${depth},
${prototypeID},
${wantsIsInstance},
${constructorArgs},
"${constructorName}",
};
""",
ctorname=ctorname,
hooks=NativePropertyHooks(self.descriptor),
protoHandleGetter=protoHandleGetter,
depth=depth,
prototypeID=prototypeID,
wantsIsInstance=toStringBool(wantsIsInstance),
constructorArgs=constructorArgs,
constructorName=constructorName,
)
class CGList(CGThing):
"""
Generate code for a list of GCThings. Just concatenates them together, with
an optional joiner string. "\n" is a common joiner.
"""
def __init__(self, children, joiner=""):
CGThing.__init__(self)
# Make a copy of the kids into a list, because if someone passes in a
# generator we won't be able to both declare and define ourselves, or
# define ourselves more than once!
self.children = list(children)
self.joiner = joiner
def append(self, child):
self.children.append(child)
def prepend(self, child):
self.children.insert(0, child)
def extend(self, kids):
self.children.extend(kids)
def join(self, iterable):
return self.joiner.join(s for s in iterable if len(s) > 0)
def declare(self):
return self.join(
child.declare() for child in self.children if child is not None
)
def define(self):
return self.join(child.define() for child in self.children if child is not None)
def forward_declare(self):
return self.join(
child.forward_declare() for child in self.children if child is not None
)
def deps(self):
deps = set()
for child in self.children:
if child is None:
continue
deps = deps.union(child.deps())
return deps
def __len__(self):
return len(self.children)
class CGGeneric(CGThing):
"""
A class that spits out a fixed string into the codegen. Can spit out a
separate string for the declaration too.
"""
def __init__(self, define="", declare="", forward_declare=""):
self.declareText = declare
self.defineText = define
self.forwardDeclareText = forward_declare
def declare(self):
return self.declareText
def define(self):
return self.defineText
def forward_declare(self):
return self.forwardDeclareText
def deps(self):
return set()
class CGIndenter(CGThing):
"""
A class that takes another CGThing and generates code that indents that
CGThing by some number of spaces. The default indent is two spaces.
"""
def __init__(self, child, indentLevel=2, declareOnly=False):
assert isinstance(child, CGThing)
CGThing.__init__(self)
self.child = child
self.indentLevel = indentLevel
self.declareOnly = declareOnly
def declare(self):
return indent(self.child.declare(), self.indentLevel)
def define(self):
defn = self.child.define()
if self.declareOnly:
return defn
else:
return indent(defn, self.indentLevel)
class CGWrapper(CGThing):
"""
Generic CGThing that wraps other CGThings with pre and post text.
"""
def __init__(
self,
child: CGThing,
pre="",
post="",
declarePre=None,
declarePost=None,
definePre=None,
definePost=None,
forwardDeclarePre=None,
forwardDeclarePost=None,
declareOnly=False,
defineOnly=False,
reindent=False,
):
CGThing.__init__(self)
self.child = child
self.declarePre = declarePre or pre
self.declarePost = declarePost or post
self.definePre = definePre or pre
self.definePost = definePost or post
self.forwardDeclarePre = forwardDeclarePre or pre
self.forwardDeclarePost = forwardDeclarePost or post
self.declareOnly = declareOnly
self.defineOnly = defineOnly
self.reindent = reindent
def declare(self):
if self.defineOnly:
return ""
decl = self.child.declare()
if self.reindent:
decl = self.reindentString(decl, self.declarePre)
return self.declarePre + decl + self.declarePost
def define(self):
if self.declareOnly:
return ""
defn = self.child.define()
if self.reindent:
defn = self.reindentString(defn, self.definePre)
return self.definePre + defn + self.definePost
def forward_declare(self):
if self.defineOnly:
return ""
decl = self.child.forward_declare()
if self.reindent:
decl = self.reindentString(decl, self.forwardDeclarePre)
return self.forwardDeclarePre + decl + self.forwardDeclarePost
@staticmethod
def reindentString(stringToIndent, widthString):
# We don't use lineStartDetector because we don't want to
# insert whitespace at the beginning of our _first_ line.
# Use the length of the last line of width string, in case
# it is a multiline string.
lastLineWidth = len(widthString.splitlines()[-1])
return stripTrailingWhitespace(
stringToIndent.replace("\n", "\n" + (" " * lastLineWidth))
)
def deps(self):
return self.child.deps()
class CGIfWrapper(CGList):
def __init__(self, child, condition):
CGList.__init__(
self,
[
CGWrapper(
CGGeneric(condition), pre="if (", post=") {\n", reindent=True
),
CGIndenter(child),
CGGeneric("}\n"),
],
)
class CGIfElseWrapper(CGList):
def __init__(self, condition, ifTrue, ifFalse):
CGList.__init__(
self,
[
CGWrapper(
CGGeneric(condition), pre="if (", post=") {\n", reindent=True
),
CGIndenter(ifTrue),
CGGeneric("} else {\n"),
CGIndenter(ifFalse),
CGGeneric("}\n"),
],
)
class CGElseChain(CGThing):
"""
Concatenate if statements in an if-else-if-else chain.
"""
def __init__(self, children):
self.children = [c for c in children if c is not None]
def declare(self):
assert False
def define(self):
if not self.children:
return ""
s = self.children[0].define()
assert s.endswith("\n")
for child in self.children[1:]:
code = child.define()
assert code.startswith("if") or code.startswith("{")
assert code.endswith("\n")
s = s.rstrip() + " else " + code
return s
class CGTemplatedType(CGWrapper):
def __init__(self, templateName, child, isConst=False, isReference=False):
if isinstance(child, list):
child = CGList(child, ", ")
const = "const " if isConst else ""
pre = "%s%s<" % (const, templateName)
ref = "&" if isReference else ""
post = ">%s" % ref
CGWrapper.__init__(self, child, pre=pre, post=post)
class CGNamespace(CGThing):
"""
Generates namespace block that wraps other CGThings.
"""
def __init__(self, namespace, child):
CGThing.__init__(self)
self.child = child
self.pre = "namespace %s {\n" % namespace
self.post = "} // namespace %s\n" % namespace
def declare(self):
decl = self.child.declare()
if len(decl.strip()) == 0:
return ""
return self.pre + decl + self.post
def define(self):
defn = self.child.define()
if len(defn.strip()) == 0:
return ""
return self.pre + defn + self.post
def forward_declare(self):
decl = self.child.forward_declare()
if len(decl.strip()) == 0:
return ""
return self.pre + decl + self.post
def deps(self):
return self.child.deps()
@staticmethod
def build(namespaces, child):
"""
Static helper method to build multiple wrapped namespaces.
"""
if not namespaces:
return CGWrapper(child)
return CGNamespace("::".join(namespaces), child)
class CGIncludeGuard(CGWrapper):
"""
Generates include guards for a header.
"""
def __init__(self, prefix, child):
"""|prefix| is the filename without the extension."""
define = "DOM_%s_H_" % prefix.upper()
forward_define = "DOM_%sFWD_H_" % prefix.upper()
CGWrapper.__init__(
self,
child,
declarePre="#ifndef %s\n#define %s\n\n" % (define, define),
declarePost="\n#endif // %s\n" % define,
forwardDeclarePre="#ifndef %s\n#define %s\n\n"
% (forward_define, forward_define),
forwardDeclarePost="\n#endif // %s\n" % forward_define,
)
class CGHeaders(CGWrapper):
"""
Generates the appropriate include statements.
"""
def __init__(
self,
descriptors,
dictionaries,
callbacks,
callbackDescriptors,
declareIncludes,
defineIncludes,
prefix,
child,
config=None,
jsImplementedDescriptors=[],
):
"""
Builds a set of includes to cover |descriptors|.
Also includes the files in |declareIncludes| in the header
file and the files in |defineIncludes| in the .cpp.
|prefix| contains the basename of the file that we generate include
statements for.
"""
# Determine the filenames for which we need headers.
interfaceDeps = [d.interface for d in descriptors]
ancestors = []
for iface in interfaceDeps:
if iface.parent:
# We're going to need our parent's prototype, to use as the
# prototype of our prototype object.
ancestors.append(iface.parent)
# And if we have an interface object, we'll need the nearest
# ancestor with an interface object too, so we can use its
# interface object as the proto of our interface object.
if iface.hasInterfaceObject():
parent = iface.parent
while parent and not parent.hasInterfaceObject():
parent = parent.parent
if parent:
ancestors.append(parent)
interfaceDeps.extend(ancestors)
# Include parent interface headers needed for default toJSON code.
jsonInterfaceParents = []
for desc in descriptors:
if not desc.hasDefaultToJSON:
continue
parent = desc.interface.parent
while parent:
parentDesc = desc.getDescriptor(parent.identifier.name)
if parentDesc.hasDefaultToJSON:
jsonInterfaceParents.append(parentDesc.interface)
parent = parent.parent
interfaceDeps.extend(jsonInterfaceParents)
bindingIncludes = set(self.getDeclarationFilename(d) for d in interfaceDeps)
# Grab all the implementation declaration files we need.
implementationIncludes = set(
d.headerFile for d in descriptors if d.needsHeaderInclude()
)
# Now find all the things we'll need as arguments because we
# need to wrap or unwrap them.
bindingHeaders = set()
declareIncludes = set(declareIncludes)
def addHeadersForType(typeAndPossibleOriginType):
"""
Add the relevant headers for this type. We use its origin type, if
passed, to decide what to do with interface types.
"""
t, originType = typeAndPossibleOriginType
isFromDictionary = originType and originType.isDictionary()
isFromCallback = originType and originType.isCallback()
# Dictionaries have members that need to be actually
# declared, not just forward-declared.
# Callbacks have nullable union arguments that need to be actually
# declared, not just forward-declared.
if isFromDictionary:
headerSet = declareIncludes
elif isFromCallback and t.nullable() and t.isUnion():
headerSet = declareIncludes
else:
headerSet = bindingHeaders
# Strip off outer layers and add headers they might require. (This
# is conservative: only nullable non-pointer types need Nullable.h;
# only sequences or observable arrays outside unions need
# ForOfIterator.h; only functions that return, and attributes that
# are, sequences or observable arrays in interfaces need Array.h, &c.)
unrolled = t
while True:
if idlTypeNeedsCallContext(unrolled):
bindingHeaders.add("mozilla/dom/BindingCallContext.h")
if unrolled.nullable():
headerSet.add("mozilla/dom/Nullable.h")
elif unrolled.isSequence() or unrolled.isObservableArray():
bindingHeaders.add("js/Array.h")
bindingHeaders.add("js/ForOfIterator.h")
if unrolled.isObservableArray():
bindingHeaders.add("mozilla/dom/ObservableArrayProxyHandler.h")
else:
break
unrolled = unrolled.inner
if unrolled.isUnion():
headerSet.add(self.getUnionDeclarationFilename(config, unrolled))
for t in unrolled.flatMemberTypes:
addHeadersForType((t, None))
elif unrolled.isPromise():
# See comment in the isInterface() case for why we add
# Promise.h to headerSet, not bindingHeaders.
headerSet.add("mozilla/dom/Promise.h")
# We need ToJSValue to do the Promise to JS conversion.
bindingHeaders.add("mozilla/dom/ToJSValue.h")
elif unrolled.isInterface():
if unrolled.isSpiderMonkeyInterface():
bindingHeaders.add("jsfriendapi.h")
if jsImplementedDescriptors:
# Since we can't forward-declare typed array types
# (because they're typedefs), we have to go ahead and
# just include their header if we need to have functions
# taking references to them declared in that header.
headerSet = declareIncludes
headerSet.add("mozilla/dom/TypedArray.h")
else:
try:
typeDesc = config.getDescriptor(unrolled.inner.identifier.name)
except NoSuchDescriptorError:
return
# Dictionaries with interface members rely on the
# actual class definition of that interface member
# being visible in the binding header, because they
# store them in RefPtr and have inline
# constructors/destructors.
#
# XXXbz maybe dictionaries with interface members
# should just have out-of-line constructors and
# destructors?
headerSet.add(typeDesc.headerFile)
elif unrolled.isDictionary():
headerSet.add(self.getDeclarationFilename(unrolled.inner))
# And if it needs rooting, we need RootedDictionary too
if typeNeedsRooting(unrolled):
headerSet.add("mozilla/dom/RootedDictionary.h")
elif unrolled.isCallback():
headerSet.add(self.getDeclarationFilename(unrolled.callback))
elif unrolled.isFloat() and not unrolled.isUnrestricted():
# Restricted floats are tested for finiteness
bindingHeaders.add("mozilla/FloatingPoint.h")
bindingHeaders.add("mozilla/dom/PrimitiveConversions.h")
elif unrolled.isEnum():
filename = self.getDeclarationFilename(unrolled.inner)
declareIncludes.add(filename)
elif unrolled.isPrimitive():
bindingHeaders.add("mozilla/dom/PrimitiveConversions.h")
elif unrolled.isRecord():
if isFromDictionary or jsImplementedDescriptors:
declareIncludes.add("mozilla/dom/Record.h")
else:
bindingHeaders.add("mozilla/dom/Record.h")
# Also add headers for the type the record is
# parametrized over, if needed.
addHeadersForType((t.inner, originType if isFromDictionary else None))
for t in getAllTypes(
descriptors + callbackDescriptors, dictionaries, callbacks
):
addHeadersForType(t)
def addHeaderForFunc(func, desc):
if func is None:
return
# Include the right class header, which we can only do
# if this is a class member function.
if desc is not None and not desc.headerIsDefault:
# An explicit header file was provided, assume that we know
# what we're doing.
return
if "::" in func:
# Strip out the function name and convert "::" to "/"
bindingHeaders.add("/".join(func.split("::")[:-1]) + ".h")
# Now for non-callback descriptors make sure we include any
# headers needed by Func declarations and other things like that.
for desc in descriptors:
# If this is an iterator or an async iterator interface generated
# for a separate iterable interface, skip generating type includes,
# as we have what we need in IterableIterator.h
if (
desc.interface.isIteratorInterface()
or desc.interface.isAsyncIteratorInterface()
):
continue
for m in desc.interface.members:
addHeaderForFunc(PropertyDefiner.getStringAttr(m, "Func"), desc)
staticTypeOverride = PropertyDefiner.getStringAttr(
m, "StaticClassOverride"
)
if staticTypeOverride:
bindingHeaders.add("/".join(staticTypeOverride.split("::")) + ".h")
# getExtendedAttribute() returns a list, extract the entry.
funcList = desc.interface.getExtendedAttribute("Func")
if funcList is not None:
addHeaderForFunc(funcList[0], desc)
if desc.interface.maplikeOrSetlikeOrIterable:
# We need ToJSValue.h for maplike/setlike type conversions
bindingHeaders.add("mozilla/dom/ToJSValue.h")
# Add headers for the key and value types of the
# maplike/setlike/iterable, since they'll be needed for
# convenience functions
if desc.interface.maplikeOrSetlikeOrIterable.hasKeyType():
addHeadersForType(
(desc.interface.maplikeOrSetlikeOrIterable.keyType, None)
)
if desc.interface.maplikeOrSetlikeOrIterable.hasValueType():
addHeadersForType(
(desc.interface.maplikeOrSetlikeOrIterable.valueType, None)
)
for d in dictionaries:
if d.parent:
declareIncludes.add(self.getDeclarationFilename(d.parent))
bindingHeaders.add(self.getDeclarationFilename(d))
for m in d.members:
addHeaderForFunc(PropertyDefiner.getStringAttr(m, "Func"), None)
# No need to worry about Func on members of ancestors, because that
# will happen automatically in whatever files those ancestors live
# in.
for c in callbacks:
bindingHeaders.add(self.getDeclarationFilename(c))
for c in callbackDescriptors:
bindingHeaders.add(self.getDeclarationFilename(c.interface))
if len(callbacks) != 0:
# We need CallbackFunction to serve as our parent class
declareIncludes.add("mozilla/dom/CallbackFunction.h")
# And we need ToJSValue.h so we can wrap "this" objects
declareIncludes.add("mozilla/dom/ToJSValue.h")
if len(callbackDescriptors) != 0 or len(jsImplementedDescriptors) != 0:
# We need CallbackInterface to serve as our parent class
declareIncludes.add("mozilla/dom/CallbackInterface.h")
# And we need ToJSValue.h so we can wrap "this" objects
declareIncludes.add("mozilla/dom/ToJSValue.h")
# Also need to include the headers for ancestors of
# JS-implemented interfaces.
for jsImplemented in jsImplementedDescriptors:
jsParent = jsImplemented.interface.parent
if jsParent:
parentDesc = jsImplemented.getDescriptor(jsParent.identifier.name)
declareIncludes.add(parentDesc.jsImplParentHeader)
# Now make sure we're not trying to include the header from inside itself
declareIncludes.discard(prefix + ".h")
# Let the machinery do its thing.
def _includeString(includes):
def headerName(include):
# System headers are specified inside angle brackets.
if include.startswith("<"):
return include
# Non-system headers need to be placed in quotes.
return '"%s"' % include
return "".join(["#include %s\n" % headerName(i) for i in includes]) + "\n"
CGWrapper.__init__(
self,
child,
declarePre=_includeString(sorted(declareIncludes)),
definePre=_includeString(
sorted(
set(defineIncludes)
| bindingIncludes
| bindingHeaders
| implementationIncludes
)
),
)
@staticmethod
def getDeclarationFilename(decl):
# Use our local version of the header, not the exported one, so that
# test bindings, which don't export, will work correctly.
basename = os.path.basename(decl.filename)
return basename.replace(".webidl", "Binding.h")
@staticmethod
def getUnionDeclarationFilename(config, unionType):
assert unionType.isUnion()
assert unionType.unroll() == unionType
# If a union is "defined" in multiple files, it goes in UnionTypes.h.
if len(config.filenamesPerUnion[unionType.name]) > 1:
return "mozilla/dom/UnionTypes.h"
# If a union is defined by a built-in typedef, it also goes in
# UnionTypes.h.
assert len(config.filenamesPerUnion[unionType.name]) == 1
if "<unknown>" in config.filenamesPerUnion[unionType.name]:
return "mozilla/dom/UnionTypes.h"
return CGHeaders.getDeclarationFilename(unionType)
def SortedDictValues(d):
"""
Returns a list of values from the dict sorted by key.
"""
return [v for k, v in sorted(d.items())]
def UnionsForFile(config, webIDLFile):
"""
Returns a list of union types for all union types that are only used in
webIDLFile. If webIDLFile is None this will return the list of tuples for
union types that are used in more than one WebIDL file.
"""
return config.unionsPerFilename.get(webIDLFile, [])
def UnionTypes(unionTypes, config):
"""
The unionTypes argument should be a list of union types. This is typically
the list generated by UnionsForFile.
Returns a tuple containing a set of header filenames to include in
the header for the types in unionTypes, a set of header filenames to
include in the implementation file for the types in unionTypes, a set
of tuples containing a type declaration and a boolean if the type is a
struct for member types of the union, a list of traverse methods,
unlink methods and a list of union types. These last three lists only
contain unique union types.
"""
headers = set()
implheaders = set()
declarations = set()
unionStructs = dict()
traverseMethods = dict()
unlinkMethods = dict()
for t in unionTypes:
name = str(t)
if name not in unionStructs:
unionStructs[name] = t
def addHeadersForType(f):
if f.nullable():
headers.add("mozilla/dom/Nullable.h")
isSequence = f.isSequence()
if isSequence:
# Dealing with sequences requires for-of-compatible
# iteration.
implheaders.add("js/ForOfIterator.h")
# Sequences can always throw "not an object" exceptions.
implheaders.add("mozilla/dom/BindingCallContext.h")
if typeNeedsRooting(f):
headers.add("mozilla/dom/RootedSequence.h")
f = f.unroll()
if idlTypeNeedsCallContext(f):
implheaders.add("mozilla/dom/BindingCallContext.h")
if f.isPromise():
headers.add("mozilla/dom/Promise.h")
# We need ToJSValue to do the Promise to JS conversion.
headers.add("mozilla/dom/ToJSValue.h")
elif f.isInterface():
if f.isSpiderMonkeyInterface():
headers.add("js/RootingAPI.h")
headers.add("js/Value.h")
headers.add("mozilla/dom/TypedArray.h")
else:
try:
typeDesc = config.getDescriptor(f.inner.identifier.name)
except NoSuchDescriptorError:
return
if typeDesc.interface.isCallback() or isSequence:
# Callback interfaces always use strong refs, so
# we need to include the right header to be able
# to Release() in our inlined code.
#
# Similarly, sequences always contain strong
# refs, so we'll need the header to handler
# those.
headers.add(typeDesc.headerFile)
elif typeDesc.interface.identifier.name == "WindowProxy":
# In UnionTypes.h we need to see the declaration of the
# WindowProxyHolder that we use to store the WindowProxy, so
# we have its sizeof and know how big to make our union.
headers.add(typeDesc.headerFile)
else:
declarations.add((typeDesc.nativeType, False))
implheaders.add(typeDesc.headerFile)
elif f.isDictionary():
# For a dictionary, we need to see its declaration in
# UnionTypes.h so we have its sizeof and know how big to
# make our union.
headers.add(CGHeaders.getDeclarationFilename(f.inner))
# And if it needs rooting, we need RootedDictionary too
if typeNeedsRooting(f):
headers.add("mozilla/dom/RootedDictionary.h")
elif f.isFloat() and not f.isUnrestricted():
# Restricted floats are tested for finiteness
implheaders.add("mozilla/FloatingPoint.h")
implheaders.add("mozilla/dom/PrimitiveConversions.h")
elif f.isEnum():
# Need to see the actual definition of the enum,
# unfortunately.
headers.add(CGHeaders.getDeclarationFilename(f.inner))
elif f.isPrimitive():
implheaders.add("mozilla/dom/PrimitiveConversions.h")
elif f.isCallback():
# Callbacks always use strong refs, so we need to include
# the right header to be able to Release() in our inlined
# code.
headers.add(CGHeaders.getDeclarationFilename(f.callback))
elif f.isRecord():
headers.add("mozilla/dom/Record.h")
# And add headers for the type we're parametrized over
addHeadersForType(f.inner)
# And if it needs rooting, we need RootedRecord too
if typeNeedsRooting(f):
headers.add("mozilla/dom/RootedRecord.h")
implheaders.add(CGHeaders.getUnionDeclarationFilename(config, t))
for f in t.flatMemberTypes:
assert not f.nullable()
addHeadersForType(f)
if idlTypeNeedsCycleCollection(t):
declarations.add(
("mozilla::dom::%s" % CGUnionStruct.unionTypeName(t, True), False)
)
traverseMethods[name] = CGCycleCollectionTraverseForOwningUnionMethod(t)
unlinkMethods[name] = CGCycleCollectionUnlinkForOwningUnionMethod(t)
# The order of items in CGList is important.
# Since the union structs friend the unlinkMethods, the forward-declaration
# for these methods should come before the class declaration. Otherwise
# some compilers treat the friend declaration as a forward-declaration in
# the class scope.
return (
headers,
implheaders,
declarations,
SortedDictValues(traverseMethods),
SortedDictValues(unlinkMethods),
SortedDictValues(unionStructs),
)
class Argument:
"""
A class for outputting the type and name of an argument
"""
def __init__(self, argType, name, default=None):
self.argType = argType
self.name = name
self.default = default
def declare(self):
string = self.argType + " " + self.name
if self.default is not None:
string += " = " + self.default
return string
def define(self):
return self.argType + " " + self.name
class CGAbstractMethod(CGThing):
"""
An abstract class for generating code for a method. Subclasses
should override definition_body to create the actual code.
descriptor is the descriptor for the interface the method is associated with
name is the name of the method as a string
returnType is the IDLType of the return value
args is a list of Argument objects
inline should be True to generate an inline method, whose body is
part of the declaration.
alwaysInline should be True to generate an inline method annotated with
MOZ_ALWAYS_INLINE.
static should be True to generate a static method, which only has
a definition.
If templateArgs is not None it should be a list of strings containing
template arguments, and the function will be templatized using those
arguments.
canRunScript should be True to generate a MOZ_CAN_RUN_SCRIPT annotation.
signatureOnly should be True to only declare the signature (either in
the header, or if static is True in the cpp file).
"""
def __init__(
self,
descriptor,
name,
returnType,
args,
inline=False,
alwaysInline=False,
static=False,
templateArgs=None,
canRunScript=False,
signatureOnly=False,
):
CGThing.__init__(self)
self.descriptor = descriptor
self.name = name
self.returnType = returnType
self.args = args
self.inline = inline
self.alwaysInline = alwaysInline
self.static = static
self.templateArgs = templateArgs
self.canRunScript = canRunScript
self.signatureOnly = signatureOnly
def _argstring(self, declare):
return ", ".join([a.declare() if declare else a.define() for a in self.args])
def _template(self):
if self.templateArgs is None:
return ""
return "template <%s>\n" % ", ".join(self.templateArgs)
def _decorators(self):
decorators = []
if self.canRunScript:
decorators.append("MOZ_CAN_RUN_SCRIPT")
if self.alwaysInline:
decorators.append("MOZ_ALWAYS_INLINE")
elif self.inline:
decorators.append("inline")
if self.static:
decorators.append("static")
decorators.append(self.returnType)
maybeNewline = " " if self.inline else "\n"
return " ".join(decorators) + maybeNewline
def signature(self):
return "%s%s%s(%s);\n" % (
self._template(),
self._decorators(),
self.name,
self._argstring(True),
)
def declare(self):
if self.static:
return ""
if self.inline:
return self._define(True)
return self.signature()
def indent_body(self, body):
"""
Indent the code returned by self.definition_body(). Most classes
simply indent everything two spaces. This is here for
CGRegisterProtos, which needs custom indentation.
"""
return indent(body)
def _define(self, fromDeclare=False):
return (
self.definition_prologue(fromDeclare)
+ self.indent_body(self.definition_body())
+ self.definition_epilogue()
)
def define(self):
if self.signatureOnly:
if self.static:
# self.static makes us not output anything in the header, so output the signature here.
return self.signature()
return ""
return "" if (self.inline and not self.static) else self._define()
def definition_prologue(self, fromDeclare):
error_reporting_label = self.error_reporting_label()
if error_reporting_label:
# We're going to want a BindingCallContext. Rename our JSContext*
# arg accordingly.
i = 0
while i < len(self.args):
arg = self.args[i]
if arg.argType == "JSContext*":
cxname = arg.name
self.args[i] = Argument(arg.argType, "cx_", arg.default)
break
i += 1
if i == len(self.args):
raise TypeError("Must have a JSContext* to create a BindingCallContext")
prologue = "%s%s%s(%s)\n{\n" % (
self._template(),
self._decorators(),
self.name,
self._argstring(fromDeclare),
)
if error_reporting_label:
prologue += indent(
fill(
"""
BindingCallContext ${cxname}(cx_, ${label});
""",
cxname=cxname,
label=error_reporting_label,
)
)
profiler_label = self.auto_profiler_label()
if profiler_label:
prologue += indent(profiler_label) + "\n"
return prologue
def definition_epilogue(self):
return "}\n"
def definition_body(self):
assert False # Override me!
"""
Override this method to return a pair of (descriptive string, name of a
JSContext* variable) in order to generate a profiler label for this method.
"""
def auto_profiler_label(self):
return None # Override me!
"""
Override this method to return a string to be used as the label for a
BindingCallContext. If this does not return None, one of the arguments of
this method must be of type 'JSContext*'. Its name will be replaced with
'cx_' and a BindingCallContext named 'cx' will be instantiated with the
given label.
"""
def error_reporting_label(self):
return None # Override me!
class CGAbstractStaticMethod(CGAbstractMethod):
"""
Abstract base class for codegen of implementation-only (no
declaration) static methods.
"""
def __init__(self, descriptor, name, returnType, args, canRunScript=False):
CGAbstractMethod.__init__(
self,
descriptor,
name,
returnType,
args,
inline=False,
static=True,
canRunScript=canRunScript,
)
class CGAbstractClassHook(CGAbstractStaticMethod):
"""
Meant for implementing JSClass hooks, like Finalize or Trace. Does very raw
'this' unwrapping as it assumes that the unwrapped type is always known.
"""
def __init__(self, descriptor, name, returnType, args):
CGAbstractStaticMethod.__init__(self, descriptor, name, returnType, args)
def definition_body_prologue(self):
return "%s* self = UnwrapPossiblyNotInitializedDOMObject<%s>(obj);\n" % (
self.descriptor.nativeType,
self.descriptor.nativeType,
)
def definition_body(self):
return self.definition_body_prologue() + self.generate_code()
def generate_code(self):
assert False # Override me!
class CGGetWrapperCacheHook(CGAbstractClassHook):
"""
A hook for GetWrapperCache, used by HasReleasedWrapper to get the
nsWrapperCache pointer for a non-nsISupports object.
"""
def __init__(self, descriptor):
args = [Argument("JS::Handle<JSObject*>", "obj")]
CGAbstractClassHook.__init__(
self, descriptor, GETWRAPPERCACHE_HOOK_NAME, "nsWrapperCache*", args
)
def generate_code(self):
assert self.descriptor.wrapperCache
return dedent(
"""
return self;
"""
)
class CGDefineHTMLAttributeSlots(CGThing):
"""
Function to get the slots object for reflected HTML attributes that return
a FrozenArray<Element> value.
"""
def __init__(self, descriptor):
self.descriptor = descriptor
CGThing.__init__(self)
def declare(self):
atts = self.descriptor.interface.reflectedHTMLAttributesReturningFrozenArray
return fill(
"""
using ReflectedHTMLAttributeSlots = binding_detail::ReflectedHTMLAttributeSlots<${slotIndex}, ${xraySlotIndex}, ${arrayLength}>;
""",
slotIndex=reservedSlot(atts.slotIndex, False),
xraySlotIndex=reservedSlot(atts.slotIndex, True),
arrayLength=atts.totalMembersInSlots,
)
def define(self):
return ""
def finalizeHook(descriptor, gcx, obj):
finalize = fill(
"""
${setReservedSlot}(${obj}, DOM_OBJECT_SLOT, JS::UndefinedValue());
""",
setReservedSlot=setReservedSlotFunc(descriptor),
obj=obj,
)
if descriptor.interface.getExtendedAttribute("LegacyOverrideBuiltIns"):
finalize += fill(
"""
// Either our proxy created an expando object or not. If it did,
// then we would have preserved ourselves, and hence if we're going
// away so is our C++ object and we should reset its expando value.
// It's possible that in this situation the C++ object's reflector
// pointer has been nulled out, but if not it's pointing to us. If
// our proxy did _not_ create an expando object then it's possible
// that we're no longer the reflector for our C++ object (and
// incremental finalization is finally getting to us), and that in
// the meantime the new reflector has created an expando object.
// In that case we do NOT want to clear the expando pointer in the
// C++ object.
//
// It's important to do this before we ClearWrapper, of course.
JSObject* reflector = self->GetWrapperMaybeDead();
if (!reflector || reflector == ${obj}) {
self->mExpandoAndGeneration.expando = JS::UndefinedValue();
}
""",
obj=obj,
)
for m in descriptor.interface.members:
if m.isAttr() and m.type.isObservableArray():
finalize += fill(
"""
{
JS::Value val = ${getReservedSlot}(obj, ${slot});
if (!val.isUndefined()) {
JSObject* proxyObj = &val.toObject();
js::SetProxyReservedSlot(proxyObj, OBSERVABLE_ARRAY_DOM_INTERFACE_SLOT, JS::UndefinedValue());
}
}
""",
getReservedSlot=getReservedSlotFunc(descriptor),
slot=memberReservedSlot(m, descriptor),
)
iface = getReflectedHTMLAttributesIface(descriptor)
if iface:
finalize += "%s::ReflectedHTMLAttributeSlots::Finalize(%s);\n" % (
toBindingNamespace(iface.identifier.name),
obj,
)
if descriptor.wrapperCache:
finalize += "ClearWrapper(self, self, %s);\n" % obj
if descriptor.isGlobal():
finalize += "mozilla::dom::FinalizeGlobal(%s, %s);\n" % (gcx, obj)
finalize += fill(
"""
if (size_t mallocBytes = BindingJSObjectMallocBytes(self)) {
JS::RemoveAssociatedMemory(${obj}, mallocBytes,
JS::MemoryUse::DOMBinding);
}
""",
obj=obj,
)
finalize += "AddForDeferredFinalization<%s>(self);\n" % descriptor.nativeType
return CGIfWrapper(CGGeneric(finalize), "self")
class CGClassFinalizeHook(CGAbstractClassHook):
"""
A hook for finalize, used to release our native object.
"""
def __init__(self, descriptor):
args = [Argument("JS::GCContext*", "gcx"), Argument("JSObject*", "obj")]
CGAbstractClassHook.__init__(self, descriptor, FINALIZE_HOOK_NAME, "void", args)
def generate_code(self):
return finalizeHook(
self.descriptor, self.args[0].name, self.args[1].name
).define()
def JSNativeArguments():
return [
Argument("JSContext*", "cx"),
Argument("unsigned", "argc"),
Argument("JS::Value*", "vp"),
]
class CGClassConstructor(CGAbstractStaticMethod):
"""
JS-visible constructor for our objects
"""
def __init__(self, descriptor, ctor, name=CONSTRUCT_HOOK_NAME):
CGAbstractStaticMethod.__init__(
self, descriptor, name, "bool", JSNativeArguments()
)
self._ctor = ctor
def define(self):
if not self._ctor:
return ""
return CGAbstractStaticMethod.define(self)
def definition_body(self):
return self.generate_code()
def generate_code(self):
if self._ctor.isHTMLConstructor():
# We better have a prototype object. Otherwise our proto
# id won't make sense.
assert self.descriptor.interface.hasInterfacePrototypeObject()
# We also better have a constructor object, if this is
# getting called!
assert self.descriptor.interface.hasInterfaceObject()
# We can't just pass null for the CreateInterfaceObjects callback,
# because our newTarget might be in a different compartment, in
# which case we'll need to look up constructor objects in that
# compartment.
return fill(
"""
return HTMLConstructor(cx, argc, vp,
constructors::id::${name},
prototypes::id::${name},
CreateInterfaceObjects);
""",
name=self.descriptor.name,
)
# If the interface is already SecureContext, notify getConditionList to skip that check,
# because the constructor won't be exposed in non-secure contexts to start with.
alreadySecureContext = self.descriptor.interface.getExtendedAttribute(
"SecureContext"
)
# We want to throw if any of the conditions returned by getConditionList are false.
conditionsCheck = ""
rawConditions = getRawConditionList(
self._ctor, "cx", "obj", alreadySecureContext
)
if len(rawConditions) > 0:
notConditions = " ||\n".join("!" + cond for cond in rawConditions)
failedCheckAction = CGGeneric("return ThrowingConstructor(cx, argc, vp);\n")
conditionsCheck = (
CGIfWrapper(failedCheckAction, notConditions).define() + "\n"
)
# Additionally, we want to throw if a caller does a bareword invocation
# of a constructor without |new|.
ctorName = GetConstructorNameForReporting(self.descriptor, self._ctor)
preamble = fill(
"""
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
JS::Rooted<JSObject*> obj(cx, &args.callee());
$*{conditionsCheck}
if (!args.isConstructing()) {
return ThrowConstructorWithoutNew(cx, "${ctorName}");
}
JS::Rooted<JSObject*> desiredProto(cx);
if (!GetDesiredProto(cx, args,
prototypes::id::${name},
CreateInterfaceObjects,
&desiredProto)) {
return false;
}
""",
conditionsCheck=conditionsCheck,
ctorName=ctorName,
name=self.descriptor.name,
)
name = self._ctor.identifier.name
nativeName = MakeNativeName(self.descriptor.binaryNameFor(name, True))
callGenerator = CGMethodCall(
nativeName, True, self.descriptor, self._ctor, isConstructor=True
)
return preamble + "\n" + callGenerator.define()
def auto_profiler_label(self):
return fill(
"""
AUTO_PROFILER_LABEL_DYNAMIC_FAST(
"${ctorName}", "constructor", DOM, cx,
uint32_t(js::ProfilingStackFrame::Flags::RELEVANT_FOR_JS));
""",
ctorName=GetConstructorNameForReporting(self.descriptor, self._ctor),
)
def error_reporting_label(self):
return CGSpecializedMethod.error_reporting_label_helper(
self.descriptor, self._ctor, isConstructor=True
)
def LegacyFactoryFunctionName(m):
return "_" + m.identifier.name
class CGLegacyFactoryFunctions(CGThing):
def __init__(self, descriptor):
self.descriptor = descriptor
CGThing.__init__(self)
def declare(self):
return ""
def define(self):
if len(self.descriptor.interface.legacyFactoryFunctions) == 0:
return ""
constructorID = "constructors::id::"
if self.descriptor.interface.hasInterfaceObject():
constructorID += self.descriptor.name
else:
constructorID += "_ID_Count"
legacyFactoryFunctions = ""
for n in self.descriptor.interface.legacyFactoryFunctions:
legacyFactoryFunctions += (
'{ "%s", { %s, &sLegacyFactoryFunctionNativePropertyHooks }, %i },\n'
% (n.identifier.name, LegacyFactoryFunctionName(n), methodLength(n))
)
return fill(
"""
bool sLegacyFactoryFunctionNativePropertiesInited = true;
const NativePropertyHooks sLegacyFactoryFunctionNativePropertyHooks = {
nullptr,
{ nullptr, nullptr, &sLegacyFactoryFunctionNativePropertiesInited },
prototypes::id::${name},
${constructorID},
nullptr
};
static const LegacyFactoryFunction legacyFactoryFunctions[] = {
$*{legacyFactoryFunctions}
};
""",
name=self.descriptor.name,
constructorID=constructorID,
legacyFactoryFunctions=legacyFactoryFunctions,
)
def isChromeOnly(m):
return m.getExtendedAttribute("ChromeOnly")
def prefIdentifier(pref):
return pref.replace(".", "_").replace("-", "_")
def prefHeader(pref):
return "mozilla/StaticPrefs_%s.h" % pref.partition(".")[0]
def computeGlobalNamesFromExposureSet(exposureSet):
assert exposureSet is None or isinstance(exposureSet, set)
if exposureSet:
# Nonempty set
return " | ".join(map(lambda g: "GlobalNames::%s" % g, sorted(exposureSet)))
return "0"
class MemberCondition:
"""
An object representing the condition for a member to actually be
exposed. Any of the arguments can be None. If not
None, they should have the following types:
pref: The name of the preference.
func: The name of the function.
secureContext: A bool indicating whether a secure context is required.
nonExposedGlobals: A set of names of globals. Can be empty, in which case
it's treated the same way as None.
trial: The name of the origin trial.
"""
def __init__(
self,
pref=None,
func=None,
secureContext=False,
nonExposedGlobals=None,
trial=None,
):
assert pref is None or isinstance(pref, str)
assert func is None or isinstance(func, str)
assert trial is None or isinstance(trial, str)
assert isinstance(secureContext, bool)
self.pref = pref
if self.pref:
identifier = prefIdentifier(self.pref)
self.prefFuncIndex = "WebIDLPrefIndex::" + identifier
else:
self.prefFuncIndex = "WebIDLPrefIndex::NoPref"
self.secureContext = secureContext
def toFuncPtr(val):
if val is None:
return "nullptr"
return "&" + val
self.func = toFuncPtr(func)
self.nonExposedGlobals = computeGlobalNamesFromExposureSet(nonExposedGlobals)
if trial:
self.trial = "OriginTrial::" + trial
else:
self.trial = "OriginTrial(0)"
def __eq__(self, other):
return (
self.pref == other.pref
and self.func == other.func
and self.secureContext == other.secureContext
and self.nonExposedGlobals == other.nonExposedGlobals
and self.trial == other.trial
)
def __ne__(self, other):
return not self.__eq__(other)
def hasDisablers(self):
return (
self.pref is not None
or self.secureContext
or self.func != "nullptr"
or self.nonExposedGlobals != "0"
or self.trial != "OriginTrial(0)"
)
class PropertyDefiner:
"""
A common superclass for defining things on prototype objects.
Subclasses should implement generateArray to generate the actual arrays of
things we're defining. They should also set self.chrome to the list of
things only exposed to chrome and self.regular to the list of things exposed
to both chrome and web pages.
"""
def __init__(self, descriptor, name):
self.descriptor = descriptor
self.name = name
def hasChromeOnly(self):
return len(self.chrome) > 0
def hasNonChromeOnly(self):
return len(self.regular) > 0
def variableName(self, chrome):
if chrome:
if self.hasChromeOnly():
return "sChrome" + self.name
else:
if self.hasNonChromeOnly():
return "s" + self.name
return "nullptr"
def usedForXrays(self):
return self.descriptor.wantsXrays
def length(self, chrome):
return len(self.chrome) if chrome else len(self.regular)
def __str__(self):
# We only need to generate id arrays for things that will end
# up used via ResolveProperty or EnumerateProperties.
str = self.generateArray(self.regular, self.variableName(False))
if self.hasChromeOnly():
str += self.generateArray(self.chrome, self.variableName(True))
return str
@staticmethod
def getStringAttr(member, name):
attr = member.getExtendedAttribute(name)
if attr is None:
return None
# It's a list of strings
assert len(attr) == 1
assert attr[0] is not None
return attr[0]
@staticmethod
def getControllingCondition(interfaceMember, descriptor):
interface = descriptor.interface
nonExposureSet = interface.exposureSet - interfaceMember.exposureSet
trial = PropertyDefiner.getStringAttr(interfaceMember, "Trial")
if trial and interface.identifier.name in ["Window", "Document"]:
raise TypeError(
% (interface.identifier.name, interfaceMember.identifier.name)
)
return MemberCondition(
PropertyDefiner.getStringAttr(interfaceMember, "Pref"),
PropertyDefiner.getStringAttr(interfaceMember, "Func"),
interfaceMember.getExtendedAttribute("SecureContext") is not None,
nonExposureSet,
trial,
)
@staticmethod
def generatePrefableArrayValues(
array,
descriptor,
specFormatter,
specTerminator,
getCondition,
getDataTuple,
switchToCondition=None,
):
"""
This method generates an array of spec entries for interface members. It returns
a tuple containing the array of spec entries and the maximum of the number of
spec entries per condition.
array is an array of interface members.
descriptor is the descriptor for the interface that array contains members of.
specFormatter is a function that takes a single argument, a tuple,
and returns a string, a spec array entry.
specTerminator is a terminator for the spec array (inserted every time
our controlling pref changes and at the end of the array).
getCondition is a callback function that takes an array entry and
returns the corresponding MemberCondition.
getDataTuple is a callback function that takes an array entry and
returns a tuple suitable to be passed to specFormatter.
switchToCondition is a function that takes a MemberCondition and an array of
previously generated spec entries. If None is passed for this function then all
the interface members should return the same value from getCondition.
"""
def unsupportedSwitchToCondition(condition, specs):
# If no specs have been added yet then this is just the first call to
# switchToCondition that we call to avoid putting a specTerminator at the
# front of the list.
if len(specs) == 0:
return
raise "Not supported"
if switchToCondition is None:
switchToCondition = unsupportedSwitchToCondition
specs = []
numSpecsInCurPrefable = 0
maxNumSpecsInPrefable = 0
# So we won't put a specTerminator at the very front of the list:
lastCondition = getCondition(array[0], descriptor)
switchToCondition(lastCondition, specs)
for member in array:
curCondition = getCondition(member, descriptor)
if lastCondition != curCondition:
# Terminate previous list
specs.append(specTerminator)
if numSpecsInCurPrefable > maxNumSpecsInPrefable:
maxNumSpecsInPrefable = numSpecsInCurPrefable
numSpecsInCurPrefable = 0
# And switch to our new condition
switchToCondition(curCondition, specs)
lastCondition = curCondition
# And the actual spec
specs.append(specFormatter(getDataTuple(member, descriptor)))
numSpecsInCurPrefable += 1
if numSpecsInCurPrefable > maxNumSpecsInPrefable:
maxNumSpecsInPrefable = numSpecsInCurPrefable
specs.append(specTerminator)
return (specs, maxNumSpecsInPrefable)
def generatePrefableArray(
self,
array,
name,
specFormatter,
specTerminator,
specType,
getCondition,
getDataTuple,
):
"""
This method generates our various arrays.
array is an array of interface members as passed to generateArray
name is the name as passed to generateArray
specFormatter is a function that takes a single argument, a tuple,
and returns a string, a spec array entry
specTerminator is a terminator for the spec array (inserted every time
our controlling pref changes and at the end of the array)
specType is the actual typename of our spec
getCondition is a callback function that takes an array entry and
returns the corresponding MemberCondition.
getDataTuple is a callback function that takes an array entry and
returns a tuple suitable to be passed to specFormatter.
"""
# We want to generate a single list of specs, but with specTerminator
# inserted at every point where the pref name controlling the member
# changes. That will make sure the order of the properties as exposed
# on the interface and interface prototype objects does not change when
# pref control is added to members while still allowing us to define all
# the members in the smallest number of JSAPI calls.
assert len(array) != 0
disablers = []
prefableSpecs = []
disablersTemplate = dedent(
"""
static const PrefableDisablers %s_disablers%d = {
%s, %s, %s, %s, %s
};
"""
)
prefableWithDisablersTemplate = " { &%s_disablers%d, &%s_specs[%d] }"
prefableWithoutDisablersTemplate = " { nullptr, &%s_specs[%d] }"
def switchToCondition(condition, specs):
# Set up pointers to the new sets of specs inside prefableSpecs
if condition.hasDisablers():
prefableSpecs.append(
prefableWithDisablersTemplate % (name, len(specs), name, len(specs))
)
disablers.append(
disablersTemplate
% (
name,
len(specs),
condition.prefFuncIndex,
condition.nonExposedGlobals,
toStringBool(condition.secureContext),
condition.trial,
condition.func,
)
)
else:
prefableSpecs.append(
prefableWithoutDisablersTemplate % (name, len(specs))
)
specs, maxNumSpecsInPrefable = self.generatePrefableArrayValues(
array,
self.descriptor,
specFormatter,
specTerminator,
getCondition,
getDataTuple,
switchToCondition,
)
prefableSpecs.append(" { nullptr, nullptr }")
specType = "const " + specType
arrays = fill(
"""
MOZ_GLOBINIT static ${specType} ${name}_specs[] = {
${specs}
};
${disablers}
static const Prefable<${specType}> ${name}[] = {
${prefableSpecs}
};
""",
specType=specType,
name=name,
disablers="\n".join(disablers),
specs=",\n".join(specs),
prefableSpecs=",\n".join(prefableSpecs),
)
if self.usedForXrays():
arrays = fill(
"""
$*{arrays}
static_assert(${numPrefableSpecs} <= 1ull << NUM_BITS_PROPERTY_INFO_PREF_INDEX,
"We have a prefable index that is >= (1 << NUM_BITS_PROPERTY_INFO_PREF_INDEX)");
static_assert(${maxNumSpecsInPrefable} <= 1ull << NUM_BITS_PROPERTY_INFO_SPEC_INDEX,
"We have a spec index that is >= (1 << NUM_BITS_PROPERTY_INFO_SPEC_INDEX)");
""",
arrays=arrays,
# Minus 1 because there's a list terminator in prefableSpecs.
numPrefableSpecs=len(prefableSpecs) - 1,
maxNumSpecsInPrefable=maxNumSpecsInPrefable,
)
return arrays
# The length of a method is the minimum of the lengths of the
# argument lists of all its overloads.
def overloadLength(arguments):
i = len(arguments)
while i > 0 and arguments[i - 1].optional:
i -= 1
return i
def methodLength(method):
signatures = method.signatures()
return min(overloadLength(arguments) for retType, arguments in signatures)
def clearableCachedAttrs(descriptor):
return (
m
for m in descriptor.interface.members
if m.isAttr() and
# Constants should never need clearing!
m.dependsOn != "Nothing" and m.slotIndices is not None
)
def MakeClearCachedValueNativeName(member):
return "ClearCached%sValue" % MakeNativeName(member.identifier.name)
def IDLToCIdentifier(name):
return name.replace("-", "_")
def EnumerabilityFlags(member):
if member.getExtendedAttribute("NonEnumerable"):
return "0"
return "JSPROP_ENUMERATE"
class MethodDefiner(PropertyDefiner):
"""
A class for defining methods on a prototype object.
"""
def __init__(self, descriptor, name, crossOriginOnly, static, unforgeable=False):
assert not (static and unforgeable)
PropertyDefiner.__init__(self, descriptor, name)
# We should be able to check for special operations without an
# identifier. For now we check if the name starts with __
# Ignore non-static methods for interfaces without a proto object
if descriptor.interface.hasInterfacePrototypeObject() or static:
methods = [
m
for m in descriptor.interface.members
if m.isMethod()
and m.isStatic() == static
and MemberIsLegacyUnforgeable(m, descriptor) == unforgeable
and (
not crossOriginOnly or m.getExtendedAttribute("CrossOriginCallable")
)
and not m.isIdentifierLess()
and not m.getExtendedAttribute("Unexposed")
]
else:
methods = []
self.chrome = []
self.regular = []
for m in methods:
method = self.methodData(m, descriptor)
if m.isStatic():
method["nativeName"] = CppKeywords.checkMethodName(
IDLToCIdentifier(m.identifier.name)
)
if isChromeOnly(m):
self.chrome.append(method)
else:
self.regular.append(method)
# TODO: Once iterable is implemented, use tiebreak rules instead of
# failing. Also, may be more tiebreak rules to implement once spec bug
# is resolved.
def hasIterator(methods, regular):
return any("@@iterator" in m.aliases for m in methods) or any(
"@@iterator" == r["name"] for r in regular
)
# Check whether we need to output an @@iterator due to having an indexed
# getter. We only do this while outputting non-static and
# non-unforgeable methods, since the @@iterator function will be
# neither.
if not static and not unforgeable and descriptor.supportsIndexedProperties():
if hasIterator(methods, self.regular):
raise TypeError(
"Cannot have indexed getter/attr on "
"interface %s with other members "
"that generate @@iterator, such as "
"maplike/setlike or aliased functions."
% self.descriptor.interface.identifier.name
)
self.regular.append(
{
"name": "@@iterator",
"methodInfo": False,
"selfHostedName": "$ArrayValues",
"length": 0,
"flags": "0", # Not enumerable, per spec.
"condition": MemberCondition(),
}
)
# Generate the keys/values/entries aliases for value iterables.
maplikeOrSetlikeOrIterable = descriptor.interface.maplikeOrSetlikeOrIterable
if (
not static
and not unforgeable
and maplikeOrSetlikeOrIterable
and maplikeOrSetlikeOrIterable.isIterable()
and maplikeOrSetlikeOrIterable.isValueIterator()
):
# Add our keys/values/entries/forEach
self.regular.append(
{
"name": "keys",
"methodInfo": False,
"selfHostedName": "ArrayKeys",
"length": 0,
"flags": "JSPROP_ENUMERATE",
"condition": PropertyDefiner.getControllingCondition(
maplikeOrSetlikeOrIterable, descriptor
),
}
)
self.regular.append(
{
"name": "values",
"methodInfo": False,
"selfHostedName": "$ArrayValues",
"length": 0,
"flags": "JSPROP_ENUMERATE",
"condition": PropertyDefiner.getControllingCondition(
maplikeOrSetlikeOrIterable, descriptor
),
}
)
self.regular.append(
{
"name": "entries",
"methodInfo": False,
"selfHostedName": "ArrayEntries",
"length": 0,
"flags": "JSPROP_ENUMERATE",
"condition": PropertyDefiner.getControllingCondition(
maplikeOrSetlikeOrIterable, descriptor
),
}
)
self.regular.append(
{
"name": "forEach",
"methodInfo": False,
"selfHostedName": "ArrayForEach",
"length": 1,
"flags": "JSPROP_ENUMERATE",
"condition": PropertyDefiner.getControllingCondition(
maplikeOrSetlikeOrIterable, descriptor
),
}
)
if not static:
stringifier = descriptor.operations["Stringifier"]
if stringifier and unforgeable == MemberIsLegacyUnforgeable(
stringifier, descriptor
):
toStringDesc = {
"name": GetWebExposedName(stringifier, descriptor),
"nativeName": stringifier.identifier.name,
"length": 0,
"flags": "JSPROP_ENUMERATE",
"condition": PropertyDefiner.getControllingCondition(
stringifier, descriptor
),
}
if isChromeOnly(stringifier):
self.chrome.append(toStringDesc)
else:
self.regular.append(toStringDesc)
if unforgeable and descriptor.interface.getExtendedAttribute(
"LegacyUnforgeable"
):
# Synthesize our valueOf method
self.regular.append(
{
"name": "valueOf",
"selfHostedName": "Object_valueOf",
"methodInfo": False,
"length": 0,
"flags": "0", # readonly/permanent added automatically.
"condition": MemberCondition(),
}
)
if descriptor.interface.isJSImplemented():
if static:
if descriptor.interface.hasInterfaceObject():
self.chrome.append(
{
"name": "_create",
"nativeName": ("%s::_Create" % descriptor.name),
"methodInfo": False,
"length": 2,
"flags": "0",
"condition": MemberCondition(),
}
)
self.unforgeable = unforgeable
if static:
if not descriptor.interface.hasInterfaceObject():
# static methods go on the interface object
assert not self.hasChromeOnly() and not self.hasNonChromeOnly()
else:
if not descriptor.interface.hasInterfacePrototypeObject():
# non-static methods go on the interface prototype object
assert not self.hasChromeOnly() and not self.hasNonChromeOnly()
@staticmethod
def methodData(m, descriptor, overrideFlags=None):
return {
"name": m.identifier.name,
"methodInfo": not m.isStatic(),
"length": methodLength(m),
"flags": (
EnumerabilityFlags(m) if (overrideFlags is None) else overrideFlags
),
"condition": PropertyDefiner.getControllingCondition(m, descriptor),
"allowCrossOriginThis": m.getExtendedAttribute("CrossOriginCallable"),
"returnsPromise": m.returnsPromise(),
"hasIteratorAlias": "@@iterator" in m.aliases,
}
@staticmethod
def formatSpec(fields):
if fields[0].startswith("@@"):
fields = (fields[0][2:],) + fields[1:]
return " JS_SYM_FNSPEC(%s, %s, %s, %s, %s, %s)" % fields
return ' JS_FNSPEC("%s", %s, %s, %s, %s, %s)' % fields
@staticmethod
def specData(m, descriptor, unforgeable=False):
def flags(m, unforgeable):
unforgeable = " | JSPROP_PERMANENT | JSPROP_READONLY" if unforgeable else ""
return m["flags"] + unforgeable
if "selfHostedName" in m:
selfHostedName = '"%s"' % m["selfHostedName"]
assert not m.get("methodInfo", True)
accessor = "nullptr"
jitinfo = "nullptr"
else:
selfHostedName = "nullptr"
# When defining symbols, function name may not match symbol name
methodName = m.get("methodName", m["name"])
accessor = m.get("nativeName", IDLToCIdentifier(methodName))
if m.get("methodInfo", True):
if m.get("returnsPromise", False):
exceptionPolicy = "ConvertExceptionsToPromises"
else:
exceptionPolicy = "ThrowExceptions"
# Cast this in case the methodInfo is a
# JSTypedMethodJitInfo.
jitinfo = (
"reinterpret_cast<const JSJitInfo*>(&%s_methodinfo)" % accessor
)
if m.get("allowCrossOriginThis", False):
accessor = (
"(GenericMethod<CrossOriginThisPolicy, %s>)" % exceptionPolicy
)
elif descriptor.interface.hasDescendantWithCrossOriginMembers:
accessor = (
"(GenericMethod<MaybeCrossOriginObjectThisPolicy, %s>)"
% exceptionPolicy
)
elif descriptor.interface.isOnGlobalProtoChain():
accessor = (
"(GenericMethod<MaybeGlobalThisPolicy, %s>)" % exceptionPolicy
)
else:
accessor = "(GenericMethod<NormalThisPolicy, %s>)" % exceptionPolicy
else:
if m.get("returnsPromise", False):
jitinfo = "&%s_methodinfo" % accessor
accessor = "StaticMethodPromiseWrapper"
else:
jitinfo = "nullptr"
return (
m["name"],
accessor,
jitinfo,
m["length"],
flags(m, unforgeable),
selfHostedName,
)
@staticmethod
def condition(m, d):
return m["condition"]
def generateArray(self, array, name):
if len(array) == 0:
return ""
return self.generatePrefableArray(
array,
name,
self.formatSpec,
" JS_FS_END",
"JSFunctionSpec",
self.condition,
functools.partial(self.specData, unforgeable=self.unforgeable),
)
class AttrDefiner(PropertyDefiner):
def __init__(self, descriptor, name, crossOriginOnly, static, unforgeable=False):
assert not (static and unforgeable)
PropertyDefiner.__init__(self, descriptor, name)
self.name = name
# Ignore non-static attributes for interfaces without a proto object
if descriptor.interface.hasInterfacePrototypeObject() or static:
idlAttrs = [
m
for m in descriptor.interface.members
if m.isAttr()
and m.isStatic() == static
and MemberIsLegacyUnforgeable(m, descriptor) == unforgeable
and (
not crossOriginOnly
or m.getExtendedAttribute("CrossOriginReadable")
or m.getExtendedAttribute("CrossOriginWritable")
)
]
else:
idlAttrs = []
attributes = []
for attr in idlAttrs:
attributes.extend(self.attrData(attr, unforgeable))
self.chrome = [m for m in attributes if isChromeOnly(m["attr"])]
self.regular = [m for m in attributes if not isChromeOnly(m["attr"])]
self.static = static
if static:
if not descriptor.interface.hasInterfaceObject():
# static attributes go on the interface object
assert not self.hasChromeOnly() and not self.hasNonChromeOnly()
else:
if not descriptor.interface.hasInterfacePrototypeObject():
# non-static attributes go on the interface prototype object
assert not self.hasChromeOnly() and not self.hasNonChromeOnly()
@staticmethod
def attrData(attr, unforgeable=False, overrideFlags=None):
if overrideFlags is None:
permanent = " | JSPROP_PERMANENT" if unforgeable else ""
flags = EnumerabilityFlags(attr) + permanent
else:
flags = overrideFlags
return (
{"name": name, "attr": attr, "flags": flags}
for name in [attr.identifier.name] + attr.bindingAliases
)
@staticmethod
def condition(m, d):
return PropertyDefiner.getControllingCondition(m["attr"], d)
@staticmethod
def specData(entry, descriptor, static=False, crossOriginOnly=False):
def getter(attr):
if crossOriginOnly and not attr.getExtendedAttribute("CrossOriginReadable"):
return "nullptr, nullptr"
if static:
if attr.type.isPromise():
raise TypeError(
"Don't know how to handle "
"static Promise-returning "
"attribute %s.%s" % (descriptor.name, attr.identifier.name)
)
accessor = "get_" + IDLToCIdentifier(attr.identifier.name)
jitinfo = "nullptr"
else:
if attr.type.isPromise():
exceptionPolicy = "ConvertExceptionsToPromises"
else:
exceptionPolicy = "ThrowExceptions"
if attr.hasLegacyLenientThis():
if attr.getExtendedAttribute("CrossOriginReadable"):
raise TypeError(
"Can't handle lenient cross-origin "
"readable attribute %s.%s"
% (descriptor.name, attr.identifier.name)
)
if descriptor.interface.hasDescendantWithCrossOriginMembers:
accessor = (
"GenericGetter<MaybeCrossOriginObjectLenientThisPolicy, %s>"
% exceptionPolicy
)
else:
accessor = (
"GenericGetter<LenientThisPolicy, %s>" % exceptionPolicy
)
elif attr.getExtendedAttribute("CrossOriginReadable"):
accessor = (
"GenericGetter<CrossOriginThisPolicy, %s>" % exceptionPolicy
)
elif descriptor.interface.hasDescendantWithCrossOriginMembers:
accessor = (
"GenericGetter<MaybeCrossOriginObjectThisPolicy, %s>"
% exceptionPolicy
)
elif descriptor.interface.isOnGlobalProtoChain():
accessor = (
"GenericGetter<MaybeGlobalThisPolicy, %s>" % exceptionPolicy
)
else:
accessor = "GenericGetter<NormalThisPolicy, %s>" % exceptionPolicy
jitinfo = "&%s_getterinfo" % IDLToCIdentifier(attr.identifier.name)
return "%s, %s" % (accessor, jitinfo)
def setter(attr):
if (
attr.readonly
and attr.getExtendedAttribute("PutForwards") is None
and attr.getExtendedAttribute("Replaceable") is None
and attr.getExtendedAttribute("LegacyLenientSetter") is None
):
return "nullptr, nullptr"
if crossOriginOnly and not attr.getExtendedAttribute("CrossOriginWritable"):
return "nullptr, nullptr"
if static:
accessor = "set_" + IDLToCIdentifier(attr.identifier.name)
jitinfo = "nullptr"
else:
if attr.hasLegacyLenientThis():
if attr.getExtendedAttribute("CrossOriginWritable"):
raise TypeError(
"Can't handle lenient cross-origin "
"writable attribute %s.%s"
% (descriptor.name, attr.identifier.name)
)
if descriptor.interface.hasDescendantWithCrossOriginMembers:
accessor = (
"GenericSetter<MaybeCrossOriginObjectLenientThisPolicy>"
)
else:
accessor = "GenericSetter<LenientThisPolicy>"
elif attr.getExtendedAttribute("CrossOriginWritable"):
accessor = "GenericSetter<CrossOriginThisPolicy>"
elif descriptor.interface.hasDescendantWithCrossOriginMembers:
accessor = "GenericSetter<MaybeCrossOriginObjectThisPolicy>"
elif descriptor.interface.isOnGlobalProtoChain():
accessor = "GenericSetter<MaybeGlobalThisPolicy>"
else:
accessor = "GenericSetter<NormalThisPolicy>"
jitinfo = "&%s_setterinfo" % IDLToCIdentifier(attr.identifier.name)
return "%s, %s" % (accessor, jitinfo)
name, attr, flags = entry["name"], entry["attr"], entry["flags"]
return (name, flags, getter(attr), setter(attr))
@staticmethod
def formatSpec(fields):
return ' JSPropertySpec::nativeAccessors("%s", %s, %s, %s)' % fields
def generateArray(self, array, name):
if len(array) == 0:
return ""
return self.generatePrefableArray(
array,
name,
self.formatSpec,
" JS_PS_END",
"JSPropertySpec",
self.condition,
functools.partial(self.specData, static=self.static),
)
class ConstDefiner(PropertyDefiner):
"""
A class for definining constants on the interface object
"""
def __init__(self, descriptor, name):
PropertyDefiner.__init__(self, descriptor, name)
self.name = name
constants = [m for m in descriptor.interface.members if m.isConst()]
self.chrome = [m for m in constants if isChromeOnly(m)]
self.regular = [m for m in constants if not isChromeOnly(m)]
def generateArray(self, array, name):
if len(array) == 0:
return ""
def specData(const, descriptor):
return (const.identifier.name, convertConstIDLValueToJSVal(const.value))
return self.generatePrefableArray(
array,
name,
lambda fields: ' { "%s", %s }' % fields,
" { 0, JS::UndefinedValue() }",
"ConstantSpec",
PropertyDefiner.getControllingCondition,
specData,
)
class PropertyArrays:
def __init__(self, descriptor, crossOriginOnly=False):
self.staticMethods = MethodDefiner(
descriptor, "StaticMethods", crossOriginOnly, static=True
)
self.staticAttrs = AttrDefiner(
descriptor, "StaticAttributes", crossOriginOnly, static=True
)
self.methods = MethodDefiner(
descriptor, "Methods", crossOriginOnly, static=False
)
self.attrs = AttrDefiner(
descriptor, "Attributes", crossOriginOnly, static=False
)
self.unforgeableMethods = MethodDefiner(
descriptor,
"UnforgeableMethods",
crossOriginOnly,
static=False,
unforgeable=True,
)
self.unforgeableAttrs = AttrDefiner(
descriptor,
"UnforgeableAttributes",
crossOriginOnly,
static=False,
unforgeable=True,
)
self.consts = ConstDefiner(descriptor, "Constants")
@staticmethod
def arrayNames():
return [
"staticMethods",
"staticAttrs",
"methods",
"attrs",
"unforgeableMethods",
"unforgeableAttrs",
"consts",
]
def hasChromeOnly(self):
return any(getattr(self, a).hasChromeOnly() for a in self.arrayNames())
def hasNonChromeOnly(self):
return any(getattr(self, a).hasNonChromeOnly() for a in self.arrayNames())
def __str__(self):
define = ""
for array in self.arrayNames():
define += str(getattr(self, array))
return define
class CGConstDefinition(CGThing):
"""
Given a const member of an interface, return the C++ static const definition
for the member. Should be part of the interface namespace in the header
file.
"""
def __init__(self, member):
assert (
member.isConst()
and member.value.type.isPrimitive()
and not member.value.type.nullable()
)
name = CppKeywords.checkMethodName(IDLToCIdentifier(member.identifier.name))
tag = member.value.type.tag()
value = member.value.value
if tag == IDLType.Tags.bool:
value = toStringBool(member.value.value)
self.const = "constexpr %s %s = %s;" % (builtinNames[tag], name, value)
def declare(self):
return self.const
def define(self):
return ""
def deps(self):
return []
class CGNativeProperties(CGList):
def __init__(self, descriptor, properties):
def generateNativeProperties(name, chrome):
def check(p):
return p.hasChromeOnly() if chrome else p.hasNonChromeOnly()
nativePropsInts = []
nativePropsPtrs = []
nativePropsDuos = []
duosOffset = 0
idsOffset = 0
for array in properties.arrayNames():
propertyArray = getattr(properties, array)
if check(propertyArray):
varName = propertyArray.variableName(chrome)
bitfields = "true, %d /* %s */" % (duosOffset, varName)
duosOffset += 1
nativePropsInts.append(CGGeneric(bitfields))
if propertyArray.usedForXrays():
ids = "&%s_propertyInfos[%d]" % (name, idsOffset)
idsOffset += propertyArray.length(chrome)
else:
ids = "nullptr"
duo = "{ %s, %s }" % (varName, ids)
nativePropsDuos.append(CGGeneric(duo))
else:
bitfields = "false, 0"
nativePropsInts.append(CGGeneric(bitfields))
iteratorAliasIndex = -1
for index, item in enumerate(properties.methods.regular):
if item.get("hasIteratorAlias"):
iteratorAliasIndex = index
break
nativePropsInts.append(CGGeneric(str(iteratorAliasIndex)))
nativePropsDuos = [
CGWrapper(
CGIndenter(CGList(nativePropsDuos, ",\n")), pre="{\n", post="\n}"
)
]
pre = "static const NativePropertiesN<%d> %s = {\n" % (duosOffset, name)
post = "\n};\n"
if descriptor.wantsXrays:
pre = fill(
"""
static uint16_t ${name}_sortedPropertyIndices[${size}];
static PropertyInfo ${name}_propertyInfos[${size}];
$*{pre}
""",
name=name,
size=idsOffset,
pre=pre,
)
if iteratorAliasIndex > 0:
# The iteratorAliasMethodIndex is a signed integer, so the
# max value it can store is 2^(nbits-1)-1.
post = fill(
"""
$*{post}
static_assert(${iteratorAliasIndex} < 1ull << (CHAR_BIT * sizeof(${name}.iteratorAliasMethodIndex) - 1),
"We have an iterator alias index that is oversized");
""",
post=post,
iteratorAliasIndex=iteratorAliasIndex,
name=name,
)
post = fill(
"""
$*{post}
static_assert(${propertyInfoCount} < 1ull << (CHAR_BIT * sizeof(${name}.propertyInfoCount)),
"We have a property info count that is oversized");
""",
post=post,
propertyInfoCount=idsOffset,
name=name,
)
nativePropsInts.append(CGGeneric("%d" % idsOffset))
nativePropsPtrs.append(CGGeneric("%s_sortedPropertyIndices" % name))
else:
nativePropsInts.append(CGGeneric("0"))
nativePropsPtrs.append(CGGeneric("nullptr"))
nativeProps = nativePropsInts + nativePropsPtrs + nativePropsDuos
return CGWrapper(CGIndenter(CGList(nativeProps, ",\n")), pre=pre, post=post)
nativeProperties = []
if properties.hasNonChromeOnly():
nativeProperties.append(
generateNativeProperties("sNativeProperties", False)
)
if properties.hasChromeOnly():
nativeProperties.append(
generateNativeProperties("sChromeOnlyNativeProperties", True)
)
CGList.__init__(self, nativeProperties, "\n")
def declare(self):
return ""
def define(self):
return CGList.define(self)
class CGCollectJSONAttributesMethod(CGAbstractMethod):
"""
Generate the CollectJSONAttributes method for an interface descriptor
"""
def __init__(self, descriptor, toJSONMethod):
args = [
Argument("JSContext*", "cx"),
Argument("JS::Handle<JSObject*>", "obj"),
Argument("%s*" % descriptor.nativeType, "self"),
Argument("JS::Rooted<JSObject*>&", "result"),
]
CGAbstractMethod.__init__(
self, descriptor, "CollectJSONAttributes", "bool", args, canRunScript=True
)
self.toJSONMethod = toJSONMethod
def definition_body(self):
ret = ""
interface = self.descriptor.interface
toJSONCondition = PropertyDefiner.getControllingCondition(
self.toJSONMethod, self.descriptor
)
needUnwrappedObj = False
for m in interface.members:
if m.isAttr() and not m.isStatic() and m.type.isJSONType():
getAndDefine = fill(
"""
JS::Rooted<JS::Value> temp(cx);
if (!get_${name}(cx, obj, self, JSJitGetterCallArgs(&temp))) {
return false;
}
if (!JS_DefineProperty(cx, result, "${name}", temp, JSPROP_ENUMERATE)) {
return false;
}
""",
name=IDLToCIdentifier(m.identifier.name),
)
# Make sure we don't include things which are supposed to be
# disabled. Things that either don't have disablers or whose
# disablers match the disablers for our toJSON method can't
# possibly be disabled, but other things might be.
condition = PropertyDefiner.getControllingCondition(m, self.descriptor)
if condition.hasDisablers() and condition != toJSONCondition:
needUnwrappedObj = True
ret += fill(
"""
// This is unfortunately a linear scan through sAttributes, but we
// only do it for things which _might_ be disabled, which should
// help keep the performance problems down.
if (IsGetterEnabled(cx, unwrappedObj, (JSJitGetterOp)get_${name}, sAttributes)) {
$*{getAndDefine}
}
""",
name=IDLToCIdentifier(m.identifier.name),
getAndDefine=getAndDefine,
)
else:
ret += fill(
"""
{ // scope for "temp"
$*{getAndDefine}
}
""",
getAndDefine=getAndDefine,
)
ret += "return true;\n"
if needUnwrappedObj:
# If we started allowing cross-origin objects here, we'd need to
# use CheckedUnwrapDynamic and figure out whether it makes sense.
# But in practice no one is trying to add toJSON methods to those,
# so let's just guard against it.
assert not self.descriptor.isMaybeCrossOriginObject()
ret = fill(
"""
JS::Rooted<JSObject*> unwrappedObj(cx, js::CheckedUnwrapStatic(obj));
if (!unwrappedObj) {
// How did that happen? We managed to get called with that
// object as "this"! Just give up on sanity.
return false;
}
$*{ret}
""",
ret=ret,
)
return ret
class CGCreateInterfaceObjectsMethod(CGAbstractMethod):
"""
Generate the CreateInterfaceObjects method for an interface descriptor.
properties should be a PropertyArrays instance.
"""
def __init__(
self, descriptor, properties, haveUnscopables, haveLegacyWindowAliases, static
):
args = [
Argument("JSContext*", "aCx"),
Argument("JS::Handle<JSObject*>", "aGlobal"),
Argument("ProtoAndIfaceCache&", "aProtoAndIfaceCache"),
Argument("DefineInterfaceProperty", "aDefineOnGlobal"),
]
CGAbstractMethod.__init__(
self, descriptor, "CreateInterfaceObjects", "void", args, static=static
)
self.properties = properties
self.haveUnscopables = haveUnscopables
self.haveLegacyWindowAliases = haveLegacyWindowAliases
def definition_body(self):
needInterfaceObject = self.descriptor.interface.hasInterfaceObject()
if needInterfaceObject and self.descriptor.isExposedConditionally():
# This code might be called when we're trying to create an object
# in a non-system compartment, for example when system code is
# calling a constructor through Xrays. In that case we do want to
# create an interface object in the non-system compartment, but we
# don't want to expose the name on the non-system global if the
# interface itself is marked as ChromeOnly.
defineOnGlobal = (
"ShouldExpose<%s::ConstructorEnabled>(aCx, aGlobal, aDefineOnGlobal)"
% toBindingNamespace(self.descriptor.name)
)
else:
defineOnGlobal = "aDefineOnGlobal != DefineInterfaceProperty::No"
if needInterfaceObject:
if self.descriptor.interface.isNamespace():
if self.descriptor.interface.getExtendedAttribute("ProtoObjectHack"):
getConstructorProto = "GetHackedNamespaceProtoObject"
else:
getConstructorProto = "JS::GetRealmObjectPrototype"
getConstructorProto = "aCx, " + getConstructorProto
constructorProtoType = "Rooted"
else:
getConstructorProto = InterfaceObjectProtoGetter(self.descriptor)
constructorProtoType = "Handle"
getConstructorProto = fill(
"""
JS::${type}<JSObject*> constructorProto(${getConstructorProto}(aCx));
if (!constructorProto) {
return;
}
""",
type=constructorProtoType,
getConstructorProto=getConstructorProto,
)
interfaceInfo = "&sInterfaceObjectInfo"
interfaceCache = (
"&aProtoAndIfaceCache.EntrySlotOrCreate(constructors::id::%s)"
% self.descriptor.name
)
getConstructorProto = CGGeneric(getConstructorProto)
constructorProto = "constructorProto"
else:
# We don't have slots to store the legacy factory functions.
assert len(self.descriptor.interface.legacyFactoryFunctions) == 0
interfaceInfo = "nullptr"
interfaceCache = "nullptr"
getConstructorProto = None
constructorProto = "nullptr"
if self.properties.hasNonChromeOnly():
properties = "sNativeProperties.Upcast()"
else:
properties = "nullptr"
if self.properties.hasChromeOnly():
chromeProperties = "sChromeOnlyNativeProperties.Upcast()"
else:
chromeProperties = "nullptr"
# We use getClassName here. This should be the right thing to pass as
# the name argument to CreateInterfaceObjects. This is generally the
# interface identifier, except for the synthetic interfaces created for
# the default iterator objects. If needInterfaceObject is true then
# we'll use the name to install a property on the global object, so
# there shouldn't be any spaces in the name.
name = self.descriptor.interface.getClassName()
assert not (needInterfaceObject and " " in name)
if self.descriptor.interface.isNamespace():
# If we don't need to create anything, why are we generating this?
assert needInterfaceObject
call = fill(
"""
JS::Heap<JSObject*>* interfaceCache = ${interfaceCache};
dom::CreateNamespaceObject(aCx, aGlobal, ${constructorProto},
sNamespaceObjectClass,
interfaceCache,
${properties},
${chromeProperties},
"${name}",
${defineOnGlobal});
""",
interfaceCache=interfaceCache,
constructorProto=constructorProto,
properties=properties,
chromeProperties=chromeProperties,
name=name,
defineOnGlobal=defineOnGlobal,
)
return CGList(
[
getConstructorProto,
CGGeneric(call),
],
"\n",
).define()
needInterfacePrototypeObject = (
self.descriptor.interface.hasInterfacePrototypeObject()
)
# If we don't need to create anything, why are we generating this?
assert needInterfaceObject or needInterfacePrototypeObject
if needInterfacePrototypeObject:
(protoGetter, protoHandleGetter) = InterfacePrototypeObjectProtoGetter(
self.descriptor
)
if protoHandleGetter is None:
parentProtoType = "Rooted"
getParentProto = "aCx, " + protoGetter
else:
parentProtoType = "Handle"
getParentProto = protoHandleGetter
getParentProto = fill(
"""
JS::${type}<JSObject*> parentProto(${getParentProto}(aCx));
if (!parentProto) {
return;
}
""",
type=parentProtoType,
getParentProto=getParentProto,
)
protoClass = "&sPrototypeClass"
protoCache = (
"&aProtoAndIfaceCache.EntrySlotOrCreate(prototypes::id::%s)"
% self.descriptor.name
)
parentProto = "parentProto"
getParentProto = CGGeneric(getParentProto)
else:
protoClass = "nullptr"
protoCache = "nullptr"
parentProto = "nullptr"
getParentProto = None
if self.descriptor.interface.ctor():
constructArgs = methodLength(self.descriptor.interface.ctor())
isConstructorChromeOnly = isChromeOnly(self.descriptor.interface.ctor())
else:
constructArgs = 0
isConstructorChromeOnly = False
if len(self.descriptor.interface.legacyFactoryFunctions) > 0:
legacyFactoryFunctions = "Span(legacyFactoryFunctions)"
else:
legacyFactoryFunctions = "Span<const LegacyFactoryFunction, 0>{}"
isGlobal = self.descriptor.isGlobal() is not None
ensureCaches = fill(
"""
JS::Heap<JSObject*>* protoCache = ${protoCache};
JS::Heap<JSObject*>* interfaceCache = ${interfaceCache};
""",
protoCache=protoCache,
interfaceCache=interfaceCache,
)
call = fill(
"""
dom::CreateInterfaceObjects(aCx, aGlobal, ${parentProto},
${protoClass}, protoCache,
${constructorProto}, ${interfaceInfo}, ${constructArgs}, ${isConstructorChromeOnly}, ${legacyFactoryFunctions},
interfaceCache,
${properties},
${chromeProperties},
"${name}",
${defineOnGlobal},
${unscopableNames},
${isGlobal},
${legacyWindowAliases});
""",
protoClass=protoClass,
parentProto=parentProto,
constructorProto=constructorProto,
interfaceInfo=interfaceInfo,
constructArgs=constructArgs,
isConstructorChromeOnly=toStringBool(isConstructorChromeOnly),
legacyFactoryFunctions=legacyFactoryFunctions,
properties=properties,
chromeProperties=chromeProperties,
name=name,
defineOnGlobal=defineOnGlobal,
unscopableNames="unscopableNames" if self.haveUnscopables else "nullptr",
isGlobal=toStringBool(isGlobal),
legacyWindowAliases=(
"legacyWindowAliases" if self.haveLegacyWindowAliases else "nullptr"
),
)
# If we fail after here, we must clear interface and prototype caches
# using this code: intermediate failure must not expose the interface in
# partially-constructed state. Note that every case after here needs an
# interface prototype object.
failureCode = dedent(
"""
*protoCache = nullptr;
if (interfaceCache) {
*interfaceCache = nullptr;
}
return;
"""
)
needProtoVar = False
aliasedMembers = [
m for m in self.descriptor.interface.members if m.isMethod() and m.aliases
]
if aliasedMembers:
assert needInterfacePrototypeObject
def defineAlias(alias):
if alias == "@@iterator" or alias == "@@asyncIterator":
name = alias[2:]
symbolJSID = (
"JS::GetWellKnownSymbolKey(aCx, JS::SymbolCode::%s)" % name
)
prop = "%sId" % name
getSymbolJSID = CGGeneric(
fill(
"JS::Rooted<jsid> ${prop}(aCx, ${symbolJSID});",
prop=prop,
symbolJSID=symbolJSID,
)
)
defineFn = "JS_DefinePropertyById"
enumFlags = "0" # Not enumerable, per spec.
elif alias.startswith("@@"):
raise TypeError(
"Can't handle any well-known Symbol other than @@iterator and @@asyncIterator"
)
else:
getSymbolJSID = None
defineFn = "JS_DefineProperty"
prop = '"%s"' % alias
# XXX If we ever create non-enumerable properties that can
# be aliased, we should consider making the aliases
# match the enumerability of the property being aliased.
enumFlags = "JSPROP_ENUMERATE"
return CGList(
[
getSymbolJSID,
CGGeneric(
fill(
"""
if (!${defineFn}(aCx, proto, ${prop}, aliasedVal, ${enumFlags})) {
$*{failureCode}
}
""",
defineFn=defineFn,
prop=prop,
enumFlags=enumFlags,
failureCode=failureCode,
)
),
],
"\n",
)
def defineAliasesFor(m):
return CGList(
[
CGGeneric(
fill(
"""
if (!JS_GetProperty(aCx, proto, \"${prop}\", &aliasedVal)) {
$*{failureCode}
}
""",
failureCode=failureCode,
prop=m.identifier.name,
)
)
]
+ [defineAlias(alias) for alias in sorted(m.aliases)]
)
defineAliases = CGList(
[
CGGeneric(
dedent(
"""
// Set up aliases on the interface prototype object we just created.
"""
)
),
CGGeneric("JS::Rooted<JS::Value> aliasedVal(aCx);\n\n"),
]
+ [
defineAliasesFor(m)
for m in sorted(aliasedMembers, key=lambda m: m.identifier.name)
]
)
needProtoVar = True
else:
defineAliases = None
# Globals handle unforgeables directly in Wrap() instead of
# via a holder.
if (
self.descriptor.hasLegacyUnforgeableMembers
and not self.descriptor.isGlobal()
):
assert needInterfacePrototypeObject
# We want to use the same JSClass and prototype as the object we'll
# end up defining the unforgeable properties on in the end, so that
# we can use JS_InitializePropertiesFromCompatibleNativeObject to do
# a fast copy. In the case of proxies that's null, because the
# expando object is a vanilla object, but in the case of other DOM
# objects it's whatever our class is.
if self.descriptor.proxy:
holderClass = "nullptr"
holderProto = "nullptr"
else:
holderClass = "sClass.ToJSClass()"
holderProto = "proto"
needProtoVar = True
createUnforgeableHolder = CGGeneric(
fill(
"""
JS::Rooted<JSObject*> unforgeableHolder(
aCx, JS_NewObjectWithoutMetadata(aCx, ${holderClass}, ${holderProto}));
if (!unforgeableHolder) {
$*{failureCode}
}
""",
holderProto=holderProto,
holderClass=holderClass,
failureCode=failureCode,
)
)
defineUnforgeables = InitUnforgeablePropertiesOnHolder(
self.descriptor, self.properties, failureCode
)
createUnforgeableHolder = CGList(
[createUnforgeableHolder, defineUnforgeables]
)
installUnforgeableHolder = CGGeneric(
dedent(
"""
if (*protoCache) {
JS::SetNativeObjectReservedSlot(*protoCache, DOM_INTERFACE_PROTO_SLOTS_BASE,
JS::ObjectValue(*unforgeableHolder));
}
"""
)
)
unforgeableHolderSetup = CGList(
[createUnforgeableHolder, installUnforgeableHolder], "\n"
)
else:
unforgeableHolderSetup = None
if (
self.descriptor.interface.isOnGlobalProtoChain()
and needInterfacePrototypeObject
):
makeProtoPrototypeImmutable = CGGeneric(
fill(
"""
{
bool succeeded;
if (!JS_SetImmutablePrototype(aCx, proto, &succeeded)) {
$*{failureCode}
}
MOZ_ASSERT(succeeded,
"making a fresh prototype object's [[Prototype]] "
"immutable can internally fail, but it should "
"never be unsuccessful");
}
""",
protoCache=protoCache,
failureCode=failureCode,
)
)
needProtoVar = True
else:
makeProtoPrototypeImmutable = None
if needProtoVar:
defineProtoVar = CGGeneric(
fill(
"""
JS::AssertObjectIsNotGray(*protoCache);
JS::Handle<JSObject*> proto = JS::Handle<JSObject*>::fromMarkedLocation(protoCache->unsafeAddress());
if (!proto) {
$*{failureCode}
}
""",
failureCode=failureCode,
)
)
else:
defineProtoVar = None
# ensureCaches needs to come first as it crashes on failure (like OOM).
# We want to make sure that the caches do exist before we try to return
# to the caller, so it can rely on that (and detect other failures by
# checking for null in the caches).
return CGList(
[
CGGeneric(ensureCaches),
getParentProto,
getConstructorProto,
CGGeneric(call),
defineProtoVar,
defineAliases,
unforgeableHolderSetup,
makeProtoPrototypeImmutable,
],
"\n",
).define()
class CGCreateAndDefineOnGlobalMethod(CGAbstractMethod):
"""
A method for creating the interface or namespace object and defining
properties for it on the global.
"""
def __init__(self, descriptor):
CGAbstractMethod.__init__(
self,
descriptor,
"CreateAndDefineOnGlobal",
"bool",
[
Argument("JSContext*", "aCx"),
],
inline=True,
)
def definition_body(self):
return fill(
"""
// Get the interface or namespace object for this class. This will
// create the object as needed and always define the properties for
// it on the global. The caller should make sure the interface or
// namespace is exposed on the global before calling this.
return GetPerInterfaceObjectHandle(aCx, constructors::id::${name},
&CreateInterfaceObjects,
DefineInterfaceProperty::Always);
""",
name=self.descriptor.name,
)
class CGGetProtoObjectHandleMethod(CGAbstractMethod):
"""
A method for getting the interface prototype object.
"""
def __init__(self, descriptor, static, signatureOnly=False):
CGAbstractMethod.__init__(
self,
descriptor,
"GetProtoObjectHandle",
"JS::Handle<JSObject*>",
[Argument("JSContext*", "aCx")],
static=static,
signatureOnly=signatureOnly,
)
def definition_body(self):
return fill(
"""
/* Get the interface prototype object for this class. This will create the
object as needed. */
return GetPerInterfaceObjectHandle(aCx, prototypes::id::${name},
&CreateInterfaceObjects,
DefineInterfaceProperty::CheckExposure);
""",
name=self.descriptor.name,
)
class CGGetProtoObjectMethod(CGAbstractMethod):
"""
A method for getting the interface prototype object.
"""
def __init__(self, descriptor):
CGAbstractMethod.__init__(
self,
descriptor,
"GetProtoObject",
"JSObject*",
[Argument("JSContext*", "aCx")],
)
def definition_body(self):
return "return GetProtoObjectHandle(aCx);\n"
class CGGetConstructorObjectHandleMethod(CGAbstractMethod):
"""
A method for getting the interface constructor object.
"""
def __init__(self, descriptor):
CGAbstractMethod.__init__(
self,
descriptor,
"GetConstructorObjectHandle",
"JS::Handle<JSObject*>",
[
Argument("JSContext*", "aCx"),
],
)
def definition_body(self):
return fill(
"""
/* Get the interface object for this class. This will create the object as
needed. */
return GetPerInterfaceObjectHandle(aCx, constructors::id::${name},
&CreateInterfaceObjects,
DefineInterfaceProperty::CheckExposure);
""",
name=self.descriptor.name,
)
class CGGetNamedPropertiesObjectMethod(CGAbstractStaticMethod):
def __init__(self, descriptor):
args = [Argument("JSContext*", "aCx")]
CGAbstractStaticMethod.__init__(
self, descriptor, "GetNamedPropertiesObject", "JSObject*", args
)
def definition_body(self):
parentProtoName = self.descriptor.parentPrototypeName
if parentProtoName is None:
getParentProto = ""
parentProto = "nullptr"
else:
getParentProto = fill(
"""
JS::Rooted<JSObject*> parentProto(aCx, ${parent}::GetProtoObjectHandle(aCx));
if (!parentProto) {
return nullptr;
}
""",
parent=toBindingNamespace(parentProtoName),
)
parentProto = "parentProto"
return fill(
"""
/* Make sure our global is sane. Hopefully we can remove this sometime */
JSObject* global = JS::CurrentGlobalOrNull(aCx);
if (!(JS::GetClass(global)->flags & JSCLASS_DOM_GLOBAL)) {
return nullptr;
}
/* Check to see whether the named properties object has already been created */
ProtoAndIfaceCache& protoAndIfaceCache = *GetProtoAndIfaceCache(global);
JS::Heap<JSObject*>& namedPropertiesObject = protoAndIfaceCache.EntrySlotOrCreate(namedpropertiesobjects::id::${ifaceName});
if (!namedPropertiesObject) {
$*{getParentProto}
namedPropertiesObject = ${nativeType}::CreateNamedPropertiesObject(aCx, ${parentProto});
DebugOnly<const DOMIfaceAndProtoJSClass*> clasp =
DOMIfaceAndProtoJSClass::FromJSClass(JS::GetClass(namedPropertiesObject));
MOZ_ASSERT(clasp->mType == eNamedPropertiesObject,
"Expected ${nativeType}::CreateNamedPropertiesObject to return a named properties object");
MOZ_ASSERT(clasp->mNativeHooks,
"The named properties object for ${nativeType} should have NativePropertyHooks.");
MOZ_ASSERT(!clasp->mNativeHooks->mIndexedOrNamedNativeProperties ||
!clasp->mNativeHooks->mIndexedOrNamedNativeProperties->mResolveOwnProperty,
"Shouldn't resolve the properties of the named properties object for ${nativeType} for Xrays.");
MOZ_ASSERT(!clasp->mNativeHooks->mIndexedOrNamedNativeProperties ||
!clasp->mNativeHooks->mIndexedOrNamedNativeProperties->mEnumerateOwnProperties,
"Shouldn't enumerate the properties of the named properties object for ${nativeType} for Xrays.");
}
return namedPropertiesObject.get();
""",
getParentProto=getParentProto,
ifaceName=self.descriptor.name,
parentProto=parentProto,
nativeType=self.descriptor.nativeType,
)
def getRawConditionList(idlobj, cxName, objName, ignoreSecureContext=False):
"""
Get the list of conditions for idlobj (to be used in "is this enabled"
checks). This will be returned as a CGList with " &&\n" as the separator,
for readability.
objName is the name of the object that we're working with, because some of
our test functions want that.
ignoreSecureContext is used only for constructors in which the WebIDL interface
itself is already marked as [SecureContext]. There is no need to do the work twice.
"""
conditions = []
pref = idlobj.getExtendedAttribute("Pref")
if pref:
assert isinstance(pref, list) and len(pref) == 1
conditions.append("StaticPrefs::%s()" % prefIdentifier(pref[0]))
if isChromeOnly(idlobj):
conditions.append("nsContentUtils::ThreadsafeIsSystemCaller(%s)" % cxName)
func = idlobj.getExtendedAttribute("Func")
if func:
assert isinstance(func, list) and len(func) == 1
conditions.append("%s(%s, %s)" % (func[0], cxName, objName))
trial = idlobj.getExtendedAttribute("Trial")
if trial:
assert isinstance(trial, list) and len(trial) == 1
conditions.append(
"OriginTrials::IsEnabled(%s, %s, OriginTrial::%s)"
% (cxName, objName, trial[0])
)
if not ignoreSecureContext and idlobj.getExtendedAttribute("SecureContext"):
conditions.append(
"mozilla::dom::IsSecureContextOrObjectIsFromSecureContext(%s, %s)"
% (cxName, objName)
)
return conditions
def getConditionList(idlobj, cxName, objName, ignoreSecureContext=False):
"""
Get the list of conditions from getRawConditionList
See comment on getRawConditionList above for more info about arguments.
The return value is a possibly-empty conjunctive CGList of conditions.
"""
conditions = getRawConditionList(idlobj, cxName, objName, ignoreSecureContext)
return CGList((CGGeneric(cond) for cond in conditions), " &&\n")
class CGConstructorEnabled(CGAbstractMethod):
"""
A method for testing whether we should be exposing this interface object.
This can perform various tests depending on what conditions are specified
on the interface.
"""
def __init__(self, descriptor):
CGAbstractMethod.__init__(
self,
descriptor,
"ConstructorEnabled",
"bool",
[Argument("JSContext*", "aCx"), Argument("JS::Handle<JSObject*>", "aObj")],
)
def definition_body(self):
body = CGList([], "\n")
iface = self.descriptor.interface
if not iface.isExposedInWindow():
exposedInWindowCheck = dedent(
"""
MOZ_ASSERT(!NS_IsMainThread(), "Why did we even get called?");
"""
)
body.append(CGGeneric(exposedInWindowCheck))
if iface.isExposedInSomeButNotAllWorkers():
workerGlobals = sorted(iface.getWorkerExposureSet())
workerCondition = CGList(
(
CGGeneric('strcmp(name, "%s")' % workerGlobal)
for workerGlobal in workerGlobals
),
" && ",
)
exposedInWorkerCheck = fill(
"""
const char* name = JS::GetClass(aObj)->name;
if (${workerCondition}) {
return false;
}
""",
workerCondition=workerCondition.define(),
)
exposedInWorkerCheck = CGGeneric(exposedInWorkerCheck)
if iface.isExposedInWindow():
exposedInWorkerCheck = CGIfWrapper(
exposedInWorkerCheck, "!NS_IsMainThread()"
)
body.append(exposedInWorkerCheck)
conditions = getConditionList(iface, "aCx", "aObj")
# We should really have some conditions
assert len(body) or len(conditions)
conditionsWrapper = ""
if len(conditions):
conditionsWrapper = CGWrapper(
conditions, pre="return ", post=";\n", reindent=True
)
else:
conditionsWrapper = CGGeneric("return true;\n")
body.append(conditionsWrapper)
return body.define()
def StructuredCloneTag(name):
return "SCTAG_DOM_%s" % name.upper()
class CGSerializer(CGAbstractStaticMethod):
"""
Implementation of serialization for things marked [Serializable].
This gets stored in our DOMJSClass, so it can be static.
The caller is expected to pass in the object whose DOMJSClass it
used to get the serializer.
"""
def __init__(self, descriptor):
args = [
Argument("JSContext*", "aCx"),
Argument("JSStructuredCloneWriter*", "aWriter"),
Argument("JS::Handle<JSObject*>", "aObj"),
]
CGAbstractStaticMethod.__init__(self, descriptor, "Serialize", "bool", args)
def definition_body(self):
return fill(
"""
MOZ_ASSERT(IsDOMObject(aObj), "Non-DOM object passed");
MOZ_ASSERT(GetDOMClass(aObj)->mSerializer == &Serialize,
"Wrong object passed");
return JS_WriteUint32Pair(aWriter, ${tag}, 0) &&
UnwrapDOMObject<${type}>(aObj)->WriteStructuredClone(aCx, aWriter);
""",
tag=StructuredCloneTag(self.descriptor.name),
type=self.descriptor.nativeType,
)
class CGDeserializer(CGAbstractMethod):
"""
Implementation of deserialization for things marked [Serializable].
This will need to be accessed from WebIDLSerializable, so can't be static.
"""
def __init__(self, descriptor):
args = [
Argument("JSContext*", "aCx"),
Argument("nsIGlobalObject*", "aGlobal"),
Argument("JSStructuredCloneReader*", "aReader"),
]
CGAbstractMethod.__init__(self, descriptor, "Deserialize", "JSObject*", args)
def definition_body(self):
# WrapObject has different signatures depending on whether
# the object is wrappercached.
if self.descriptor.wrapperCache:
wrapCall = dedent(
"""
result = obj->WrapObject(aCx, nullptr);
if (!result) {
return nullptr;
}
"""
)
else:
wrapCall = dedent(
"""
if (!obj->WrapObject(aCx, nullptr, &result)) {
return nullptr;
}
"""
)
return fill(
"""
// Protect the result from a moving GC in ~RefPtr
JS::Rooted<JSObject*> result(aCx);
{ // Scope for the RefPtr
RefPtr<${type}> obj = ${type}::ReadStructuredClone(aCx, aGlobal, aReader);
if (!obj) {
return nullptr;
}
$*{wrapCall}
}
return result;
""",
type=self.descriptor.nativeType,
wrapCall=wrapCall,
)
def CreateBindingJSObject(descriptor):
objDecl = "BindingJSObjectCreator<%s> creator(aCx);\n" % descriptor.nativeType
# We don't always need to root obj, but there are a variety
# of cases where we do, so for simplicity, just always root it.
if descriptor.proxy:
if descriptor.interface.getExtendedAttribute("LegacyOverrideBuiltIns"):
assert not descriptor.isMaybeCrossOriginObject()
create = dedent(
"""
aObject->mExpandoAndGeneration.expando.setUndefined();
JS::Rooted<JS::Value> expandoValue(aCx, JS::PrivateValue(&aObject->mExpandoAndGeneration));
creator.CreateProxyObject(aCx, &sClass.mBase, DOMProxyHandler::getInstance(),
proto, /* aLazyProto = */ false, aObject,
expandoValue, aReflector);
"""
)
else:
if descriptor.isMaybeCrossOriginObject():
proto = "nullptr"
lazyProto = "true"
else:
proto = "proto"
lazyProto = "false"
create = fill(
"""
creator.CreateProxyObject(aCx, &sClass.mBase, DOMProxyHandler::getInstance(),
${proto}, /* aLazyProto = */ ${lazyProto},
aObject, JS::UndefinedHandleValue, aReflector);
""",
proto=proto,
lazyProto=lazyProto,
)
else:
create = dedent(
"""
creator.CreateObject(aCx, sClass.ToJSClass(), proto, aObject, aReflector);
"""
)
return (
objDecl
+ create
+ dedent(
"""
if (!aReflector) {
return false;
}
"""
)
)
def InitUnforgeablePropertiesOnHolder(
descriptor, properties, failureCode, holderName="unforgeableHolder"
):
"""
Define the unforgeable properties on the unforgeable holder for
the interface represented by descriptor.
properties is a PropertyArrays instance.
"""
assert (
properties.unforgeableAttrs.hasNonChromeOnly()
or properties.unforgeableAttrs.hasChromeOnly()
or properties.unforgeableMethods.hasNonChromeOnly()
or properties.unforgeableMethods.hasChromeOnly()
)
unforgeables = []
defineUnforgeableAttrs = fill(
"""
if (!DefineLegacyUnforgeableAttributes(aCx, ${holderName}, %s)) {
$*{failureCode}
}
""",
failureCode=failureCode,
holderName=holderName,
)
defineUnforgeableMethods = fill(
"""
if (!DefineLegacyUnforgeableMethods(aCx, ${holderName}, %s)) {
$*{failureCode}
}
""",
failureCode=failureCode,
holderName=holderName,
)
unforgeableMembers = [
(defineUnforgeableAttrs, properties.unforgeableAttrs),
(defineUnforgeableMethods, properties.unforgeableMethods),
]
for template, array in unforgeableMembers:
if array.hasNonChromeOnly():
unforgeables.append(CGGeneric(template % array.variableName(False)))
if array.hasChromeOnly():
unforgeables.append(
CGIfWrapper(
CGGeneric(template % array.variableName(True)),
"nsContentUtils::ThreadsafeIsSystemCaller(aCx)",
)
)
if descriptor.interface.getExtendedAttribute("LegacyUnforgeable"):
# We do our undefined toPrimitive here, not as a regular property
# because we don't have a concept of value props anywhere in IDL.
unforgeables.append(
CGGeneric(
fill(
"""
JS::Rooted<JS::PropertyKey> toPrimitive(aCx,
JS::GetWellKnownSymbolKey(aCx, JS::SymbolCode::toPrimitive));
if (!JS_DefinePropertyById(aCx, ${holderName}, toPrimitive,
JS::UndefinedHandleValue,
JSPROP_READONLY | JSPROP_PERMANENT)) {
$*{failureCode}
}
""",
failureCode=failureCode,
holderName=holderName,
)
)
)
return CGWrapper(CGList(unforgeables), pre="\n")
def CopyUnforgeablePropertiesToInstance(descriptor, failureCode):
"""
Copy the unforgeable properties from the unforgeable holder for
this interface to the instance object we have.
"""
assert not descriptor.isGlobal()
if not descriptor.hasLegacyUnforgeableMembers:
return ""
copyCode = [
CGGeneric(
dedent(
"""
// Important: do unforgeable property setup after we have handed
// over ownership of the C++ object to obj as needed, so that if
// we fail and it ends up GCed it won't have problems in the
// finalizer trying to drop its ownership of the C++ object.
"""
)
)
]
# For proxies, we want to define on the expando object, not directly on the
# reflector, so we can make sure we don't get confused by named getters.
if descriptor.proxy:
copyCode.append(
CGGeneric(
fill(
"""
JS::Rooted<JSObject*> expando(aCx,
DOMProxyHandler::EnsureExpandoObject(aCx, aReflector));
if (!expando) {
$*{failureCode}
}
""",
failureCode=failureCode,
)
)
)
obj = "expando"
else:
obj = "aReflector"
copyCode.append(
CGGeneric(
fill(
"""
JS::Rooted<JSObject*> unforgeableHolder(aCx,
&JS::GetNativeObjectReservedSlot(canonicalProto, DOM_INTERFACE_PROTO_SLOTS_BASE).toObject());
if (!JS_InitializePropertiesFromCompatibleNativeObject(aCx, ${obj}, unforgeableHolder)) {
$*{failureCode}
}
""",
obj=obj,
failureCode=failureCode,
)
)
)
return CGWrapper(CGList(copyCode), pre="\n").define()
def AssertInheritanceChain(descriptor):
# We can skip the reinterpret_cast check for the descriptor's nativeType
# if aObject is a pointer of that type.
asserts = fill(
"""
static_assert(std::is_same_v<decltype(aObject), ${nativeType}*>);
""",
nativeType=descriptor.nativeType,
)
iface = descriptor.interface
while iface.parent:
iface = iface.parent
desc = descriptor.getDescriptor(iface.identifier.name)
asserts += (
"MOZ_ASSERT(static_cast<%s*>(aObject) == \n"
" reinterpret_cast<%s*>(aObject),\n"
' "Multiple inheritance for %s is broken.");\n'
% (desc.nativeType, desc.nativeType, desc.nativeType)
)
asserts += "MOZ_ASSERT(ToSupportsIsCorrect(aObject));\n"
return asserts
def InitMemberSlots(descriptor, failureCode):
"""
Initialize member slots on our JS object if we're supposed to have some.
Note that this is called after the SetWrapper() call in the
wrapperCache case, since that can affect how our getters behave
and we plan to invoke them here. So if we fail, we need to
ClearWrapper.
"""
if not descriptor.interface.hasMembersInSlots():
return ""
return fill(
"""
if (!UpdateMemberSlots(aCx, aReflector, aObject)) {
$*{failureCode}
}
""",
failureCode=failureCode,
)
def DeclareProto(descriptor, noGivenProto=False):
"""
Declare the canonicalProto and proto we have for our wrapping operation.
"""
getCanonical = dedent(
"""
JS::Handle<JSObject*> ${canonicalProto} = GetProtoObjectHandle(aCx);
if (!${canonicalProto}) {
return false;
}
"""
)
if noGivenProto:
return fill(getCanonical, canonicalProto="proto")
getCanonical = fill(getCanonical, canonicalProto="canonicalProto")
preamble = getCanonical + dedent(
"""
JS::Rooted<JSObject*> proto(aCx);
"""
)
if descriptor.isMaybeCrossOriginObject():
return preamble + dedent(
"""
MOZ_ASSERT(!aGivenProto,
"Shouldn't have constructors on cross-origin objects");
// Set proto to canonicalProto to avoid preserving our wrapper if
// we don't have to.
proto = canonicalProto;
"""
)
return preamble + dedent(
"""
if (aGivenProto) {
proto = aGivenProto;
// Unfortunately, while aGivenProto was in the compartment of aCx
// coming in, we changed compartments to that of "parent" so may need
// to wrap the proto here.
if (js::GetContextCompartment(aCx) != JS::GetCompartment(proto)) {
if (!JS_WrapObject(aCx, &proto)) {
return false;
}
}
} else {
proto = canonicalProto;
}
"""
)
class CGWrapWithCacheMethod(CGAbstractMethod):
"""
Create a wrapper JSObject for a given native that implements nsWrapperCache.
"""
def __init__(self, descriptor):
assert descriptor.interface.hasInterfacePrototypeObject()
args = [
Argument("JSContext*", "aCx"),
Argument(descriptor.nativeType + "*", "aObject"),
Argument("nsWrapperCache*", "aCache"),
Argument("JS::Handle<JSObject*>", "aGivenProto"),
Argument("JS::MutableHandle<JSObject*>", "aReflector"),
]
CGAbstractMethod.__init__(self, descriptor, "Wrap", "bool", args)
def definition_body(self):
failureCode = dedent(
"""
aCache->ReleaseWrapper(aObject);
aCache->ClearWrapperOnWrapFailure();
return false;
"""
)
if self.descriptor.proxy:
finalize = "DOMProxyHandler::getInstance()->finalize"
else:
finalize = FINALIZE_HOOK_NAME
return fill(
"""
static_assert(!std::is_base_of_v<NonRefcountedDOMObject, ${nativeType}>,
"Shouldn't have wrappercached things that are not refcounted.");
$*{assertInheritance}
MOZ_ASSERT_IF(aGivenProto, js::IsObjectInContextCompartment(aGivenProto, aCx));
MOZ_ASSERT(!aCache->GetWrapper(),
"You should probably not be using Wrap() directly; use "
"GetOrCreateDOMReflector instead");
MOZ_ASSERT(ToSupportsIsOnPrimaryInheritanceChain(aObject, aCache),
"nsISupports must be on our primary inheritance chain");
// If the wrapper cache contains a dead reflector then finalize that
// now, ensuring that the finalizer for the old reflector always
// runs before the new reflector is created and attached. This
// avoids the awkward situation where there are multiple reflector
// objects that contain pointers to the same native.
if (JSObject* oldReflector = aCache->GetWrapperMaybeDead()) {
${finalize}(nullptr /* unused */, oldReflector);
MOZ_ASSERT(!aCache->GetWrapperMaybeDead());
}
JS::Rooted<JSObject*> global(aCx, FindAssociatedGlobal(aCx, aObject->GetParentObject()));
if (!global) {
return false;
}
MOZ_ASSERT(JS_IsGlobalObject(global));
JS::AssertObjectIsNotGray(global);
// That might have ended up wrapping us already, due to the wonders
// of XBL. Check for that, and bail out as needed.
aReflector.set(aCache->GetWrapper());
if (aReflector) {
#ifdef DEBUG
AssertReflectorHasGivenProto(aCx, aReflector, aGivenProto);
#endif // DEBUG
return true;
}
JSAutoRealm ar(aCx, global);
$*{declareProto}
$*{createObject}
aCache->SetWrapper(aReflector);
$*{unforgeable}
$*{slots}
creator.InitializationSucceeded();
MOZ_ASSERT(aCache->GetWrapperPreserveColor() &&
aCache->GetWrapperPreserveColor() == aReflector);
// If proto != canonicalProto, we have to preserve our wrapper;
// otherwise we won't be able to properly recreate it later, since
// we won't know what proto to use. Note that we don't check
// aGivenProto here, since it's entirely possible (and even
// somewhat common) to have a non-null aGivenProto which is the
// same as canonicalProto.
if (proto != canonicalProto) {
PreserveWrapper(aObject);
}
return true;
""",
nativeType=self.descriptor.nativeType,
assertInheritance=AssertInheritanceChain(self.descriptor),
declareProto=DeclareProto(self.descriptor),
createObject=CreateBindingJSObject(self.descriptor),
unforgeable=CopyUnforgeablePropertiesToInstance(
self.descriptor, failureCode
),
slots=InitMemberSlots(self.descriptor, failureCode),
finalize=finalize,
)
class CGWrapMethod(CGAbstractMethod):
def __init__(self, descriptor):
# XXX can we wrap if we don't have an interface prototype object?
assert descriptor.interface.hasInterfacePrototypeObject()
args = [
Argument("JSContext*", "aCx"),
Argument("T*", "aObject"),
Argument("JS::Handle<JSObject*>", "aGivenProto"),
]
CGAbstractMethod.__init__(
self,
descriptor,
"Wrap",
"JSObject*",
args,
inline=True,
templateArgs=["class T"],
)
def definition_body(self):
return dedent(
"""
JS::Rooted<JSObject*> reflector(aCx);
return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
"""
)
class CGWrapNonWrapperCacheMethod(CGAbstractMethod):
"""
Create a wrapper JSObject for a given native that does not implement
nsWrapperCache.
"""
def __init__(self, descriptor, static=False, signatureOnly=False):
# XXX can we wrap if we don't have an interface prototype object?
assert descriptor.interface.hasInterfacePrototypeObject()
self.noGivenProto = (
descriptor.interface.isIteratorInterface()
or descriptor.interface.isAsyncIteratorInterface()
)
args = [
Argument("JSContext*", "aCx"),
Argument(descriptor.nativeType + "*", "aObject"),
]
if not self.noGivenProto:
args.append(Argument("JS::Handle<JSObject*>", "aGivenProto"))
args.append(Argument("JS::MutableHandle<JSObject*>", "aReflector"))
CGAbstractMethod.__init__(
self,
descriptor,
"Wrap",
"bool",
args,
static=static,
signatureOnly=signatureOnly,
)
def definition_body(self):
failureCode = "return false;\n"
declareProto = DeclareProto(self.descriptor, noGivenProto=self.noGivenProto)
if self.noGivenProto:
assertGivenProto = ""
else:
assertGivenProto = dedent(
"""
MOZ_ASSERT_IF(aGivenProto, js::IsObjectInContextCompartment(aGivenProto, aCx));
"""
)
return fill(
"""
$*{assertions}
$*{assertGivenProto}
JS::Rooted<JSObject*> global(aCx, JS::CurrentGlobalOrNull(aCx));
$*{declareProto}
$*{createObject}
$*{unforgeable}
$*{slots}
creator.InitializationSucceeded();
return true;
""",
assertions=AssertInheritanceChain(self.descriptor),
assertGivenProto=assertGivenProto,
declareProto=declareProto,
createObject=CreateBindingJSObject(self.descriptor),
unforgeable=CopyUnforgeablePropertiesToInstance(
self.descriptor, failureCode
),
slots=InitMemberSlots(self.descriptor, failureCode),
)
class CGWrapGlobalMethod(CGAbstractMethod):
"""
Create a wrapper JSObject for a global. The global must implement
nsWrapperCache.
properties should be a PropertyArrays instance.
"""
def __init__(self, descriptor, properties):
assert (
descriptor.interface.hasInterfacePrototypeObject()
or descriptor.hasOrdinaryObjectPrototype()
)
args = [
Argument("JSContext*", "aCx"),
Argument(descriptor.nativeType + "*", "aObject"),
Argument("nsWrapperCache*", "aCache"),
Argument("JS::RealmOptions&", "aOptions"),
Argument("JSPrincipals*", "aPrincipal"),
Argument("JS::MutableHandle<JSObject*>", "aReflector"),
]
CGAbstractMethod.__init__(self, descriptor, "Wrap", "bool", args)
self.descriptor = descriptor
self.properties = properties
def definition_body(self):
if self.properties.hasNonChromeOnly():
properties = "sNativeProperties.Upcast()"
else:
properties = "nullptr"
if self.properties.hasChromeOnly():
chromeProperties = "nsContentUtils::ThreadsafeIsSystemCaller(aCx) ? sChromeOnlyNativeProperties.Upcast() : nullptr"
else:
chromeProperties = "nullptr"
failureCode = dedent(
"""
aCache->ReleaseWrapper(aObject);
aCache->ClearWrapper();
return false;
"""
)
if self.descriptor.hasLegacyUnforgeableMembers:
unforgeable = InitUnforgeablePropertiesOnHolder(
self.descriptor, self.properties, failureCode, "aReflector"
).define()
else:
unforgeable = ""
if self.descriptor.hasOrdinaryObjectPrototype():
getProto = "JS::GetRealmObjectPrototypeHandle"
else:
getProto = "GetProtoObjectHandle"
return fill(
"""
$*{assertions}
MOZ_ASSERT(ToSupportsIsOnPrimaryInheritanceChain(aObject, aCache),
"nsISupports must be on our primary inheritance chain");
if (!CreateGlobal<${nativeType}, ${getProto}>(aCx,
aObject,
aCache,
sClass.ToJSClass(),
aOptions,
aPrincipal,
aReflector)) {
$*{failureCode}
}
// aReflector is a new global, so has a new realm. Enter it
// before doing anything with it.
JSAutoRealm ar(aCx, aReflector);
if (!DefineProperties(aCx, aReflector, ${properties}, ${chromeProperties})) {
$*{failureCode}
}
$*{unforgeable}
$*{slots}
return true;
""",
assertions=AssertInheritanceChain(self.descriptor),
nativeType=self.descriptor.nativeType,
getProto=getProto,
properties=properties,
chromeProperties=chromeProperties,
failureCode=failureCode,
unforgeable=unforgeable,
slots=InitMemberSlots(self.descriptor, failureCode),
)
class CGUpdateMemberSlotsMethod(CGAbstractStaticMethod):
def __init__(self, descriptor):
args = [
Argument("JSContext*", "aCx"),
Argument("JS::Handle<JSObject*>", "aWrapper"),
Argument(descriptor.nativeType + "*", "aObject"),
]
CGAbstractStaticMethod.__init__(
self, descriptor, "UpdateMemberSlots", "bool", args
)
def definition_body(self):
body = "JS::Rooted<JS::Value> temp(aCx);\n" "JSJitGetterCallArgs args(&temp);\n"
for m in self.descriptor.interface.members:
if m.isAttr() and m.getExtendedAttribute("StoreInSlot"):
# Skip doing this for the "window" and "self" attributes on the
# Window interface, because those can't be gotten safely until
# we have hooked it up correctly to the outer window. The
# window code handles doing the get itself.
if self.descriptor.interface.identifier.name == "Window" and (
m.identifier.name == "window" or m.identifier.name == "self"
):
continue
body += fill(
"""
static_assert(${slot} < JS::shadow::Object::MAX_FIXED_SLOTS,
"Not enough fixed slots to fit '${interface}.${member}. Ion's visitGetDOMMemberV/visitGetDOMMemberT assume StoreInSlot things are all in fixed slots.");
if (!get_${member}(aCx, aWrapper, aObject, args)) {
return false;
}
// Getter handled setting our reserved slots
""",
slot=memberReservedSlot(m, self.descriptor),
interface=self.descriptor.interface.identifier.name,
member=m.identifier.name,
)
body += "\nreturn true;\n"
return body
class CGClearCachedValueMethod(CGAbstractMethod):
def __init__(self, descriptor, member):
self.member = member
# If we're StoreInSlot, we'll need to call the getter
if member.getExtendedAttribute("StoreInSlot"):
args = [Argument("JSContext*", "aCx")]
returnType = "bool"
else:
args = []
returnType = "void"
args.append(Argument(descriptor.nativeType + "*", "aObject"))
name = MakeClearCachedValueNativeName(member)
CGAbstractMethod.__init__(self, descriptor, name, returnType, args)
def definition_body(self):
slotIndex = memberReservedSlot(self.member, self.descriptor)
getReservedSlot = getReservedSlotFunc(self.descriptor)
setReservedSlot = setReservedSlotFunc(self.descriptor)
clearCachedValue = fill(
"""
${setReservedSlot}(obj, ${slotIndex}, JS::UndefinedValue());
""",
setReservedSlot=setReservedSlot,
slotIndex=slotIndex,
)
if self.member.getExtendedAttribute("StoreInSlot"):
# We have to root things and save the old value in case
# regetting fails, so we can restore it.
declObj = "JS::Rooted<JSObject*> obj(aCx);\n"
noopRetval = " true"
saveMember = fill(
"""
JS::Rooted<JS::Value> oldValue(aCx, ${getReservedSlot}(obj, ${slotIndex}));
""",
getReservedSlot=getReservedSlot,
slotIndex=slotIndex,
)
regetMember = fill(
"""
JS::Rooted<JS::Value> temp(aCx);
JSJitGetterCallArgs args(&temp);
JSAutoRealm ar(aCx, obj);
if (!get_${name}(aCx, obj, aObject, args)) {
${setReservedSlot}(obj, ${slotIndex}, oldValue);
return false;
}
return true;
""",
name=self.member.identifier.name,
setReservedSlot=setReservedSlot,
slotIndex=slotIndex,
)
else:
declObj = "JSObject* obj;\n"
noopRetval = ""
saveMember = ""
if self.member.getExtendedAttribute(
"ReflectedHTMLAttributeReturningFrozenArray"
):
clearCachedValue = fill(
"""
ReflectedHTMLAttributeSlots::Clear(obj, ${arrayIndex});
""",
arrayIndex=reflectedHTMLAttributesArrayIndex(
self.descriptor, self.member
),
)
regetMember = ""
if self.descriptor.wantsXrays:
if self.member.getExtendedAttribute("StoreInSlot"):
cx = "JS::RootingContext::get(aCx)"
else:
cx = "RootingCx()"
if self.member.getExtendedAttribute(
"ReflectedHTMLAttributeReturningFrozenArray"
):
clearXrayExpandoSlots = fill(
"""
ReflectedHTMLAttributeSlots::ClearInXrays(${cx}, obj, ${arrayIndex});
""",
cx=cx,
arrayIndex=reflectedHTMLAttributesArrayIndex(
self.descriptor, self.member
),
)
else:
clearXrayExpandoSlots = fill(
"""
ClearXrayExpandoSlots(${cx}, obj, ${xraySlotIndex});
""",
cx=cx,
xraySlotIndex=memberXrayExpandoReservedSlot(
self.member, self.descriptor
),
)
else:
clearXrayExpandoSlots = ""
return fill(
"""
$*{declObj}
obj = aObject->GetWrapper();
if (!obj) {
return${noopRetval};
}
$*{saveMember}
$*{clearCachedValue}
$*{clearXrayExpandoSlots}
$*{regetMember}
""",
declObj=declObj,
noopRetval=noopRetval,
saveMember=saveMember,
slotIndex=slotIndex,
clearCachedValue=clearCachedValue,
clearXrayExpandoSlots=clearXrayExpandoSlots,
regetMember=regetMember,
)
class CGCrossOriginProperties(CGThing):
def __init__(self, descriptor):
attrs = []
chromeOnlyAttrs = []
methods = []
chromeOnlyMethods = []
for m in descriptor.interface.members:
if m.isAttr() and (
m.getExtendedAttribute("CrossOriginReadable")
or m.getExtendedAttribute("CrossOriginWritable")
):
if m.isStatic():
raise TypeError(
"Don't know how to deal with static method %s"
% m.identifier.name
)
if PropertyDefiner.getControllingCondition(
m, descriptor
).hasDisablers():
raise TypeError(
"Don't know how to deal with disabler for %s"
% m.identifier.name
)
if len(m.bindingAliases) > 0:
raise TypeError(
"Don't know how to deal with aliases for %s" % m.identifier.name
)
if m.getExtendedAttribute("ChromeOnly") is not None:
chromeOnlyAttrs.extend(AttrDefiner.attrData(m, overrideFlags="0"))
else:
attrs.extend(AttrDefiner.attrData(m, overrideFlags="0"))
elif m.isMethod() and m.getExtendedAttribute("CrossOriginCallable"):
if m.isStatic():
raise TypeError(
"Don't know how to deal with static method %s"
% m.identifier.name
)
if PropertyDefiner.getControllingCondition(
m, descriptor
).hasDisablers():
raise TypeError(
"Don't know how to deal with disabler for %s"
% m.identifier.name
)
if len(m.aliases) > 0:
raise TypeError(
"Don't know how to deal with aliases for %s" % m.identifier.name
)
if m.getExtendedAttribute("ChromeOnly") is not None:
chromeOnlyMethods.append(
MethodDefiner.methodData(
m, descriptor, overrideFlags="JSPROP_READONLY"
)
)
else:
methods.append(
MethodDefiner.methodData(
m, descriptor, overrideFlags="JSPROP_READONLY"
)
)
if len(attrs) > 0:
self.attributeSpecs, _ = PropertyDefiner.generatePrefableArrayValues(
attrs,
descriptor,
AttrDefiner.formatSpec,
" JS_PS_END\n",
AttrDefiner.condition,
functools.partial(AttrDefiner.specData, crossOriginOnly=True),
)
else:
self.attributeSpecs = [" JS_PS_END\n"]
if len(methods) > 0:
self.methodSpecs, _ = PropertyDefiner.generatePrefableArrayValues(
methods,
descriptor,
MethodDefiner.formatSpec,
" JS_FS_END\n",
MethodDefiner.condition,
MethodDefiner.specData,
)
else:
self.methodSpecs = [" JS_FS_END\n"]
if len(chromeOnlyAttrs) > 0:
(
self.chromeOnlyAttributeSpecs,
_,
) = PropertyDefiner.generatePrefableArrayValues(
chromeOnlyAttrs,
descriptor,
AttrDefiner.formatSpec,
" JS_PS_END\n",
AttrDefiner.condition,
functools.partial(AttrDefiner.specData, crossOriginOnly=True),
)
else:
self.chromeOnlyAttributeSpecs = []
if len(chromeOnlyMethods) > 0:
self.chromeOnlyMethodSpecs, _ = PropertyDefiner.generatePrefableArrayValues(
chromeOnlyMethods,
descriptor,
MethodDefiner.formatSpec,
" JS_FS_END\n",
MethodDefiner.condition,
MethodDefiner.specData,
)
else:
self.chromeOnlyMethodSpecs = []
def declare(self):
return dedent(
"""
extern const CrossOriginProperties sCrossOriginProperties;
"""
)
def define(self):
def defineChromeOnly(name, specs, specType):
if len(specs) == 0:
return ("", "nullptr")
name = "sChromeOnlyCrossOrigin" + name
define = fill(
"""
static const ${specType} ${name}[] = {
$*{specs}
};
""",
specType=specType,
name=name,
specs=",\n".join(specs),
)
return (define, name)
chromeOnlyAttributes = defineChromeOnly(
"Attributes", self.chromeOnlyAttributeSpecs, "JSPropertySpec"
)
chromeOnlyMethods = defineChromeOnly(
"Methods", self.chromeOnlyMethodSpecs, "JSFunctionSpec"
)
return fill(
"""
static const JSPropertySpec sCrossOriginAttributes[] = {
$*{attributeSpecs}
};
static const JSFunctionSpec sCrossOriginMethods[] = {
$*{methodSpecs}
};
$*{chromeOnlyAttributeSpecs}
$*{chromeOnlyMethodSpecs}
const CrossOriginProperties sCrossOriginProperties = {
sCrossOriginAttributes,
sCrossOriginMethods,
${chromeOnlyAttributes},
${chromeOnlyMethods}
};
""",
attributeSpecs=",\n".join(self.attributeSpecs),
methodSpecs=",\n".join(self.methodSpecs),
chromeOnlyAttributeSpecs=chromeOnlyAttributes[0],
chromeOnlyMethodSpecs=chromeOnlyMethods[0],
chromeOnlyAttributes=chromeOnlyAttributes[1],
chromeOnlyMethods=chromeOnlyMethods[1],
)
class CGCycleCollectionTraverseForOwningUnionMethod(CGAbstractMethod):
"""
ImplCycleCollectionUnlink for owning union type.
"""
def __init__(self, type):
self.type = type
args = [
Argument("nsCycleCollectionTraversalCallback&", "aCallback"),
Argument("%s&" % CGUnionStruct.unionTypeName(type, True), "aUnion"),
Argument("const char*", "aName"),
Argument("uint32_t", "aFlags", "0"),
]
CGAbstractMethod.__init__(
self, None, "ImplCycleCollectionTraverse", "void", args
)
def deps(self):
return self.type.getDeps()
def definition_body(self):
memberNames = [
getUnionMemberName(t)
for t in self.type.flatMemberTypes
if idlTypeNeedsCycleCollection(t)
]
assert memberNames
conditionTemplate = "aUnion.Is%s()"
functionCallTemplate = (
'ImplCycleCollectionTraverse(aCallback, aUnion.GetAs%s(), "m%s", aFlags);\n'
)
ifStaments = (
CGIfWrapper(CGGeneric(functionCallTemplate % (m, m)), conditionTemplate % m)
for m in memberNames
)
return CGElseChain(ifStaments).define()
class CGCycleCollectionUnlinkForOwningUnionMethod(CGAbstractMethod):
"""
ImplCycleCollectionUnlink for owning union type.
"""
def __init__(self, type):
self.type = type
args = [Argument("%s&" % CGUnionStruct.unionTypeName(type, True), "aUnion")]
CGAbstractMethod.__init__(self, None, "ImplCycleCollectionUnlink", "void", args)
def deps(self):
return self.type.getDeps()
def definition_body(self):
return "aUnion.Uninit();\n"
builtinNames = {
IDLType.Tags.bool: "bool",
IDLType.Tags.int8: "int8_t",
IDLType.Tags.int16: "int16_t",
IDLType.Tags.int32: "int32_t",
IDLType.Tags.int64: "int64_t",
IDLType.Tags.uint8: "uint8_t",
IDLType.Tags.uint16: "uint16_t",
IDLType.Tags.uint32: "uint32_t",
IDLType.Tags.uint64: "uint64_t",
IDLType.Tags.unrestricted_float: "float",
IDLType.Tags.float: "float",
IDLType.Tags.unrestricted_double: "double",
IDLType.Tags.double: "double",
}
numericSuffixes = {
IDLType.Tags.int8: "",
IDLType.Tags.uint8: "",
IDLType.Tags.int16: "",
IDLType.Tags.uint16: "",
IDLType.Tags.int32: "",
IDLType.Tags.uint32: "U",
IDLType.Tags.int64: "LL",
IDLType.Tags.uint64: "ULL",
IDLType.Tags.unrestricted_float: "F",
IDLType.Tags.float: "F",
IDLType.Tags.unrestricted_double: "",
IDLType.Tags.double: "",
}
def numericValue(t, v):
if t == IDLType.Tags.unrestricted_double or t == IDLType.Tags.unrestricted_float:
typeName = builtinNames[t]
if v == float("inf"):
return "mozilla::PositiveInfinity<%s>()" % typeName
if v == float("-inf"):
return "mozilla::NegativeInfinity<%s>()" % typeName
if math.isnan(v):
return "mozilla::UnspecifiedNaN<%s>()" % typeName
return "%s%s" % (v, numericSuffixes[t])
class CastableObjectUnwrapper:
"""
A class for unwrapping an object stored in a JS Value (or
MutableHandle<Value> or Handle<Value>) named by the "source" and
"mutableSource" arguments based on the passed-in descriptor and storing it
in a variable called by the name in the "target" argument. The "source"
argument should be able to produce a Value or Handle<Value>; the
"mutableSource" argument should be able to produce a MutableHandle<Value>
codeOnFailure is the code to run if unwrapping fails.
If isCallbackReturnValue is "JSImpl" and our descriptor is also
JS-implemented, fall back to just creating the right object if what we
have isn't one already.
"""
def __init__(
self,
descriptor,
source,
mutableSource,
target,
codeOnFailure,
exceptionCode=None,
isCallbackReturnValue=False,
):
self.substitution = {
"type": descriptor.nativeType,
"protoID": "prototypes::id::" + descriptor.name,
"target": target,
"codeOnFailure": codeOnFailure,
"source": source,
"mutableSource": mutableSource,
}
if isCallbackReturnValue == "JSImpl" and descriptor.interface.isJSImplemented():
exceptionCode = exceptionCode or codeOnFailure
self.substitution["codeOnFailure"] = fill(
"""
// Be careful to not wrap random DOM objects here, even if
// they're wrapped in opaque security wrappers for some reason.
// XXXbz Wish we could check for a JS-implemented object
// that already has a content reflection...
if (!IsDOMObject(js::UncheckedUnwrap(&${source}.toObject()))) {
nsCOMPtr<nsIGlobalObject> contentGlobal;
JS::Rooted<JSObject*> callback(cx, CallbackOrNull());
if (!callback ||
!GetContentGlobalForJSImplementedObject(cx, callback, getter_AddRefs(contentGlobal))) {
$*{exceptionCode}
}
JS::Rooted<JSObject*> jsImplSourceObj(cx, &${source}.toObject());
MOZ_RELEASE_ASSERT(!js::IsWrapper(jsImplSourceObj),
"Don't return JS implementations from other compartments");
JS::Rooted<JSObject*> jsImplSourceGlobal(cx, JS::GetNonCCWObjectGlobal(jsImplSourceObj));
${target} = new ${type}(jsImplSourceObj, jsImplSourceGlobal, contentGlobal);
} else {
$*{codeOnFailure}
}
""",
exceptionCode=exceptionCode,
**self.substitution,
)
else:
self.substitution["codeOnFailure"] = codeOnFailure
def __str__(self):
substitution = self.substitution.copy()
substitution["codeOnFailure"] %= {
"securityError": "rv == NS_ERROR_XPC_SECURITY_MANAGER_VETO"
}
return fill(
"""
{
// Our JSContext should be in the right global to do unwrapping in.
nsresult rv = UnwrapObject<${protoID}, ${type}>(${mutableSource}, ${target}, cx);
if (NS_FAILED(rv)) {
$*{codeOnFailure}
}
}
""",
**substitution,
)
class FailureFatalCastableObjectUnwrapper(CastableObjectUnwrapper):
"""
As CastableObjectUnwrapper, but defaulting to throwing if unwrapping fails
"""
def __init__(
self,
descriptor,
source,
mutableSource,
target,
exceptionCode,
isCallbackReturnValue,
sourceDescription,
):
CastableObjectUnwrapper.__init__(
self,
descriptor,
source,
mutableSource,
target,
'cx.ThrowErrorMessage<MSG_DOES_NOT_IMPLEMENT_INTERFACE>("%s", "%s");\n'
"%s"
% (sourceDescription, descriptor.interface.identifier.name, exceptionCode),
exceptionCode,
isCallbackReturnValue,
)
def getCallbackConversionInfo(
type, idlObject, isMember, isCallbackReturnValue, isOptional
):
"""
Returns a tuple containing the declType, declArgs, and basic
conversion for the given callback type, with the given callback
idl object in the given context (isMember/isCallbackReturnValue/isOptional).
"""
name = idlObject.identifier.name
# We can't use fast callbacks if isOptional because then we get an
# Optional<RootedCallback> thing, which is not transparent to consumers.
useFastCallback = (
(not isMember or isMember == "Union")
and not isCallbackReturnValue
and not isOptional
)
if useFastCallback:
name = "binding_detail::Fast%s" % name
rootArgs = ""
args = "&${val}.toObject(), JS::CurrentGlobalOrNull(cx)"
else:
rootArgs = dedent(
"""
JS::Rooted<JSObject*> tempRoot(cx, &${val}.toObject());
JS::Rooted<JSObject*> tempGlobalRoot(cx, JS::CurrentGlobalOrNull(cx));
"""
)
args = "cx, tempRoot, tempGlobalRoot, GetIncumbentGlobal()"
if type.nullable() or isCallbackReturnValue:
declType = CGGeneric("RefPtr<%s>" % name)
else:
declType = CGGeneric("OwningNonNull<%s>" % name)
if useFastCallback:
declType = CGTemplatedType("RootedCallback", declType)
declArgs = "cx"
else:
declArgs = None
conversion = fill(
"""
{ // scope for tempRoot and tempGlobalRoot if needed
$*{rootArgs}
$${declName} = new ${name}(${args});
}
""",
rootArgs=rootArgs,
name=name,
args=args,
)
return (declType, declArgs, conversion)
class JSToNativeConversionInfo:
"""
An object representing information about a JS-to-native conversion.
"""
def __init__(
self,
template,
declType=None,
holderType=None,
dealWithOptional=False,
declArgs=None,
holderArgs=None,
):
"""
template: A string representing the conversion code. This will have
template substitution performed on it as follows:
${val} is a handle to the JS::Value in question
${maybeMutableVal} May be a mutable handle to the JS::Value in
question. This is only OK to use if ${val} is
known to not be undefined.
${holderName} replaced by the holder's name, if any
${declName} replaced by the declaration's name
${haveValue} replaced by an expression that evaluates to a boolean
for whether we have a JS::Value. Only used when
defaultValue is not None or when True is passed for
checkForValue to instantiateJSToNativeConversion.
This expression may not be already-parenthesized, so if
you use it with && or || make sure to put parens
around it.
${passedToJSImpl} replaced by an expression that evaluates to a boolean
for whether this value is being passed to a JS-
implemented interface.
declType: A CGThing representing the native C++ type we're converting
to. This is allowed to be None if the conversion code is
supposed to be used as-is.
holderType: A CGThing representing the type of a "holder" which will
hold a possible reference to the C++ thing whose type we
returned in declType, or None if no such holder is needed.
dealWithOptional: A boolean indicating whether the caller has to do
optional-argument handling. This should only be set
to true if the JS-to-native conversion is being done
for an optional argument or dictionary member with no
default value and if the returned template expects
both declType and holderType to be wrapped in
Optional<>, with ${declName} and ${holderName}
adjusted to point to the Value() of the Optional, and
Construct() calls to be made on the Optional<>s as
needed.
declArgs: If not None, the arguments to pass to the ${declName}
constructor. These will have template substitution performed
on them so you can use things like ${val}. This is a
single string, not a list of strings.
holderArgs: If not None, the arguments to pass to the ${holderName}
constructor. These will have template substitution
performed on them so you can use things like ${val}.
This is a single string, not a list of strings.
${declName} must be in scope before the code from 'template' is entered.
If holderType is not None then ${holderName} must be in scope before
the code from 'template' is entered.
"""
assert isinstance(template, str)
assert declType is None or isinstance(declType, CGThing)
assert holderType is None or isinstance(holderType, CGThing)
self.template = template
self.declType = declType
self.holderType = holderType
self.dealWithOptional = dealWithOptional
self.declArgs = declArgs
self.holderArgs = holderArgs
def getHandleDefault(defaultValue):
tag = defaultValue.type.tag()
if tag in numericSuffixes:
# Some numeric literals require a suffix to compile without warnings
return numericValue(tag, defaultValue.value)
assert tag == IDLType.Tags.bool
return toStringBool(defaultValue.value)
def handleDefaultStringValue(defaultValue, method):
"""
Returns a string which ends up calling 'method' with a (char_t*, length)
pair that sets this string default value. This string is suitable for
passing as the second argument of handleDefault.
"""
assert (
defaultValue.type.isDOMString()
or defaultValue.type.isUSVString()
or defaultValue.type.isUTF8String()
or defaultValue.type.isByteString()
)
# There shouldn't be any non-ASCII or embedded nulls in here; if
# it ever sneaks in we will need to think about how to properly
# represent that in the C++.
assert all(ord(c) < 128 and ord(c) > 0 for c in defaultValue.value)
if defaultValue.type.isByteString() or defaultValue.type.isUTF8String():
prefix = ""
else:
prefix = "u"
return fill(
"""
${method}(${prefix}"${value}");
""",
method=method,
prefix=prefix,
value=defaultValue.value,
)
def recordKeyType(recordType):
assert recordType.keyType.isString()
if recordType.keyType.isByteString() or recordType.keyType.isUTF8String():
return "nsCString"
return "nsString"
def recordKeyDeclType(recordType):
return CGGeneric(recordKeyType(recordType))
def initializerForType(type):
"""
Get the right initializer for the given type for a data location where we
plan to then initialize it from a JS::Value. Some types need to always be
initialized even before we start the JS::Value-to-IDL-value conversion.
Returns a string or None if no initialization is needed.
"""
if type.isObject():
return "nullptr"
# We could probably return CGDictionary.getNonInitializingCtorArg() for the
# dictionary case, but code outside DictionaryBase subclasses can't use
# that, so we can't do it across the board.
return None
# If this function is modified, modify CGNativeMember.getArg and
# CGNativeMember.getRetvalInfo accordingly. The latter cares about the decltype
# and holdertype we end up using, because it needs to be able to return the code
# that will convert those to the actual return value of the callback function.
def getJSToNativeConversionInfo(
type,
descriptorProvider,
failureCode=None,
isDefinitelyObject=False,
isMember=False,
isOptional=False,
invalidEnumValueFatal=True,
defaultValue=None,
isNullOrUndefined=False,
isKnownMissing=False,
exceptionCode=None,
lenientFloatCode=None,
allowTreatNonCallableAsNull=False,
isCallbackReturnValue=False,
sourceDescription="value",
nestingLevel="",
):
"""
Get a template for converting a JS value to a native object based on the
given type and descriptor. If failureCode is given, then we're actually
testing whether we can convert the argument to the desired type. That
means that failures to convert due to the JS value being the wrong type of
value need to use failureCode instead of throwing exceptions. Failures to
convert that are due to JS exceptions (from toString or valueOf methods) or
out of memory conditions need to throw exceptions no matter what
failureCode is. However what actually happens when throwing an exception
can be controlled by exceptionCode. The only requirement on that is that
exceptionCode must end up doing a return, and every return from this
function must happen via exceptionCode if exceptionCode is not None.
If isDefinitelyObject is True, that means we have a value and the value
tests true for isObject(), so we have no need to recheck that.
If isNullOrUndefined is True, that means we have a value and the value
tests true for isNullOrUndefined(), so we have no need to recheck that.
If isKnownMissing is True, that means that we are known-missing, and for
cases when we have a default value we only need to output the default value.
if isMember is not False, we're being converted from a property of some JS
object, not from an actual method argument, so we can't rely on our jsval
being rooted or outliving us in any way. Callers can pass "Dictionary",
"Variadic", "Sequence", "Union", or "OwningUnion" to indicate that the conversion
is for something that is a dictionary member, a variadic argument, a sequence,
an union, or an owning union respectively.
XXX Once we swtich *Rooter to Rooted* for Record and Sequence type entirely,
we could remove "Union" from isMember.
If isOptional is true, then we are doing conversion of an optional
argument with no default value.
invalidEnumValueFatal controls whether an invalid enum value conversion
attempt will throw (if true) or simply return without doing anything (if
false).
If defaultValue is not None, it's the IDL default value for this conversion
If isEnforceRange is true, we're converting an integer and throwing if the
value is out of range.
If isClamp is true, we're converting an integer and clamping if the
value is out of range.
If isAllowShared is false, we're converting a buffer source and throwing if
it is a SharedArrayBuffer or backed by a SharedArrayBuffer.
If lenientFloatCode is not None, it should be used in cases when
we're a non-finite float that's not unrestricted.
If allowTreatNonCallableAsNull is true, then [TreatNonCallableAsNull] and
[LegacyTreatNonObjectAsNull] extended attributes on nullable callback functions
will be honored.
If isCallbackReturnValue is "JSImpl" or "Callback", then the declType may be
adjusted to make it easier to return from a callback. Since that type is
never directly observable by any consumers of the callback code, this is OK.
Furthermore, if isCallbackReturnValue is "JSImpl", that affects the behavior
of the FailureFatalCastableObjectUnwrapper conversion; this is used for
implementing auto-wrapping of JS-implemented return values from a
JS-implemented interface.
sourceDescription is a description of what this JS value represents, to be
used in error reporting. Callers should assume that it might get placed in
the middle of a sentence. If it ends up at the beginning of a sentence, its
first character will be automatically uppercased.
The return value from this function is a JSToNativeConversionInfo.
"""
# If we have a defaultValue then we're not actually optional for
# purposes of what we need to be declared as.
assert defaultValue is None or not isOptional
# Also, we should not have a defaultValue if we know we're an object
assert not isDefinitelyObject or defaultValue is None
# And we can't both be an object and be null or undefined
assert not isDefinitelyObject or not isNullOrUndefined
isClamp = type.hasClamp()
isEnforceRange = type.hasEnforceRange()
isAllowShared = type.hasAllowShared()
isAllowLarge = type.hasAllowLarge()
# If exceptionCode is not set, we'll just rethrow the exception we got.
# Note that we can't just set failureCode to exceptionCode, because setting
# failureCode will prevent pending exceptions from being set in cases when
# they really should be!
if exceptionCode is None:
exceptionCode = "return false;\n"
# Unfortunately, .capitalize() on a string will lowercase things inside the
# string, which we do not want.
def firstCap(string):
return string[0].upper() + string[1:]
# Helper functions for dealing with failures due to the JS value being the
# wrong type of value
def onFailureNotAnObject(failureCode):
return CGGeneric(
failureCode
or (
'cx.ThrowErrorMessage<MSG_NOT_OBJECT>("%s");\n'
"%s" % (firstCap(sourceDescription), exceptionCode)
)
)
def onFailureBadType(failureCode, typeName):
return CGGeneric(
failureCode
or (
'cx.ThrowErrorMessage<MSG_DOES_NOT_IMPLEMENT_INTERFACE>("%s", "%s");\n'
"%s" % (firstCap(sourceDescription), typeName, exceptionCode)
)
)
# It's a failure in the committed-to conversion, not a failure to match up
# to a type, so we don't want to use failureCode in here. We want to just
# throw an exception unconditionally.
def onFailureIsShared():
return CGGeneric(
'cx.ThrowErrorMessage<MSG_TYPEDARRAY_IS_SHARED>("%s");\n'
"%s" % (firstCap(sourceDescription), exceptionCode)
)
def onFailureIsLarge():
return CGGeneric(
'cx.ThrowErrorMessage<MSG_TYPEDARRAY_IS_LARGE>("%s");\n'
"%s" % (firstCap(sourceDescription), exceptionCode)
)
def onFailureIsResizable():
return CGGeneric(
'cx.ThrowErrorMessage<MSG_TYPEDARRAY_IS_RESIZABLE>("%s");\n'
"%s" % (firstCap(sourceDescription), exceptionCode)
)
def onFailureIsImmutable():
desc = firstCap(sourceDescription)
return CGGeneric(
f'cx.ThrowErrorMessage<MSG_TYPEDARRAY_IS_IMMUTABLE>("{desc}");\n'
f"{exceptionCode}"
)
def onFailureNotCallable(failureCode):
return CGGeneric(
failureCode
or (
'cx.ThrowErrorMessage<MSG_NOT_CALLABLE>("%s");\n'
"%s" % (firstCap(sourceDescription), exceptionCode)
)
)
# A helper function for handling default values. Takes a template
# body and the C++ code to set the default value and wraps the
# given template body in handling for the default value.
def handleDefault(template, setDefault):
if defaultValue is None:
return template
if isKnownMissing:
return fill(
"""
{
// scope for any temporaries our default value setting needs.
$*{setDefault}
}
""",
setDefault=setDefault,
)
return fill(
"""
if ($${haveValue}) {
$*{templateBody}
} else {
$*{setDefault}
}
""",
templateBody=template,
setDefault=setDefault,
)
# A helper function for wrapping up the template body for
# possibly-nullable objecty stuff
def wrapObjectTemplate(templateBody, type, codeToSetNull, failureCode=None):
if isNullOrUndefined and type.nullable():
# Just ignore templateBody and set ourselves to null.
# Note that we don't have to worry about default values
# here either, since we already examined this value.
return codeToSetNull
if not isDefinitelyObject:
# Handle the non-object cases by wrapping up the whole
# thing in an if cascade.
if type.nullable():
elifLine = "} else if (${val}.isNullOrUndefined()) {\n"
elifBody = codeToSetNull
else:
elifLine = ""
elifBody = ""
# Note that $${val} below expands to ${val}. This string is
# used as a template later, and val will be filled in then.
templateBody = fill(
"""
if ($${val}.isObject()) {
$*{templateBody}
$*{elifLine}
$*{elifBody}
} else {
$*{failureBody}
}
""",
templateBody=templateBody,
elifLine=elifLine,
elifBody=elifBody,
failureBody=onFailureNotAnObject(failureCode).define(),
)
if isinstance(defaultValue, IDLNullValue):
assert type.nullable() # Parser should enforce this
templateBody = handleDefault(templateBody, codeToSetNull)
elif isinstance(defaultValue, IDLEmptySequenceValue):
# Our caller will handle it
pass
else:
assert defaultValue is None
return templateBody
# A helper function for converting things that look like a JSObject*.
def handleJSObjectType(
type, isMember, failureCode, exceptionCode, sourceDescription
):
if not isMember or isMember == "Union":
if isOptional:
# We have a specialization of Optional that will use a
# Rooted for the storage here.
declType = CGGeneric("JS::Handle<JSObject*>")
else:
declType = CGGeneric("JS::Rooted<JSObject*>")
declArgs = "cx"
else:
assert isMember in (
"Sequence",
"Variadic",
"Dictionary",
"OwningUnion",
"Record",
)
# We'll get traced by the sequence or dictionary or union tracer
declType = CGGeneric("JSObject*")
declArgs = None
templateBody = "${declName} = &${val}.toObject();\n"
# For JS-implemented APIs, we refuse to allow passing objects that the
# API consumer does not subsume. The extra parens around
# ($${passedToJSImpl}) suppress unreachable code warnings when
# $${passedToJSImpl} is the literal `false`. But Apple is shipping a
# buggy clang (clang 3.9) in Xcode 8.3, so there even the parens are not
# enough. So we manually disable some warnings in clang.
if (
not isinstance(descriptorProvider, Descriptor)
or descriptorProvider.interface.isJSImplemented()
):
templateBody = (
fill(
"""
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunreachable-code"
#pragma clang diagnostic ignored "-Wunreachable-code-return"
#endif // __clang__
if (($${passedToJSImpl}) && !CallerSubsumes($${val})) {
cx.ThrowErrorMessage<MSG_PERMISSION_DENIED_TO_PASS_ARG>("${sourceDescription}");
$*{exceptionCode}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif // __clang__
""",
sourceDescription=sourceDescription,
exceptionCode=exceptionCode,
)
+ templateBody
)
setToNullCode = "${declName} = nullptr;\n"
template = wrapObjectTemplate(templateBody, type, setToNullCode, failureCode)
return JSToNativeConversionInfo(
template, declType=declType, dealWithOptional=isOptional, declArgs=declArgs
)
def incrementNestingLevel():
if nestingLevel == "":
return 1
return nestingLevel + 1
assert not (isEnforceRange and isClamp) # These are mutually exclusive
if type.isSequence() or type.isObservableArray():
assert not isEnforceRange and not isClamp and not isAllowShared
if failureCode is None:
notSequence = (
'cx.ThrowErrorMessage<MSG_CONVERSION_ERROR>("%s", "%s");\n'
"%s"
% (
firstCap(sourceDescription),
"sequence" if type.isSequence() else "observable array",
exceptionCode,
)
)
else:
notSequence = failureCode
nullable = type.nullable()
# Be very careful not to change "type": we need it later
if nullable:
elementType = type.inner.inner
else:
elementType = type.inner
# We want to use auto arrays if we can, but we have to be careful with
# reallocation behavior for arrays. In particular, if we use auto
# arrays for sequences and have a sequence of elements which are
# themselves sequences or have sequences as members, we have a problem.
# In that case, resizing the outermost AutoTArray to the right size
# will memmove its elements, but AutoTArrays are not memmovable and
# hence will end up with pointers to bogus memory, which is bad. To
# deal with this, we typically map WebIDL sequences to our Sequence
# type, which is in fact memmovable. The one exception is when we're
# passing in a sequence directly as an argument without any sort of
# optional or nullable complexity going on. In that situation, we can
# use an AutoSequence instead. We have to keep using Sequence in the
# nullable and optional cases because we don't want to leak the
# AutoSequence type to consumers, which would be unavoidable with
# Nullable<AutoSequence> or Optional<AutoSequence>.
if (
(isMember and isMember != "Union")
or isOptional
or nullable
or isCallbackReturnValue
):
sequenceClass = "Sequence"
else:
sequenceClass = "binding_detail::AutoSequence"
# XXXbz we can't include the index in the sourceDescription, because
# we don't really have a way to pass one in dynamically at runtime...
elementInfo = getJSToNativeConversionInfo(
elementType,
descriptorProvider,
isMember="Sequence",
exceptionCode=exceptionCode,
lenientFloatCode=lenientFloatCode,
isCallbackReturnValue=isCallbackReturnValue,
sourceDescription="element of %s" % sourceDescription,
nestingLevel=incrementNestingLevel(),
)
if elementInfo.dealWithOptional:
raise TypeError("Shouldn't have optional things in sequences")
if elementInfo.holderType is not None:
raise TypeError("Shouldn't need holders for sequences")
typeName = CGTemplatedType(sequenceClass, elementInfo.declType)
sequenceType = typeName.define()
if isMember == "Union" and typeNeedsRooting(type):
assert not nullable
typeName = CGTemplatedType(
"binding_detail::RootedAutoSequence", elementInfo.declType
)
elif nullable:
typeName = CGTemplatedType("Nullable", typeName)
if nullable:
arrayRef = "${declName}.SetValue()"
else:
arrayRef = "${declName}"
elementConversion = string.Template(elementInfo.template).substitute(
{
"val": "temp" + str(nestingLevel),
"maybeMutableVal": "&temp" + str(nestingLevel),
"declName": "slot" + str(nestingLevel),
# We only need holderName here to handle isExternal()
# interfaces, which use an internal holder for the
# conversion even when forceOwningType ends up true.
"holderName": "tempHolder" + str(nestingLevel),
"passedToJSImpl": "${passedToJSImpl}",
}
)
elementInitializer = initializerForType(elementType)
if elementInitializer is None:
elementInitializer = ""
else:
elementInitializer = elementInitializer + ", "
# NOTE: Keep this in sync with variadic conversions as needed
templateBody = fill(
"""
JS::ForOfIterator iter${nestingLevel}(cx);
if (!iter${nestingLevel}.init($${val}, JS::ForOfIterator::AllowNonIterable)) {
$*{exceptionCode}
}
if (!iter${nestingLevel}.valueIsIterable()) {
$*{notSequence}
}
${sequenceType} &arr${nestingLevel} = ${arrayRef};
JS::Rooted<JS::Value> temp${nestingLevel}(cx);
while (true) {
bool done${nestingLevel};
if (!iter${nestingLevel}.next(&temp${nestingLevel}, &done${nestingLevel})) {
$*{exceptionCode}
}
if (done${nestingLevel}) {
break;
}
${elementType}* slotPtr${nestingLevel} = arr${nestingLevel}.AppendElement(${elementInitializer}mozilla::fallible);
if (!slotPtr${nestingLevel}) {
JS_ReportOutOfMemory(cx);
$*{exceptionCode}
}
${elementType}& slot${nestingLevel} = *slotPtr${nestingLevel};
$*{elementConversion}
}
""",
exceptionCode=exceptionCode,
notSequence=notSequence,
sequenceType=sequenceType,
arrayRef=arrayRef,
elementType=elementInfo.declType.define(),
elementConversion=elementConversion,
elementInitializer=elementInitializer,
nestingLevel=str(nestingLevel),
)
templateBody = wrapObjectTemplate(
templateBody, type, "${declName}.SetNull();\n", notSequence
)
if isinstance(defaultValue, IDLEmptySequenceValue):
if type.nullable():
codeToSetEmpty = "${declName}.SetValue();\n"
else:
codeToSetEmpty = (
"/* ${declName} array is already empty; nothing to do */\n"
)
templateBody = handleDefault(templateBody, codeToSetEmpty)
declArgs = None
holderType = None
holderArgs = None
# Sequence arguments that might contain traceable things need
# to get traced
if typeNeedsRooting(elementType):
if not isMember:
holderType = CGTemplatedType("SequenceRooter", elementInfo.declType)
# If our sequence is nullable, this will set the Nullable to be
# not-null, but that's ok because we make an explicit SetNull() call
# on it as needed if our JS value is actually null.
holderArgs = "cx, &%s" % arrayRef
elif isMember == "Union":
declArgs = "cx"
return JSToNativeConversionInfo(
templateBody,
declType=typeName,
declArgs=declArgs,
holderType=holderType,
dealWithOptional=isOptional,
holderArgs=holderArgs,
)
if type.isRecord():
assert not isEnforceRange and not isClamp and not isAllowShared
if failureCode is None:
notRecord = 'cx.ThrowErrorMessage<MSG_NOT_OBJECT>("%s");\n' "%s" % (
firstCap(sourceDescription),
exceptionCode,
)
else:
notRecord = failureCode
nullable = type.nullable()
# Be very careful not to change "type": we need it later
if nullable:
recordType = type.inner
else:
recordType = type
valueType = recordType.inner
valueInfo = getJSToNativeConversionInfo(
valueType,
descriptorProvider,
isMember="Record",
exceptionCode=exceptionCode,
lenientFloatCode=lenientFloatCode,
isCallbackReturnValue=isCallbackReturnValue,
sourceDescription="value in %s" % sourceDescription,
nestingLevel=incrementNestingLevel(),
)
if valueInfo.dealWithOptional:
raise TypeError("Shouldn't have optional things in record")
if valueInfo.holderType is not None:
raise TypeError("Shouldn't need holders for record")
declType = CGTemplatedType(
"Record", [recordKeyDeclType(recordType), valueInfo.declType]
)
typeName = declType.define()
if isMember == "Union" and typeNeedsRooting(type):
assert not nullable
declType = CGTemplatedType(
"RootedRecord", [recordKeyDeclType(recordType), valueInfo.declType]
)
elif nullable:
declType = CGTemplatedType("Nullable", declType)
if nullable:
recordRef = "${declName}.SetValue()"
else:
recordRef = "${declName}"
valueConversion = string.Template(valueInfo.template).substitute(
{
"val": "temp",
"maybeMutableVal": "&temp",
"declName": "slot",
# We only need holderName here to handle isExternal()
# interfaces, which use an internal holder for the
# conversion even when forceOwningType ends up true.
"holderName": "tempHolder",
"passedToJSImpl": "${passedToJSImpl}",
}
)
keyType = recordKeyType(recordType)
if recordType.keyType.isJSString():
raise TypeError(
"Have do deal with JSString record type, but don't know how"
)
if recordType.keyType.isByteString() or recordType.keyType.isUTF8String():
hashKeyType = "nsCStringHashKey"
if recordType.keyType.isByteString():
keyConversionFunction = "ConvertJSValueToByteString"
else:
keyConversionFunction = "ConvertJSValueToString"
else:
hashKeyType = "nsStringHashKey"
if recordType.keyType.isDOMString():
keyConversionFunction = "ConvertJSValueToString"
else:
assert recordType.keyType.isUSVString()
keyConversionFunction = "ConvertJSValueToUSVString"
templateBody = fill(
"""
auto& recordEntries = ${recordRef}.Entries();
JS::Rooted<JSObject*> recordObj(cx, &$${val}.toObject());
JS::RootedVector<jsid> ids(cx);
if (!js::GetPropertyKeys(cx, recordObj,
JSITER_OWNONLY | JSITER_HIDDEN | JSITER_SYMBOLS, &ids)) {
$*{exceptionCode}
}
if (!recordEntries.SetCapacity(ids.length(), mozilla::fallible)) {
JS_ReportOutOfMemory(cx);
$*{exceptionCode}
}
JS::Rooted<JS::Value> propNameValue(cx);
JS::Rooted<JS::Value> temp(cx);
JS::Rooted<jsid> curId(cx);
JS::Rooted<JS::Value> idVal(cx);
// Use a hashset to keep track of ids seen, to avoid
// introducing nasty O(N^2) behavior scanning for them all the
// time. Ideally we'd use a data structure with O(1) lookup
// _and_ ordering for the MozMap, but we don't have one lying
// around.
nsTHashtable<${hashKeyType}> idsSeen;
for (size_t i = 0; i < ids.length(); ++i) {
curId = ids[i];
JS::Rooted<mozilla::Maybe<JS::PropertyDescriptor>> desc(cx);
if (!JS_GetOwnPropertyDescriptorById(cx, recordObj, curId,
&desc)) {
$*{exceptionCode}
}
if (desc.isNothing() || !desc->enumerable()) {
continue;
}
idVal = js::IdToValue(curId);
${keyType} propName;
// This will just throw if idVal is a Symbol, like the spec says
// to do.
if (!${keyConversionFunction}(cx, idVal, "key of ${sourceDescription}", propName)) {
$*{exceptionCode}
}
if (!JS_GetPropertyById(cx, recordObj, curId, &temp)) {
$*{exceptionCode}
}
${typeName}::EntryType* entry;
if (!idsSeen.EnsureInserted(propName)) {
// Find the existing entry.
auto idx = recordEntries.IndexOf(propName);
MOZ_ASSERT(idx != recordEntries.NoIndex,
"Why is it not found?");
// Now blow it away to make it look like it was just added
// to the array, because it's not obvious that it's
// safe to write to its already-initialized mValue via our
// normal codegen conversions. For example, the value
// could be a union and this would change its type, but
// codegen assumes we won't do that.
entry = recordEntries.ReconstructElementAt(idx);
} else {
// Safe to do an infallible append here, because we did a
// SetCapacity above to the right capacity.
entry = recordEntries.AppendElement();
}
entry->mKey = propName;
${valueType}& slot = entry->mValue;
$*{valueConversion}
}
""",
exceptionCode=exceptionCode,
recordRef=recordRef,
hashKeyType=hashKeyType,
keyType=keyType,
keyConversionFunction=keyConversionFunction,
sourceDescription=sourceDescription,
typeName=typeName,
valueType=valueInfo.declType.define(),
valueConversion=valueConversion,
)
templateBody = wrapObjectTemplate(
templateBody, type, "${declName}.SetNull();\n", notRecord
)
declArgs = None
holderType = None
holderArgs = None
# record arguments that might contain traceable things need
# to get traced
if not isMember and isCallbackReturnValue:
# Go ahead and just convert directly into our actual return value
declType = CGWrapper(declType, post="&")
declArgs = "aRetVal"
elif typeNeedsRooting(valueType):
if not isMember:
holderType = CGTemplatedType(
"RecordRooter", [recordKeyDeclType(recordType), valueInfo.declType]
)
# If our record is nullable, this will set the Nullable to be
# not-null, but that's ok because we make an explicit SetNull() call
# on it as needed if our JS value is actually null.
holderArgs = "cx, &%s" % recordRef
elif isMember == "Union":
declArgs = "cx"
return JSToNativeConversionInfo(
templateBody,
declType=declType,
declArgs=declArgs,
holderType=holderType,
dealWithOptional=isOptional,
holderArgs=holderArgs,
)
if type.isUnion():
nullable = type.nullable()
if nullable:
type = type.inner
isOwningUnion = (isMember and isMember != "Union") or isCallbackReturnValue
unionArgumentObj = "${declName}"
if nullable:
if isOptional and not isOwningUnion:
unionArgumentObj += ".Value()"
# If we're owning, we're a Nullable, which hasn't been told it has
# a value. Otherwise we're an already-constructed Maybe.
unionArgumentObj += ".SetValue()"
templateBody = CGIfWrapper(
CGGeneric(exceptionCode),
'!%s.Init(cx, ${val}, "%s", ${passedToJSImpl})'
% (unionArgumentObj, firstCap(sourceDescription)),
)
if type.hasNullableType:
assert not nullable
# Make sure to handle a null default value here
if defaultValue and isinstance(defaultValue, IDLNullValue):
assert defaultValue.type == type
templateBody = CGIfElseWrapper(
"!(${haveValue})",
CGGeneric("%s.SetNull();\n" % unionArgumentObj),
templateBody,
)
typeName = CGUnionStruct.unionTypeDecl(type, isOwningUnion)
argumentTypeName = typeName + "Argument"
if nullable:
typeName = "Nullable<" + typeName + " >"
declType = CGGeneric(typeName)
if isOwningUnion:
holderType = None
else:
holderType = CGGeneric(argumentTypeName)
if nullable:
holderType = CGTemplatedType("Maybe", holderType)
# If we're isOptional and not nullable the normal optional handling will
# handle lazy construction of our holder. If we're nullable and not
# owning we do it all by hand because we do not want our holder
# constructed if we're null. But if we're owning we don't have a
# holder anyway, so we can do the normal Optional codepath.
declLoc = "${declName}"
constructDecl = None
if nullable:
if isOptional and not isOwningUnion:
declType = CGTemplatedType("Optional", declType)
constructDecl = CGGeneric("${declName}.Construct();\n")
declLoc = "${declName}.Value()"
if not isMember and isCallbackReturnValue:
declType = CGWrapper(declType, post="&")
declArgs = "aRetVal"
else:
declArgs = None
if (
defaultValue
and not isinstance(defaultValue, IDLNullValue)
and not isinstance(defaultValue, IDLDefaultDictionaryValue)
):
tag = defaultValue.type.tag()
if tag in numericSuffixes or tag is IDLType.Tags.bool:
defaultStr = getHandleDefault(defaultValue)
# Make sure we actually construct the thing inside the nullable.
value = declLoc + (".SetValue()" if nullable else "")
name = getUnionMemberName(defaultValue.type)
default = CGGeneric(
"%s.RawSetAs%s() = %s;\n" % (value, name, defaultStr)
)
elif isinstance(defaultValue, IDLEmptySequenceValue):
name = getUnionMemberName(defaultValue.type)
# Make sure we actually construct the thing inside the nullable.
value = declLoc + (".SetValue()" if nullable else "")
if not isOwningUnion and typeNeedsRooting(defaultValue.type):
ctorArgs = "cx"
else:
ctorArgs = ""
# It's enough to set us to the right type; that will
# create an empty array, which is all we need here.
default = CGGeneric(
"(void)%s.RawSetAs%s(%s);\n" % (value, name, ctorArgs)
)
elif defaultValue.type.isEnum():
name = getUnionMemberName(defaultValue.type)
# Make sure we actually construct the thing inside the nullable.
value = declLoc + (".SetValue()" if nullable else "")
default = CGGeneric(
"%s.RawSetAs%s() = %s::%s;\n"
% (
value,
name,
defaultValue.type.inner.identifier.name,
getEnumValueName(defaultValue.value),
)
)
else:
default = CGGeneric(
handleDefaultStringValue(
defaultValue, "%s.SetStringLiteral" % unionArgumentObj
)
)
templateBody = CGIfElseWrapper("!(${haveValue})", default, templateBody)
if nullable:
assert not type.hasNullableType
if defaultValue:
if isinstance(defaultValue, IDLNullValue):
extraConditionForNull = "!(${haveValue}) || "
else:
extraConditionForNull = "(${haveValue}) && "
else:
extraConditionForNull = ""
hasUndefinedType = any(t.isUndefined() for t in type.flatMemberTypes)
assert not hasUndefinedType or defaultValue is None
nullTest = (
"${val}.isNull()" if hasUndefinedType else "${val}.isNullOrUndefined()"
)
templateBody = CGIfElseWrapper(
extraConditionForNull + nullTest,
CGGeneric("%s.SetNull();\n" % declLoc),
templateBody,
)
elif (
not type.hasNullableType
and defaultValue
and isinstance(defaultValue, IDLDefaultDictionaryValue)
):
assert type.hasDictionaryType()
assert defaultValue.type.isDictionary()
if not isOwningUnion and typeNeedsRooting(defaultValue.type):
ctorArgs = "cx"
else:
ctorArgs = ""
initDictionaryWithNull = CGIfWrapper(
CGGeneric("return false;\n"),
(
'!%s.RawSetAs%s(%s).Init(cx, JS::NullHandleValue, "Member of %s")'
% (
declLoc,
getUnionMemberName(defaultValue.type),
ctorArgs,
type.prettyName(),
)
),
)
templateBody = CGIfElseWrapper(
"!(${haveValue})", initDictionaryWithNull, templateBody
)
templateBody = CGList([constructDecl, templateBody])
return JSToNativeConversionInfo(
templateBody.define(),
declType=declType,
declArgs=declArgs,
dealWithOptional=isOptional and (not nullable or isOwningUnion),
)
if type.isPromise():
assert not type.nullable()
assert defaultValue is None
# We always have to hold a strong ref to Promise here, because
# Promise::resolve returns an addrefed thing.
argIsPointer = isCallbackReturnValue
if argIsPointer:
declType = CGGeneric("RefPtr<Promise>")
else:
declType = CGGeneric("OwningNonNull<Promise>")
# Per spec, what we're supposed to do is take the original
# Promise.resolve and call it with the original Promise as this
# value to make a Promise out of whatever value we actually have
# here. The question is which global we should use. There are
# several cases to consider:
#
# 1) Normal call to API with a Promise argument. This is a case the
# spec covers, and we should be using the current Realm's
# Promise. That means the current compartment.
# 2) Call to API with a Promise argument over Xrays. In practice,
# this sort of thing seems to be used for giving an API
# implementation a way to wait for conclusion of an asyc
# operation, _not_ to expose the Promise to content code. So we
# probably want to allow callers to use such an API in a
# "natural" way, by passing chrome-side promises; indeed, that
# may be all that the caller has to represent their async
# operation. That means we really need to do the
# Promise.resolve() in the caller (chrome) compartment: if we do
# it in the content compartment, we will try to call .then() on
# the chrome promise while in the content compartment, which will
# throw and we'll just get a rejected Promise. Note that this is
# also the reason why a caller who has a chrome Promise
# representing an async operation can't itself convert it to a
# content-side Promise (at least not without some serious
# gyrations).
# 3) Promise return value from a callback or callback interface.
# Per spec, this should use the Realm of the callback object. In
# our case, that's the compartment of the underlying callback,
# not the current compartment (which may be the compartment of
# some cross-compartment wrapper around said callback).
# 4) Return value from a JS-implemented interface. In this case we
# have a problem. Our current compartment is the compartment of
# the JS implementation. But if the JS implementation returned
# a page-side Promise (which is a totally sane thing to do, and
# in fact the right thing to do given that this return value is
# going right to content script) then we don't want to
# Promise.resolve with our current compartment Promise, because
# that will wrap it up in a chrome-side Promise, which is
# decidedly _not_ what's desired here. So in that case we
# should really unwrap the return value and use the global of
# the result. CheckedUnwrapStatic should be good enough for that;
# if it fails, then we're failing unwrap while in a
# system-privileged compartment, so presumably we have a dead
# object wrapper. Just error out. Do NOT fall back to using
# the current compartment instead: that will return a
# system-privileged rejected (because getting .then inside
# resolve() failed) Promise to the caller, which they won't be
# able to touch. That's not helpful. If we error out, on the
# other hand, they will get a content-side rejected promise.
# Same thing if the value returned is not even an object.
if isCallbackReturnValue == "JSImpl":
# Case 4 above. Note that globalObj defaults to the current
# compartment global. Note that we don't use $*{exceptionCode}
# here because that will try to aRv.Throw(NS_ERROR_UNEXPECTED)
# which we don't really want here.
assert exceptionCode == "aRv.Throw(NS_ERROR_UNEXPECTED);\nreturn nullptr;\n"
getPromiseGlobal = fill(
"""
if (!$${val}.isObject()) {
aRv.ThrowTypeError<MSG_NOT_OBJECT>("${sourceDescription}");
return nullptr;
}
JSObject* unwrappedVal = js::CheckedUnwrapStatic(&$${val}.toObject());
if (!unwrappedVal) {
// A slight lie, but not much of one, for a dead object wrapper.
aRv.ThrowTypeError<MSG_NOT_OBJECT>("${sourceDescription}");
return nullptr;
}
globalObj = JS::GetNonCCWObjectGlobal(unwrappedVal);
""",
sourceDescription=sourceDescription,
)
elif isCallbackReturnValue == "Callback":
getPromiseGlobal = dedent(
"""
// We basically want our entry global here. Play it safe
// and use GetEntryGlobal() to get it, with whatever
// principal-clamping it ends up doing.
globalObj = GetEntryGlobal()->GetGlobalJSObject();
"""
)
else:
getPromiseGlobal = dedent(
"""
globalObj = JS::CurrentGlobalOrNull(cx);
"""
)
templateBody = fill(
"""
{ // Scope for our GlobalObject, FastErrorResult, JSAutoRealm,
// etc.
JS::Rooted<JSObject*> globalObj(cx);
$*{getPromiseGlobal}
JSAutoRealm ar(cx, globalObj);
GlobalObject promiseGlobal(cx, globalObj);
if (promiseGlobal.Failed()) {
$*{exceptionCode}
}
JS::Rooted<JS::Value> valueToResolve(cx, $${val});
if (!JS_WrapValue(cx, &valueToResolve)) {
$*{exceptionCode}
}
binding_detail::FastErrorResult promiseRv;
nsCOMPtr<nsIGlobalObject> global =
do_QueryInterface(promiseGlobal.GetAsSupports());
if (!global) {
promiseRv.Throw(NS_ERROR_UNEXPECTED);
MOZ_ALWAYS_TRUE(promiseRv.MaybeSetPendingException(cx));
$*{exceptionCode}
}
$${declName} = Promise::Resolve(global, cx, valueToResolve,
promiseRv);
if (promiseRv.MaybeSetPendingException(cx)) {
$*{exceptionCode}
}
}
""",
getPromiseGlobal=getPromiseGlobal,
exceptionCode=exceptionCode,
)
return JSToNativeConversionInfo(
templateBody, declType=declType, dealWithOptional=isOptional
)
if type.isGeckoInterface():
assert not isEnforceRange and not isClamp and not isAllowShared
descriptor = descriptorProvider.getDescriptor(
type.unroll().inner.identifier.name
)
assert descriptor.nativeType != "JSObject"
if descriptor.interface.isCallback():
(declType, declArgs, conversion) = getCallbackConversionInfo(
type, descriptor.interface, isMember, isCallbackReturnValue, isOptional
)
template = wrapObjectTemplate(
conversion, type, "${declName} = nullptr;\n", failureCode
)
return JSToNativeConversionInfo(
template,
declType=declType,
declArgs=declArgs,
dealWithOptional=isOptional,
)
if descriptor.interface.identifier.name == "WindowProxy":
declType = CGGeneric("mozilla::dom::WindowProxyHolder")
if type.nullable():
declType = CGTemplatedType("Nullable", declType)
windowProxyHolderRef = "${declName}.SetValue()"
else:
windowProxyHolderRef = "${declName}"
failureCode = onFailureBadType(
failureCode, descriptor.interface.identifier.name
).define()
templateBody = fill(
"""
JS::Rooted<JSObject*> source(cx, &$${val}.toObject());
if (NS_FAILED(UnwrapWindowProxyArg(cx, source, ${windowProxyHolderRef}))) {
$*{onFailure}
}
""",
windowProxyHolderRef=windowProxyHolderRef,
onFailure=failureCode,
)
templateBody = wrapObjectTemplate(
templateBody, type, "${declName}.SetNull();\n", failureCode
)
return JSToNativeConversionInfo(
templateBody, declType=declType, dealWithOptional=isOptional
)
# This is an interface that we implement as a concrete class
# or an XPCOM interface.
# Allow null pointers for nullable types and old-binding classes, and
# use an RefPtr or raw pointer for callback return values to make
# them easier to return.
argIsPointer = (
type.nullable() or type.unroll().inner.isExternal() or isCallbackReturnValue
)
# Sequence and dictionary members, as well as owning unions (which can
# appear here as return values in JS-implemented interfaces) have to
# hold a strong ref to the thing being passed down. Those all set
# isMember.
#
# Also, callback return values always end up addrefing anyway, so there
# is no point trying to avoid it here and it makes other things simpler
# since we can assume the return value is a strong ref.
assert not descriptor.interface.isCallback()
forceOwningType = (isMember and isMember != "Union") or isCallbackReturnValue
typeName = descriptor.nativeType
typePtr = typeName + "*"
# Compute a few things:
# - declType is the type we want to return as the first element of our
# tuple.
# - holderType is the type we want to return as the third element
# of our tuple.
# Set up some sensible defaults for these things insofar as we can.
holderType = None
if argIsPointer:
if forceOwningType:
declType = "RefPtr<" + typeName + ">"
else:
declType = typePtr
else:
if forceOwningType:
declType = "OwningNonNull<" + typeName + ">"
else:
declType = "NonNull<" + typeName + ">"
templateBody = ""
if forceOwningType:
templateBody += fill(
"""
static_assert(IsRefcounted<${typeName}>::value, "We can only store refcounted classes.");
""",
typeName=typeName,
)
if not descriptor.interface.isExternal():
if failureCode is not None:
templateBody += str(
CastableObjectUnwrapper(
descriptor,
"${val}",
"${maybeMutableVal}",
"${declName}",
failureCode,
)
)
else:
templateBody += str(
FailureFatalCastableObjectUnwrapper(
descriptor,
"${val}",
"${maybeMutableVal}",
"${declName}",
exceptionCode,
isCallbackReturnValue,
firstCap(sourceDescription),
)
)
else:
# External interface. We always have a holder for these, because we
# don't actually know whether we have to addref when unwrapping or not.
# So we just pass an getter_AddRefs(RefPtr) to XPConnect and if we'll
# need a release it'll put a non-null pointer in there.
if forceOwningType:
# Don't return a holderType in this case; our declName
# will just own stuff.
templateBody += "RefPtr<" + typeName + "> ${holderName};\n"
else:
holderType = "RefPtr<" + typeName + ">"
templateBody += (
"JS::Rooted<JSObject*> source(cx, &${val}.toObject());\n"
+ "if (NS_FAILED(UnwrapArg<"
+ typeName
+ ">(cx, source, getter_AddRefs(${holderName})))) {\n"
)
templateBody += CGIndenter(
onFailureBadType(failureCode, descriptor.interface.identifier.name)
).define()
templateBody += "}\n" "MOZ_ASSERT(${holderName});\n"
# And store our value in ${declName}
templateBody += "${declName} = ${holderName};\n"
# Just pass failureCode, not onFailureBadType, here, so we'll report
# the thing as not an object as opposed to not implementing whatever
# our interface is.
templateBody = wrapObjectTemplate(
templateBody, type, "${declName} = nullptr;\n", failureCode
)
declType = CGGeneric(declType)
if holderType is not None:
holderType = CGGeneric(holderType)
return JSToNativeConversionInfo(
templateBody,
declType=declType,
holderType=holderType,
dealWithOptional=isOptional,
)
if type.isSpiderMonkeyInterface():
assert not isEnforceRange and not isClamp
name = type.unroll().name # unroll() because it may be nullable
interfaceType = CGGeneric(name)
declType = interfaceType
if type.nullable():
declType = CGTemplatedType("Nullable", declType)
objRef = "${declName}.SetValue()"
else:
objRef = "${declName}"
# Again, this is a bit strange since we are actually building a
# template string here. ${objRef} and $*{badType} below are filled in
# right now; $${val} expands to ${val}, to be filled in later.
template = fill(
"""
if (!${objRef}.Init(&$${val}.toObject())) {
$*{badType}
}
""",
objRef=objRef,
badType=onFailureBadType(failureCode, type.name).define(),
)
if type.isBufferSource():
if type.isArrayBuffer():
isSharedMethod = "JS::IsSharedArrayBufferObject"
isLargeMethod = "JS::IsLargeArrayBufferMaybeShared"
isResizableMethod = "JS::IsResizableArrayBufferMaybeShared"
isImmutableMethod = "JS::IsImmutableArrayBufferMaybeShared"
else:
assert type.isArrayBufferView() or type.isTypedArray()
isSharedMethod = "JS::IsArrayBufferViewShared"
isLargeMethod = "JS::IsLargeArrayBufferView"
isResizableMethod = "JS::IsResizableArrayBufferView"
isImmutableMethod = "JS::IsImmutableArrayBufferView"
if not isAllowShared:
template += fill(
"""
if (${isSharedMethod}(${objRef}.Obj())) {
$*{badType}
}
""",
isSharedMethod=isSharedMethod,
objRef=objRef,
badType=onFailureIsShared().define(),
)
if not isAllowLarge:
template += fill(
"""
if (${isLargeMethod}(${objRef}.Obj())) {
$*{badType}
}
""",
isLargeMethod=isLargeMethod,
objRef=objRef,
badType=onFailureIsLarge().define(),
)
# For now reject resizable ArrayBuffers and growable
# SharedArrayBuffers. Supporting this will require changing
# dom::TypedArray and consumers.
template += fill(
"""
if (${isResizableMethod}(${objRef}.Obj())) {
$*{badType}
}
""",
isResizableMethod=isResizableMethod,
objRef=objRef,
badType=onFailureIsResizable().define(),
)
# For now reject immutable ArrayBuffers. Supporting this will
# require changing dom::TypedArray and consumers.
template += fill(
"""
if (${isImmutableMethod}(${objRef}.Obj())) {
$*{badType}
}
""",
isImmutableMethod=isImmutableMethod,
objRef=objRef,
badType=onFailureIsImmutable().define(),
)
template = wrapObjectTemplate(
template, type, "${declName}.SetNull();\n", failureCode
)
if not isMember or isMember == "Union":
# This is a bit annoying. In a union we don't want to have a
# holder, since unions don't support that. But if we're optional we
# want to have a holder, so that the callee doesn't see
# Optional<RootedSpiderMonkeyInterface<InterfaceType>>. So do a
# holder if we're optional and use a RootedSpiderMonkeyInterface
# otherwise.
if isOptional:
holderType = CGTemplatedType(
"SpiderMonkeyInterfaceRooter", interfaceType
)
# If our SpiderMonkey interface is nullable, this will set the
# Nullable to be not-null, but that's ok because we make an
# explicit SetNull() call on it as needed if our JS value is
# actually null. XXXbz Because "Maybe" takes const refs for
# constructor arguments, we can't pass a reference here; have
# to pass a pointer.
holderArgs = "cx, &%s" % objRef
declArgs = None
else:
holderType = None
holderArgs = None
declType = CGTemplatedType("RootedSpiderMonkeyInterface", declType)
declArgs = "cx"
else:
holderType = None
holderArgs = None
declArgs = None
return JSToNativeConversionInfo(
template,
declType=declType,
holderType=holderType,
dealWithOptional=isOptional,
declArgs=declArgs,
holderArgs=holderArgs,
)
if type.isJSString():
assert not isEnforceRange and not isClamp and not isAllowShared
if type.nullable():
raise TypeError("Nullable JSString not supported")
declArgs = "cx"
if isMember:
raise TypeError("JSString not supported as member")
else:
declType = "JS::Rooted<JSString*>"
if isOptional:
raise TypeError("JSString not supported as optional")
templateBody = fill(
"""
if (!($${declName} = ConvertJSValueToJSString(cx, $${val}))) {
$*{exceptionCode}
}
""",
exceptionCode=exceptionCode,
)
if defaultValue is not None:
assert not isinstance(defaultValue, IDLNullValue)
defaultCode = fill(
"""
static const char data[] = { ${data} };
$${declName} = JS_NewStringCopyN(cx, data, std::size(data) - 1);
if (!$${declName}) {
$*{exceptionCode}
}
""",
data=", ".join(
["'" + char + "'" for char in defaultValue.value] + ["0"]
),
exceptionCode=exceptionCode,
)
templateBody = handleDefault(templateBody, defaultCode)
return JSToNativeConversionInfo(
templateBody, declType=CGGeneric(declType), declArgs=declArgs
)
if type.isDOMString() or type.isUSVString() or type.isUTF8String():
assert not isEnforceRange and not isClamp and not isAllowShared
treatAs = {
"Default": "eStringify",
"EmptyString": "eEmpty",
"Null": "eNull",
}
if type.nullable():
# For nullable strings null becomes a null string.
treatNullAs = "Null"
# For nullable strings undefined also becomes a null string.
undefinedBehavior = "eNull"
else:
undefinedBehavior = "eStringify"
if type.legacyNullToEmptyString:
treatNullAs = "EmptyString"
else:
treatNullAs = "Default"
nullBehavior = treatAs[treatNullAs]
def getConversionCode(varName):
normalizeCode = ""
if type.isUSVString():
normalizeCode = fill(
"""
if (!NormalizeUSVString(${var})) {
JS_ReportOutOfMemory(cx);
$*{exceptionCode}
}
""",
var=varName,
exceptionCode=exceptionCode,
)
conversionCode = fill(
"""
if (!ConvertJSValueToString(cx, $${val}, ${nullBehavior}, ${undefinedBehavior}, ${varName})) {
$*{exceptionCode}
}
$*{normalizeCode}
""",
nullBehavior=nullBehavior,
undefinedBehavior=undefinedBehavior,
varName=varName,
exceptionCode=exceptionCode,
normalizeCode=normalizeCode,
)
if defaultValue is None:
return conversionCode
if isinstance(defaultValue, IDLNullValue):
assert type.nullable()
defaultCode = "%s.SetIsVoid(true);\n" % varName
else:
defaultCode = handleDefaultStringValue(
defaultValue, "%s.AssignLiteral" % varName
)
return handleDefault(conversionCode, defaultCode)
if isMember and isMember != "Union":
# Convert directly into the ns[C]String member we have.
if type.isUTF8String():
declType = "nsCString"
else:
declType = "nsString"
return JSToNativeConversionInfo(
getConversionCode("${declName}"),
declType=CGGeneric(declType),
dealWithOptional=isOptional,
)
if isOptional:
if type.isUTF8String():
declType = "Optional<nsACString>"
holderType = CGGeneric("nsAutoCString")
else:
declType = "Optional<nsAString>"
holderType = CGGeneric("nsAutoString")
conversionCode = "%s" "${declName} = &${holderName};\n" % getConversionCode(
"${holderName}"
)
else:
if type.isUTF8String():
declType = "nsAutoCString"
else:
declType = "nsAutoString"
holderType = None
conversionCode = getConversionCode("${declName}")
# No need to deal with optional here; we handled it already
return JSToNativeConversionInfo(
conversionCode, declType=CGGeneric(declType), holderType=holderType
)
if type.isByteString():
assert not isEnforceRange and not isClamp and not isAllowShared
nullable = toStringBool(type.nullable())
conversionCode = fill(
"""
if (!ConvertJSValueToByteString(cx, $${val}, ${nullable}, "${sourceDescription}", $${declName})) {
$*{exceptionCode}
}
""",
nullable=nullable,
sourceDescription=sourceDescription,
exceptionCode=exceptionCode,
)
if defaultValue is not None:
if isinstance(defaultValue, IDLNullValue):
assert type.nullable()
defaultCode = "${declName}.SetIsVoid(true);\n"
else:
defaultCode = handleDefaultStringValue(
defaultValue, "${declName}.AssignLiteral"
)
conversionCode = handleDefault(conversionCode, defaultCode)
return JSToNativeConversionInfo(
conversionCode, declType=CGGeneric("nsCString"), dealWithOptional=isOptional
)
if type.isEnum():
assert not isEnforceRange and not isClamp and not isAllowShared
enumName = type.unroll().inner.identifier.name
declType = CGGeneric(enumName)
if type.nullable():
declType = CGTemplatedType("Nullable", declType)
declType = declType.define()
enumLoc = "${declName}.SetValue()"
else:
enumLoc = "${declName}"
declType = declType.define()
if invalidEnumValueFatal:
handleInvalidEnumValueCode = "MOZ_ASSERT(index >= 0);\n"
else:
# invalidEnumValueFatal is false only for attributes. So we won't
# have a non-default exceptionCode here unless attribute "arg
# conversion" code starts passing in an exceptionCode. At which
# point we'll need to figure out what that even means.
assert exceptionCode == "return false;\n"
handleInvalidEnumValueCode = dedent(
"""
if (index < 0) {
return true;
}
"""
)
template = fill(
"""
{
int index;
if (!binding_detail::FindEnumStringIndex<${invalidEnumValueFatal}>(cx, $${val},
binding_detail::EnumStrings<${enumtype}>::Values,
"${enumtype}", "${sourceDescription}",
&index)) {
$*{exceptionCode}
}
$*{handleInvalidEnumValueCode}
${enumLoc} = static_cast<${enumtype}>(index);
}
""",
enumtype=enumName,
invalidEnumValueFatal=toStringBool(invalidEnumValueFatal),
handleInvalidEnumValueCode=handleInvalidEnumValueCode,
exceptionCode=exceptionCode,
enumLoc=enumLoc,
sourceDescription=sourceDescription,
)
setNull = "${declName}.SetNull();\n"
if type.nullable():
template = CGIfElseWrapper(
"${val}.isNullOrUndefined()", CGGeneric(setNull), CGGeneric(template)
).define()
if defaultValue is not None:
if isinstance(defaultValue, IDLNullValue):
assert type.nullable()
template = handleDefault(template, setNull)
else:
assert defaultValue.type.tag() == IDLType.Tags.domstring
template = handleDefault(
template,
(
"%s = %s::%s;\n"
% (enumLoc, enumName, getEnumValueName(defaultValue.value))
),
)
return JSToNativeConversionInfo(
template, declType=CGGeneric(declType), dealWithOptional=isOptional
)
if type.isCallback():
assert not isEnforceRange and not isClamp and not isAllowShared
assert not type.treatNonCallableAsNull() or type.nullable()
assert not type.treatNonObjectAsNull() or type.nullable()
assert not type.treatNonObjectAsNull() or not type.treatNonCallableAsNull()
callback = type.unroll().callback
name = callback.identifier.name
(declType, declArgs, conversion) = getCallbackConversionInfo(
type, callback, isMember, isCallbackReturnValue, isOptional
)
if allowTreatNonCallableAsNull and type.treatNonCallableAsNull():
haveCallable = "JS::IsCallable(&${val}.toObject())"
if not isDefinitelyObject:
haveCallable = "${val}.isObject() && " + haveCallable
if defaultValue is not None:
assert isinstance(defaultValue, IDLNullValue)
haveCallable = "(${haveValue}) && " + haveCallable
template = (
("if (%s) {\n" % haveCallable) + conversion + "} else {\n"
" ${declName} = nullptr;\n"
"}\n"
)
elif allowTreatNonCallableAsNull and type.treatNonObjectAsNull():
if not isDefinitelyObject:
haveObject = "${val}.isObject()"
if defaultValue is not None:
assert isinstance(defaultValue, IDLNullValue)
haveObject = "(${haveValue}) && " + haveObject
template = CGIfElseWrapper(
haveObject,
CGGeneric(conversion),
CGGeneric("${declName} = nullptr;\n"),
).define()
else:
template = conversion
else:
template = wrapObjectTemplate(
"if (JS::IsCallable(&${val}.toObject())) {\n"
+ conversion
+ "} else {\n"
+ indent(onFailureNotCallable(failureCode).define())
+ "}\n",
type,
"${declName} = nullptr;\n",
failureCode,
)
return JSToNativeConversionInfo(
template, declType=declType, declArgs=declArgs, dealWithOptional=isOptional
)
if type.isAny():
assert not isEnforceRange and not isClamp and not isAllowShared
declArgs = None
if isMember in ("Variadic", "Sequence", "Dictionary", "Record"):
# Rooting is handled by the sequence and dictionary tracers.
declType = "JS::Value"
else:
assert not isMember
declType = "JS::Rooted<JS::Value>"
declArgs = "cx"
assert not isOptional
templateBody = "${declName} = ${val};\n"
# For JS-implemented APIs, we refuse to allow passing objects that the
# API consumer does not subsume. The extra parens around
# ($${passedToJSImpl}) suppress unreachable code warnings when
# $${passedToJSImpl} is the literal `false`. But Apple is shipping a
# buggy clang (clang 3.9) in Xcode 8.3, so there even the parens are not
# enough. So we manually disable some warnings in clang.
if (
not isinstance(descriptorProvider, Descriptor)
or descriptorProvider.interface.isJSImplemented()
):
templateBody = (
fill(
"""
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunreachable-code"
#pragma clang diagnostic ignored "-Wunreachable-code-return"
#endif // __clang__
if (($${passedToJSImpl}) && !CallerSubsumes($${val})) {
cx.ThrowErrorMessage<MSG_PERMISSION_DENIED_TO_PASS_ARG>("${sourceDescription}");
$*{exceptionCode}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif // __clang__
""",
sourceDescription=sourceDescription,
exceptionCode=exceptionCode,
)
+ templateBody
)
# We may not have a default value if we're being converted for
# a setter, say.
if defaultValue:
if isinstance(defaultValue, IDLNullValue):
defaultHandling = "${declName} = JS::NullValue();\n"
else:
assert isinstance(defaultValue, IDLUndefinedValue)
defaultHandling = "${declName} = JS::UndefinedValue();\n"
templateBody = handleDefault(templateBody, defaultHandling)
return JSToNativeConversionInfo(
templateBody, declType=CGGeneric(declType), declArgs=declArgs
)
if type.isObject():
assert not isEnforceRange and not isClamp and not isAllowShared
return handleJSObjectType(
type, isMember, failureCode, exceptionCode, sourceDescription
)
if type.isDictionary():
# There are no nullable dictionary-typed arguments or dictionary-typed
# dictionary members.
assert (
not type.nullable()
or isCallbackReturnValue
or (isMember and isMember != "Dictionary")
)
# All optional dictionary-typed arguments always have default values,
# but dictionary-typed dictionary members can be optional.
assert not isOptional or isMember == "Dictionary"
# In the callback return value case we never have to worry
# about a default value; we always have a value.
assert not isCallbackReturnValue or defaultValue is None
typeName = CGDictionary.makeDictionaryName(type.unroll().inner)
if (not isMember or isMember == "Union") and not isCallbackReturnValue:
# Since we're not a member and not nullable or optional, no one will
# see our real type, so we can do the fast version of the dictionary
# that doesn't pre-initialize members.
typeName = "binding_detail::Fast" + typeName
declType = CGGeneric(typeName)
# We do manual default value handling here, because we actually do want
# a jsval, and we only handle the default-dictionary case (which we map
# into initialization with the JS value `null`) anyway
# NOTE: if isNullOrUndefined or isDefinitelyObject are true,
# we know we have a value, so we don't have to worry about the
# default value.
if (
not isNullOrUndefined
and not isDefinitelyObject
and defaultValue is not None
):
assert isinstance(defaultValue, IDLDefaultDictionaryValue)
# Initializing from JS null does the right thing to give
# us a default-initialized dictionary.
val = "(${haveValue}) ? ${val} : JS::NullHandleValue"
else:
val = "${val}"
dictLoc = "${declName}"
if type.nullable():
dictLoc += ".SetValue()"
if type.unroll().inner.needsConversionFromJS:
args = "cx, %s, " % val
else:
# We can end up in this case if a dictionary that does not need
# conversion from JS has a dictionary-typed member with a default
# value of {}.
args = ""
conversionCode = fill(
"""
if (!${dictLoc}.Init(${args}"${desc}", $${passedToJSImpl})) {
$*{exceptionCode}
}
""",
dictLoc=dictLoc,
args=args,
desc=firstCap(sourceDescription),
exceptionCode=exceptionCode,
)
if failureCode is not None:
# This means we're part of an overload or union conversion, and
# should simply skip stuff if our value is not convertible to
# dictionary, instead of trying and throwing. If we're either
# isDefinitelyObject or isNullOrUndefined then we're convertible to
# dictionary and don't need to check here.
if isDefinitelyObject or isNullOrUndefined:
template = conversionCode
else:
template = fill(
"""
if (!IsConvertibleToDictionary(${val})) {
$*{failureCode}
}
$*{conversionCode}
""",
val=val,
failureCode=failureCode,
conversionCode=conversionCode,
)
else:
template = conversionCode
if type.nullable():
declType = CGTemplatedType("Nullable", declType)
template = CGIfElseWrapper(
"${val}.isNullOrUndefined()",
CGGeneric("${declName}.SetNull();\n"),
CGGeneric(template),
).define()
# Dictionary arguments that might contain traceable things need to get
# traced
if (not isMember or isMember == "Union") and isCallbackReturnValue:
# Go ahead and just convert directly into our actual return value
declType = CGWrapper(declType, post="&")
declArgs = "aRetVal"
elif (not isMember or isMember == "Union") and typeNeedsRooting(type):
declType = CGTemplatedType("RootedDictionary", declType)
declArgs = "cx"
else:
declArgs = None
return JSToNativeConversionInfo(
template, declType=declType, declArgs=declArgs, dealWithOptional=isOptional
)
if type.isUndefined():
assert not isOptional
# This one only happens for return values, and its easy: Just
# ignore the jsval.
return JSToNativeConversionInfo("")
if not type.isPrimitive():
raise TypeError("Need conversion for argument type '%s'" % str(type))
typeName = builtinNames[type.tag()]
conversionBehavior = "eDefault"
if isEnforceRange:
assert type.isInteger()
conversionBehavior = "eEnforceRange"
elif isClamp:
assert type.isInteger()
conversionBehavior = "eClamp"
alwaysNull = False
if type.nullable():
declType = CGGeneric("Nullable<" + typeName + ">")
writeLoc = "${declName}.SetValue()"
readLoc = "${declName}.Value()"
nullCondition = "${val}.isNullOrUndefined()"
if defaultValue is not None and isinstance(defaultValue, IDLNullValue):
nullCondition = "!(${haveValue}) || " + nullCondition
if isKnownMissing:
alwaysNull = True
template = dedent(
"""
${declName}.SetNull();
"""
)
if not alwaysNull:
template = fill(
"""
if (${nullCondition}) {
$${declName}.SetNull();
} else if (!ValueToPrimitive<${typeName}, ${conversionBehavior}>(cx, $${val}, "${sourceDescription}", &${writeLoc})) {
$*{exceptionCode}
}
""",
nullCondition=nullCondition,
typeName=typeName,
conversionBehavior=conversionBehavior,
sourceDescription=firstCap(sourceDescription),
writeLoc=writeLoc,
exceptionCode=exceptionCode,
)
else:
assert defaultValue is None or not isinstance(defaultValue, IDLNullValue)
writeLoc = "${declName}"
readLoc = writeLoc
template = fill(
"""
if (!ValueToPrimitive<${typeName}, ${conversionBehavior}>(cx, $${val}, "${sourceDescription}", &${writeLoc})) {
$*{exceptionCode}
}
""",
typeName=typeName,
conversionBehavior=conversionBehavior,
sourceDescription=firstCap(sourceDescription),
writeLoc=writeLoc,
exceptionCode=exceptionCode,
)
declType = CGGeneric(typeName)
if type.isFloat() and not type.isUnrestricted() and not alwaysNull:
if lenientFloatCode is not None:
nonFiniteCode = lenientFloatCode
else:
nonFiniteCode = 'cx.ThrowErrorMessage<MSG_NOT_FINITE>("%s");\n' "%s" % (
firstCap(sourceDescription),
exceptionCode,
)
# We're appending to an if-block brace, so strip trailing whitespace
# and add an extra space before the else.
template = template.rstrip()
template += fill(
"""
else if (!std::isfinite(${readLoc})) {
$*{nonFiniteCode}
}
""",
readLoc=readLoc,
nonFiniteCode=nonFiniteCode,
)
if (
defaultValue is not None
and
# We already handled IDLNullValue, so just deal with the other ones
not isinstance(defaultValue, IDLNullValue)
):
tag = defaultValue.type.tag()
defaultStr = getHandleDefault(defaultValue)
template = handleDefault(template, "%s = %s;\n" % (writeLoc, defaultStr))
return JSToNativeConversionInfo(
template, declType=declType, dealWithOptional=isOptional
)
def instantiateJSToNativeConversion(info, replacements, checkForValue=False):
"""
Take a JSToNativeConversionInfo as returned by getJSToNativeConversionInfo
and a set of replacements as required by the strings in such an object, and
generate code to convert into stack C++ types.
If checkForValue is True, then the conversion will get wrapped in
a check for ${haveValue}.
"""
templateBody, declType, holderType, dealWithOptional = (
info.template,
info.declType,
info.holderType,
info.dealWithOptional,
)
if dealWithOptional and not checkForValue:
raise TypeError("Have to deal with optional things, but don't know how")
if checkForValue and declType is None:
raise TypeError(
"Need to predeclare optional things, so they will be "
"outside the check for big enough arg count!"
)
# We can't precompute our holder constructor arguments, since
# those might depend on ${declName}, which we change below. Just
# compute arguments at the point when we need them as we go.
def getArgsCGThing(args):
return CGGeneric(string.Template(args).substitute(replacements))
result = CGList([])
# Make a copy of "replacements" since we may be about to start modifying it
replacements = dict(replacements)
originalDeclName = replacements["declName"]
if declType is not None:
if dealWithOptional:
replacements["declName"] = "%s.Value()" % originalDeclName
declType = CGTemplatedType("Optional", declType)
declCtorArgs = None
elif info.declArgs is not None:
declCtorArgs = CGWrapper(getArgsCGThing(info.declArgs), pre="(", post=")")
else:
declCtorArgs = None
result.append(
CGList(
[
declType,
CGGeneric(" "),
CGGeneric(originalDeclName),
declCtorArgs,
CGGeneric(";\n"),
]
)
)
originalHolderName = replacements["holderName"]
if holderType is not None:
if dealWithOptional:
replacements["holderName"] = "%s.ref()" % originalHolderName
holderType = CGTemplatedType("Maybe", holderType)
holderCtorArgs = None
elif info.holderArgs is not None:
holderCtorArgs = CGWrapper(
getArgsCGThing(info.holderArgs), pre="(", post=")"
)
else:
holderCtorArgs = None
result.append(
CGList(
[
holderType,
CGGeneric(" "),
CGGeneric(originalHolderName),
holderCtorArgs,
CGGeneric(";\n"),
]
)
)
if "maybeMutableVal" not in replacements:
replacements["maybeMutableVal"] = replacements["val"]
conversion = CGGeneric(string.Template(templateBody).substitute(replacements))
if checkForValue:
if dealWithOptional:
declConstruct = CGIndenter(
CGGeneric(
"%s.Construct(%s);\n"
% (
originalDeclName,
getArgsCGThing(info.declArgs).define() if info.declArgs else "",
)
)
)
if holderType is not None:
holderConstruct = CGIndenter(
CGGeneric(
"%s.emplace(%s);\n"
% (
originalHolderName,
(
getArgsCGThing(info.holderArgs).define()
if info.holderArgs
else ""
),
)
)
)
else:
holderConstruct = None
else:
declConstruct = None