17563 lines
722 KiB
Python
17563 lines
722 KiB
Python
# This Source Code Form is subject to the terms of the Mozilla Public
|
|
# License, v. 2.0. If a copy of the MPL was not distributed with this file,
|
|
# You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
|
|
# Common codegen classes.
|
|
|
|
import os
|
|
import re
|
|
import string
|
|
import math
|
|
import textwrap
|
|
import functools
|
|
|
|
from WebIDL import BuiltinTypes, IDLBuiltinType, IDLNullValue, IDLSequenceType, IDLType, IDLAttribute, IDLInterfaceMember, IDLUndefinedValue, IDLEmptySequenceValue, IDLDictionary
|
|
from Configuration import NoSuchDescriptorError, getTypesFromDescriptor, getTypesFromDictionary, getTypesFromCallback, getAllTypes, Descriptor, MemberIsUnforgeable, iteratorNativeType
|
|
|
|
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"
|
|
ADDPROPERTY_HOOK_NAME = '_addProperty'
|
|
FINALIZE_HOOK_NAME = '_finalize'
|
|
OBJECT_MOVED_HOOK_NAME = '_objectMoved'
|
|
CONSTRUCT_HOOK_NAME = '_constructor'
|
|
LEGACYCALLER_HOOK_NAME = '_legacycaller'
|
|
HASINSTANCE_HOOK_NAME = '_hasInstance'
|
|
RESOLVE_HOOK_NAME = '_resolve'
|
|
MAY_RESOLVE_HOOK_NAME = '_mayResolve'
|
|
ENUMERATE_HOOK_NAME = '_enumerate'
|
|
ENUM_ENTRY_VARIABLE_NAME = 'strings'
|
|
INSTANCE_RESERVED_SLOTS = 1
|
|
|
|
|
|
def memberReservedSlot(member, descriptor):
|
|
return ("(DOM_INSTANCE_RESERVED_SLOTS + %d)" %
|
|
member.slotIndices[descriptor.interface.identifier.name])
|
|
|
|
|
|
def memberXrayExpandoReservedSlot(member, descriptor):
|
|
return ("(xpc::JSSLOT_EXPANDO_COUNT + %d)" %
|
|
member.slotIndices[descriptor.interface.identifier.name])
|
|
|
|
|
|
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 toStringBool(arg):
|
|
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.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()))
|
|
|
|
|
|
def idlTypeNeedsCycleCollection(type):
|
|
type = type.unroll() # Takes care of sequences and nullables
|
|
if ((type.isPrimitive() and type.tag() in builtinNames) or
|
|
type.isEnum() or
|
|
type.isString() or
|
|
type.isAny() or
|
|
type.isObject() or
|
|
type.isSpiderMonkeyInterface()):
|
|
return False
|
|
elif type.isCallback() 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 TypeError("Cycle collection for type %s is not supported" % type)
|
|
return False
|
|
elif type.isDictionary():
|
|
if any(idlTypeNeedsCycleCollection(m.type) for m in type.inner.members):
|
|
raise TypeError("Cycle collection for type %s is not supported" % type)
|
|
return False
|
|
else:
|
|
raise TypeError("Don't know whether to cycle-collect type %s" % type)
|
|
|
|
|
|
def wantsAddProperty(desc):
|
|
return (desc.concrete and desc.wrapperCache and not desc.isGlobal())
|
|
|
|
|
|
# We'll want to insert the indent at the beginnings of lines, but we
|
|
# don't want to indent empty lines. So only indent lines that have a
|
|
# non-newline character on them.
|
|
lineStartDetector = re.compile("^(?=[^\n#])", re.MULTILINE)
|
|
|
|
|
|
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).
|
|
"""
|
|
if s == "":
|
|
return s
|
|
return re.sub(lineStartDetector, indentLevel * " ", s)
|
|
|
|
|
|
# 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 deps(self):
|
|
"""Produce the deps for a pp file"""
|
|
assert False # Override me!
|
|
|
|
|
|
class CGStringTable(CGThing):
|
|
"""
|
|
Generate a string table for the given strings with a function accessor:
|
|
|
|
const char *accessorName(unsigned int index) {
|
|
static const char table[] = "...";
|
|
static const uint16_t indices = { ... };
|
|
return &table[indices[index]];
|
|
}
|
|
|
|
This is more efficient than the more natural:
|
|
|
|
const char *table[] = {
|
|
...
|
|
};
|
|
|
|
The uint16_t indices are smaller than the pointer equivalents, and the
|
|
string table requires no runtime relocations.
|
|
"""
|
|
def __init__(self, accessorName, strings):
|
|
CGThing.__init__(self)
|
|
self.accessorName = accessorName
|
|
self.strings = strings
|
|
|
|
def declare(self):
|
|
return "extern const char *%s(unsigned int aIndex);\n" % self.accessorName
|
|
|
|
def define(self):
|
|
table = ' "\\0" '.join('"%s"' % s for s in self.strings)
|
|
indices = []
|
|
currentIndex = 0
|
|
for s in self.strings:
|
|
indices.append(currentIndex)
|
|
currentIndex += len(s) + 1 # for the null terminator
|
|
return fill(
|
|
"""
|
|
const char *${name}(unsigned int aIndex)
|
|
{
|
|
static const char table[] = ${table};
|
|
static const uint16_t indices[] = { ${indices} };
|
|
static_assert(${currentIndex} <= UINT16_MAX, "string table overflow!");
|
|
return &table[indices[aIndex]];
|
|
}
|
|
""",
|
|
name=self.accessorName,
|
|
table=table,
|
|
indices=", ".join("%d" % index for index in indices),
|
|
currentIndex=currentIndex)
|
|
|
|
|
|
class CGNativePropertyHooks(CGThing):
|
|
"""
|
|
Generate a NativePropertyHooks for a given descriptor
|
|
"""
|
|
def __init__(self, descriptor, properties):
|
|
CGThing.__init__(self)
|
|
self.descriptor = descriptor
|
|
self.properties = properties
|
|
|
|
def declare(self):
|
|
if not self.descriptor.wantsXrays:
|
|
return ""
|
|
return dedent("""
|
|
// We declare this as an array so that retrieving a pointer to this
|
|
// binding's property hooks only requires compile/link-time resolvable
|
|
// address arithmetic. Declaring it as a pointer instead would require
|
|
// doing a run-time load to fetch a pointer to this binding's property
|
|
// hooks. And then structures which embedded a pointer to this structure
|
|
// would require a run-time load for proper initialization, which would
|
|
// then induce static constructors. Lots of static constructors.
|
|
extern const NativePropertyHooks sNativePropertyHooks[];
|
|
""")
|
|
|
|
def define(self):
|
|
if not self.descriptor.wantsXrays:
|
|
return ""
|
|
deleteNamedProperty = "nullptr"
|
|
if self.descriptor.concrete and self.descriptor.proxy:
|
|
resolveOwnProperty = "ResolveOwnProperty"
|
|
enumerateOwnProperties = "EnumerateOwnProperties"
|
|
if self.descriptor.needsXrayNamedDeleterHook():
|
|
deleteNamedProperty = "DeleteNamedProperty"
|
|
elif self.descriptor.needsXrayResolveHooks():
|
|
resolveOwnProperty = "ResolveOwnPropertyViaResolve"
|
|
enumerateOwnProperties = "EnumerateOwnPropertiesViaGetOwnPropertyNames"
|
|
else:
|
|
resolveOwnProperty = "nullptr"
|
|
enumerateOwnProperties = "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"
|
|
parentProtoName = self.descriptor.parentPrototypeName
|
|
parentHooks = (toBindingNamespace(parentProtoName) + "::sNativePropertyHooks"
|
|
if parentProtoName else 'nullptr')
|
|
|
|
if self.descriptor.wantsXrayExpandoClass:
|
|
expandoClass = "&sXrayExpandoObjectClass"
|
|
else:
|
|
expandoClass = "&DefaultXrayExpandoObjectClass"
|
|
|
|
return fill(
|
|
"""
|
|
const NativePropertyHooks sNativePropertyHooks[] = { {
|
|
${resolveOwnProperty},
|
|
${enumerateOwnProperties},
|
|
${deleteNamedProperty},
|
|
{ ${regular}, ${chrome} },
|
|
${prototypeID},
|
|
${constructorID},
|
|
${parentHooks},
|
|
${expandoClass}
|
|
} };
|
|
""",
|
|
resolveOwnProperty=resolveOwnProperty,
|
|
enumerateOwnProperties=enumerateOwnProperties,
|
|
deleteNamedProperty=deleteNamedProperty,
|
|
regular=regular,
|
|
chrome=chrome,
|
|
prototypeID=prototypeID,
|
|
constructorID=constructorID,
|
|
parentHooks=parentHooks,
|
|
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)))
|
|
|
|
return fill(
|
|
"""
|
|
{ ${protoChain} },
|
|
IsBaseOf<nsISupports, ${nativeType} >::value,
|
|
${hooks},
|
|
FindAssociatedGlobalForNative<${nativeType}>::Get,
|
|
GetProtoObjectHandle,
|
|
GetCCParticipant<${nativeType}>::Get()
|
|
""",
|
|
protoChain=', '.join(protoList),
|
|
nativeType=descriptor.nativeType,
|
|
hooks=NativePropertyHooks(descriptor))
|
|
|
|
|
|
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'
|
|
objectMovedHook = OBJECT_MOVED_HOOK_NAME if self.descriptor.wrapperCache else 'nullptr'
|
|
slotCount = INSTANCE_RESERVED_SLOTS + self.descriptor.interface.totalMembersInSlots
|
|
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
|
|
traceHook = 'nullptr'
|
|
reservedSlots = slotCount
|
|
if self.descriptor.interface.isProbablyShortLivingObject():
|
|
classFlags += " | JSCLASS_SKIP_NURSERY_FINALIZE"
|
|
if self.descriptor.interface.getExtendedAttribute("NeedResolve"):
|
|
resolveHook = RESOLVE_HOOK_NAME
|
|
mayResolveHook = MAY_RESOLVE_HOOK_NAME
|
|
enumerateHook = ENUMERATE_HOOK_NAME
|
|
elif self.descriptor.isGlobal():
|
|
resolveHook = "mozilla::dom::ResolveGlobal"
|
|
mayResolveHook = "mozilla::dom::MayResolveGlobal"
|
|
enumerateHook = "mozilla::dom::EnumerateGlobal"
|
|
else:
|
|
resolveHook = "nullptr"
|
|
mayResolveHook = "nullptr"
|
|
enumerateHook = "nullptr"
|
|
|
|
return fill(
|
|
"""
|
|
static const js::ClassOps sClassOps = {
|
|
${addProperty}, /* addProperty */
|
|
nullptr, /* delProperty */
|
|
nullptr, /* getProperty */
|
|
nullptr, /* setProperty */
|
|
${enumerate}, /* enumerate */
|
|
${resolve}, /* resolve */
|
|
${mayResolve}, /* mayResolve */
|
|
${finalize}, /* finalize */
|
|
${call}, /* call */
|
|
nullptr, /* hasInstance */
|
|
nullptr, /* construct */
|
|
${trace}, /* trace */
|
|
};
|
|
|
|
static const js::ClassExtension sClassExtension = {
|
|
nullptr, /* weakmapKeyDelegateOp */
|
|
${objectMoved} /* objectMovedOp */
|
|
};
|
|
|
|
static const DOMJSClass sClass = {
|
|
{ "${name}",
|
|
${flags},
|
|
&sClassOps,
|
|
JS_NULL_CLASS_SPEC,
|
|
&sClassExtension,
|
|
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.identifier.name,
|
|
flags=classFlags,
|
|
addProperty=ADDPROPERTY_HOOK_NAME if wantsAddProperty(self.descriptor) else 'nullptr',
|
|
enumerate=enumerateHook,
|
|
resolve=resolveHook,
|
|
mayResolve=mayResolveHook,
|
|
finalize=FINALIZE_HOOK_NAME,
|
|
call=callHook,
|
|
trace=traceHook,
|
|
objectMoved=objectMovedHook,
|
|
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):
|
|
flags = ["JSCLASS_IS_DOMJSCLASS"]
|
|
# 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")
|
|
objectMovedHook = OBJECT_MOVED_HOOK_NAME if self.descriptor.wrapperCache else 'nullptr'
|
|
return fill(
|
|
"""
|
|
static const js::ClassExtension sClassExtension = PROXY_MAKE_EXT(
|
|
${objectMoved}
|
|
);
|
|
|
|
static const DOMJSClass sClass = {
|
|
PROXY_CLASS_WITH_EXT("${name}",
|
|
${flags},
|
|
&sClassExtension),
|
|
$*{descriptor}
|
|
};
|
|
""",
|
|
name=self.descriptor.interface.identifier.name,
|
|
flags=" | ".join(flags),
|
|
objectMoved=objectMovedHook,
|
|
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):
|
|
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(static, sXrayExpandoObjectClass, ${memberSlots});
|
|
""",
|
|
memberSlots=self.descriptor.interface.totalMembersInSlots)
|
|
|
|
|
|
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:
|
|
if descriptor.interface.getExtendedAttribute("ArrayClass"):
|
|
protoGetter = "JS::GetRealmArrayPrototype"
|
|
elif descriptor.interface.getExtendedAttribute("ExceptionClass"):
|
|
protoGetter = "JS::GetRealmErrorPrototype"
|
|
elif descriptor.interface.isIteratorInterface():
|
|
protoGetter = "JS::GetRealmIteratorPrototype"
|
|
else:
|
|
protoGetter = "JS::GetRealmObjectPrototype"
|
|
protoHandleGetter = None
|
|
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.hasUnforgeableMembers 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},
|
|
false,
|
|
${prototypeID},
|
|
${depth},
|
|
${hooks},
|
|
"[object ${name}Prototype]",
|
|
${protoGetter}
|
|
};
|
|
""",
|
|
name=self.descriptor.interface.identifier.name,
|
|
slotCount=slotCount,
|
|
type=type,
|
|
hooks=NativePropertyHooks(self.descriptor),
|
|
prototypeID=prototypeID,
|
|
depth=depth,
|
|
protoGetter=protoGetter)
|
|
|
|
|
|
def NeedsGeneratedHasInstance(descriptor):
|
|
assert descriptor.interface.hasInterfaceObject()
|
|
return descriptor.hasXPConnectImpls or descriptor.interface.isConsequential()
|
|
|
|
|
|
def InterfaceObjectProtoGetter(descriptor, forXrays=False):
|
|
"""
|
|
Returns a tuple with two elements:
|
|
|
|
1) The name of the function to call to get the prototype to use for the
|
|
interface object as a JSObject*.
|
|
|
|
2) The name of the function to call to get the prototype to use for the
|
|
interface prototype as a JS::Handle<JSObject*> or None if no such
|
|
function exists.
|
|
"""
|
|
parentInterface = descriptor.interface.parent
|
|
if parentInterface:
|
|
assert not descriptor.interface.isNamespace()
|
|
parentIfaceName = parentInterface.identifier.name
|
|
parentDesc = descriptor.getDescriptor(parentIfaceName)
|
|
prefix = toBindingNamespace(parentDesc.name)
|
|
protoGetter = prefix + "::GetConstructorObject"
|
|
protoHandleGetter = prefix + "::GetConstructorObjectHandle"
|
|
elif descriptor.interface.isNamespace():
|
|
if (forXrays or
|
|
not descriptor.interface.getExtendedAttribute("ProtoObjectHack")):
|
|
protoGetter = "JS::GetRealmObjectPrototype"
|
|
else:
|
|
protoGetter = "binding_detail::GetHackedNamespaceProtoObject"
|
|
protoHandleGetter = None
|
|
else:
|
|
protoGetter = "JS::GetRealmFunctionPrototype"
|
|
protoHandleGetter = None
|
|
return (protoGetter, protoHandleGetter)
|
|
|
|
|
|
class CGInterfaceObjectJSClass(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):
|
|
if self.descriptor.interface.ctor():
|
|
assert not self.descriptor.interface.isNamespace()
|
|
ctorname = CONSTRUCT_HOOK_NAME
|
|
elif self.descriptor.interface.isNamespace():
|
|
ctorname = "nullptr"
|
|
else:
|
|
ctorname = "ThrowingConstructor"
|
|
needsHasInstance = (
|
|
not NeedsGeneratedHasInstance(self.descriptor) and
|
|
self.descriptor.interface.hasInterfacePrototypeObject())
|
|
|
|
prototypeID, depth = PrototypeIDAndDepth(self.descriptor)
|
|
slotCount = "DOM_INTERFACE_SLOTS_BASE"
|
|
if len(self.descriptor.interface.namedConstructors) > 0:
|
|
slotCount += (" + %i /* slots for the named constructors */" %
|
|
len(self.descriptor.interface.namedConstructors))
|
|
(protoGetter, _) = InterfaceObjectProtoGetter(self.descriptor,
|
|
forXrays=True)
|
|
|
|
if ctorname == "ThrowingConstructor":
|
|
ret = ""
|
|
classOpsPtr = "&sBoringInterfaceObjectClassClassOps"
|
|
elif ctorname == "nullptr":
|
|
ret = ""
|
|
classOpsPtr = "JS_NULL_CLASS_OPS"
|
|
else:
|
|
ret = fill(
|
|
"""
|
|
static const js::ClassOps sInterfaceObjectClassOps = {
|
|
nullptr, /* addProperty */
|
|
nullptr, /* delProperty */
|
|
nullptr, /* getProperty */
|
|
nullptr, /* setProperty */
|
|
nullptr, /* enumerate */
|
|
nullptr, /* resolve */
|
|
nullptr, /* mayResolve */
|
|
nullptr, /* finalize */
|
|
${ctorname}, /* call */
|
|
nullptr, /* hasInstance */
|
|
${ctorname}, /* construct */
|
|
nullptr, /* trace */
|
|
};
|
|
|
|
""",
|
|
ctorname=ctorname)
|
|
classOpsPtr = "&sInterfaceObjectClassOps"
|
|
|
|
if self.descriptor.interface.isNamespace():
|
|
classString = self.descriptor.interface.getExtendedAttribute("ClassString")
|
|
if classString is None:
|
|
classString = "Object"
|
|
else:
|
|
classString = classString[0]
|
|
toStringResult = "[object %s]" % classString
|
|
objectOps = "JS_NULL_OBJECT_OPS"
|
|
else:
|
|
classString = "Function"
|
|
toStringResult = ("function %s() {\\n [native code]\\n}" %
|
|
self.descriptor.interface.identifier.name)
|
|
# We need non-default ObjectOps so we can actually make
|
|
# use of our toStringResult.
|
|
objectOps = "&sInterfaceObjectClassObjectOps"
|
|
|
|
ret = ret + fill(
|
|
"""
|
|
static const DOMIfaceAndProtoJSClass sInterfaceObjectClass = {
|
|
{
|
|
"${classString}",
|
|
JSCLASS_IS_DOMIFACEANDPROTOJSCLASS | JSCLASS_HAS_RESERVED_SLOTS(${slotCount}),
|
|
${classOpsPtr},
|
|
JS_NULL_CLASS_SPEC,
|
|
JS_NULL_CLASS_EXT,
|
|
${objectOps}
|
|
},
|
|
eInterface,
|
|
${needsHasInstance},
|
|
${prototypeID},
|
|
${depth},
|
|
${hooks},
|
|
"${toStringResult}",
|
|
${protoGetter}
|
|
};
|
|
""",
|
|
classString=classString,
|
|
slotCount=slotCount,
|
|
classOpsPtr=classOpsPtr,
|
|
hooks=NativePropertyHooks(self.descriptor),
|
|
objectOps=objectOps,
|
|
needsHasInstance=toStringBool(needsHasInstance),
|
|
prototypeID=prototypeID,
|
|
depth=depth,
|
|
toStringResult=toStringResult,
|
|
protoGetter=protoGetter)
|
|
return ret
|
|
|
|
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 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=""):
|
|
self.declareText = declare
|
|
self.defineText = define
|
|
|
|
def declare(self):
|
|
return self.declareText
|
|
|
|
def define(self):
|
|
return self.defineText
|
|
|
|
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, pre="", post="", declarePre=None,
|
|
declarePost=None, definePre=None, definePost=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.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
|
|
|
|
@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(CGWrapper):
|
|
def __init__(self, namespace, child, declareOnly=False):
|
|
pre = "namespace %s {\n" % namespace
|
|
post = "} // namespace %s\n" % namespace
|
|
CGWrapper.__init__(self, child, pre=pre, post=post,
|
|
declareOnly=declareOnly)
|
|
|
|
@staticmethod
|
|
def build(namespaces, child, declareOnly=False):
|
|
"""
|
|
Static helper method to build multiple wrapped namespaces.
|
|
"""
|
|
if not namespaces:
|
|
return CGWrapper(child, declareOnly=declareOnly)
|
|
inner = CGNamespace.build(namespaces[1:], child, declareOnly=declareOnly)
|
|
return CGNamespace(namespaces[0], inner, declareOnly=declareOnly)
|
|
|
|
|
|
class CGIncludeGuard(CGWrapper):
|
|
"""
|
|
Generates include guards for a header.
|
|
"""
|
|
def __init__(self, prefix, child):
|
|
"""|prefix| is the filename without the extension."""
|
|
define = 'mozilla_dom_%s_h' % prefix
|
|
CGWrapper.__init__(self, child,
|
|
declarePre='#ifndef %s\n#define %s\n\n' % (define, define),
|
|
declarePost='\n#endif // %s\n' % 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 jsonifier code.
|
|
jsonInterfaceParents = []
|
|
for desc in descriptors:
|
|
if not desc.operations['Jsonifier']:
|
|
continue
|
|
parent = desc.interface.parent
|
|
while parent:
|
|
parentDesc = desc.getDescriptor(parent.identifier.name)
|
|
if parentDesc.operations['Jsonifier']:
|
|
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())
|
|
|
|
# Grab the includes for checking hasInstance
|
|
interfacesImplementingSelf = set()
|
|
for d in descriptors:
|
|
interfacesImplementingSelf |= d.interface.interfacesImplementingSelf
|
|
implementationIncludes |= set(self.getDeclarationFilename(i) for i in
|
|
interfacesImplementingSelf)
|
|
|
|
# Grab the includes for the things that involve XPCOM interfaces
|
|
hasInstanceIncludes = set("nsIDOM" + d.interface.identifier.name + ".h" for d
|
|
in descriptors if
|
|
d.interface.hasInterfaceObject() and
|
|
NeedsGeneratedHasInstance(d) and
|
|
d.interface.hasInterfacePrototypeObject())
|
|
if len(hasInstanceIncludes) > 0:
|
|
hasInstanceIncludes.add("nsContentUtils.h")
|
|
|
|
# Now find all the things we'll need as arguments because we
|
|
# need to wrap or unwrap them.
|
|
bindingHeaders = set()
|
|
|
|
# KeyframeAnimationOptions.webidl is doing something VERY screwy and
|
|
# Unified Building really sucks so directly include this
|
|
if prefix == "KeyframeAnimationOptionsBinding":
|
|
bindingHeaders.add("mozilla/dom/PrimitiveConversions.h")
|
|
|
|
declareIncludes = set(declareIncludes)
|
|
|
|
def addHeadersForType((t, dictionary)):
|
|
"""
|
|
Add the relevant headers for this type. We use dictionary, if
|
|
passed, to decide what to do with interface types.
|
|
"""
|
|
# Dictionaries have members that need to be actually
|
|
# declared, not just forward-declared.
|
|
if dictionary:
|
|
headerSet = declareIncludes
|
|
else:
|
|
headerSet = bindingHeaders
|
|
if t.nullable():
|
|
# Need to make sure that Nullable as a dictionary
|
|
# member works.
|
|
headerSet.add("mozilla/dom/Nullable.h")
|
|
unrolled = t.unroll()
|
|
if unrolled.isUnion():
|
|
headerSet.add(self.getUnionDeclarationFilename(config, unrolled))
|
|
bindingHeaders.add("mozilla/dom/UnionConversions.h")
|
|
elif unrolled.isDate():
|
|
if dictionary or jsImplementedDescriptors:
|
|
declareIncludes.add("mozilla/dom/Date.h")
|
|
else:
|
|
bindingHeaders.add("mozilla/dom/Date.h")
|
|
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))
|
|
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 dictionary 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, dictionary))
|
|
|
|
map(addHeadersForType,
|
|
getAllTypes(descriptors + callbackDescriptors, dictionaries,
|
|
callbacks))
|
|
|
|
# Now make sure we're not trying to include the header from inside itself
|
|
declareIncludes.discard(prefix + ".h")
|
|
|
|
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 interface generated for a seperate
|
|
# iterable interface, skip generating type includes, as we have
|
|
# what we need in IterableIterator.h
|
|
if desc.interface.isExternal() or desc.interface.isIteratorInterface():
|
|
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)
|
|
|
|
# Let the machinery do its thing.
|
|
def _includeString(includes):
|
|
return ''.join(['#include "%s"\n' % i for i in includes]) + '\n'
|
|
CGWrapper.__init__(self, child,
|
|
declarePre=_includeString(sorted(declareIncludes)),
|
|
definePre=_includeString(sorted(set(defineIncludes) |
|
|
bindingIncludes |
|
|
bindingHeaders |
|
|
hasInstanceIncludes |
|
|
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()
|
|
f = f.unroll()
|
|
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("jsfriendapi.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)
|
|
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.isEnum():
|
|
# Need to see the actual definition of the enum,
|
|
# unfortunately.
|
|
headers.add(CGHeaders.getDeclarationFilename(f.inner))
|
|
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)
|
|
|
|
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))
|
|
|
|
|
|
def UnionConversions(unionTypes, config):
|
|
"""
|
|
The unionTypes argument should be a list of tuples, each containing two
|
|
elements: a union type and a descriptor. This is typically the list
|
|
generated by UnionsForFile.
|
|
|
|
Returns a tuple containing a list of headers and a CGThing to declare all
|
|
union argument conversion helper structs.
|
|
"""
|
|
headers = set()
|
|
unionConversions = dict()
|
|
|
|
for t in unionTypes:
|
|
name = str(t)
|
|
if name not in unionConversions:
|
|
unionConversions[name] = CGUnionConversionStruct(t, config)
|
|
|
|
def addHeadersForType(f):
|
|
f = f.unroll()
|
|
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("jsfriendapi.h")
|
|
headers.add("mozilla/dom/TypedArray.h")
|
|
elif f.inner.isExternal():
|
|
try:
|
|
typeDesc = config.getDescriptor(f.inner.identifier.name)
|
|
except NoSuchDescriptorError:
|
|
return
|
|
headers.add(typeDesc.headerFile)
|
|
else:
|
|
headers.add(CGHeaders.getDeclarationFilename(f.inner))
|
|
elif f.isDictionary():
|
|
headers.add(CGHeaders.getDeclarationFilename(f.inner))
|
|
elif f.isPrimitive():
|
|
headers.add("mozilla/dom/PrimitiveConversions.h")
|
|
elif f.isRecord():
|
|
headers.add("mozilla/dom/Record.h")
|
|
# And the internal type of the record
|
|
addHeadersForType(f.inner)
|
|
|
|
# We plan to include UnionTypes.h no matter what, so it's
|
|
# OK if we throw it into the set here.
|
|
headers.add(CGHeaders.getUnionDeclarationFilename(config, t))
|
|
|
|
for f in t.flatMemberTypes:
|
|
addHeadersForType(f)
|
|
|
|
return (headers,
|
|
CGWrapper(CGList(SortedDictValues(unionConversions), "\n"),
|
|
post="\n\n"))
|
|
|
|
|
|
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.
|
|
"""
|
|
def __init__(self, descriptor, name, returnType, args, inline=False, alwaysInline=False, static=False, templateArgs=None):
|
|
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
|
|
|
|
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.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 declare(self):
|
|
if self.inline:
|
|
return self._define(True)
|
|
return "%s%s%s(%s);\n" % (self._template(), self._decorators(), self.name, self._argstring(True))
|
|
|
|
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):
|
|
return "" if self.inline else self._define()
|
|
|
|
def definition_prologue(self, fromDeclare):
|
|
return "%s%s%s(%s)\n{\n" % (self._template(), self._decorators(),
|
|
self.name, self._argstring(fromDeclare))
|
|
|
|
def definition_epilogue(self):
|
|
return "}\n"
|
|
|
|
def definition_body(self):
|
|
assert False # Override me!
|
|
|
|
|
|
class CGAbstractStaticMethod(CGAbstractMethod):
|
|
"""
|
|
Abstract base class for codegen of implementation-only (no
|
|
declaration) static methods.
|
|
"""
|
|
def __init__(self, descriptor, name, returnType, args):
|
|
CGAbstractMethod.__init__(self, descriptor, name, returnType, args,
|
|
inline=False, static=True)
|
|
|
|
def declare(self):
|
|
# We only have implementation
|
|
return ""
|
|
|
|
|
|
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 CGGetJSClassMethod(CGAbstractMethod):
|
|
def __init__(self, descriptor):
|
|
CGAbstractMethod.__init__(self, descriptor, 'GetJSClass', 'const JSClass*',
|
|
[])
|
|
|
|
def definition_body(self):
|
|
return "return sClass.ToJSClass();\n"
|
|
|
|
|
|
class CGAddPropertyHook(CGAbstractClassHook):
|
|
"""
|
|
A hook for addProperty, used to preserve our wrapper from GC.
|
|
"""
|
|
def __init__(self, descriptor):
|
|
args = [Argument('JSContext*', 'cx'),
|
|
Argument('JS::Handle<JSObject*>', 'obj'),
|
|
Argument('JS::Handle<jsid>', 'id'),
|
|
Argument('JS::Handle<JS::Value>', 'val')]
|
|
CGAbstractClassHook.__init__(self, descriptor, ADDPROPERTY_HOOK_NAME,
|
|
'bool', args)
|
|
|
|
def generate_code(self):
|
|
assert self.descriptor.wrapperCache
|
|
return dedent("""
|
|
// We don't want to preserve if we don't have a wrapper, and we
|
|
// obviously can't preserve if we're not initialized.
|
|
if (self && self->GetWrapperPreserveColor()) {
|
|
PreserveWrapper(self);
|
|
}
|
|
return true;
|
|
""")
|
|
|
|
|
|
def finalizeHook(descriptor, hookName, freeOp):
|
|
finalize = ""
|
|
if descriptor.wrapperCache:
|
|
finalize += "ClearWrapper(self, self);\n"
|
|
if descriptor.interface.getExtendedAttribute('OverrideBuiltins'):
|
|
finalize += "self->mExpandoAndGeneration.expando = JS::UndefinedValue();\n"
|
|
if descriptor.isGlobal():
|
|
finalize += "mozilla::dom::FinalizeGlobal(CastToJSFreeOp(%s), obj);\n" % freeOp
|
|
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::FreeOp*', 'fop'), Argument('JSObject*', 'obj')]
|
|
CGAbstractClassHook.__init__(self, descriptor, FINALIZE_HOOK_NAME,
|
|
'void', args)
|
|
|
|
def generate_code(self):
|
|
return finalizeHook(self.descriptor, self.name, self.args[0].name).define()
|
|
|
|
|
|
class CGClassObjectMovedHook(CGAbstractClassHook):
|
|
"""
|
|
A hook for objectMovedOp, used to update the wrapper cache when an object it
|
|
is holding moves.
|
|
"""
|
|
def __init__(self, descriptor):
|
|
args = [Argument('JSObject*', 'obj'), Argument('const JSObject*', 'old')]
|
|
CGAbstractClassHook.__init__(self, descriptor, OBJECT_MOVED_HOOK_NAME,
|
|
'void', args)
|
|
|
|
def generate_code(self):
|
|
assert self.descriptor.wrapperCache
|
|
return CGIfWrapper(CGGeneric("UpdateWrapper(self, self, obj, old);\n"),
|
|
"self").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):
|
|
# [ChromeOnly] interfaces may only be constructed by chrome.
|
|
chromeOnlyCheck = ""
|
|
if isChromeOnly(self._ctor):
|
|
chromeOnlyCheck = dedent("""
|
|
if (!nsContentUtils::ThreadsafeIsCallerChrome()) {
|
|
return ThrowingConstructor(cx, argc, vp);
|
|
}
|
|
|
|
""")
|
|
|
|
# Additionally, we want to throw if a caller does a bareword invocation
|
|
# of a constructor without |new|. We don't enforce this for chrome in
|
|
# realease builds to avoid the addon compat fallout of making that
|
|
# change. See bug 916644.
|
|
#
|
|
# Figure out the name of our constructor for error reporting purposes.
|
|
# For unnamed webidl constructors, identifier.name is "constructor" but
|
|
# the name JS sees is the interface name; for named constructors
|
|
# identifier.name is the actual name.
|
|
name = self._ctor.identifier.name
|
|
if name != "constructor":
|
|
ctorName = name
|
|
else:
|
|
ctorName = self.descriptor.interface.identifier.name
|
|
|
|
# [HTMLConstructor] for custom element
|
|
# This needs to live in bindings code because it directly examines
|
|
# newtarget and the callee function to do HTMLConstructor specific things.
|
|
if self._ctor.isHTMLConstructor():
|
|
htmlConstructorSanityCheck = dedent("""
|
|
// The newTarget might be a cross-compartment wrapper. Get the underlying object
|
|
// so we can do the spec's object-identity checks.
|
|
JS::Rooted<JSObject*> newTarget(cx, js::CheckedUnwrap(&args.newTarget().toObject()));
|
|
if (!newTarget) {
|
|
return ThrowErrorMessage(cx, MSG_ILLEGAL_CONSTRUCTOR);
|
|
}
|
|
|
|
// Step 2 of https://html.spec.whatwg.org/multipage/dom.html#htmlconstructor.
|
|
// Enter the compartment of our underlying newTarget object, so we end
|
|
// up comparing to the constructor object for our interface from that global.
|
|
{
|
|
JSAutoCompartment ac(cx, newTarget);
|
|
JS::Handle<JSObject*> constructor(GetConstructorObjectHandle(cx));
|
|
if (!constructor) {
|
|
return false;
|
|
}
|
|
if (newTarget == constructor) {
|
|
return ThrowErrorMessage(cx, MSG_ILLEGAL_CONSTRUCTOR);
|
|
}
|
|
}
|
|
|
|
""")
|
|
|
|
# If we are unable to get desired prototype from newTarget, then we
|
|
# fall back to the interface prototype object from newTarget's realm.
|
|
htmlConstructorFallback = dedent("""
|
|
if (!desiredProto) {
|
|
// Step 7 of https://html.spec.whatwg.org/multipage/dom.html#htmlconstructor.
|
|
// This fallback behavior is designed to match analogous behavior for the
|
|
// JavaScript built-ins. So we enter the compartment of our underlying
|
|
// newTarget object and fall back to the prototype object from that global.
|
|
// XXX The spec says to use GetFunctionRealm(), which is not actually
|
|
// the same thing as what we have here (e.g. in the case of scripted callable proxies
|
|
// whose target is not same-compartment with the proxy, or bound functions, etc).
|
|
// https://bugzilla.mozilla.org/show_bug.cgi?id=1317658
|
|
{
|
|
JSAutoCompartment ac(cx, newTarget);
|
|
desiredProto = GetProtoObjectHandle(cx);
|
|
if (!desiredProto) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// desiredProto is in the compartment of the underlying newTarget object.
|
|
// Wrap it into the context compartment.
|
|
if (!JS_WrapObject(cx, &desiredProto)) {
|
|
return false;
|
|
}
|
|
}
|
|
""")
|
|
else:
|
|
htmlConstructorSanityCheck = ""
|
|
htmlConstructorFallback = ""
|
|
|
|
|
|
# If we're a constructor, "obj" may not be a function, so calling
|
|
# XrayAwareCalleeGlobal() on it is not safe. Of course in the
|
|
# constructor case either "obj" is an Xray or we're already in the
|
|
# content compartment, not the Xray compartment, so just
|
|
# constructing the GlobalObject from "obj" is fine.
|
|
preamble = fill(
|
|
"""
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
JS::Rooted<JSObject*> obj(cx, &args.callee());
|
|
$*{chromeOnlyCheck}
|
|
if (!args.isConstructing()) {
|
|
// XXXbz wish I could get the name from the callee instead of
|
|
// Adding more relocations
|
|
return ThrowConstructorWithoutNew(cx, "${ctorName}");
|
|
}
|
|
|
|
GlobalObject global(cx, obj);
|
|
if (global.Failed()) {
|
|
return false;
|
|
}
|
|
|
|
$*{htmlConstructorSanityCheck}
|
|
JS::Rooted<JSObject*> desiredProto(cx);
|
|
if (!GetDesiredProto(cx, args, &desiredProto)) {
|
|
return false;
|
|
}
|
|
$*{htmlConstructorFallback}
|
|
""",
|
|
chromeOnlyCheck=chromeOnlyCheck,
|
|
ctorName=ctorName,
|
|
htmlConstructorSanityCheck=htmlConstructorSanityCheck,
|
|
htmlConstructorFallback=htmlConstructorFallback)
|
|
|
|
if self._ctor.isHTMLConstructor():
|
|
signatures = self._ctor.signatures()
|
|
assert len(signatures) == 1
|
|
# Given that HTMLConstructor takes no args, we can just codegen a
|
|
# call to CreateHTMLElement() in BindingUtils which reuses the
|
|
# factory thing in HTMLContentSink. Then we don't have to implement
|
|
# Constructor on all the HTML elements.
|
|
callGenerator = CGPerSignatureCall(signatures[0][0], signatures[0][1],
|
|
"CreateHTMLElement", True,
|
|
self.descriptor, self._ctor,
|
|
isConstructor=True)
|
|
else:
|
|
name = self._ctor.identifier.name
|
|
nativeName = MakeNativeName(self.descriptor.binaryNameFor(name))
|
|
callGenerator = CGMethodCall(nativeName, True, self.descriptor,
|
|
self._ctor, isConstructor=True,
|
|
constructorName=ctorName)
|
|
return preamble + "\n" + callGenerator.define()
|
|
|
|
|
|
# Encapsulate the constructor in a helper method to share genConstructorBody with CGJSImplMethod.
|
|
class CGConstructNavigatorObject(CGAbstractMethod):
|
|
"""
|
|
Construct a new JS-implemented WebIDL DOM object, for use on navigator.
|
|
"""
|
|
def __init__(self, descriptor):
|
|
args = [Argument('JSContext*', 'cx'),
|
|
Argument('JS::Handle<JSObject*>', 'obj'),
|
|
Argument('ErrorResult&', 'aRv')]
|
|
rtype = 'already_AddRefed<%s>' % descriptor.name
|
|
CGAbstractMethod.__init__(self, descriptor, "ConstructNavigatorObject",
|
|
rtype, args)
|
|
|
|
def definition_body(self):
|
|
if not self.descriptor.interface.isJSImplemented():
|
|
raise TypeError("Only JS-implemented classes are currently supported "
|
|
"on navigator. See bug 856820.")
|
|
|
|
return dedent(
|
|
"""
|
|
GlobalObject global(cx, obj);
|
|
if (global.Failed()) {
|
|
aRv.Throw(NS_ERROR_FAILURE);
|
|
return nullptr;
|
|
}
|
|
""") + genConstructorBody(self.descriptor)
|
|
|
|
|
|
def NamedConstructorName(m):
|
|
return '_' + m.identifier.name
|
|
|
|
|
|
class CGNamedConstructors(CGThing):
|
|
def __init__(self, descriptor):
|
|
self.descriptor = descriptor
|
|
CGThing.__init__(self)
|
|
|
|
def declare(self):
|
|
return ""
|
|
|
|
def define(self):
|
|
if len(self.descriptor.interface.namedConstructors) == 0:
|
|
return ""
|
|
|
|
constructorID = "constructors::id::"
|
|
if self.descriptor.interface.hasInterfaceObject():
|
|
constructorID += self.descriptor.name
|
|
else:
|
|
constructorID += "_ID_Count"
|
|
|
|
namedConstructors = ""
|
|
for n in self.descriptor.interface.namedConstructors:
|
|
namedConstructors += (
|
|
"{ \"%s\", { %s, &sNamedConstructorNativePropertyHooks }, %i },\n" %
|
|
(n.identifier.name, NamedConstructorName(n), methodLength(n)))
|
|
|
|
return fill(
|
|
"""
|
|
const NativePropertyHooks sNamedConstructorNativePropertyHooks = {
|
|
nullptr,
|
|
nullptr,
|
|
nullptr,
|
|
{ nullptr, nullptr },
|
|
prototypes::id::${name},
|
|
${constructorID},
|
|
nullptr
|
|
};
|
|
|
|
static const NamedConstructor namedConstructors[] = {
|
|
$*{namedConstructors}
|
|
{ nullptr, { nullptr, nullptr }, 0 }
|
|
};
|
|
""",
|
|
name=self.descriptor.name,
|
|
constructorID=constructorID,
|
|
namedConstructors=namedConstructors)
|
|
|
|
|
|
class CGHasInstanceHook(CGAbstractStaticMethod):
|
|
def __init__(self, descriptor):
|
|
args = [Argument('JSContext*', 'cx'),
|
|
Argument('unsigned', 'argc'),
|
|
Argument('JS::Value*', 'vp')]
|
|
assert descriptor.interface.hasInterfaceObject()
|
|
assert NeedsGeneratedHasInstance(descriptor)
|
|
CGAbstractStaticMethod.__init__(self, descriptor, HASINSTANCE_HOOK_NAME,
|
|
'bool', args)
|
|
|
|
def define(self):
|
|
return CGAbstractStaticMethod.define(self)
|
|
|
|
def definition_body(self):
|
|
return self.generate_code()
|
|
|
|
def generate_code(self):
|
|
header = dedent("""
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
if (!args.get(0).isObject()) {
|
|
args.rval().setBoolean(false);
|
|
return true;
|
|
}
|
|
|
|
JS::Rooted<JSObject*> instance(cx, &args[0].toObject());
|
|
""")
|
|
if self.descriptor.interface.hasInterfacePrototypeObject():
|
|
return (
|
|
header +
|
|
fill(
|
|
"""
|
|
|
|
static_assert(IsBaseOf<nsISupports, ${nativeType}>::value,
|
|
"HasInstance only works for nsISupports-based classes.");
|
|
|
|
bool ok = InterfaceHasInstance(cx, argc, vp);
|
|
if (!ok || args.rval().toBoolean()) {
|
|
return ok;
|
|
}
|
|
|
|
// FIXME Limit this to chrome by checking xpc::AccessCheck::isChrome(obj).
|
|
nsCOMPtr<nsISupports> native =
|
|
xpc::UnwrapReflectorToISupports(js::UncheckedUnwrap(instance, /* stopAtWindowProxy = */ false));
|
|
nsCOMPtr<nsIDOM${name}> qiResult = do_QueryInterface(native);
|
|
args.rval().setBoolean(!!qiResult);
|
|
return true;
|
|
""",
|
|
nativeType=self.descriptor.nativeType,
|
|
name=self.descriptor.interface.identifier.name))
|
|
|
|
hasInstanceCode = dedent("""
|
|
|
|
const DOMJSClass* domClass = GetDOMClass(js::UncheckedUnwrap(instance, /* stopAtWindowProxy = */ false));
|
|
if (!domClass) {
|
|
// Not a DOM object, so certainly not an instance of this interface
|
|
args.rval().setBoolean(false);
|
|
return true;
|
|
}
|
|
""")
|
|
if self.descriptor.interface.identifier.name == "ChromeWindow":
|
|
setRval = "args.rval().setBoolean(UnwrapDOMObject<nsGlobalWindow>(js::UncheckedUnwrap(instance, /* stopAtWindowProxy = */ false))->IsChromeWindow())"
|
|
else:
|
|
setRval = "args.rval().setBoolean(true)"
|
|
# Sort interaces implementing self by name so we get stable output.
|
|
for iface in sorted(self.descriptor.interface.interfacesImplementingSelf,
|
|
key=lambda iface: iface.identifier.name):
|
|
hasInstanceCode += fill(
|
|
"""
|
|
|
|
if (domClass->mInterfaceChain[PrototypeTraits<prototypes::id::${name}>::Depth] == prototypes::id::${name}) {
|
|
${setRval};
|
|
return true;
|
|
}
|
|
""",
|
|
name=iface.identifier.name,
|
|
setRval=setRval)
|
|
hasInstanceCode += ("args.rval().setBoolean(false);\n"
|
|
"return true;\n")
|
|
return header + hasInstanceCode
|
|
|
|
|
|
def isChromeOnly(m):
|
|
return m.getExtendedAttribute("ChromeOnly")
|
|
|
|
|
|
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.
|
|
"""
|
|
def __init__(self, pref=None, func=None, secureContext=False,
|
|
nonExposedGlobals=None):
|
|
assert pref is None or isinstance(pref, str)
|
|
assert func is None or isinstance(func, str)
|
|
assert isinstance(secureContext, bool)
|
|
assert nonExposedGlobals is None or isinstance(nonExposedGlobals, set)
|
|
self.pref = pref
|
|
self.secureContext = secureContext
|
|
|
|
def toFuncPtr(val):
|
|
if val is None:
|
|
return "nullptr"
|
|
return "&" + val
|
|
self.func = toFuncPtr(func)
|
|
|
|
if nonExposedGlobals:
|
|
# Nonempty set
|
|
self.nonExposedGlobals = " | ".join(
|
|
map(lambda g: "GlobalNames::%s" % g,
|
|
sorted(nonExposedGlobals)))
|
|
else:
|
|
self.nonExposedGlobals = "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)
|
|
|
|
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")
|
|
|
|
|
|
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
|
|
# self.prefCacheData will store an array of (prefname, bool*)
|
|
# pairs for our bool var caches. generateArray will fill it
|
|
# in as needed.
|
|
self.prefCacheData = []
|
|
|
|
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 __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),
|
|
self.usedForXrays())
|
|
if self.hasChromeOnly():
|
|
str += self.generateArray(self.chrome, self.variableName(True),
|
|
self.usedForXrays())
|
|
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
|
|
|
|
return MemberCondition(
|
|
PropertyDefiner.getStringAttr(interfaceMember,
|
|
"Pref"),
|
|
PropertyDefiner.getStringAttr(interfaceMember,
|
|
"Func"),
|
|
interfaceMember.getExtendedAttribute("SecureContext") is not None,
|
|
nonExposureSet)
|
|
|
|
def generatePrefableArray(self, array, name, specFormatter, specTerminator,
|
|
specType, getCondition, getDataTuple, doIdArrays):
|
|
"""
|
|
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
|
|
# So we won't put a specTerminator at the very front of the list:
|
|
lastCondition = getCondition(array[0], self.descriptor)
|
|
|
|
specs = []
|
|
disablers = []
|
|
prefableSpecs = []
|
|
|
|
disablersTemplate = dedent(
|
|
"""
|
|
static PrefableDisablers %s_disablers%d = {
|
|
true, %s, %s, %s
|
|
};
|
|
""")
|
|
prefableWithDisablersTemplate = ' { &%s_disablers%d, &%s_specs[%d] }'
|
|
prefableWithoutDisablersTemplate = ' { nullptr, &%s_specs[%d] }'
|
|
prefCacheTemplate = '&%s[%d].disablers->enabled'
|
|
|
|
def switchToCondition(props, condition):
|
|
# Remember the info about where our pref-controlled
|
|
# booleans live.
|
|
if condition.pref is not None:
|
|
props.prefCacheData.append(
|
|
(condition.pref,
|
|
prefCacheTemplate % (name, len(prefableSpecs))))
|
|
# 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),
|
|
toStringBool(condition.secureContext),
|
|
condition.nonExposedGlobals,
|
|
condition.func))
|
|
else:
|
|
prefableSpecs.append(prefableWithoutDisablersTemplate %
|
|
(name, len(specs)))
|
|
|
|
switchToCondition(self, lastCondition)
|
|
|
|
for member in array:
|
|
curCondition = getCondition(member, self.descriptor)
|
|
if lastCondition != curCondition:
|
|
# Terminate previous list
|
|
specs.append(specTerminator)
|
|
# And switch to our new condition
|
|
switchToCondition(self, curCondition)
|
|
lastCondition = curCondition
|
|
# And the actual spec
|
|
specs.append(specFormatter(getDataTuple(member)))
|
|
specs.append(specTerminator)
|
|
prefableSpecs.append(" { nullptr, nullptr }")
|
|
|
|
specType = "const " + specType
|
|
arrays = fill(
|
|
"""
|
|
static ${specType} ${name}_specs[] = {
|
|
${specs}
|
|
};
|
|
|
|
${disablers}
|
|
// Can't be const because the pref-enabled boolean needs to be writable
|
|
static Prefable<${specType}> ${name}[] = {
|
|
${prefableSpecs}
|
|
};
|
|
|
|
""",
|
|
specType=specType,
|
|
name=name,
|
|
disablers='\n'.join(disablers),
|
|
specs=',\n'.join(specs),
|
|
prefableSpecs=',\n'.join(prefableSpecs))
|
|
if doIdArrays:
|
|
arrays += "static jsid %s_ids[%i];\n\n" % (name, len(specs))
|
|
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 MakeJSImplClearCachedValueNativeName(member):
|
|
return "_" + MakeClearCachedValueNativeName(member)
|
|
|
|
|
|
def IDLToCIdentifier(name):
|
|
return name.replace("-", "_")
|
|
|
|
|
|
class MethodDefiner(PropertyDefiner):
|
|
"""
|
|
A class for defining methods on a prototype object.
|
|
"""
|
|
def __init__(self, descriptor, name, static, unforgeable=False):
|
|
assert not (static and unforgeable)
|
|
PropertyDefiner.__init__(self, descriptor, name)
|
|
|
|
# FIXME https://bugzilla.mozilla.org/show_bug.cgi?id=772822
|
|
# 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
|
|
MemberIsUnforgeable(m, descriptor) == unforgeable and
|
|
not m.isIdentifierLess()]
|
|
else:
|
|
methods = []
|
|
self.chrome = []
|
|
self.regular = []
|
|
for m in methods:
|
|
if m.identifier.name == 'queryInterface':
|
|
if m.isStatic():
|
|
raise TypeError("Legacy queryInterface member shouldn't be static")
|
|
signatures = m.signatures()
|
|
|
|
def argTypeIsIID(arg):
|
|
return arg.type.inner.isExternal() and arg.type.inner.identifier.name == 'IID'
|
|
if len(signatures) > 1 or len(signatures[0][1]) > 1 or not argTypeIsIID(signatures[0][1][0]):
|
|
raise TypeError("There should be only one queryInterface method with 1 argument of type IID")
|
|
|
|
# Make sure to not stick QueryInterface on abstract interfaces that
|
|
# have hasXPConnectImpls (like EventTarget). So only put it on
|
|
# interfaces that are concrete and all of whose ancestors are abstract.
|
|
def allAncestorsAbstract(iface):
|
|
if not iface.parent:
|
|
return True
|
|
desc = self.descriptor.getDescriptor(iface.parent.identifier.name)
|
|
if desc.concrete:
|
|
return False
|
|
return allAncestorsAbstract(iface.parent)
|
|
if (not self.descriptor.interface.hasInterfacePrototypeObject() or
|
|
not self.descriptor.concrete or
|
|
not allAncestorsAbstract(self.descriptor.interface)):
|
|
raise TypeError("QueryInterface is only supported on "
|
|
"interfaces that are concrete and all "
|
|
"of whose ancestors are abstract: " +
|
|
self.descriptor.name)
|
|
condition = "WantsQueryInterface<%s>::Enabled" % descriptor.nativeType
|
|
self.regular.append({
|
|
"name": 'QueryInterface',
|
|
"methodInfo": False,
|
|
"length": 1,
|
|
"flags": "0",
|
|
"condition": MemberCondition(func=condition)
|
|
})
|
|
continue
|
|
|
|
# Iterable methods should be enumerable, maplike/setlike methods
|
|
# should not.
|
|
isMaplikeOrSetlikeMethod = (m.isMaplikeOrSetlikeOrIterableMethod() and
|
|
(m.maplikeOrSetlikeOrIterable.isMaplike() or
|
|
m.maplikeOrSetlikeOrIterable.isSetlike()))
|
|
method = {
|
|
"name": m.identifier.name,
|
|
"methodInfo": not m.isStatic(),
|
|
"length": methodLength(m),
|
|
# Methods generated for a maplike/setlike declaration are not
|
|
# enumerable.
|
|
"flags": "JSPROP_ENUMERATE" if not isMaplikeOrSetlikeMethod else "0",
|
|
"condition": PropertyDefiner.getControllingCondition(m, descriptor),
|
|
"allowCrossOriginThis": m.getExtendedAttribute("CrossOriginCallable"),
|
|
"returnsPromise": m.returnsPromise(),
|
|
"hasIteratorAlias": "@@iterator" in m.aliases
|
|
}
|
|
|
|
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.
|
|
# https://www.w3.org/Bugs/Public/show_bug.cgi?id=28592
|
|
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": "JSPROP_ENUMERATE",
|
|
"condition": MemberCondition()
|
|
})
|
|
|
|
if (static and
|
|
not unforgeable and
|
|
descriptor.interface.hasInterfaceObject() and
|
|
NeedsGeneratedHasInstance(descriptor)):
|
|
self.regular.append({
|
|
"name": "@@hasInstance",
|
|
"methodInfo": False,
|
|
"nativeName": HASINSTANCE_HOOK_NAME,
|
|
"length": 1,
|
|
# Flags match those of Function[Symbol.hasInstance]
|
|
"flags": "JSPROP_READONLY | JSPROP_PERMANENT",
|
|
"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(m,
|
|
descriptor)
|
|
})
|
|
self.regular.append({
|
|
"name": "values",
|
|
"methodInfo": False,
|
|
"selfHostedName": "ArrayValues",
|
|
"length": 0,
|
|
"flags": "JSPROP_ENUMERATE",
|
|
"condition": PropertyDefiner.getControllingCondition(m,
|
|
descriptor)
|
|
})
|
|
self.regular.append({
|
|
"name": "entries",
|
|
"methodInfo": False,
|
|
"selfHostedName": "ArrayEntries",
|
|
"length": 0,
|
|
"flags": "JSPROP_ENUMERATE",
|
|
"condition": PropertyDefiner.getControllingCondition(m,
|
|
descriptor)
|
|
})
|
|
self.regular.append({
|
|
"name": "forEach",
|
|
"methodInfo": False,
|
|
"selfHostedName": "ArrayForEach",
|
|
"length": 1,
|
|
"flags": "JSPROP_ENUMERATE",
|
|
"condition": PropertyDefiner.getControllingCondition(m,
|
|
descriptor)
|
|
})
|
|
|
|
if not static:
|
|
stringifier = descriptor.operations['Stringifier']
|
|
if (stringifier and
|
|
unforgeable == MemberIsUnforgeable(stringifier, descriptor)):
|
|
toStringDesc = {
|
|
"name": "toString",
|
|
"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)
|
|
jsonifier = descriptor.operations['Jsonifier']
|
|
if (jsonifier and
|
|
unforgeable == MemberIsUnforgeable(jsonifier, descriptor)):
|
|
toJSONDesc = {
|
|
"name": "toJSON",
|
|
"nativeName": jsonifier.identifier.name,
|
|
"length": 0,
|
|
"flags": "JSPROP_ENUMERATE",
|
|
"condition": PropertyDefiner.getControllingCondition(jsonifier, descriptor)
|
|
}
|
|
if isChromeOnly(jsonifier):
|
|
self.chrome.append(toJSONDesc)
|
|
else:
|
|
self.regular.append(toJSONDesc)
|
|
if (unforgeable and
|
|
descriptor.interface.getExtendedAttribute("Unforgeable")):
|
|
# 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()
|
|
})
|
|
else:
|
|
for m in clearableCachedAttrs(descriptor):
|
|
attrName = MakeNativeName(m.identifier.name)
|
|
self.chrome.append({
|
|
"name": "_clearCached%sValue" % attrName,
|
|
"nativeName": MakeJSImplClearCachedValueNativeName(m),
|
|
"methodInfo": False,
|
|
"length": "0",
|
|
"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()
|
|
|
|
def generateArray(self, array, name, doIdArrays):
|
|
if len(array) == 0:
|
|
return ""
|
|
|
|
def condition(m, d):
|
|
return m["condition"]
|
|
|
|
def flags(m):
|
|
unforgeable = " | JSPROP_PERMANENT | JSPROP_READONLY" if self.unforgeable else ""
|
|
return m["flags"] + unforgeable
|
|
|
|
def specData(m):
|
|
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):
|
|
# Cast this in case the methodInfo is a
|
|
# JSTypedMethodJitInfo.
|
|
jitinfo = ("reinterpret_cast<const JSJitInfo*>(&%s_methodinfo)" % accessor)
|
|
if m.get("allowCrossOriginThis", False):
|
|
if m.get("returnsPromise", False):
|
|
raise TypeError("%s returns a Promise but should "
|
|
"be allowed cross-origin?" %
|
|
accessor)
|
|
accessor = "genericCrossOriginMethod"
|
|
elif self.descriptor.needsSpecialGenericOps():
|
|
if m.get("returnsPromise", False):
|
|
accessor = "genericPromiseReturningMethod"
|
|
else:
|
|
accessor = "genericMethod"
|
|
elif m.get("returnsPromise", False):
|
|
accessor = "GenericPromiseReturningBindingMethod"
|
|
else:
|
|
accessor = "GenericBindingMethod"
|
|
else:
|
|
if m.get("returnsPromise", False):
|
|
jitinfo = "&%s_methodinfo" % accessor
|
|
accessor = "StaticMethodPromiseWrapper"
|
|
else:
|
|
jitinfo = "nullptr"
|
|
|
|
return (m["name"], accessor, jitinfo, m["length"], flags(m), selfHostedName)
|
|
|
|
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
|
|
|
|
return self.generatePrefableArray(
|
|
array, name,
|
|
formatSpec,
|
|
' JS_FS_END',
|
|
'JSFunctionSpec',
|
|
condition, specData, doIdArrays)
|
|
|
|
|
|
def IsCrossOriginWritable(attr, descriptor):
|
|
"""
|
|
Return whether the IDLAttribute in question is cross-origin writable on the
|
|
interface represented by descriptor. This is needed to handle the fact that
|
|
some, but not all, interfaces implementing URLUtils want a cross-origin
|
|
writable .href.
|
|
"""
|
|
crossOriginWritable = attr.getExtendedAttribute("CrossOriginWritable")
|
|
if not crossOriginWritable:
|
|
return False
|
|
if crossOriginWritable is True:
|
|
return True
|
|
assert (isinstance(crossOriginWritable, list) and
|
|
len(crossOriginWritable) == 1)
|
|
return crossOriginWritable[0] == descriptor.interface.identifier.name
|
|
|
|
def isNonExposedNavigatorObjectGetter(attr, descriptor):
|
|
return (attr.navigatorObjectGetter and
|
|
not descriptor.getDescriptor(attr.type.inner.identifier.name).register)
|
|
|
|
class AttrDefiner(PropertyDefiner):
|
|
def __init__(self, descriptor, name, 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:
|
|
attributes = [m for m in descriptor.interface.members if
|
|
m.isAttr() and m.isStatic() == static and
|
|
MemberIsUnforgeable(m, descriptor) == unforgeable and
|
|
not isNonExposedNavigatorObjectGetter(m, descriptor)]
|
|
else:
|
|
attributes = []
|
|
self.chrome = [m for m in attributes if isChromeOnly(m)]
|
|
self.regular = [m for m in attributes if not isChromeOnly(m)]
|
|
self.static = static
|
|
self.unforgeable = unforgeable
|
|
|
|
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()
|
|
|
|
def generateArray(self, array, name, doIdArrays):
|
|
if len(array) == 0:
|
|
return ""
|
|
|
|
def flags(attr):
|
|
unforgeable = " | JSPROP_PERMANENT" if self.unforgeable else ""
|
|
# Attributes generated as part of a maplike/setlike declaration are
|
|
# not enumerable.
|
|
enumerable = " | JSPROP_ENUMERATE" if not attr.isMaplikeOrSetlikeAttr() else ""
|
|
return ("JSPROP_SHARED" + enumerable + unforgeable)
|
|
|
|
def getter(attr):
|
|
if self.static:
|
|
accessor = 'get_' + IDLToCIdentifier(attr.identifier.name)
|
|
jitinfo = "nullptr"
|
|
else:
|
|
if attr.hasLenientThis():
|
|
accessor = "genericLenientGetter"
|
|
elif attr.getExtendedAttribute("CrossOriginReadable"):
|
|
accessor = "genericCrossOriginGetter"
|
|
elif self.descriptor.needsSpecialGenericOps():
|
|
accessor = "genericGetter"
|
|
else:
|
|
accessor = "GenericBindingGetter"
|
|
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("LenientSetter") is None):
|
|
return "JSNATIVE_WRAPPER(nullptr)"
|
|
if self.static:
|
|
accessor = 'set_' + IDLToCIdentifier(attr.identifier.name)
|
|
jitinfo = "nullptr"
|
|
else:
|
|
if attr.hasLenientThis():
|
|
accessor = "genericLenientSetter"
|
|
elif IsCrossOriginWritable(attr, self.descriptor):
|
|
accessor = "genericCrossOriginSetter"
|
|
elif self.descriptor.needsSpecialGenericOps():
|
|
accessor = "genericSetter"
|
|
else:
|
|
accessor = "GenericBindingSetter"
|
|
jitinfo = "&%s_setterinfo" % IDLToCIdentifier(attr.identifier.name)
|
|
return "{ { %s, %s } }" % \
|
|
(accessor, jitinfo)
|
|
|
|
def specData(attr):
|
|
return (attr.identifier.name, flags(attr), getter(attr),
|
|
setter(attr))
|
|
|
|
return self.generatePrefableArray(
|
|
array, name,
|
|
lambda fields: ' { "%s", %s, { { %s, %s } } }' % fields,
|
|
' JS_PS_END',
|
|
'JSPropertySpec',
|
|
PropertyDefiner.getControllingCondition, specData, doIdArrays)
|
|
|
|
|
|
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, doIdArrays):
|
|
if len(array) == 0:
|
|
return ""
|
|
|
|
def specData(const):
|
|
return (const.identifier.name,
|
|
convertConstIDLValueToJSVal(const.value))
|
|
|
|
return self.generatePrefableArray(
|
|
array, name,
|
|
lambda fields: ' { "%s", %s }' % fields,
|
|
' { 0, JS::UndefinedValue() }',
|
|
'ConstantSpec',
|
|
PropertyDefiner.getControllingCondition, specData, doIdArrays)
|
|
|
|
|
|
class PropertyArrays():
|
|
def __init__(self, descriptor):
|
|
self.staticMethods = MethodDefiner(descriptor, "StaticMethods",
|
|
static=True)
|
|
self.staticAttrs = AttrDefiner(descriptor, "StaticAttributes",
|
|
static=True)
|
|
self.methods = MethodDefiner(descriptor, "Methods", static=False)
|
|
self.attrs = AttrDefiner(descriptor, "Attributes", static=False)
|
|
self.unforgeableMethods = MethodDefiner(descriptor, "UnforgeableMethods",
|
|
static=False, unforgeable=True)
|
|
self.unforgeableAttrs = AttrDefiner(descriptor, "UnforgeableAttributes",
|
|
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 CGNativeProperties(CGList):
|
|
def __init__(self, descriptor, properties):
|
|
def generateNativeProperties(name, chrome):
|
|
def check(p):
|
|
return p.hasChromeOnly() if chrome else p.hasNonChromeOnly()
|
|
|
|
nativePropsInts = []
|
|
nativePropsTrios = []
|
|
|
|
iteratorAliasIndex = -1
|
|
for index, item in enumerate(properties.methods.regular):
|
|
if item.get("hasIteratorAlias"):
|
|
iteratorAliasIndex = index
|
|
break
|
|
nativePropsInts.append(CGGeneric(str(iteratorAliasIndex)))
|
|
|
|
offset = 0
|
|
for array in properties.arrayNames():
|
|
propertyArray = getattr(properties, array)
|
|
if check(propertyArray):
|
|
varName = propertyArray.variableName(chrome)
|
|
bitfields = "true, %d /* %s */" % (offset, varName)
|
|
offset += 1
|
|
nativePropsInts.append(CGGeneric(bitfields))
|
|
|
|
if propertyArray.usedForXrays():
|
|
ids = "%(name)s_ids"
|
|
else:
|
|
ids = "nullptr"
|
|
trio = "{ %(name)s, " + ids + ", %(name)s_specs }"
|
|
trio = trio % {'name': varName}
|
|
nativePropsTrios.append(CGGeneric(trio))
|
|
else:
|
|
bitfields = "false, 0"
|
|
nativePropsInts.append(CGGeneric(bitfields))
|
|
|
|
nativePropsTrios = \
|
|
[CGWrapper(CGIndenter(CGList(nativePropsTrios, ",\n")),
|
|
pre='{\n', post='\n}')]
|
|
nativeProps = nativePropsInts + nativePropsTrios
|
|
pre = ("static const NativePropertiesN<%d> %s = {\n" %
|
|
(offset, name))
|
|
return CGWrapper(CGIndenter(CGList(nativeProps, ",\n")),
|
|
pre=pre, post="\n};\n")
|
|
|
|
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 CGJsonifyAttributesMethod(CGAbstractMethod):
|
|
"""
|
|
Generate the JsonifyAttributes method for an interface descriptor
|
|
"""
|
|
def __init__(self, descriptor):
|
|
args = [Argument('JSContext*', 'aCx'),
|
|
Argument('JS::Handle<JSObject*>', 'obj'),
|
|
Argument('%s*' % descriptor.nativeType, 'self'),
|
|
Argument('JS::Rooted<JSObject*>&', 'aResult')]
|
|
CGAbstractMethod.__init__(self, descriptor, 'JsonifyAttributes', 'bool', args)
|
|
|
|
def definition_body(self):
|
|
ret = ''
|
|
interface = self.descriptor.interface
|
|
for m in interface.members:
|
|
if m.isAttr() and not m.isStatic() and m.type.isSerializable():
|
|
ret += fill(
|
|
"""
|
|
{ // scope for "temp"
|
|
JS::Rooted<JS::Value> temp(aCx);
|
|
if (!get_${name}(aCx, obj, self, JSJitGetterCallArgs(&temp))) {
|
|
return false;
|
|
}
|
|
if (!JS_DefineProperty(aCx, aResult, "${name}", temp, JSPROP_ENUMERATE)) {
|
|
return false;
|
|
}
|
|
}
|
|
""",
|
|
name=IDLToCIdentifier(m.identifier.name))
|
|
ret += 'return true;\n'
|
|
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):
|
|
args = [Argument('JSContext*', 'aCx'),
|
|
Argument('JS::Handle<JSObject*>', 'aGlobal'),
|
|
Argument('ProtoAndIfaceCache&', 'aProtoAndIfaceCache'),
|
|
Argument('bool', 'aDefineOnGlobal')]
|
|
CGAbstractMethod.__init__(self, descriptor, 'CreateInterfaceObjects', 'void', args)
|
|
self.properties = properties
|
|
self.haveUnscopables = haveUnscopables
|
|
|
|
def definition_body(self):
|
|
(protoGetter, protoHandleGetter) = InterfacePrototypeObjectProtoGetter(self.descriptor)
|
|
if protoHandleGetter is None:
|
|
parentProtoType = "Rooted"
|
|
getParentProto = "aCx, " + protoGetter
|
|
else:
|
|
parentProtoType = "Handle"
|
|
getParentProto = protoHandleGetter
|
|
getParentProto = getParentProto + "(aCx)"
|
|
|
|
(protoGetter, protoHandleGetter) = InterfaceObjectProtoGetter(self.descriptor)
|
|
if protoHandleGetter is None:
|
|
getConstructorProto = "aCx, " + protoGetter
|
|
constructorProtoType = "Rooted"
|
|
else:
|
|
getConstructorProto = protoHandleGetter
|
|
constructorProtoType = "Handle"
|
|
getConstructorProto += "(aCx)"
|
|
|
|
needInterfaceObject = self.descriptor.interface.hasInterfaceObject()
|
|
needInterfacePrototypeObject = self.descriptor.interface.hasInterfacePrototypeObject()
|
|
|
|
# if we don't need to create anything, why are we generating this?
|
|
assert needInterfaceObject or needInterfacePrototypeObject
|
|
|
|
getParentProto = fill(
|
|
"""
|
|
JS::${type}<JSObject*> parentProto(${getParentProto});
|
|
if (!parentProto) {
|
|
return;
|
|
}
|
|
""",
|
|
type=parentProtoType,
|
|
getParentProto=getParentProto)
|
|
|
|
getConstructorProto = fill(
|
|
"""
|
|
JS::${type}<JSObject*> constructorProto(${getConstructorProto});
|
|
if (!constructorProto) {
|
|
return;
|
|
}
|
|
""",
|
|
type=constructorProtoType,
|
|
getConstructorProto=getConstructorProto)
|
|
|
|
idsToInit = []
|
|
# There is no need to init any IDs in bindings that don't want Xrays.
|
|
if self.descriptor.wantsXrays:
|
|
for var in self.properties.arrayNames():
|
|
props = getattr(self.properties, var)
|
|
# We only have non-chrome ids to init if we have no chrome ids.
|
|
if props.hasChromeOnly():
|
|
idsToInit.append(props.variableName(True))
|
|
if props.hasNonChromeOnly():
|
|
idsToInit.append(props.variableName(False))
|
|
if len(idsToInit) > 0:
|
|
initIdCalls = ["!InitIds(aCx, %s, %s_ids)" % (varname, varname)
|
|
for varname in idsToInit]
|
|
idsInitedFlag = CGGeneric("static bool sIdsInited = false;\n")
|
|
setFlag = CGGeneric("sIdsInited = true;\n")
|
|
initIdConditionals = [CGIfWrapper(CGGeneric("return;\n"), call)
|
|
for call in initIdCalls]
|
|
initIds = CGList([idsInitedFlag,
|
|
CGIfWrapper(CGList(initIdConditionals + [setFlag]),
|
|
"!sIdsInited && NS_IsMainThread()")])
|
|
else:
|
|
initIds = None
|
|
|
|
prefCacheData = []
|
|
for var in self.properties.arrayNames():
|
|
props = getattr(self.properties, var)
|
|
prefCacheData.extend(props.prefCacheData)
|
|
if len(prefCacheData) != 0:
|
|
prefCacheData = [
|
|
CGGeneric('Preferences::AddBoolVarCache(%s, "%s");\n' % (ptr, pref))
|
|
for pref, ptr in prefCacheData]
|
|
prefCache = CGWrapper(CGIndenter(CGList(prefCacheData)),
|
|
pre=("static bool sPrefCachesInited = false;\n"
|
|
"if (!sPrefCachesInited && NS_IsMainThread()) {\n"
|
|
" sPrefCachesInited = true;\n"),
|
|
post="}\n")
|
|
else:
|
|
prefCache = None
|
|
|
|
if self.descriptor.interface.ctor():
|
|
constructArgs = methodLength(self.descriptor.interface.ctor())
|
|
else:
|
|
constructArgs = 0
|
|
if len(self.descriptor.interface.namedConstructors) > 0:
|
|
namedConstructors = "namedConstructors"
|
|
else:
|
|
namedConstructors = "nullptr"
|
|
|
|
if needInterfacePrototypeObject:
|
|
protoClass = "&sPrototypeClass.mBase"
|
|
protoCache = "&aProtoAndIfaceCache.EntrySlotOrCreate(prototypes::id::%s)" % self.descriptor.name
|
|
parentProto = "parentProto"
|
|
getParentProto = CGGeneric(getParentProto)
|
|
else:
|
|
protoClass = "nullptr"
|
|
protoCache = "nullptr"
|
|
parentProto = "nullptr"
|
|
getParentProto = None
|
|
|
|
if needInterfaceObject:
|
|
interfaceClass = "&sInterfaceObjectClass.mBase"
|
|
interfaceCache = "&aProtoAndIfaceCache.EntrySlotOrCreate(constructors::id::%s)" % self.descriptor.name
|
|
getConstructorProto = CGGeneric(getConstructorProto)
|
|
constructorProto = "constructorProto"
|
|
else:
|
|
# We don't have slots to store the named constructors.
|
|
assert len(self.descriptor.interface.namedConstructors) == 0
|
|
interfaceClass = "nullptr"
|
|
interfaceCache = "nullptr"
|
|
getConstructorProto = None
|
|
constructorProto = "nullptr"
|
|
|
|
isGlobal = self.descriptor.isGlobal() is not None
|
|
if self.properties.hasNonChromeOnly():
|
|
properties = "sNativeProperties.Upcast()"
|
|
else:
|
|
properties = "nullptr"
|
|
if self.properties.hasChromeOnly():
|
|
chromeProperties = "nsContentUtils::ThreadsafeIsCallerChrome() ? sChromeOnlyNativeProperties.Upcast() : nullptr"
|
|
else:
|
|
chromeProperties = "nullptr"
|
|
|
|
call = fill(
|
|
"""
|
|
JS::Heap<JSObject*>* protoCache = ${protoCache};
|
|
JS::Heap<JSObject*>* interfaceCache = ${interfaceCache};
|
|
dom::CreateInterfaceObjects(aCx, aGlobal, ${parentProto},
|
|
${protoClass}, protoCache,
|
|
${constructorProto}, ${interfaceClass}, ${constructArgs}, ${namedConstructors},
|
|
interfaceCache,
|
|
${properties},
|
|
${chromeProperties},
|
|
${name}, aDefineOnGlobal,
|
|
${unscopableNames},
|
|
${isGlobal});
|
|
""",
|
|
protoClass=protoClass,
|
|
parentProto=parentProto,
|
|
protoCache=protoCache,
|
|
constructorProto=constructorProto,
|
|
interfaceClass=interfaceClass,
|
|
constructArgs=constructArgs,
|
|
namedConstructors=namedConstructors,
|
|
interfaceCache=interfaceCache,
|
|
properties=properties,
|
|
chromeProperties=chromeProperties,
|
|
name='"' + self.descriptor.interface.identifier.name + '"' if needInterfaceObject else "nullptr",
|
|
unscopableNames="unscopableNames" if self.haveUnscopables else "nullptr",
|
|
isGlobal=toStringBool(isGlobal))
|
|
|
|
# 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;
|
|
""")
|
|
|
|
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":
|
|
symbolJSID = "SYMBOL_TO_JSID(JS::GetWellKnownSymbol(aCx, JS::SymbolCode::iterator))"
|
|
getSymbolJSID = CGGeneric(fill("JS::Rooted<jsid> iteratorId(aCx, ${symbolJSID});",
|
|
symbolJSID=symbolJSID))
|
|
defineFn = "JS_DefinePropertyById"
|
|
prop = "iteratorId"
|
|
elif alias.startswith("@@"):
|
|
raise TypeError("Can't handle any well-known Symbol other than @@iterator")
|
|
else:
|
|
getSymbolJSID = None
|
|
defineFn = "JS_DefineProperty"
|
|
prop = '"%s"' % alias
|
|
return CGList([
|
|
getSymbolJSID,
|
|
# 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.
|
|
CGGeneric(fill(
|
|
"""
|
|
if (!${defineFn}(aCx, proto, ${prop}, aliasedVal, JSPROP_ENUMERATE)) {
|
|
$*{failureCode}
|
|
}
|
|
""",
|
|
defineFn=defineFn,
|
|
prop=prop,
|
|
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(fill("""
|
|
// Set up aliases on the interface prototype object we just created.
|
|
JS::Handle<JSObject*> proto = GetProtoObjectHandle(aCx);
|
|
if (!proto) {
|
|
$*{failureCode}
|
|
}
|
|
|
|
""",
|
|
failureCode=failureCode)),
|
|
CGGeneric("JS::Rooted<JS::Value> aliasedVal(aCx);\n\n")
|
|
] + [defineAliasesFor(m) for m in sorted(aliasedMembers)])
|
|
else:
|
|
defineAliases = None
|
|
|
|
# Globals handle unforgeables directly in Wrap() instead of
|
|
# via a holder.
|
|
if self.descriptor.hasUnforgeableMembers 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 = "*protoCache"
|
|
createUnforgeableHolder = CGGeneric(fill(
|
|
"""
|
|
JS::Rooted<JSObject*> unforgeableHolder(aCx);
|
|
{
|
|
JS::Rooted<JSObject*> holderProto(aCx, ${holderProto});
|
|
unforgeableHolder = 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::SetReservedSlot(*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(
|
|
"""
|
|
if (*${protoCache}) {
|
|
bool succeeded;
|
|
JS::Handle<JSObject*> prot = GetProtoObjectHandle(aCx);
|
|
if (!JS_SetImmutablePrototype(aCx, prot, &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))
|
|
else:
|
|
makeProtoPrototypeImmutable = None
|
|
|
|
return CGList(
|
|
[getParentProto, getConstructorProto, initIds,
|
|
prefCache, CGGeneric(call), defineAliases, unforgeableHolderSetup,
|
|
makeProtoPrototypeImmutable],
|
|
"\n").define()
|
|
|
|
|
|
class CGGetPerInterfaceObject(CGAbstractMethod):
|
|
"""
|
|
A method for getting a per-interface object (a prototype object or interface
|
|
constructor object).
|
|
"""
|
|
def __init__(self, descriptor, name, idPrefix="", extraArgs=[]):
|
|
args = [Argument('JSContext*', 'aCx')] + extraArgs
|
|
CGAbstractMethod.__init__(self, descriptor, name,
|
|
'JS::Handle<JSObject*>', args)
|
|
self.id = idPrefix + "id::" + self.descriptor.name
|
|
|
|
def definition_body(self):
|
|
return fill(
|
|
"""
|
|
/* Make sure our global is sane. Hopefully we can remove this sometime */
|
|
JSObject* global = JS::CurrentGlobalOrNull(aCx);
|
|
if (!(js::GetObjectClass(global)->flags & JSCLASS_DOM_GLOBAL)) {
|
|
return nullptr;
|
|
}
|
|
|
|
/* Check to see whether the interface objects are already installed */
|
|
ProtoAndIfaceCache& protoAndIfaceCache = *GetProtoAndIfaceCache(global);
|
|
if (!protoAndIfaceCache.EntrySlotIfExists(${id})) {
|
|
JS::Rooted<JSObject*> rootedGlobal(aCx, global);
|
|
CreateInterfaceObjects(aCx, rootedGlobal, protoAndIfaceCache, aDefineOnGlobal);
|
|
}
|
|
|
|
/*
|
|
* The object might _still_ be null, but that's OK.
|
|
*
|
|
* Calling fromMarkedLocation() is safe because protoAndIfaceCache is
|
|
* traced by TraceProtoAndIfaceCache() and its contents are never
|
|
* changed after they have been set.
|
|
*
|
|
* Calling address() avoids the read read barrier that does gray
|
|
* unmarking, but it's not possible for the object to be gray here.
|
|
*/
|
|
|
|
const JS::Heap<JSObject*>& entrySlot = protoAndIfaceCache.EntrySlotMustExist(${id});
|
|
MOZ_ASSERT_IF(entrySlot, !JS::ObjectIsMarkedGray(entrySlot));
|
|
return JS::Handle<JSObject*>::fromMarkedLocation(entrySlot.address());
|
|
""",
|
|
id=self.id)
|
|
|
|
|
|
class CGGetProtoObjectHandleMethod(CGGetPerInterfaceObject):
|
|
"""
|
|
A method for getting the interface prototype object.
|
|
"""
|
|
def __init__(self, descriptor):
|
|
CGGetPerInterfaceObject.__init__(self, descriptor, "GetProtoObjectHandle",
|
|
"prototypes::")
|
|
|
|
def definition_body(self):
|
|
return dedent("""
|
|
/* Get the interface prototype object for this class. This will create the
|
|
object as needed. */
|
|
bool aDefineOnGlobal = true;
|
|
|
|
""") + CGGetPerInterfaceObject.definition_body(self)
|
|
|
|
|
|
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(CGGetPerInterfaceObject):
|
|
"""
|
|
A method for getting the interface constructor object.
|
|
"""
|
|
def __init__(self, descriptor):
|
|
CGGetPerInterfaceObject.__init__(
|
|
self, descriptor, "GetConstructorObjectHandle",
|
|
"constructors::",
|
|
extraArgs=[Argument("bool", "aDefineOnGlobal", "true")])
|
|
|
|
def definition_body(self):
|
|
return dedent("""
|
|
/* Get the interface object for this class. This will create the object as
|
|
needed. */
|
|
|
|
""") + CGGetPerInterfaceObject.definition_body(self)
|
|
|
|
|
|
class CGGetConstructorObjectMethod(CGAbstractMethod):
|
|
"""
|
|
A method for getting the interface constructor object.
|
|
"""
|
|
def __init__(self, descriptor):
|
|
CGAbstractMethod.__init__(
|
|
self, descriptor, "GetConstructorObject", "JSObject*",
|
|
[Argument('JSContext*', 'aCx')])
|
|
|
|
def definition_body(self):
|
|
return "return GetConstructorObjectHandle(aCx);\n"
|
|
|
|
|
|
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::GetObjectClass(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::GetObjectClass(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->mResolveOwnProperty,
|
|
"Don't know how to resolve the properties of the named properties object for ${nativeType}.");
|
|
MOZ_ASSERT(clasp->mNativeHooks->mEnumerateOwnProperties,
|
|
"Don't know how to enumerate the properties of the named properties object for ${nativeType}.");
|
|
}
|
|
return namedPropertiesObject.get();
|
|
""",
|
|
getParentProto=getParentProto,
|
|
ifaceName=self.descriptor.name,
|
|
parentProto=parentProto,
|
|
nativeType=self.descriptor.nativeType)
|
|
|
|
|
|
class CGDefineDOMInterfaceMethod(CGAbstractMethod):
|
|
"""
|
|
A method for resolve hooks to try to lazily define the interface object for
|
|
a given interface.
|
|
"""
|
|
def __init__(self, descriptor):
|
|
args = [Argument('JSContext*', 'aCx'),
|
|
Argument('JS::Handle<JSObject*>', 'aGlobal'),
|
|
Argument('JS::Handle<jsid>', 'id'),
|
|
Argument('bool', 'aDefineOnGlobal')]
|
|
CGAbstractMethod.__init__(self, descriptor, 'DefineDOMInterface', 'JSObject*', args)
|
|
|
|
def definition_body(self):
|
|
if len(self.descriptor.interface.namedConstructors) > 0:
|
|
getConstructor = dedent("""
|
|
JSObject* interfaceObject = GetConstructorObjectHandle(aCx, aDefineOnGlobal);
|
|
if (!interfaceObject) {
|
|
return nullptr;
|
|
}
|
|
for (unsigned slot = DOM_INTERFACE_SLOTS_BASE; slot < JSCLASS_RESERVED_SLOTS(&sInterfaceObjectClass.mBase); ++slot) {
|
|
JSObject* constructor = &js::GetReservedSlot(interfaceObject, slot).toObject();
|
|
if (JS_GetFunctionId(JS_GetObjectFunction(constructor)) == JSID_TO_STRING(id)) {
|
|
return constructor;
|
|
}
|
|
}
|
|
return interfaceObject;
|
|
""")
|
|
else:
|
|
getConstructor = "return GetConstructorObjectHandle(aCx, aDefineOnGlobal);\n"
|
|
return getConstructor
|
|
|
|
|
|
def getConditionList(idlobj, cxName, objName):
|
|
"""
|
|
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.
|
|
"""
|
|
conditions = []
|
|
pref = idlobj.getExtendedAttribute("Pref")
|
|
if pref:
|
|
assert isinstance(pref, list) and len(pref) == 1
|
|
conditions.append('Preferences::GetBool("%s")' % pref[0])
|
|
if idlobj.getExtendedAttribute("ChromeOnly"):
|
|
conditions.append("nsContentUtils::ThreadsafeIsCallerChrome()")
|
|
func = idlobj.getExtendedAttribute("Func")
|
|
if func:
|
|
assert isinstance(func, list) and len(func) == 1
|
|
conditions.append("%s(%s, %s)" % (func[0], cxName, objName))
|
|
if idlobj.getExtendedAttribute("SecureContext"):
|
|
conditions.append("mozilla::dom::IsSecureContextOrObjectIsFromSecureContext(%s, %s)" % (cxName, objName))
|
|
|
|
return CGList((CGGeneric(cond) for cond in conditions), " &&\n")
|
|
|
|
|
|
class CGConstructorEnabled(CGAbstractMethod):
|
|
"""
|
|
A method for testing whether we should be exposing this interface
|
|
object or navigator property. 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.isExposedOnMainThread():
|
|
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::GetObjectClass(aObj)->name;
|
|
if (${workerCondition}) {
|
|
return false;
|
|
}
|
|
""", workerCondition=workerCondition.define())
|
|
exposedInWorkerCheck = CGGeneric(exposedInWorkerCheck)
|
|
if iface.isExposedOnMainThread():
|
|
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 CreateBindingJSObject(descriptor, properties):
|
|
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:
|
|
create = dedent(
|
|
"""
|
|
creator.CreateProxyObject(aCx, &sClass.mBase, DOMProxyHandler::getInstance(),
|
|
proto, aObject, aReflector);
|
|
if (!aReflector) {
|
|
return false;
|
|
}
|
|
|
|
""")
|
|
if descriptor.interface.getExtendedAttribute('OverrideBuiltins'):
|
|
create += dedent("""
|
|
js::SetProxyExtra(aReflector, JSPROXYSLOT_EXPANDO,
|
|
JS::PrivateValue(&aObject->mExpandoAndGeneration));
|
|
|
|
""")
|
|
else:
|
|
create = dedent(
|
|
"""
|
|
creator.CreateObject(aCx, sClass.ToJSClass(), proto, aObject, aReflector);
|
|
if (!aReflector) {
|
|
return false;
|
|
}
|
|
""")
|
|
return objDecl + create
|
|
|
|
|
|
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 (!DefineUnforgeableAttributes(aCx, ${holderName}, %s)) {
|
|
$*{failureCode}
|
|
}
|
|
""",
|
|
failureCode=failureCode,
|
|
holderName=holderName)
|
|
defineUnforgeableMethods = fill(
|
|
"""
|
|
if (!DefineUnforgeableMethods(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::ThreadsafeIsCallerChrome()"))
|
|
|
|
if descriptor.interface.getExtendedAttribute("Unforgeable"):
|
|
# 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::RootedId toPrimitive(aCx,
|
|
SYMBOL_TO_JSID(JS::GetWellKnownSymbol(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.hasUnforgeableMembers:
|
|
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::GetReservedSlot(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):
|
|
asserts = ""
|
|
iface = descriptor.interface
|
|
while iface:
|
|
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))
|
|
iface = iface.parent
|
|
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 SetImmutablePrototype(descriptor, failureCode):
|
|
if not descriptor.hasNonOrdinaryGetPrototypeOf():
|
|
return ""
|
|
|
|
return fill(
|
|
"""
|
|
bool succeeded;
|
|
if (!JS_SetImmutablePrototype(aCx, aReflector, &succeeded)) {
|
|
${failureCode}
|
|
}
|
|
MOZ_ASSERT(succeeded,
|
|
"Making a fresh reflector instance have an immutable "
|
|
"prototype can internally fail, but it should never be "
|
|
"unsuccessful");
|
|
""",
|
|
failureCode=failureCode)
|
|
|
|
|
|
def DeclareProto():
|
|
"""
|
|
Declare the canonicalProto and proto we have for our wrapping operation.
|
|
"""
|
|
return dedent(
|
|
"""
|
|
JS::Handle<JSObject*> canonicalProto = GetProtoObjectHandle(aCx);
|
|
if (!canonicalProto) {
|
|
return false;
|
|
}
|
|
JS::Rooted<JSObject*> proto(aCx);
|
|
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::GetObjectCompartment(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.
|
|
|
|
properties should be a PropertyArrays instance.
|
|
"""
|
|
def __init__(self, descriptor, properties):
|
|
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)
|
|
self.properties = properties
|
|
|
|
def definition_body(self):
|
|
if self.descriptor.proxy:
|
|
preserveWrapper = dedent(
|
|
"""
|
|
// For DOM proxies, the only reliable way to preserve the wrapper
|
|
// is to force creation of the expando object.
|
|
JS::Rooted<JSObject*> unused(aCx,
|
|
DOMProxyHandler::EnsureExpandoObject(aCx, aReflector));
|
|
""")
|
|
else:
|
|
preserveWrapper = "PreserveWrapper(aObject);\n"
|
|
|
|
failureCode = dedent(
|
|
"""
|
|
aCache->ReleaseWrapper(aObject);
|
|
aCache->ClearWrapper();
|
|
return false;
|
|
""")
|
|
|
|
return fill(
|
|
"""
|
|
$*{assertInheritance}
|
|
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");
|
|
|
|
JS::Rooted<JSObject*> global(aCx, FindAssociatedGlobal(aCx, aObject->GetParentObject()));
|
|
if (!global) {
|
|
return false;
|
|
}
|
|
MOZ_ASSERT(JS_IsGlobalObject(global));
|
|
MOZ_ASSERT(!JS::ObjectIsMarkedGray(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
|
|
binding_detail::AssertReflectorHasGivenProto(aCx, aReflector, aGivenProto);
|
|
#endif // DEBUG
|
|
return true;
|
|
}
|
|
|
|
JSAutoCompartment ac(aCx, global);
|
|
$*{declareProto}
|
|
|
|
$*{createObject}
|
|
|
|
aCache->SetWrapper(aReflector);
|
|
$*{unforgeable}
|
|
$*{slots}
|
|
$*{setImmutablePrototype}
|
|
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}
|
|
}
|
|
|
|
return true;
|
|
""",
|
|
assertInheritance=AssertInheritanceChain(self.descriptor),
|
|
declareProto=DeclareProto(),
|
|
createObject=CreateBindingJSObject(self.descriptor, self.properties),
|
|
unforgeable=CopyUnforgeablePropertiesToInstance(self.descriptor,
|
|
failureCode),
|
|
slots=InitMemberSlots(self.descriptor, failureCode),
|
|
setImmutablePrototype=SetImmutablePrototype(self.descriptor,
|
|
failureCode),
|
|
preserveWrapper=preserveWrapper)
|
|
|
|
|
|
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.
|
|
|
|
properties should be a PropertyArrays instance.
|
|
"""
|
|
def __init__(self, descriptor, properties):
|
|
# XXX can we wrap if we don't have an interface prototype object?
|
|
assert descriptor.interface.hasInterfacePrototypeObject()
|
|
args = [Argument('JSContext*', 'aCx'),
|
|
Argument(descriptor.nativeType + '*', 'aObject'),
|
|
Argument('JS::Handle<JSObject*>', 'aGivenProto'),
|
|
Argument('JS::MutableHandle<JSObject*>', 'aReflector')]
|
|
CGAbstractMethod.__init__(self, descriptor, 'Wrap', 'bool', args)
|
|
self.properties = properties
|
|
|
|
def definition_body(self):
|
|
failureCode = "return false;\n"
|
|
|
|
return fill(
|
|
"""
|
|
$*{assertions}
|
|
|
|
JS::Rooted<JSObject*> global(aCx, JS::CurrentGlobalOrNull(aCx));
|
|
$*{declareProto}
|
|
|
|
$*{createObject}
|
|
|
|
$*{unforgeable}
|
|
|
|
$*{slots}
|
|
|
|
$*{setImmutablePrototype}
|
|
creator.InitializationSucceeded();
|
|
return true;
|
|
""",
|
|
assertions=AssertInheritanceChain(self.descriptor),
|
|
declareProto=DeclareProto(),
|
|
createObject=CreateBindingJSObject(self.descriptor, self.properties),
|
|
unforgeable=CopyUnforgeablePropertiesToInstance(self.descriptor,
|
|
failureCode),
|
|
slots=InitMemberSlots(self.descriptor, failureCode),
|
|
setImmutablePrototype=SetImmutablePrototype(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()
|
|
args = [Argument('JSContext*', 'aCx'),
|
|
Argument(descriptor.nativeType + '*', 'aObject'),
|
|
Argument('nsWrapperCache*', 'aCache'),
|
|
Argument('JS::CompartmentOptions&', 'aOptions'),
|
|
Argument('JSPrincipals*', 'aPrincipal'),
|
|
Argument('bool', 'aInitStandardClasses'),
|
|
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::ThreadsafeIsCallerChrome() ? sChromeOnlyNativeProperties.Upcast() : nullptr"
|
|
else:
|
|
chromeProperties = "nullptr"
|
|
|
|
failureCode = dedent(
|
|
"""
|
|
aCache->ReleaseWrapper(aObject);
|
|
aCache->ClearWrapper();
|
|
return false;
|
|
""");
|
|
|
|
if self.descriptor.hasUnforgeableMembers:
|
|
unforgeable = InitUnforgeablePropertiesOnHolder(
|
|
self.descriptor, self.properties, failureCode,
|
|
"aReflector").define();
|
|
else:
|
|
unforgeable = ""
|
|
|
|
return fill(
|
|
"""
|
|
$*{assertions}
|
|
MOZ_ASSERT(ToSupportsIsOnPrimaryInheritanceChain(aObject, aCache),
|
|
"nsISupports must be on our primary inheritance chain");
|
|
|
|
if (!CreateGlobal<${nativeType}, GetProtoObjectHandle>(aCx,
|
|
aObject,
|
|
aCache,
|
|
sClass.ToJSClass(),
|
|
aOptions,
|
|
aPrincipal,
|
|
aInitStandardClasses,
|
|
aReflector)) {
|
|
$*{failureCode}
|
|
}
|
|
|
|
// aReflector is a new global, so has a new compartment. Enter it
|
|
// before doing anything with it.
|
|
JSAutoCompartment ac(aCx, aReflector);
|
|
|
|
if (!DefineProperties(aCx, aReflector, ${properties}, ${chromeProperties})) {
|
|
$*{failureCode}
|
|
}
|
|
$*{unforgeable}
|
|
|
|
$*{slots}
|
|
|
|
return true;
|
|
""",
|
|
assertions=AssertInheritanceChain(self.descriptor),
|
|
nativeType=self.descriptor.nativeType,
|
|
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(
|
|
"""
|
|
|
|
if (!get_${member}(aCx, aWrapper, aObject, args)) {
|
|
return false;
|
|
}
|
|
// Getter handled setting our reserved slots
|
|
""",
|
|
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)
|
|
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 = (
|
|
"JS::Rooted<JS::Value> oldValue(aCx, js::GetReservedSlot(obj, %s));\n" %
|
|
slotIndex)
|
|
regetMember = fill(
|
|
"""
|
|
JS::Rooted<JS::Value> temp(aCx);
|
|
JSJitGetterCallArgs args(&temp);
|
|
JSAutoCompartment ac(aCx, obj);
|
|
if (!get_${name}(aCx, obj, aObject, args)) {
|
|
js::SetReservedSlot(obj, ${slotIndex}, oldValue);
|
|
return false;
|
|
}
|
|
return true;
|
|
""",
|
|
name=self.member.identifier.name,
|
|
slotIndex=slotIndex)
|
|
else:
|
|
declObj = "JSObject* obj;\n"
|
|
noopRetval = ""
|
|
saveMember = ""
|
|
regetMember = ""
|
|
|
|
if self.descriptor.wantsXrays:
|
|
clearXrayExpandoSlots = fill(
|
|
"""
|
|
xpc::ClearXrayExpandoSlots(obj, ${xraySlotIndex});
|
|
""",
|
|
xraySlotIndex=memberXrayExpandoReservedSlot(self.member,
|
|
self.descriptor))
|
|
else :
|
|
clearXrayExpandoSlots = ""
|
|
|
|
return fill(
|
|
"""
|
|
$*{declObj}
|
|
obj = aObject->GetWrapper();
|
|
if (!obj) {
|
|
return${noopRetval};
|
|
}
|
|
$*{saveMember}
|
|
js::SetReservedSlot(obj, ${slotIndex}, JS::UndefinedValue());
|
|
$*{clearXrayExpandoSlots}
|
|
$*{regetMember}
|
|
""",
|
|
declObj=declObj,
|
|
noopRetval=noopRetval,
|
|
saveMember=saveMember,
|
|
slotIndex=slotIndex,
|
|
clearXrayExpandoSlots=clearXrayExpandoSlots,
|
|
regetMember=regetMember)
|
|
|
|
|
|
class CGIsPermittedMethod(CGAbstractMethod):
|
|
"""
|
|
crossOriginGetters/Setters/Methods are sets of names of the relevant members.
|
|
"""
|
|
def __init__(self, descriptor, crossOriginGetters, crossOriginSetters,
|
|
crossOriginMethods):
|
|
self.crossOriginGetters = crossOriginGetters
|
|
self.crossOriginSetters = crossOriginSetters
|
|
self.crossOriginMethods = crossOriginMethods
|
|
args = [Argument("JSFlatString*", "prop"),
|
|
Argument("char16_t", "propFirstChar"),
|
|
Argument("bool", "set")]
|
|
CGAbstractMethod.__init__(self, descriptor, "IsPermitted", "bool", args,
|
|
inline=True)
|
|
|
|
def definition_body(self):
|
|
allNames = self.crossOriginGetters | self.crossOriginSetters | self.crossOriginMethods
|
|
readwrite = self.crossOriginGetters & self.crossOriginSetters
|
|
readonly = (self.crossOriginGetters - self.crossOriginSetters) | self.crossOriginMethods
|
|
writeonly = self.crossOriginSetters - self.crossOriginGetters
|
|
cases = {}
|
|
for name in sorted(allNames):
|
|
cond = 'JS_FlatStringEqualsAscii(prop, "%s")' % name
|
|
if name in readonly:
|
|
cond = "!set && %s" % cond
|
|
elif name in writeonly:
|
|
cond = "set && %s" % cond
|
|
else:
|
|
assert name in readwrite
|
|
firstLetter = name[0]
|
|
case = cases.get(firstLetter, CGList([]))
|
|
case.append(CGGeneric("if (%s) {\n"
|
|
" return true;\n"
|
|
"}\n" % cond))
|
|
cases[firstLetter] = case
|
|
caseList = []
|
|
for firstLetter in sorted(cases.keys()):
|
|
caseList.append(CGCase("'%s'" % firstLetter, cases[firstLetter]))
|
|
switch = CGSwitch("propFirstChar", caseList)
|
|
return switch.define() + "\nreturn false;\n"
|
|
|
|
|
|
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.
|
|
|
|
If allowCrossOriginObj is True, then we'll first do an
|
|
UncheckedUnwrap and then operate on the result.
|
|
"""
|
|
def __init__(self, descriptor, source, mutableSource, target, codeOnFailure,
|
|
exceptionCode=None, isCallbackReturnValue=False,
|
|
allowCrossOriginObj=False):
|
|
self.substitution = {
|
|
"type": descriptor.nativeType,
|
|
"protoID": "prototypes::id::" + descriptor.name,
|
|
"target": target,
|
|
"codeOnFailure": codeOnFailure,
|
|
}
|
|
# Supporting both the "cross origin object" case and the "has
|
|
# XPConnect impls" case at the same time is a pain, so let's
|
|
# not do that. That allows us to assume that our source is
|
|
# always a Handle or MutableHandle.
|
|
if allowCrossOriginObj and descriptor.hasXPConnectImpls:
|
|
raise TypeError("Interface %s both allows a cross-origin 'this' "
|
|
"and has XPConnect impls. We don't support that" %
|
|
descriptor.name)
|
|
if allowCrossOriginObj:
|
|
self.substitution["uncheckedObjDecl"] = fill(
|
|
"""
|
|
JS::Rooted<JSObject*> maybeUncheckedObj(cx, &${source}.toObject());
|
|
""",
|
|
source=source)
|
|
self.substitution["uncheckedObjGet"] = fill(
|
|
"""
|
|
if (xpc::WrapperFactory::IsXrayWrapper(maybeUncheckedObj)) {
|
|
maybeUncheckedObj = js::UncheckedUnwrap(maybeUncheckedObj);
|
|
} else {
|
|
maybeUncheckedObj = js::CheckedUnwrap(maybeUncheckedObj);
|
|
if (!maybeUncheckedObj) {
|
|
$*{codeOnFailure}
|
|
}
|
|
}
|
|
""",
|
|
codeOnFailure=(codeOnFailure % { 'securityError': 'true'}))
|
|
self.substitution["source"] = "maybeUncheckedObj"
|
|
self.substitution["mutableSource"] = "&maybeUncheckedObj"
|
|
# No need to set up xpconnectUnwrap, since it won't be
|
|
# used in the allowCrossOriginObj case.
|
|
else:
|
|
self.substitution["uncheckedObjDecl"] = ""
|
|
self.substitution["uncheckedObjGet"] = ""
|
|
self.substitution["source"] = source
|
|
self.substitution["mutableSource"] = mutableSource
|
|
xpconnectUnwrap = (
|
|
"nsresult rv = UnwrapXPConnect<${type}>(cx, ${mutableSource}, getter_AddRefs(objPtr));\n")
|
|
|
|
if descriptor.hasXPConnectImpls:
|
|
self.substitution["codeOnFailure"] = string.Template(
|
|
"RefPtr<${type}> objPtr;\n" +
|
|
xpconnectUnwrap +
|
|
"if (NS_FAILED(rv)) {\n"
|
|
"${indentedCodeOnFailure}"
|
|
"}\n"
|
|
"// We should have an object\n"
|
|
"MOZ_ASSERT(objPtr);\n"
|
|
"${target} = objPtr;\n"
|
|
).substitute(self.substitution,
|
|
indentedCodeOnFailure=indent(codeOnFailure))
|
|
elif (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;
|
|
if (!GetContentGlobalForJSImplementedObject(cx, Callback(), getter_AddRefs(contentGlobal))) {
|
|
$*{exceptionCode}
|
|
}
|
|
JS::Rooted<JSObject*> jsImplSourceObj(cx, &${source}.toObject());
|
|
${target} = new ${type}(jsImplSourceObj, 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(
|
|
"""
|
|
$*{uncheckedObjDecl}
|
|
{
|
|
$*{uncheckedObjGet}
|
|
nsresult rv = UnwrapObject<${protoID}, ${type}>(${mutableSource}, ${target});
|
|
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,
|
|
'ThrowErrorMessage(cx, MSG_DOES_NOT_IMPLEMENT_INTERFACE, "%s", "%s");\n'
|
|
'%s' % (sourceDescription, descriptor.interface.identifier.name,
|
|
exceptionCode),
|
|
exceptionCode,
|
|
isCallbackReturnValue)
|
|
|
|
|
|
class CGCallbackTempRoot(CGGeneric):
|
|
def __init__(self, name):
|
|
define = dedent("""
|
|
{ // Scope for tempRoot
|
|
JS::Rooted<JSObject*> tempRoot(cx, &${val}.toObject());
|
|
${declName} = new %s(cx, tempRoot, mozilla::dom::GetIncumbentGlobal());
|
|
}
|
|
""") % name
|
|
CGGeneric.__init__(self, define=define)
|
|
|
|
|
|
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 and not isCallbackReturnValue and
|
|
not isOptional)
|
|
if useFastCallback:
|
|
name = "binding_detail::Fast%s" % name
|
|
|
|
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 = indent(CGCallbackTempRoot(name).define())
|
|
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; in particular it does not
|
|
end with a ';'
|
|
"""
|
|
assert (defaultValue.type.isDOMString() or
|
|
defaultValue.type.isUSVString() or
|
|
defaultValue.type.isByteString())
|
|
return ("static const %(char_t)s data[] = { %(data)s };\n"
|
|
"%(method)s(data, ArrayLength(data) - 1)") % {
|
|
'char_t': "char" if defaultValue.type.isByteString() else "char16_t",
|
|
'method': method,
|
|
'data': ", ".join(["'" + char + "'" for char in
|
|
defaultValue.value] + ["0"])
|
|
}
|
|
|
|
|
|
def recordKeyType(recordType):
|
|
assert recordType.keyType.isString()
|
|
if recordType.keyType.isByteString():
|
|
return "nsCString"
|
|
return "nsString"
|
|
|
|
|
|
def recordKeyDeclType(recordType):
|
|
return CGGeneric(recordKeyType(recordType))
|
|
|
|
|
|
# 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,
|
|
treatNullAs="Default",
|
|
isEnforceRange=False,
|
|
isClamp=False,
|
|
isNullOrUndefined=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 know the value
|
|
isObject() and we have no need to recheck that.
|
|
|
|
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", or "OwningUnion" to indicate that the conversion is
|
|
for something that is a dictionary member, a variadic argument, a sequence,
|
|
or an owning union respectively.
|
|
|
|
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 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
|
|
[TreatNonObjectAsNull] 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
|
|
|
|
# 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
|
|
('ThrowErrorMessage(cx, MSG_NOT_OBJECT, "%s");\n'
|
|
'%s' % (firstCap(sourceDescription), exceptionCode)))
|
|
|
|
def onFailureBadType(failureCode, typeName):
|
|
return CGGeneric(
|
|
failureCode or
|
|
('ThrowErrorMessage(cx, MSG_DOES_NOT_IMPLEMENT_INTERFACE, "%s", "%s");\n'
|
|
'%s' % (firstCap(sourceDescription), typeName, exceptionCode)))
|
|
|
|
def onFailureNotCallable(failureCode):
|
|
return CGGeneric(
|
|
failureCode or
|
|
('ThrowErrorMessage(cx, 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
|
|
return (
|
|
"if (${haveValue}) {\n" +
|
|
indent(template) +
|
|
"} else {\n" +
|
|
indent(setDefault) +
|
|
"}\n")
|
|
|
|
# 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:
|
|
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`.
|
|
if not isinstance(descriptorProvider, Descriptor) or descriptorProvider.interface.isJSImplemented():
|
|
templateBody = fill(
|
|
"""
|
|
if (($${passedToJSImpl}) && !CallerSubsumes($${val})) {
|
|
ThrowErrorMessage(cx, MSG_PERMISSION_DENIED_TO_PASS_ARG, "${sourceDescription}");
|
|
$*{exceptionCode}
|
|
}
|
|
""",
|
|
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 is "":
|
|
return 1
|
|
return nestingLevel + 1
|
|
|
|
assert not (isEnforceRange and isClamp) # These are mutually exclusive
|
|
|
|
if type.isSequence():
|
|
assert not isEnforceRange and not isClamp
|
|
|
|
if failureCode is None:
|
|
notSequence = ('ThrowErrorMessage(cx, MSG_NOT_SEQUENCE, "%s");\n'
|
|
"%s" % (firstCap(sourceDescription), 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 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 nullable:
|
|
typeName = CGTemplatedType("Nullable", typeName)
|
|
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}"
|
|
})
|
|
|
|
# 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(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,
|
|
nestingLevel=str(nestingLevel))
|
|
|
|
templateBody = wrapObjectTemplate(templateBody, type,
|
|
"${declName}.SetNull();\n", notSequence)
|
|
if isinstance(defaultValue, IDLEmptySequenceValue):
|
|
if type.nullable():
|
|
codeToSetEmpty = "${declName}.SetValue();\n"
|
|
else:
|
|
codeToSetEmpty = "/* Array is already empty; nothing to do */\n"
|
|
templateBody = handleDefault(templateBody, codeToSetEmpty)
|
|
|
|
# Sequence arguments that might contain traceable things need
|
|
# to get traced
|
|
if not isMember and typeNeedsRooting(elementType):
|
|
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
|
|
else:
|
|
holderType = None
|
|
holderArgs = None
|
|
|
|
return JSToNativeConversionInfo(templateBody, declType=typeName,
|
|
holderType=holderType,
|
|
dealWithOptional=isOptional,
|
|
holderArgs=holderArgs)
|
|
|
|
if type.isRecord():
|
|
assert not isEnforceRange and not isClamp
|
|
if failureCode is None:
|
|
notRecord = ('ThrowErrorMessage(cx, 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 nullable:
|
|
declType = CGTemplatedType("Nullable", declType)
|
|
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.isByteString():
|
|
keyConversionFunction = "ConvertJSValueToByteString"
|
|
hashKeyType = "nsCStringHashKey"
|
|
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::AutoIdVector 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<JS::PropertyDescriptor> desc(cx);
|
|
if (!JS_GetOwnPropertyDescriptorById(cx, recordObj, curId,
|
|
&desc)) {
|
|
$*{exceptionCode}
|
|
}
|
|
|
|
if (!desc.object() /* == undefined in spec terms */ ||
|
|
!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, propName)) {
|
|
$*{exceptionCode}
|
|
}
|
|
|
|
if (!JS_GetPropertyById(cx, recordObj, curId, &temp)) {
|
|
$*{exceptionCode}
|
|
}
|
|
|
|
${typeName}::EntryType* entry;
|
|
if (idsSeen.Contains(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();
|
|
idsSeen.PutEntry(propName);
|
|
}
|
|
entry->mKey = propName;
|
|
${valueType}& slot = entry->mValue;
|
|
$*{valueConversion}
|
|
}
|
|
""",
|
|
exceptionCode=exceptionCode,
|
|
recordRef=recordRef,
|
|
hashKeyType=hashKeyType,
|
|
keyType=keyType,
|
|
keyConversionFunction=keyConversionFunction,
|
|
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 not isMember and typeNeedsRooting(valueType):
|
|
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
|
|
|
|
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 or isCallbackReturnValue
|
|
unionArgumentObj = "${declName}" if isOwningUnion else "${holderName}"
|
|
if nullable:
|
|
# 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()" if isOwningUnion else ".ref()"
|
|
|
|
memberTypes = type.flatMemberTypes
|
|
names = []
|
|
|
|
interfaceMemberTypes = filter(lambda t: t.isNonCallbackInterface(), memberTypes)
|
|
if len(interfaceMemberTypes) > 0:
|
|
interfaceObject = []
|
|
for memberType in interfaceMemberTypes:
|
|
name = getUnionMemberName(memberType)
|
|
interfaceObject.append(
|
|
CGGeneric("(failed = !%s.TrySetTo%s(cx, ${val}, tryNext, ${passedToJSImpl})) || !tryNext" %
|
|
(unionArgumentObj, name)))
|
|
names.append(name)
|
|
interfaceObject = CGWrapper(CGList(interfaceObject, " ||\n"),
|
|
pre="done = ", post=";\n\n", reindent=True)
|
|
else:
|
|
interfaceObject = None
|
|
|
|
sequenceObjectMemberTypes = filter(lambda t: t.isSequence(), memberTypes)
|
|
if len(sequenceObjectMemberTypes) > 0:
|
|
assert len(sequenceObjectMemberTypes) == 1
|
|
name = getUnionMemberName(sequenceObjectMemberTypes[0])
|
|
sequenceObject = CGGeneric(
|
|
"done = (failed = !%s.TrySetTo%s(cx, ${val}, tryNext, ${passedToJSImpl})) || !tryNext;\n" %
|
|
(unionArgumentObj, name))
|
|
names.append(name)
|
|
else:
|
|
sequenceObject = None
|
|
|
|
dateObjectMemberTypes = filter(lambda t: t.isDate(), memberTypes)
|
|
if len(dateObjectMemberTypes) > 0:
|
|
assert len(dateObjectMemberTypes) == 1
|
|
memberType = dateObjectMemberTypes[0]
|
|
name = getUnionMemberName(memberType)
|
|
dateObject = CGGeneric("%s.SetTo%s(cx, ${val});\n"
|
|
"done = true;\n" % (unionArgumentObj, name))
|
|
dateObject = CGIfWrapper(dateObject, "JS_ObjectIsDate(cx, argObj)")
|
|
names.append(name)
|
|
else:
|
|
dateObject = None
|
|
|
|
callbackMemberTypes = filter(lambda t: t.isCallback() or t.isCallbackInterface(), memberTypes)
|
|
if len(callbackMemberTypes) > 0:
|
|
assert len(callbackMemberTypes) == 1
|
|
memberType = callbackMemberTypes[0]
|
|
name = getUnionMemberName(memberType)
|
|
callbackObject = CGGeneric(
|
|
"done = (failed = !%s.TrySetTo%s(cx, ${val}, tryNext, ${passedToJSImpl})) || !tryNext;\n" %
|
|
(unionArgumentObj, name))
|
|
names.append(name)
|
|
else:
|
|
callbackObject = None
|
|
|
|
dictionaryMemberTypes = filter(lambda t: t.isDictionary(), memberTypes)
|
|
if len(dictionaryMemberTypes) > 0:
|
|
assert len(dictionaryMemberTypes) == 1
|
|
name = getUnionMemberName(dictionaryMemberTypes[0])
|
|
setDictionary = CGGeneric(
|
|
"done = (failed = !%s.TrySetTo%s(cx, ${val}, tryNext, ${passedToJSImpl})) || !tryNext;\n" %
|
|
(unionArgumentObj, name))
|
|
names.append(name)
|
|
else:
|
|
setDictionary = None
|
|
|
|
recordMemberTypes = filter(lambda t: t.isRecord(), memberTypes)
|
|
if len(recordMemberTypes) > 0:
|
|
assert len(recordMemberTypes) == 1
|
|
name = getUnionMemberName(recordMemberTypes[0])
|
|
recordObject = CGGeneric(
|
|
"done = (failed = !%s.TrySetTo%s(cx, ${val}, tryNext, ${passedToJSImpl})) || !tryNext;\n" %
|
|
(unionArgumentObj, name))
|
|
names.append(name)
|
|
else:
|
|
recordObject = None
|
|
|
|
objectMemberTypes = filter(lambda t: t.isObject(), memberTypes)
|
|
if len(objectMemberTypes) > 0:
|
|
assert len(objectMemberTypes) == 1
|
|
# Very important to NOT construct a temporary Rooted here, since the
|
|
# SetToObject call can call a Rooted constructor and we need to keep
|
|
# stack discipline for Rooted.
|
|
object = CGGeneric("if (!%s.SetToObject(cx, &${val}.toObject(), ${passedToJSImpl})) {\n"
|
|
"%s"
|
|
"}\n"
|
|
"done = true;\n" % (unionArgumentObj, indent(exceptionCode)))
|
|
names.append(objectMemberTypes[0].name)
|
|
else:
|
|
object = None
|
|
|
|
hasObjectTypes = interfaceObject or sequenceObject or dateObject or callbackObject or object or recordObject
|
|
if hasObjectTypes:
|
|
# "object" is not distinguishable from other types
|
|
assert not object or not (interfaceObject or sequenceObject or dateObject or callbackObject or recordObject)
|
|
if sequenceObject or dateObject or callbackObject:
|
|
# An object can be both an sequence object and a callback or
|
|
# dictionary, but we shouldn't have both in the union's members
|
|
# because they are not distinguishable.
|
|
assert not (sequenceObject and callbackObject)
|
|
templateBody = CGElseChain([sequenceObject, dateObject, callbackObject])
|
|
else:
|
|
templateBody = None
|
|
if interfaceObject:
|
|
assert not object
|
|
if templateBody:
|
|
templateBody = CGIfWrapper(templateBody, "!done")
|
|
templateBody = CGList([interfaceObject, templateBody])
|
|
else:
|
|
templateBody = CGList([templateBody, object])
|
|
|
|
if dateObject:
|
|
templateBody.prepend(CGGeneric("JS::Rooted<JSObject*> argObj(cx, &${val}.toObject());\n"))
|
|
|
|
if recordObject:
|
|
templateBody = CGList([templateBody,
|
|
CGIfWrapper(recordObject, "!done")])
|
|
|
|
templateBody = CGIfWrapper(templateBody, "${val}.isObject()")
|
|
else:
|
|
templateBody = CGGeneric()
|
|
|
|
if setDictionary:
|
|
assert not object
|
|
templateBody = CGList([templateBody,
|
|
CGIfWrapper(setDictionary, "!done")])
|
|
|
|
stringTypes = [t for t in memberTypes if t.isString() or t.isEnum()]
|
|
numericTypes = [t for t in memberTypes if t.isNumeric()]
|
|
booleanTypes = [t for t in memberTypes if t.isBoolean()]
|
|
if stringTypes or numericTypes or booleanTypes:
|
|
assert len(stringTypes) <= 1
|
|
assert len(numericTypes) <= 1
|
|
assert len(booleanTypes) <= 1
|
|
|
|
# We will wrap all this stuff in a do { } while (0); so we
|
|
# can use "break" for flow control.
|
|
def getStringOrPrimitiveConversion(memberType):
|
|
name = getUnionMemberName(memberType)
|
|
return CGGeneric("done = (failed = !%s.TrySetTo%s(cx, ${val}, tryNext)) || !tryNext;\n"
|
|
"break;\n" % (unionArgumentObj, name))
|
|
other = CGList([])
|
|
stringConversion = map(getStringOrPrimitiveConversion, stringTypes)
|
|
numericConversion = map(getStringOrPrimitiveConversion, numericTypes)
|
|
booleanConversion = map(getStringOrPrimitiveConversion, booleanTypes)
|
|
if stringConversion:
|
|
if booleanConversion:
|
|
other.append(CGIfWrapper(booleanConversion[0],
|
|
"${val}.isBoolean()"))
|
|
if numericConversion:
|
|
other.append(CGIfWrapper(numericConversion[0],
|
|
"${val}.isNumber()"))
|
|
other.append(stringConversion[0])
|
|
elif numericConversion:
|
|
if booleanConversion:
|
|
other.append(CGIfWrapper(booleanConversion[0],
|
|
"${val}.isBoolean()"))
|
|
other.append(numericConversion[0])
|
|
else:
|
|
assert booleanConversion
|
|
other.append(booleanConversion[0])
|
|
|
|
other = CGWrapper(CGIndenter(other), pre="do {\n", post="} while (0);\n")
|
|
if hasObjectTypes or setDictionary:
|
|
other = CGWrapper(CGIndenter(other), "{\n", post="}\n")
|
|
if object:
|
|
templateBody = CGElseChain([templateBody, other])
|
|
else:
|
|
other = CGWrapper(other, pre="if (!done) ")
|
|
templateBody = CGList([templateBody, other])
|
|
else:
|
|
assert templateBody.define() == ""
|
|
templateBody = other
|
|
else:
|
|
other = None
|
|
|
|
templateBody = CGWrapper(templateBody, pre="bool done = false, failed = false, tryNext;\n")
|
|
throw = CGGeneric(fill(
|
|
"""
|
|
if (failed) {
|
|
$*{exceptionCode}
|
|
}
|
|
if (!done) {
|
|
ThrowErrorMessage(cx, MSG_NOT_IN_UNION, "${desc}", "${names}");
|
|
$*{exceptionCode}
|
|
}
|
|
""",
|
|
exceptionCode=exceptionCode,
|
|
desc=firstCap(sourceDescription),
|
|
names=", ".join(names)))
|
|
|
|
templateBody = CGWrapper(CGIndenter(CGList([templateBody, throw])), pre="{\n", post="}\n")
|
|
|
|
typeName = CGUnionStruct.unionTypeDecl(type, isOwningUnion)
|
|
argumentTypeName = typeName + "Argument"
|
|
if nullable:
|
|
typeName = "Nullable<" + typeName + " >"
|
|
|
|
def handleNull(templateBody, setToNullVar, extraConditionForNull=""):
|
|
nullTest = "%s${val}.isNullOrUndefined()" % extraConditionForNull
|
|
return CGIfElseWrapper(nullTest,
|
|
CGGeneric("%s.SetNull();\n" % setToNullVar),
|
|
templateBody)
|
|
|
|
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
|
|
extraConditionForNull = "!(${haveValue}) || "
|
|
else:
|
|
extraConditionForNull = ""
|
|
templateBody = handleNull(templateBody, unionArgumentObj,
|
|
extraConditionForNull=extraConditionForNull)
|
|
|
|
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:
|
|
holderArgs = "${declName}.Value().SetValue()"
|
|
declType = CGTemplatedType("Optional", declType)
|
|
constructDecl = CGGeneric("${declName}.Construct();\n")
|
|
declLoc = "${declName}.Value()"
|
|
else:
|
|
holderArgs = "${declName}.SetValue()"
|
|
if holderType is not None:
|
|
constructHolder = CGGeneric("${holderName}.emplace(%s);\n" % holderArgs)
|
|
else:
|
|
constructHolder = None
|
|
# Don't need to pass those args when the holder is being constructed
|
|
holderArgs = None
|
|
else:
|
|
holderArgs = "${declName}"
|
|
constructHolder = None
|
|
|
|
if not isMember and isCallbackReturnValue:
|
|
declType = CGWrapper(declType, post="&")
|
|
declArgs = "aRetVal"
|
|
else:
|
|
declArgs = None
|
|
|
|
if defaultValue and not isinstance(defaultValue, IDLNullValue):
|
|
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 "")
|
|
# It's enough to set us to the right type; that will
|
|
# create an empty array, which is all we need here.
|
|
default = CGGeneric("%s.RawSetAs%s();\n" %
|
|
(value, name))
|
|
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.SetStringData" % unionArgumentObj) +
|
|
";\n")
|
|
|
|
templateBody = CGIfElseWrapper("!(${haveValue})", default, templateBody)
|
|
|
|
templateBody = CGList([constructHolder, templateBody])
|
|
|
|
if nullable:
|
|
if defaultValue:
|
|
if isinstance(defaultValue, IDLNullValue):
|
|
extraConditionForNull = "!(${haveValue}) || "
|
|
else:
|
|
extraConditionForNull = "(${haveValue}) && "
|
|
else:
|
|
extraConditionForNull = ""
|
|
templateBody = handleNull(templateBody, declLoc,
|
|
extraConditionForNull=extraConditionForNull)
|
|
elif (not type.hasNullableType and defaultValue and
|
|
isinstance(defaultValue, IDLNullValue)):
|
|
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)))
|
|
templateBody = CGIfElseWrapper("!(${haveValue})",
|
|
initDictionaryWithNull,
|
|
templateBody)
|
|
|
|
templateBody = CGList([constructDecl, templateBody])
|
|
|
|
return JSToNativeConversionInfo(templateBody.define(),
|
|
declType=declType,
|
|
declArgs=declArgs,
|
|
holderType=holderType,
|
|
holderArgs=holderArgs,
|
|
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. CheckedUnwrap 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>(NS_LITERAL_STRING("${sourceDescription}"));
|
|
return nullptr;
|
|
}
|
|
JSObject* unwrappedVal = js::CheckedUnwrap(&$${val}.toObject());
|
|
if (!unwrappedVal) {
|
|
// A slight lie, but not much of one, for a dead object wrapper.
|
|
aRv.ThrowTypeError<MSG_NOT_OBJECT>(NS_LITERAL_STRING("${sourceDescription}"));
|
|
return nullptr;
|
|
}
|
|
globalObj = js::GetGlobalForObjectCrossCompartment(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 = ""
|
|
|
|
templateBody = fill(
|
|
"""
|
|
{ // Scope for our GlobalObject, FastErrorResult, JSAutoCompartment,
|
|
// etc.
|
|
|
|
JS::Rooted<JSObject*> globalObj(cx, JS::CurrentGlobalOrNull(cx));
|
|
$*{getPromiseGlobal}
|
|
JSAutoCompartment ac(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);
|
|
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
|
|
|
|
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)
|
|
|
|
# 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 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 += 'static_assert(IsRefcounted<%s>::value, "We can only store refcounted classes.");' % typeName
|
|
|
|
if (not descriptor.interface.isConsequential() and
|
|
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:
|
|
# Either external, or new-binding non-castable. 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 + ">(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
|
|
arrayType = CGGeneric(name)
|
|
declType = arrayType
|
|
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())
|
|
template = wrapObjectTemplate(template, type, "${declName}.SetNull();\n",
|
|
failureCode)
|
|
if not isMember:
|
|
# 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<RootedTypedArray<ArrayType> >. So do a holder if we're
|
|
# optional and use a RootedTypedArray otherwise.
|
|
if isOptional:
|
|
holderType = CGTemplatedType("TypedArrayRooter", arrayType)
|
|
# If our typed array 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("RootedTypedArray", 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.isDOMString() or type.isUSVString():
|
|
assert not isEnforceRange and not isClamp
|
|
|
|
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"
|
|
nullBehavior = treatAs[treatNullAs]
|
|
|
|
def getConversionCode(varName):
|
|
normalizeCode = ""
|
|
if type.isUSVString():
|
|
normalizeCode = "NormalizeUSVString(%s);\n" % varName
|
|
|
|
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)" % varName
|
|
else:
|
|
defaultCode = handleDefaultStringValue(defaultValue,
|
|
"%s.Rebind" % varName)
|
|
return handleDefault(conversionCode, defaultCode + ";\n")
|
|
|
|
if isMember:
|
|
# Convert directly into the nsString member we have.
|
|
declType = CGGeneric("nsString")
|
|
return JSToNativeConversionInfo(
|
|
getConversionCode("${declName}"),
|
|
declType=declType,
|
|
dealWithOptional=isOptional)
|
|
|
|
if isOptional:
|
|
declType = "Optional<nsAString>"
|
|
holderType = CGGeneric("binding_detail::FakeString")
|
|
conversionCode = ("%s"
|
|
"${declName} = &${holderName};\n" %
|
|
getConversionCode("${holderName}"))
|
|
else:
|
|
declType = "binding_detail::FakeString"
|
|
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
|
|
|
|
nullable = toStringBool(type.nullable())
|
|
|
|
conversionCode = fill("""
|
|
if (!ConvertJSValueToByteString(cx, $${val}, ${nullable}, $${declName})) {
|
|
$*{exceptionCode}
|
|
}
|
|
""",
|
|
nullable=nullable,
|
|
exceptionCode=exceptionCode)
|
|
|
|
if defaultValue is not None:
|
|
if isinstance(defaultValue, IDLNullValue):
|
|
assert(type.nullable())
|
|
defaultCode = "${declName}.SetIsVoid(true)"
|
|
else:
|
|
defaultCode = handleDefaultStringValue(defaultValue,
|
|
"${declName}.Rebind")
|
|
conversionCode = handleDefault(conversionCode, defaultCode + ";\n")
|
|
|
|
return JSToNativeConversionInfo(
|
|
conversionCode,
|
|
declType=CGGeneric("nsCString"),
|
|
dealWithOptional=isOptional)
|
|
|
|
if type.isEnum():
|
|
assert not isEnforceRange and not isClamp
|
|
|
|
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 (!FindEnumStringIndex<${invalidEnumValueFatal}>(cx, $${val}, ${values}, "${enumtype}", "${sourceDescription}", &index)) {
|
|
$*{exceptionCode}
|
|
}
|
|
$*{handleInvalidEnumValueCode}
|
|
${enumLoc} = static_cast<${enumtype}>(index);
|
|
}
|
|
""",
|
|
enumtype=enumName,
|
|
values=enumName + "Values::" + ENUM_ENTRY_VARIABLE_NAME,
|
|
invalidEnumValueFatal=toStringBool(invalidEnumValueFatal),
|
|
handleInvalidEnumValueCode=handleInvalidEnumValueCode,
|
|
exceptionCode=exceptionCode,
|
|
enumLoc=enumLoc,
|
|
sourceDescription=firstCap(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
|
|
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
|
|
|
|
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`.
|
|
if not isinstance(descriptorProvider, Descriptor) or descriptorProvider.interface.isJSImplemented():
|
|
templateBody = fill(
|
|
"""
|
|
if (($${passedToJSImpl}) && !CallerSubsumes($${val})) {
|
|
ThrowErrorMessage(cx, MSG_PERMISSION_DENIED_TO_PASS_ARG, "${sourceDescription}");
|
|
$*{exceptionCode}
|
|
}
|
|
""",
|
|
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
|
|
return handleJSObjectType(type, isMember, failureCode, exceptionCode, sourceDescription)
|
|
|
|
if type.isDictionary():
|
|
# There are no nullable dictionary arguments or dictionary members
|
|
assert(not type.nullable() or isCallbackReturnValue or
|
|
(isMember and isMember != "Dictionary"))
|
|
# All optional dictionaries always have default values, so we
|
|
# should be able to assume not isOptional here.
|
|
assert not isOptional
|
|
# 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 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 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, IDLNullValue))
|
|
val = "(${haveValue}) ? ${val} : JS::NullHandleValue"
|
|
else:
|
|
val = "${val}"
|
|
|
|
dictLoc = "${declName}"
|
|
if type.nullable():
|
|
dictLoc += ".SetValue()"
|
|
|
|
conversionCode = fill("""
|
|
if (!${dictLoc}.Init(cx, ${val}, "${desc}", $${passedToJSImpl})) {
|
|
$*{exceptionCode}
|
|
}
|
|
""",
|
|
dictLoc=dictLoc,
|
|
val=val,
|
|
desc=firstCap(sourceDescription),
|
|
exceptionCode=exceptionCode)
|
|
|
|
if failureCode is not None:
|
|
if isDefinitelyObject:
|
|
dictionaryTest = "IsObjectValueConvertibleToDictionary"
|
|
else:
|
|
dictionaryTest = "IsConvertibleToDictionary"
|
|
|
|
template = fill("""
|
|
{ // scope for isConvertible
|
|
bool isConvertible;
|
|
if (!${testConvertible}(cx, ${val}, &isConvertible)) {
|
|
$*{exceptionCode}
|
|
}
|
|
if (!isConvertible) {
|
|
$*{failureCode}
|
|
}
|
|
|
|
$*{conversionCode}
|
|
}
|
|
|
|
""",
|
|
testConvertible=dictionaryTest,
|
|
val=val,
|
|
exceptionCode=exceptionCode,
|
|
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 and isCallbackReturnValue:
|
|
# Go ahead and just convert directly into our actual return value
|
|
declType = CGWrapper(declType, post="&")
|
|
declArgs = "aRetVal"
|
|
elif not isMember and typeNeedsRooting(type):
|
|
declType = CGTemplatedType("RootedDictionary", declType)
|
|
declArgs = "cx"
|
|
else:
|
|
declArgs = None
|
|
|
|
return JSToNativeConversionInfo(template, declType=declType,
|
|
declArgs=declArgs)
|
|
|
|
if type.isVoid():
|
|
assert not isOptional
|
|
# This one only happens for return values, and its easy: Just
|
|
# ignore the jsval.
|
|
return JSToNativeConversionInfo("")
|
|
|
|
if type.isDate():
|
|
assert not isEnforceRange and not isClamp
|
|
|
|
declType = CGGeneric("Date")
|
|
if type.nullable():
|
|
declType = CGTemplatedType("Nullable", declType)
|
|
dateVal = "${declName}.SetValue()"
|
|
else:
|
|
dateVal = "${declName}"
|
|
|
|
if failureCode is None:
|
|
notDate = ('ThrowErrorMessage(cx, MSG_NOT_DATE, "%s");\n'
|
|
"%s" % (firstCap(sourceDescription), exceptionCode))
|
|
else:
|
|
notDate = failureCode
|
|
|
|
conversion = fill(
|
|
"""
|
|
JS::Rooted<JSObject*> possibleDateObject(cx, &$${val}.toObject());
|
|
{ // scope for isDate
|
|
bool isDate;
|
|
if (!JS_ObjectIsDate(cx, possibleDateObject, &isDate)) {
|
|
$*{exceptionCode}
|
|
}
|
|
if (!isDate) {
|
|
$*{notDate}
|
|
}
|
|
if (!${dateVal}.SetTimeStamp(cx, possibleDateObject)) {
|
|
$*{exceptionCode}
|
|
}
|
|
}
|
|
""",
|
|
exceptionCode=exceptionCode,
|
|
dateVal=dateVal,
|
|
notDate=notDate)
|
|
|
|
conversion = wrapObjectTemplate(conversion, type,
|
|
"${declName}.SetNull();\n", notDate)
|
|
return JSToNativeConversionInfo(conversion,
|
|
declType=declType,
|
|
dealWithOptional=isOptional)
|
|
|
|
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"
|
|
|
|
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
|
|
template = fill("""
|
|
if (${nullCondition}) {
|
|
$${declName}.SetNull();
|
|
} else if (!ValueToPrimitive<${typeName}, ${conversionBehavior}>(cx, $${val}, &${writeLoc})) {
|
|
$*{exceptionCode}
|
|
}
|
|
""",
|
|
nullCondition=nullCondition,
|
|
typeName=typeName,
|
|
conversionBehavior=conversionBehavior,
|
|
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}, &${writeLoc})) {
|
|
$*{exceptionCode}
|
|
}
|
|
""",
|
|
typeName=typeName,
|
|
conversionBehavior=conversionBehavior,
|
|
writeLoc=writeLoc,
|
|
exceptionCode=exceptionCode)
|
|
declType = CGGeneric(typeName)
|
|
|
|
if type.isFloat() and not type.isUnrestricted():
|
|
if lenientFloatCode is not None:
|
|
nonFiniteCode = lenientFloatCode
|
|
else:
|
|
nonFiniteCode = ('ThrowErrorMessage(cx, 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 (!mozilla::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 = CGIfElseWrapper(
|
|
"${haveValue}",
|
|
CGGeneric(template),
|
|
CGGeneric("%s = %s;\n" % (writeLoc, defaultStr))).define()
|
|
|
|
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
|
|
holderConstruct = None
|
|
|
|
conversion = CGList([
|
|
CGGeneric(
|
|
string.Template("if (${haveValue}) {\n").substitute(replacements)),
|
|
declConstruct,
|
|
holderConstruct,
|
|
CGIndenter(conversion),
|
|
CGGeneric("}\n")
|
|
])
|
|
|
|
result.append(conversion)
|
|
return result
|
|
|
|
|
|
def convertConstIDLValueToJSVal(value):
|
|
if isinstance(value, IDLNullValue):
|
|
return "JS::NullValue()"
|
|
if isinstance(value, IDLUndefinedValue):
|
|
return "JS::UndefinedValue()"
|
|
tag = value.type.tag()
|
|
if tag in [IDLType.Tags.int8, IDLType.Tags.uint8, IDLType.Tags.int16,
|
|
IDLType.Tags.uint16, IDLType.Tags.int32]:
|
|
return "JS::Int32Value(%s)" % (value.value)
|
|
if tag == IDLType.Tags.uint32:
|
|
return "JS::NumberValue(%sU)" % (value.value)
|
|
if tag in [IDLType.Tags.int64, IDLType.Tags.uint64]:
|
|
return "JS::CanonicalizedDoubleValue(%s)" % numericValue(tag, value.value)
|
|
if tag == IDLType.Tags.bool:
|
|
return "JS::BooleanValue(true)" if value.value else "JS::BooleanValue(false)"
|
|
if tag in [IDLType.Tags.float, IDLType.Tags.double]:
|
|
return "JS::CanonicalizedDoubleValue(%s)" % (value.value)
|
|
raise TypeError("Const value of unhandled type: %s" % value.type)
|
|
|
|
|
|
class CGArgumentConverter(CGThing):
|
|
"""
|
|
A class that takes an IDL argument object and its index in the
|
|
argument list and generates code to unwrap the argument to the
|
|
right native type.
|
|
|
|
argDescription is a description of the argument for error-reporting
|
|
purposes. 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.
|
|
"""
|
|
def __init__(self, argument, index, descriptorProvider,
|
|
argDescription, member,
|
|
invalidEnumValueFatal=True, lenientFloatCode=None):
|
|
CGThing.__init__(self)
|
|
self.argument = argument
|
|
self.argDescription = argDescription
|
|
assert(not argument.defaultValue or argument.optional)
|
|
|
|
replacer = {
|
|
"index": index,
|
|
"argc": "args.length()"
|
|
}
|
|
self.replacementVariables = {
|
|
"declName": "arg%d" % index,
|
|
"holderName": ("arg%d" % index) + "_holder",
|
|
"obj": "obj",
|
|
"passedToJSImpl": toStringBool(isJSImplementedDescriptor(descriptorProvider))
|
|
}
|
|
# If we have a method generated by the maplike/setlike portion of an
|
|
# interface, arguments can possibly be undefined, but will need to be
|
|
# converted to the key/value type of the backing object. In this case,
|
|
# use .get() instead of direct access to the argument. This won't
|
|
# matter for iterable since generated functions for those interface
|
|
# don't take arguments.
|
|
if member.isMethod() and member.isMaplikeOrSetlikeOrIterableMethod():
|
|
self.replacementVariables["val"] = string.Template(
|
|
"args.get(${index})").substitute(replacer)
|
|
self.replacementVariables["maybeMutableVal"] = string.Template(
|
|
"args[${index}]").substitute(replacer)
|
|
else:
|
|
self.replacementVariables["val"] = string.Template(
|
|
"args[${index}]").substitute(replacer)
|
|
haveValueCheck = string.Template(
|
|
"args.hasDefined(${index})").substitute(replacer)
|
|
self.replacementVariables["haveValue"] = haveValueCheck
|
|
self.descriptorProvider = descriptorProvider
|
|
if self.argument.canHaveMissingValue():
|
|
self.argcAndIndex = replacer
|
|
else:
|
|
self.argcAndIndex = None
|
|
self.invalidEnumValueFatal = invalidEnumValueFatal
|
|
self.lenientFloatCode = lenientFloatCode
|
|
|
|
def define(self):
|
|
typeConversion = getJSToNativeConversionInfo(
|
|
self.argument.type,
|
|
self.descriptorProvider,
|
|
isOptional=(self.argcAndIndex is not None and
|
|
not self.argument.variadic),
|
|
invalidEnumValueFatal=self.invalidEnumValueFatal,
|
|
defaultValue=self.argument.defaultValue,
|
|
treatNullAs=self.argument.treatNullAs,
|
|
isEnforceRange=self.argument.enforceRange,
|
|
isClamp=self.argument.clamp,
|
|
lenientFloatCode=self.lenientFloatCode,
|
|
isMember="Variadic" if self.argument.variadic else False,
|
|
allowTreatNonCallableAsNull=self.argument.allowTreatNonCallableAsNull(),
|
|
sourceDescription=self.argDescription)
|
|
|
|
if not self.argument.variadic:
|
|
return instantiateJSToNativeConversion(
|
|
typeConversion,
|
|
self.replacementVariables,
|
|
self.argcAndIndex is not None).define()
|
|
|
|
# Variadic arguments get turned into a sequence.
|
|
if typeConversion.dealWithOptional:
|
|
raise TypeError("Shouldn't have optional things in variadics")
|
|
if typeConversion.holderType is not None:
|
|
raise TypeError("Shouldn't need holders for variadics")
|
|
|
|
replacer = dict(self.argcAndIndex, **self.replacementVariables)
|
|
replacer["seqType"] = CGTemplatedType("binding_detail::AutoSequence",
|
|
typeConversion.declType).define()
|
|
if typeNeedsRooting(self.argument.type):
|
|
rooterDecl = ("SequenceRooter<%s> ${holderName}(cx, &${declName});\n" %
|
|
typeConversion.declType.define())
|
|
else:
|
|
rooterDecl = ""
|
|
replacer["elemType"] = typeConversion.declType.define()
|
|
|
|
# NOTE: Keep this in sync with sequence conversions as needed
|
|
variadicConversion = string.Template(
|
|
"${seqType} ${declName};\n" +
|
|
rooterDecl +
|
|
dedent("""
|
|
if (${argc} > ${index}) {
|
|
if (!${declName}.SetCapacity(${argc} - ${index}, mozilla::fallible)) {
|
|
JS_ReportOutOfMemory(cx);
|
|
return false;
|
|
}
|
|
for (uint32_t variadicArg = ${index}; variadicArg < ${argc}; ++variadicArg) {
|
|
${elemType}& slot = *${declName}.AppendElement(mozilla::fallible);
|
|
""")
|
|
).substitute(replacer)
|
|
|
|
val = string.Template("args[variadicArg]").substitute(replacer)
|
|
variadicConversion += indent(
|
|
string.Template(typeConversion.template).substitute({
|
|
"val": val,
|
|
"maybeMutableVal": val,
|
|
"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",
|
|
# Use the same ${obj} as for the variadic arg itself
|
|
"obj": replacer["obj"],
|
|
"passedToJSImpl": toStringBool(isJSImplementedDescriptor(self.descriptorProvider))
|
|
}), 4)
|
|
|
|
variadicConversion += (" }\n"
|
|
"}\n")
|
|
return variadicConversion
|
|
|
|
|
|
def getMaybeWrapValueFuncForType(type):
|
|
# Callbacks might actually be DOM objects; nothing prevents a page from
|
|
# doing that.
|
|
if type.isCallback() or type.isCallbackInterface() or type.isObject():
|
|
if type.nullable():
|
|
return "MaybeWrapObjectOrNullValue"
|
|
return "MaybeWrapObjectValue"
|
|
# Spidermonkey interfaces are never DOM objects. Neither are sequences or
|
|
# dictionaries, since those are always plain JS objects.
|
|
if type.isSpiderMonkeyInterface() or type.isDictionary() or type.isSequence():
|
|
if type.nullable():
|
|
return "MaybeWrapNonDOMObjectOrNullValue"
|
|
return "MaybeWrapNonDOMObjectValue"
|
|
if type.isAny():
|
|
return "MaybeWrapValue"
|
|
|
|
# For other types, just go ahead an fall back on MaybeWrapValue for now:
|
|
# it's always safe to do, and shouldn't be particularly slow for any of
|
|
# them
|
|
return "MaybeWrapValue"
|
|
|
|
|
|
sequenceWrapLevel = 0
|
|
recordWrapLevel = 0
|
|
|
|
|
|
def getWrapTemplateForType(type, descriptorProvider, result, successCode,
|
|
returnsNewObject, exceptionCode, typedArraysAreStructs,
|
|
isConstructorRetval=False):
|
|
"""
|
|
Reflect a C++ value stored in "result", of IDL type "type" into JS. The
|
|
"successCode" is the code to run once we have successfully done the
|
|
conversion and must guarantee that execution of the conversion template
|
|
stops once the successCode has executed (e.g. by doing a 'return', or by
|
|
doing a 'break' if the entire conversion template is inside a block that
|
|
the 'break' will exit).
|
|
|
|
If typedArraysAreStructs is true, then if the type is a typed array,
|
|
"result" is one of the dom::TypedArray subclasses, not a JSObject*.
|
|
|
|
The resulting string should be used with string.Template. It
|
|
needs the following keys when substituting:
|
|
|
|
jsvalHandle: something that can be passed to methods taking a
|
|
JS::MutableHandle<JS::Value>. This can be a
|
|
JS::MutableHandle<JS::Value> or a JS::Rooted<JS::Value>*.
|
|
jsvalRef: something that can have .address() called on it to get a
|
|
JS::Value* and .set() called on it to set it to a JS::Value.
|
|
This can be a JS::MutableHandle<JS::Value> or a
|
|
JS::Rooted<JS::Value>.
|
|
obj: a JS::Handle<JSObject*>.
|
|
|
|
Returns (templateString, infallibility of conversion template)
|
|
"""
|
|
if successCode is None:
|
|
successCode = "return true;\n"
|
|
|
|
def setUndefined():
|
|
return _setValue("", setter="setUndefined")
|
|
|
|
def setNull():
|
|
return _setValue("", setter="setNull")
|
|
|
|
def setInt32(value):
|
|
return _setValue(value, setter="setInt32")
|
|
|
|
def setString(value):
|
|
return _setValue(value, setter="setString")
|
|
|
|
def setObject(value, wrapAsType=None):
|
|
return _setValue(value, wrapAsType=wrapAsType, setter="setObject")
|
|
|
|
def setObjectOrNull(value, wrapAsType=None):
|
|
return _setValue(value, wrapAsType=wrapAsType, setter="setObjectOrNull")
|
|
|
|
def setUint32(value):
|
|
return _setValue(value, setter="setNumber")
|
|
|
|
def setDouble(value):
|
|
return _setValue("JS_NumberValue(%s)" % value)
|
|
|
|
def setBoolean(value):
|
|
return _setValue(value, setter="setBoolean")
|
|
|
|
def _setValue(value, wrapAsType=None, setter="set"):
|
|
"""
|
|
Returns the code to set the jsval to value.
|
|
|
|
If wrapAsType is not None, then will wrap the resulting value using the
|
|
function that getMaybeWrapValueFuncForType(wrapAsType) returns.
|
|
Otherwise, no wrapping will be done.
|
|
"""
|
|
if wrapAsType is None:
|
|
tail = successCode
|
|
else:
|
|
tail = fill(
|
|
"""
|
|
if (!${maybeWrap}(cx, $${jsvalHandle})) {
|
|
$*{exceptionCode}
|
|
}
|
|
$*{successCode}
|
|
""",
|
|
maybeWrap=getMaybeWrapValueFuncForType(wrapAsType),
|
|
exceptionCode=exceptionCode,
|
|
successCode=successCode)
|
|
return ("${jsvalRef}.%s(%s);\n" % (setter, value)) + tail
|
|
|
|
def wrapAndSetPtr(wrapCall, failureCode=None):
|
|
"""
|
|
Returns the code to set the jsval by calling "wrapCall". "failureCode"
|
|
is the code to run if calling "wrapCall" fails
|
|
"""
|
|
if failureCode is None:
|
|
failureCode = exceptionCode
|
|
return fill(
|
|
"""
|
|
if (!${wrapCall}) {
|
|
$*{failureCode}
|
|
}
|
|
$*{successCode}
|
|
""",
|
|
wrapCall=wrapCall,
|
|
failureCode=failureCode,
|
|
successCode=successCode)
|
|
|
|
if type is None or type.isVoid():
|
|
return (setUndefined(), True)
|
|
|
|
if (type.isSequence() or type.isRecord()) and type.nullable():
|
|
# These are both wrapped in Nullable<>
|
|
recTemplate, recInfall = getWrapTemplateForType(type.inner, descriptorProvider,
|
|
"%s.Value()" % result, successCode,
|
|
returnsNewObject, exceptionCode,
|
|
typedArraysAreStructs)
|
|
code = fill(
|
|
"""
|
|
|
|
if (${result}.IsNull()) {
|
|
$*{setNull}
|
|
}
|
|
$*{recTemplate}
|
|
""",
|
|
result=result,
|
|
setNull=setNull(),
|
|
recTemplate=recTemplate)
|
|
return code, recInfall
|
|
|
|
if type.isSequence():
|
|
# Now do non-nullable sequences. Our success code is just to break to
|
|
# where we set the element in the array. Note that we bump the
|
|
# sequenceWrapLevel around this call so that nested sequence conversions
|
|
# will use different iteration variables.
|
|
global sequenceWrapLevel
|
|
index = "sequenceIdx%d" % sequenceWrapLevel
|
|
sequenceWrapLevel += 1
|
|
innerTemplate = wrapForType(
|
|
type.inner, descriptorProvider,
|
|
{
|
|
'result': "%s[%s]" % (result, index),
|
|
'successCode': "break;\n",
|
|
'jsvalRef': "tmp",
|
|
'jsvalHandle': "&tmp",
|
|
'returnsNewObject': returnsNewObject,
|
|
'exceptionCode': exceptionCode,
|
|
'obj': "returnArray",
|
|
'typedArraysAreStructs': typedArraysAreStructs
|
|
})
|
|
sequenceWrapLevel -= 1
|
|
code = fill(
|
|
"""
|
|
|
|
uint32_t length = ${result}.Length();
|
|
JS::Rooted<JSObject*> returnArray(cx, JS_NewArrayObject(cx, length));
|
|
if (!returnArray) {
|
|
$*{exceptionCode}
|
|
}
|
|
// Scope for 'tmp'
|
|
{
|
|
JS::Rooted<JS::Value> tmp(cx);
|
|
for (uint32_t ${index} = 0; ${index} < length; ++${index}) {
|
|
// Control block to let us common up the JS_DefineElement calls when there
|
|
// are different ways to succeed at wrapping the object.
|
|
do {
|
|
$*{innerTemplate}
|
|
} while (0);
|
|
if (!JS_DefineElement(cx, returnArray, ${index}, tmp,
|
|
JSPROP_ENUMERATE)) {
|
|
$*{exceptionCode}
|
|
}
|
|
}
|
|
}
|
|
$*{set}
|
|
""",
|
|
result=result,
|
|
exceptionCode=exceptionCode,
|
|
index=index,
|
|
innerTemplate=innerTemplate,
|
|
set=setObject("*returnArray"))
|
|
|
|
return (code, False)
|
|
|
|
if type.isRecord():
|
|
# Now do non-nullable record. Our success code is just to break to
|
|
# where we define the property on the object. Note that we bump the
|
|
# recordWrapLevel around this call so that nested record conversions
|
|
# will use different temp value names.
|
|
global recordWrapLevel
|
|
valueName = "recordValue%d" % recordWrapLevel
|
|
recordWrapLevel += 1
|
|
innerTemplate = wrapForType(
|
|
type.inner, descriptorProvider,
|
|
{
|
|
'result': valueName,
|
|
'successCode': "break;\n",
|
|
'jsvalRef': "tmp",
|
|
'jsvalHandle': "&tmp",
|
|
'returnsNewObject': returnsNewObject,
|
|
'exceptionCode': exceptionCode,
|
|
'obj': "returnObj",
|
|
'typedArraysAreStructs': typedArraysAreStructs
|
|
})
|
|
recordWrapLevel -= 1
|
|
if type.keyType.isByteString():
|
|
# There is no length-taking JS_DefineProperty. So to keep
|
|
# things sane with embedded nulls, we want to byte-inflate
|
|
# to an nsAString. The only byte-inflation function we
|
|
# have around is AppendASCIItoUTF16, which luckily doesn't
|
|
# assert anything about the input being ASCII.
|
|
expandedKeyDecl = "NS_ConvertASCIItoUTF16 expandedKey(entry.mKey);\n"
|
|
keyName = "expandedKey"
|
|
else:
|
|
expandedKeyDecl = ""
|
|
keyName = "entry.mKey"
|
|
|
|
code = fill(
|
|
"""
|
|
|
|
JS::Rooted<JSObject*> returnObj(cx, JS_NewPlainObject(cx));
|
|
if (!returnObj) {
|
|
$*{exceptionCode}
|
|
}
|
|
// Scope for 'tmp'
|
|
{
|
|
JS::Rooted<JS::Value> tmp(cx);
|
|
for (auto& entry : ${result}.Entries()) {
|
|
auto& ${valueName} = entry.mValue;
|
|
// Control block to let us common up the JS_DefineUCProperty calls when there
|
|
// are different ways to succeed at wrapping the value.
|
|
do {
|
|
$*{innerTemplate}
|
|
} while (0);
|
|
$*{expandedKeyDecl}
|
|
if (!JS_DefineUCProperty(cx, returnObj,
|
|
${keyName}.BeginReading(),
|
|
${keyName}.Length(), tmp,
|
|
JSPROP_ENUMERATE)) {
|
|
$*{exceptionCode}
|
|
}
|
|
}
|
|
}
|
|
$*{set}
|
|
""",
|
|
result=result,
|
|
exceptionCode=exceptionCode,
|
|
valueName=valueName,
|
|
innerTemplate=innerTemplate,
|
|
expandedKeyDecl=expandedKeyDecl,
|
|
keyName=keyName,
|
|
set=setObject("*returnObj"))
|
|
|
|
return (code, False)
|
|
|
|
if type.isPromise():
|
|
assert not type.nullable()
|
|
# The use of ToJSValue here is a bit annoying because the Promise
|
|
# version is not inlined, but we can't put an inline version in either
|
|
# ToJSValue.h or BindingUtils.h, because Promise.h includes ToJSValue.h
|
|
# and that includes BindingUtils.h, so we'd get an include loop if
|
|
# either of those headers included Promise.h. Trying to write the
|
|
# conversion by hand here is annoying because we'd have to handle
|
|
# the various RefPtr, rawptr, NonNull, etc. cases, which ToJSValue will
|
|
# already handle for us, so we just use the function call.
|
|
return (wrapAndSetPtr("ToJSValue(cx, %s, ${jsvalHandle})" % result),
|
|
False)
|
|
|
|
if type.isGeckoInterface() and not type.isCallbackInterface():
|
|
descriptor = descriptorProvider.getDescriptor(type.unroll().inner.identifier.name)
|
|
if type.nullable():
|
|
wrappingCode = ("if (!%s) {\n" % (result) +
|
|
indent(setNull()) +
|
|
"}\n")
|
|
else:
|
|
wrappingCode = ""
|
|
|
|
if not descriptor.interface.isExternal():
|
|
if descriptor.wrapperCache:
|
|
wrapMethod = "GetOrCreateDOMReflector"
|
|
wrapArgs = "cx, %s, ${jsvalHandle}" % result
|
|
else:
|
|
wrapMethod = "WrapNewBindingNonWrapperCachedObject"
|
|
wrapArgs = "cx, ${obj}, %s, ${jsvalHandle}" % result
|
|
if isConstructorRetval:
|
|
wrapArgs += ", desiredProto"
|
|
wrap = "%s(%s)" % (wrapMethod, wrapArgs)
|
|
if not descriptor.hasXPConnectImpls:
|
|
# Can only fail to wrap as a new-binding object
|
|
# if they already threw an exception.
|
|
# XXX Assertion disabled for now, see bug 991271.
|
|
failed = ("MOZ_ASSERT(true || JS_IsExceptionPending(cx));\n" +
|
|
exceptionCode)
|
|
else:
|
|
if descriptor.notflattened:
|
|
raise TypeError("%s has XPConnect impls but not flattened; "
|
|
"fallback won't work correctly" %
|
|
descriptor.interface.identifier.name)
|
|
# Try old-style wrapping for bindings which might be XPConnect impls.
|
|
failed = wrapAndSetPtr("HandleNewBindingWrappingFailure(cx, ${obj}, %s, ${jsvalHandle})" % result)
|
|
else:
|
|
if descriptor.notflattened:
|
|
getIID = "&NS_GET_IID(%s), " % descriptor.nativeType
|
|
else:
|
|
getIID = ""
|
|
wrap = "WrapObject(cx, %s, %s${jsvalHandle})" % (result, getIID)
|
|
failed = None
|
|
|
|
wrappingCode += wrapAndSetPtr(wrap, failed)
|
|
return (wrappingCode, False)
|
|
|
|
if type.isDOMString() or type.isUSVString():
|
|
if type.nullable():
|
|
return (wrapAndSetPtr("xpc::StringToJsval(cx, %s, ${jsvalHandle})" % result), False)
|
|
else:
|
|
return (wrapAndSetPtr("xpc::NonVoidStringToJsval(cx, %s, ${jsvalHandle})" % result), False)
|
|
|
|
if type.isByteString():
|
|
if type.nullable():
|
|
return (wrapAndSetPtr("ByteStringToJsval(cx, %s, ${jsvalHandle})" % result), False)
|
|
else:
|
|
return (wrapAndSetPtr("NonVoidByteStringToJsval(cx, %s, ${jsvalHandle})" % result), False)
|
|
|
|
if type.isEnum():
|
|
if type.nullable():
|
|
resultLoc = "%s.Value()" % result
|
|
else:
|
|
resultLoc = result
|
|
conversion = fill(
|
|
"""
|
|
if (!ToJSValue(cx, ${result}, $${jsvalHandle})) {
|
|
$*{exceptionCode}
|
|
}
|
|
$*{successCode}
|
|
""",
|
|
result=resultLoc,
|
|
exceptionCode=exceptionCode,
|
|
successCode=successCode)
|
|
|
|
if type.nullable():
|
|
conversion = CGIfElseWrapper(
|
|
"%s.IsNull()" % result,
|
|
CGGeneric(setNull()),
|
|
CGGeneric(conversion)).define()
|
|
return conversion, False
|
|
|
|
if type.isCallback() or type.isCallbackInterface():
|
|
wrapCode = setObject(
|
|
"*GetCallbackFromCallbackObject(%(result)s)",
|
|
wrapAsType=type)
|
|
if type.nullable():
|
|
wrapCode = (
|
|
"if (%(result)s) {\n" +
|
|
indent(wrapCode) +
|
|
"} else {\n" +
|
|
indent(setNull()) +
|
|
"}\n")
|
|
wrapCode = wrapCode % {"result": result}
|
|
return wrapCode, False
|
|
|
|
if type.isAny():
|
|
# See comments in GetOrCreateDOMReflector explaining why we need
|
|
# to wrap here.
|
|
# NB: _setValue(..., type-that-is-any) calls JS_WrapValue(), so is fallible
|
|
head = "JS::ExposeValueToActiveJS(%s);\n" % result
|
|
return (head + _setValue(result, wrapAsType=type), False)
|
|
|
|
if (type.isObject() or (type.isSpiderMonkeyInterface() and
|
|
not typedArraysAreStructs)):
|
|
# See comments in GetOrCreateDOMReflector explaining why we need
|
|
# to wrap here.
|
|
if type.nullable():
|
|
toValue = "%s"
|
|
setter = setObjectOrNull
|
|
head = """if (%s) {
|
|
JS::ExposeObjectToActiveJS(%s);
|
|
}
|
|
""" % (result, result)
|
|
else:
|
|
toValue = "*%s"
|
|
setter = setObject
|
|
head = "JS::ExposeObjectToActiveJS(%s);\n" % result
|
|
# NB: setObject{,OrNull}(..., some-object-type) calls JS_WrapValue(), so is fallible
|
|
return (head + setter(toValue % result, wrapAsType=type), False)
|
|
|
|
if not (type.isUnion() or type.isPrimitive() or type.isDictionary() or
|
|
type.isDate() or
|
|
(type.isSpiderMonkeyInterface() and typedArraysAreStructs)):
|
|
raise TypeError("Need to learn to wrap %s" % type)
|
|
|
|
if type.nullable():
|
|
recTemplate, recInfal = getWrapTemplateForType(type.inner, descriptorProvider,
|
|
"%s.Value()" % result, successCode,
|
|
returnsNewObject, exceptionCode,
|
|
typedArraysAreStructs)
|
|
return ("if (%s.IsNull()) {\n" % result +
|
|
indent(setNull()) +
|
|
"}\n" +
|
|
recTemplate, recInfal)
|
|
|
|
if type.isSpiderMonkeyInterface():
|
|
assert typedArraysAreStructs
|
|
# See comments in GetOrCreateDOMReflector explaining why we need
|
|
# to wrap here.
|
|
# NB: setObject(..., some-object-type) calls JS_WrapValue(), so is fallible
|
|
return (setObject("*%s.Obj()" % result,
|
|
wrapAsType=type), False)
|
|
|
|
if type.isUnion():
|
|
return (wrapAndSetPtr("%s.ToJSVal(cx, ${obj}, ${jsvalHandle})" % result),
|
|
False)
|
|
|
|
if type.isDictionary():
|
|
return (wrapAndSetPtr("%s.ToObjectInternal(cx, ${jsvalHandle})" % result),
|
|
False)
|
|
|
|
if type.isDate():
|
|
return (wrapAndSetPtr("%s.ToDateObject(cx, ${jsvalHandle})" % result),
|
|
False)
|
|
|
|
tag = type.tag()
|
|
|
|
if tag in [IDLType.Tags.int8, IDLType.Tags.uint8, IDLType.Tags.int16,
|
|
IDLType.Tags.uint16, IDLType.Tags.int32]:
|
|
return (setInt32("int32_t(%s)" % result), True)
|
|
|
|
elif tag in [IDLType.Tags.int64, IDLType.Tags.uint64,
|
|
IDLType.Tags.unrestricted_float, IDLType.Tags.float,
|
|
IDLType.Tags.unrestricted_double, IDLType.Tags.double]:
|
|
# XXXbz will cast to double do the "even significand" thing that webidl
|
|
# calls for for 64-bit ints? Do we care?
|
|
return (setDouble("double(%s)" % result), True)
|
|
|
|
elif tag == IDLType.Tags.uint32:
|
|
return (setUint32(result), True)
|
|
|
|
elif tag == IDLType.Tags.bool:
|
|
return (setBoolean(result), True)
|
|
|
|
else:
|
|
raise TypeError("Need to learn to wrap primitive: %s" % type)
|
|
|
|
|
|
def wrapForType(type, descriptorProvider, templateValues):
|
|
"""
|
|
Reflect a C++ value of IDL type "type" into JS. TemplateValues is a dict
|
|
that should contain:
|
|
|
|
* 'jsvalRef': something that can have .address() called on it to get a
|
|
JS::Value* and .set() called on it to set it to a JS::Value.
|
|
This can be a JS::MutableHandle<JS::Value> or a
|
|
JS::Rooted<JS::Value>.
|
|
* 'jsvalHandle': something that can be passed to methods taking a
|
|
JS::MutableHandle<JS::Value>. This can be a
|
|
JS::MutableHandle<JS::Value> or a JS::Rooted<JS::Value>*.
|
|
* 'obj' (optional): the name of the variable that contains the JSObject to
|
|
use as a scope when wrapping, if not supplied 'obj'
|
|
will be used as the name
|
|
* 'result' (optional): the name of the variable in which the C++ value is
|
|
stored, if not supplied 'result' will be used as
|
|
the name
|
|
* 'successCode' (optional): the code to run once we have successfully
|
|
done the conversion, if not supplied 'return
|
|
true;' will be used as the code. The
|
|
successCode must ensure that once it runs no
|
|
more of the conversion template will be
|
|
executed (e.g. by doing a 'return' or 'break'
|
|
as appropriate).
|
|
* 'returnsNewObject' (optional): If true, we're wrapping for the return
|
|
value of a [NewObject] method. Assumed
|
|
false if not set.
|
|
* 'exceptionCode' (optional): Code to run when a JS exception is thrown.
|
|
The default is "return false;". The code
|
|
passed here must return.
|
|
* 'isConstructorRetval' (optional): If true, we're wrapping a constructor
|
|
return value.
|
|
"""
|
|
wrap = getWrapTemplateForType(
|
|
type, descriptorProvider,
|
|
templateValues.get('result', 'result'),
|
|
templateValues.get('successCode', None),
|
|
templateValues.get('returnsNewObject', False),
|
|
templateValues.get('exceptionCode', "return false;\n"),
|
|
templateValues.get('typedArraysAreStructs', False),
|
|
isConstructorRetval=templateValues.get('isConstructorRetval', False))[0]
|
|
|
|
defaultValues = {'obj': 'obj'}
|
|
return string.Template(wrap).substitute(defaultValues, **templateValues)
|
|
|
|
|
|
def infallibleForMember(member, type, descriptorProvider):
|
|
"""
|
|
Determine the fallibility of changing a C++ value of IDL type "type" into
|
|
JS for the given attribute. Apart from returnsNewObject, all the defaults
|
|
are used, since the fallbility does not change based on the boolean values,
|
|
and the template will be discarded.
|
|
|
|
CURRENT ASSUMPTIONS:
|
|
We assume that successCode for wrapping up return values cannot contain
|
|
failure conditions.
|
|
"""
|
|
return getWrapTemplateForType(type, descriptorProvider, 'result', None,
|
|
memberReturnsNewObject(member), "return false;\n",
|
|
False)[1]
|
|
|
|
|
|
def leafTypeNeedsCx(type, retVal):
|
|
return (type.isAny() or type.isObject() or
|
|
(retVal and type.isSpiderMonkeyInterface()))
|
|
|
|
|
|
def leafTypeNeedsScopeObject(type, retVal):
|
|
return retVal and type.isSpiderMonkeyInterface()
|
|
|
|
|
|
def leafTypeNeedsRooting(type):
|
|
return leafTypeNeedsCx(type, False) or type.isSpiderMonkeyInterface()
|
|
|
|
|
|
def typeNeedsRooting(type):
|
|
return typeMatchesLambda(type,
|
|
lambda t: leafTypeNeedsRooting(t))
|
|
|
|
|
|
def typeNeedsCx(type, retVal=False):
|
|
return typeMatchesLambda(type,
|
|
lambda t: leafTypeNeedsCx(t, retVal))
|
|
|
|
|
|
def typeNeedsScopeObject(type, retVal=False):
|
|
return typeMatchesLambda(type,
|
|
lambda t: leafTypeNeedsScopeObject(t, retVal))
|
|
|
|
|
|
def typeMatchesLambda(type, func):
|
|
if type is None:
|
|
return False
|
|
if type.nullable():
|
|
return typeMatchesLambda(type.inner, func)
|
|
if type.isSequence() or type.isRecord():
|
|
return typeMatchesLambda(type.inner, func)
|
|
if type.isUnion():
|
|
return any(typeMatchesLambda(t, func) for t in
|
|
type.unroll().flatMemberTypes)
|
|
if type.isDictionary():
|
|
return dictionaryMatchesLambda(type.inner, func)
|
|
return func(type)
|
|
|
|
|
|
def dictionaryMatchesLambda(dictionary, func):
|
|
return (any(typeMatchesLambda(m.type, func) for m in dictionary.members) or
|
|
(dictionary.parent and dictionaryMatchesLambda(dictionary.parent, func)))
|
|
|
|
|
|
# Whenever this is modified, please update CGNativeMember.getRetvalInfo as
|
|
# needed to keep the types compatible.
|
|
def getRetvalDeclarationForType(returnType, descriptorProvider,
|
|
isMember=False):
|
|
"""
|
|
Returns a tuple containing five things:
|
|
|
|
1) A CGThing for the type of the return value, or None if there is no need
|
|
for a return value.
|
|
|
|
2) A value indicating the kind of ourparam to pass the value as. Valid
|
|
options are None to not pass as an out param at all, "ref" (to pass a
|
|
reference as an out param), and "ptr" (to pass a pointer as an out
|
|
param).
|
|
|
|
3) A CGThing for a tracer for the return value, or None if no tracing is
|
|
needed.
|
|
|
|
4) An argument string to pass to the retval declaration
|
|
constructor or None if there are no arguments.
|
|
|
|
5) The name of a function that needs to be called with the return value
|
|
before using it, or None if no function needs to be called.
|
|
"""
|
|
if returnType is None or returnType.isVoid():
|
|
# Nothing to declare
|
|
return None, None, None, None, None
|
|
if returnType.isPrimitive() and returnType.tag() in builtinNames:
|
|
result = CGGeneric(builtinNames[returnType.tag()])
|
|
if returnType.nullable():
|
|
result = CGTemplatedType("Nullable", result)
|
|
return result, None, None, None, None
|
|
if returnType.isDOMString() or returnType.isUSVString():
|
|
if isMember:
|
|
return CGGeneric("nsString"), "ref", None, None, None
|
|
return CGGeneric("DOMString"), "ref", None, None, None
|
|
if returnType.isByteString():
|
|
return CGGeneric("nsCString"), "ref", None, None, None
|
|
if returnType.isEnum():
|
|
result = CGGeneric(returnType.unroll().inner.identifier.name)
|
|
if returnType.nullable():
|
|
result = CGTemplatedType("Nullable", result)
|
|
return result, None, None, None, None
|
|
if returnType.isGeckoInterface() or returnType.isPromise():
|
|
if returnType.isGeckoInterface():
|
|
typeName = descriptorProvider.getDescriptor(
|
|
returnType.unroll().inner.identifier.name).nativeType
|
|
else:
|
|
typeName = "Promise"
|
|
if isMember:
|
|
conversion = None
|
|
result = CGGeneric("StrongPtrForMember<%s>::Type" % typeName)
|
|
else:
|
|
conversion = CGGeneric("StrongOrRawPtr<%s>" % typeName)
|
|
result = CGGeneric("auto")
|
|
return result, None, None, None, conversion
|
|
if returnType.isCallback():
|
|
name = returnType.unroll().callback.identifier.name
|
|
return CGGeneric("RefPtr<%s>" % name), None, None, None, None
|
|
if returnType.isAny():
|
|
if isMember:
|
|
return CGGeneric("JS::Value"), None, None, None, None
|
|
return CGGeneric("JS::Rooted<JS::Value>"), "ptr", None, "cx", None
|
|
if returnType.isObject() or returnType.isSpiderMonkeyInterface():
|
|
if isMember:
|
|
return CGGeneric("JSObject*"), None, None, None, None
|
|
return CGGeneric("JS::Rooted<JSObject*>"), "ptr", None, "cx", None
|
|
if returnType.isSequence():
|
|
nullable = returnType.nullable()
|
|
if nullable:
|
|
returnType = returnType.inner
|
|
result, _, _, _, _ = getRetvalDeclarationForType(returnType.inner,
|
|
descriptorProvider,
|
|
isMember="Sequence")
|
|
# While we have our inner type, set up our rooter, if needed
|
|
if not isMember and typeNeedsRooting(returnType):
|
|
rooter = CGGeneric("SequenceRooter<%s > resultRooter(cx, &result);\n" %
|
|
result.define())
|
|
else:
|
|
rooter = None
|
|
result = CGTemplatedType("nsTArray", result)
|
|
if nullable:
|
|
result = CGTemplatedType("Nullable", result)
|
|
return result, "ref", rooter, None, None
|
|
if returnType.isRecord():
|
|
nullable = returnType.nullable()
|
|
if nullable:
|
|
returnType = returnType.inner
|
|
result, _, _, _, _ = getRetvalDeclarationForType(returnType.inner,
|
|
descriptorProvider,
|
|
isMember="Record")
|
|
# While we have our inner type, set up our rooter, if needed
|
|
if not isMember and typeNeedsRooting(returnType):
|
|
rooter = CGGeneric("RecordRooter<%s> resultRooter(cx, &result);\n" %
|
|
("nsString, " + result.define()))
|
|
else:
|
|
rooter = None
|
|
result = CGTemplatedType("Record", [recordKeyDeclType(returnType),
|
|
result])
|
|
if nullable:
|
|
result = CGTemplatedType("Nullable", result)
|
|
return result, "ref", rooter, None, None
|
|
if returnType.isDictionary():
|
|
nullable = returnType.nullable()
|
|
dictName = CGDictionary.makeDictionaryName(returnType.unroll().inner)
|
|
result = CGGeneric(dictName)
|
|
if not isMember and typeNeedsRooting(returnType):
|
|
if nullable:
|
|
result = CGTemplatedType("NullableRootedDictionary", result)
|
|
else:
|
|
result = CGTemplatedType("RootedDictionary", result)
|
|
resultArgs = "cx"
|
|
else:
|
|
if nullable:
|
|
result = CGTemplatedType("Nullable", result)
|
|
resultArgs = None
|
|
return result, "ref", None, resultArgs, None
|
|
if returnType.isUnion():
|
|
result = CGGeneric(CGUnionStruct.unionTypeName(returnType.unroll(), True))
|
|
if not isMember and typeNeedsRooting(returnType):
|
|
if returnType.nullable():
|
|
result = CGTemplatedType("NullableRootedUnion", result)
|
|
else:
|
|
result = CGTemplatedType("RootedUnion", result)
|
|
resultArgs = "cx"
|
|
else:
|
|
if returnType.nullable():
|
|
result = CGTemplatedType("Nullable", result)
|
|
resultArgs = None
|
|
return result, "ref", None, resultArgs, None
|
|
if returnType.isDate():
|
|
result = CGGeneric("Date")
|
|
if returnType.nullable():
|
|
result = CGTemplatedType("Nullable", result)
|
|
return result, None, None, None, None
|
|
raise TypeError("Don't know how to declare return value for %s" %
|
|
returnType)
|
|
|
|
|
|
def needCx(returnType, arguments, extendedAttributes, considerTypes,
|
|
static=False):
|
|
return (not static and considerTypes and
|
|
(typeNeedsCx(returnType, True) or
|
|
any(typeNeedsCx(a.type) for a in arguments)) or
|
|
'implicitJSContext' in extendedAttributes)
|
|
|
|
|
|
def needScopeObject(returnType, arguments, extendedAttributes,
|
|
isWrapperCached, considerTypes, isMember):
|
|
"""
|
|
isMember should be true if we're dealing with an attribute
|
|
annotated as [StoreInSlot].
|
|
"""
|
|
return (considerTypes and not isWrapperCached and
|
|
((not isMember and typeNeedsScopeObject(returnType, True)) or
|
|
any(typeNeedsScopeObject(a.type) for a in arguments)))
|
|
|
|
|
|
class CGCallGenerator(CGThing):
|
|
"""
|
|
A class to generate an actual call to a C++ object. Assumes that the C++
|
|
object is stored in a variable whose name is given by the |object| argument.
|
|
|
|
needsSubjectPrincipal is a boolean indicating whether the call should
|
|
receive the subject nsIPrincipal as argument.
|
|
|
|
needsCallerType is a boolean indicating whether the call should receive
|
|
a PrincipalType for the caller.
|
|
|
|
isFallible is a boolean indicating whether the call should be fallible.
|
|
|
|
resultVar: If the returnType is not void, then the result of the call is
|
|
stored in a C++ variable named by resultVar. The caller is responsible for
|
|
declaring the result variable. If the caller doesn't care about the result
|
|
value, resultVar can be omitted.
|
|
"""
|
|
def __init__(self, isFallible, needsSubjectPrincipal, needsCallerType,
|
|
arguments, argsPre, returnType, extendedAttributes, descriptor,
|
|
nativeMethodName, static, object="self", argsPost=[],
|
|
resultVar=None):
|
|
CGThing.__init__(self)
|
|
|
|
result, resultOutParam, resultRooter, resultArgs, resultConversion = \
|
|
getRetvalDeclarationForType(returnType, descriptor)
|
|
|
|
args = CGList([CGGeneric(arg) for arg in argsPre], ", ")
|
|
for a, name in arguments:
|
|
arg = CGGeneric(name)
|
|
|
|
# Now constify the things that need it
|
|
def needsConst(a):
|
|
if a.type.isDictionary():
|
|
return True
|
|
if a.type.isSequence():
|
|
return True
|
|
if a.type.isRecord():
|
|
return True
|
|
# isObject() types are always a JS::Rooted, whether
|
|
# nullable or not, and it turns out a const JS::Rooted
|
|
# is not very helpful at all (in particular, it won't
|
|
# even convert to a JS::Handle).
|
|
# XXX bz Well, why not???
|
|
if a.type.nullable() and not a.type.isObject():
|
|
return True
|
|
if a.type.isString():
|
|
return True
|
|
if a.canHaveMissingValue():
|
|
# This will need an Optional or it's a variadic;
|
|
# in both cases it should be const.
|
|
return True
|
|
if a.type.isUnion():
|
|
return True
|
|
if a.type.isSpiderMonkeyInterface():
|
|
return True
|
|
return False
|
|
if needsConst(a):
|
|
arg = CGWrapper(arg, pre="Constify(", post=")")
|
|
# And convert NonNull<T> to T&
|
|
if (((a.type.isGeckoInterface() or a.type.isCallback() or
|
|
a.type.isPromise()) and
|
|
not a.type.nullable()) or
|
|
a.type.isDOMString()):
|
|
arg = CGWrapper(arg, pre="NonNullHelper(", post=")")
|
|
args.append(arg)
|
|
|
|
needResultDecl = False
|
|
|
|
# Return values that go in outparams go here
|
|
if resultOutParam is not None:
|
|
if resultVar is None:
|
|
needResultDecl = True
|
|
resultVar = "result"
|
|
if resultOutParam == "ref":
|
|
args.append(CGGeneric(resultVar))
|
|
else:
|
|
assert resultOutParam == "ptr"
|
|
args.append(CGGeneric("&" + resultVar))
|
|
|
|
if needsSubjectPrincipal:
|
|
args.append(CGGeneric("subjectPrincipal"))
|
|
|
|
if needsCallerType:
|
|
args.append(CGGeneric("callerType"))
|
|
|
|
if isFallible:
|
|
args.append(CGGeneric("rv"))
|
|
args.extend(CGGeneric(arg) for arg in argsPost)
|
|
|
|
# Build up our actual call
|
|
self.cgRoot = CGList([])
|
|
|
|
call = CGGeneric(nativeMethodName)
|
|
if not static:
|
|
call = CGWrapper(call, pre="%s->" % object)
|
|
call = CGList([call, CGWrapper(args, pre="(", post=")")])
|
|
if resultConversion is not None:
|
|
call = CGList([resultConversion, CGWrapper(call, pre="(", post=")")])
|
|
if resultVar is None and result is not None:
|
|
needResultDecl = True
|
|
resultVar = "result"
|
|
|
|
if needResultDecl:
|
|
if resultRooter is not None:
|
|
self.cgRoot.prepend(resultRooter)
|
|
if resultArgs is not None:
|
|
resultArgsStr = "(%s)" % resultArgs
|
|
else:
|
|
resultArgsStr = ""
|
|
result = CGWrapper(result, post=(" %s%s" % (resultVar, resultArgsStr)))
|
|
if resultOutParam is None and resultArgs is None:
|
|
call = CGList([result, CGWrapper(call, pre="(", post=")")])
|
|
else:
|
|
self.cgRoot.prepend(CGWrapper(result, post=";\n"))
|
|
if resultOutParam is None:
|
|
call = CGWrapper(call, pre=resultVar + " = ")
|
|
elif result is not None:
|
|
assert resultOutParam is None
|
|
call = CGWrapper(call, pre=resultVar + " = ")
|
|
|
|
call = CGWrapper(call, post=";\n")
|
|
self.cgRoot.append(call)
|
|
|
|
if needsSubjectPrincipal:
|
|
getPrincipal = dedent(
|
|
"""
|
|
JSCompartment* compartment = js::GetContextCompartment(cx);
|
|
MOZ_ASSERT(compartment);
|
|
JSPrincipals* principals = JS_GetCompartmentPrincipals(compartment);
|
|
""")
|
|
|
|
if descriptor.interface.isExposedInAnyWorker():
|
|
self.cgRoot.prepend(CGGeneric(fill(
|
|
"""
|
|
Maybe<nsIPrincipal*> subjectPrincipal;
|
|
if (NS_IsMainThread()) {
|
|
$*{getPrincipal}
|
|
subjectPrincipal.emplace(nsJSPrincipals::get(principals));
|
|
}
|
|
""",
|
|
getPrincipal=getPrincipal)))
|
|
else:
|
|
self.cgRoot.prepend(CGGeneric(fill(
|
|
"""
|
|
$*{getPrincipal}
|
|
// Initializing a nonnull is pretty darn annoying...
|
|
NonNull<nsIPrincipal> subjectPrincipal;
|
|
subjectPrincipal = static_cast<nsIPrincipal*>(nsJSPrincipals::get(principals));
|
|
""",
|
|
getPrincipal=getPrincipal)))
|
|
|
|
if needsCallerType:
|
|
# Note that we do not want to use
|
|
# IsCallerChrome/ThreadsafeIsCallerChrome directly because those
|
|
# will pull in the check for UniversalXPConnect, which we ideally
|
|
# don't want to have in the new thing we're doing here. If not
|
|
# NS_IsMainThread(), though, we'll go ahead and call
|
|
# ThreasafeIsCallerChrome(), since that won't mess with
|
|
# UnivesalXPConnect and we don't want to worry about the right
|
|
# worker includes here.
|
|
callerCheck = CGGeneric("callerType = nsContentUtils::IsSystemPrincipal(nsContentUtils::SubjectPrincipal()) ? CallerType::System : CallerType::NonSystem;\n")
|
|
if descriptor.interface.isExposedInAnyWorker():
|
|
callerCheck = CGIfElseWrapper(
|
|
"NS_IsMainThread()",
|
|
callerCheck,
|
|
CGGeneric("callerType = nsContentUtils::ThreadsafeIsCallerChrome() ? CallerType::System : CallerType::NonSystem;\n"));
|
|
self.cgRoot.prepend(callerCheck)
|
|
self.cgRoot.prepend(CGGeneric("CallerType callerType;\n"))
|
|
|
|
if isFallible:
|
|
self.cgRoot.prepend(CGGeneric("binding_detail::FastErrorResult rv;\n"))
|
|
self.cgRoot.append(CGGeneric(dedent(
|
|
"""
|
|
if (MOZ_UNLIKELY(rv.MaybeSetPendingException(cx))) {
|
|
return false;
|
|
}
|
|
""")))
|
|
|
|
self.cgRoot.append(CGGeneric("MOZ_ASSERT(!JS_IsExceptionPending(cx));\n"))
|
|
|
|
def define(self):
|
|
return self.cgRoot.define()
|
|
|
|
|
|
def getUnionMemberName(type):
|
|
# Promises can't be in unions, because they're not distinguishable
|
|
# from anything else.
|
|
assert not type.isPromise()
|
|
if type.isGeckoInterface():
|
|
return type.inner.identifier.name
|
|
if type.isEnum():
|
|
return type.inner.identifier.name
|
|
return type.name
|
|
|
|
|
|
class MethodNotNewObjectError(Exception):
|
|
def __init__(self, typename):
|
|
self.typename = typename
|
|
|
|
# A counter for making sure that when we're wrapping up things in
|
|
# nested sequences we don't use the same variable name to iterate over
|
|
# different sequences.
|
|
sequenceWrapLevel = 0
|
|
recordWrapLevel = 0
|
|
|
|
|
|
def wrapTypeIntoCurrentCompartment(type, value, isMember=True):
|
|
"""
|
|
Take the thing named by "value" and if it contains "any",
|
|
"object", or spidermonkey-interface types inside return a CGThing
|
|
that will wrap them into the current compartment.
|
|
"""
|
|
if type.isAny():
|
|
assert not type.nullable()
|
|
if isMember:
|
|
value = "JS::MutableHandle<JS::Value>::fromMarkedLocation(&%s)" % value
|
|
else:
|
|
value = "&" + value
|
|
return CGGeneric("if (!JS_WrapValue(cx, %s)) {\n"
|
|
" return false;\n"
|
|
"}\n" % value)
|
|
|
|
if type.isObject():
|
|
if isMember:
|
|
value = "JS::MutableHandle<JSObject*>::fromMarkedLocation(&%s)" % value
|
|
else:
|
|
value = "&" + value
|
|
return CGGeneric("if (!JS_WrapObject(cx, %s)) {\n"
|
|
" return false;\n"
|
|
"}\n" % value)
|
|
|
|
if type.isSpiderMonkeyInterface():
|
|
origValue = value
|
|
if type.nullable():
|
|
value = "%s.Value()" % value
|
|
wrapCode = CGGeneric("if (!%s.WrapIntoNewCompartment(cx)) {\n"
|
|
" return false;\n"
|
|
"}\n" % value)
|
|
if type.nullable():
|
|
wrapCode = CGIfWrapper(wrapCode, "!%s.IsNull()" % origValue)
|
|
return wrapCode
|
|
|
|
if type.isSequence():
|
|
origValue = value
|
|
origType = type
|
|
if type.nullable():
|
|
type = type.inner
|
|
value = "%s.Value()" % value
|
|
global sequenceWrapLevel
|
|
index = "indexName%d" % sequenceWrapLevel
|
|
sequenceWrapLevel += 1
|
|
wrapElement = wrapTypeIntoCurrentCompartment(type.inner,
|
|
"%s[%s]" % (value, index))
|
|
sequenceWrapLevel -= 1
|
|
if not wrapElement:
|
|
return None
|
|
wrapCode = CGWrapper(CGIndenter(wrapElement),
|
|
pre=("for (uint32_t %s = 0; %s < %s.Length(); ++%s) {\n" %
|
|
(index, index, value, index)),
|
|
post="}\n")
|
|
if origType.nullable():
|
|
wrapCode = CGIfWrapper(wrapCode, "!%s.IsNull()" % origValue)
|
|
return wrapCode
|
|
|
|
if type.isRecord():
|
|
origType = type
|
|
if type.nullable():
|
|
type = type.inner
|
|
recordRef = "%s.Value()" % value
|
|
else:
|
|
recordRef = value
|
|
global recordWrapLevel
|
|
entryRef = "mapEntry%d" % recordWrapLevel
|
|
recordWrapLevel += 1
|
|
wrapElement = wrapTypeIntoCurrentCompartment(type.inner,
|
|
"%s.mValue" % entryRef)
|
|
recordWrapLevel -= 1
|
|
if not wrapElement:
|
|
return None
|
|
wrapCode = CGWrapper(CGIndenter(wrapElement),
|
|
pre=("for (auto& %s : %s.Entries()) {\n" %
|
|
(entryRef, recordRef)),
|
|
post="}\n")
|
|
if origType.nullable():
|
|
wrapCode = CGIfWrapper(wrapCode, "!%s.IsNull()" % value)
|
|
return wrapCode
|
|
|
|
if type.isDictionary():
|
|
assert not type.nullable()
|
|
myDict = type.inner
|
|
memberWraps = []
|
|
while myDict:
|
|
for member in myDict.members:
|
|
memberWrap = wrapArgIntoCurrentCompartment(
|
|
member,
|
|
"%s.%s" % (value, CGDictionary.makeMemberName(member.identifier.name)))
|
|
if memberWrap:
|
|
memberWraps.append(memberWrap)
|
|
myDict = myDict.parent
|
|
return CGList(memberWraps) if len(memberWraps) != 0 else None
|
|
|
|
if type.isUnion():
|
|
memberWraps = []
|
|
if type.nullable():
|
|
type = type.inner
|
|
value = "%s.Value()" % value
|
|
for member in type.flatMemberTypes:
|
|
memberName = getUnionMemberName(member)
|
|
memberWrap = wrapTypeIntoCurrentCompartment(
|
|
member, "%s.GetAs%s()" % (value, memberName))
|
|
if memberWrap:
|
|
memberWrap = CGIfWrapper(
|
|
memberWrap, "%s.Is%s()" % (value, memberName))
|
|
memberWraps.append(memberWrap)
|
|
return CGList(memberWraps, "else ") if len(memberWraps) != 0 else None
|
|
|
|
if (type.isString() or type.isPrimitive() or type.isEnum() or
|
|
type.isGeckoInterface() or type.isCallback() or type.isDate() or
|
|
type.isPromise()):
|
|
# All of these don't need wrapping.
|
|
return None
|
|
|
|
raise TypeError("Unknown type; we don't know how to wrap it in constructor "
|
|
"arguments: %s" % type)
|
|
|
|
|
|
def wrapArgIntoCurrentCompartment(arg, value, isMember=True):
|
|
"""
|
|
As wrapTypeIntoCurrentCompartment but handles things being optional
|
|
"""
|
|
origValue = value
|
|
isOptional = arg.canHaveMissingValue()
|
|
if isOptional:
|
|
value = value + ".Value()"
|
|
wrap = wrapTypeIntoCurrentCompartment(arg.type, value, isMember)
|
|
if wrap and isOptional:
|
|
wrap = CGIfWrapper(wrap, "%s.WasPassed()" % origValue)
|
|
return wrap
|
|
|
|
|
|
def needsContainsHack(m):
|
|
return m.getExtendedAttribute("ReturnValueNeedsContainsHack")
|
|
|
|
def needsCallerType(m):
|
|
return m.getExtendedAttribute("NeedsCallerType")
|
|
|
|
class CGPerSignatureCall(CGThing):
|
|
"""
|
|
This class handles the guts of generating code for a particular
|
|
call signature. A call signature consists of four things:
|
|
|
|
1) A return type, which can be None to indicate that there is no
|
|
actual return value (e.g. this is an attribute setter) or an
|
|
IDLType if there's an IDL type involved (including |void|).
|
|
2) An argument list, which is allowed to be empty.
|
|
3) A name of a native method to call.
|
|
4) Whether or not this method is static. Note that this only controls how
|
|
the method is called (|self->nativeMethodName(...)| vs
|
|
|nativeMethodName(...)|).
|
|
|
|
We also need to know whether this is a method or a getter/setter
|
|
to do error reporting correctly.
|
|
|
|
The idlNode parameter can be either a method or an attr. We can query
|
|
|idlNode.identifier| in both cases, so we can be agnostic between the two.
|
|
"""
|
|
# XXXbz For now each entry in the argument list is either an
|
|
# IDLArgument or a FakeArgument, but longer-term we may want to
|
|
# have ways of flagging things like JSContext* or optional_argc in
|
|
# there.
|
|
|
|
def __init__(self, returnType, arguments, nativeMethodName, static,
|
|
descriptor, idlNode, argConversionStartsAt=0, getter=False,
|
|
setter=False, isConstructor=False, useCounterName=None,
|
|
resultVar=None, objectName="obj"):
|
|
assert idlNode.isMethod() == (not getter and not setter)
|
|
assert idlNode.isAttr() == (getter or setter)
|
|
# Constructors are always static
|
|
assert not isConstructor or static
|
|
|
|
CGThing.__init__(self)
|
|
self.returnType = returnType
|
|
self.descriptor = descriptor
|
|
self.idlNode = idlNode
|
|
self.extendedAttributes = descriptor.getExtendedAttributes(idlNode,
|
|
getter=getter,
|
|
setter=setter)
|
|
self.arguments = arguments
|
|
self.argCount = len(arguments)
|
|
self.isConstructor = isConstructor
|
|
cgThings = []
|
|
|
|
# Here, we check if the current getter, setter, method, interface or
|
|
# inherited interfaces have the UnsafeInPrerendering extended attribute
|
|
# and if so, we add a check to make sure it is safe.
|
|
if (idlNode.getExtendedAttribute("UnsafeInPrerendering") or
|
|
descriptor.interface.getExtendedAttribute("UnsafeInPrerendering") or
|
|
any(i.getExtendedAttribute("UnsafeInPrerendering")
|
|
for i in descriptor.interface.getInheritedInterfaces())):
|
|
cgThings.append(CGGeneric(dedent(
|
|
"""
|
|
if (!mozilla::dom::EnforceNotInPrerendering(cx, obj)) {
|
|
// Return false from the JSNative in order to trigger
|
|
// an uncatchable exception.
|
|
MOZ_ASSERT(!JS_IsExceptionPending(cx));
|
|
return false;
|
|
}
|
|
""")))
|
|
|
|
deprecated = (idlNode.getExtendedAttribute("Deprecated") or
|
|
(idlNode.isStatic() and descriptor.interface.getExtendedAttribute("Deprecated")))
|
|
if deprecated:
|
|
cgThings.append(CGGeneric(dedent(
|
|
"""
|
|
DeprecationWarning(cx, obj, nsIDocument::e%s);
|
|
""" % deprecated[0])))
|
|
|
|
lenientFloatCode = None
|
|
if (idlNode.getExtendedAttribute('LenientFloat') is not None and
|
|
(setter or idlNode.isMethod())):
|
|
cgThings.append(CGGeneric(dedent(
|
|
"""
|
|
bool foundNonFiniteFloat = false;
|
|
""")))
|
|
lenientFloatCode = "foundNonFiniteFloat = true;\n"
|
|
|
|
argsPre = []
|
|
if idlNode.isStatic():
|
|
# If we're a constructor, the GlobalObject struct will be created in
|
|
# CGClassConstructor.
|
|
if not isConstructor:
|
|
cgThings.append(CGGeneric(dedent(
|
|
"""
|
|
GlobalObject global(cx, xpc::XrayAwareCalleeGlobal(obj));
|
|
if (global.Failed()) {
|
|
return false;
|
|
}
|
|
|
|
""")))
|
|
|
|
argsPre.append("global")
|
|
|
|
if isConstructor and idlNode.isHTMLConstructor():
|
|
argsPre.extend(["args", "desiredProto"])
|
|
|
|
# For JS-implemented interfaces we do not want to base the
|
|
# needsCx decision on the types involved, just on our extended
|
|
# attributes. Also, JSContext is not needed for the static case
|
|
# since GlobalObject already contains the context.
|
|
needsCx = needCx(returnType, arguments, self.extendedAttributes,
|
|
not descriptor.interface.isJSImplemented(), static)
|
|
if needsCx:
|
|
argsPre.append("cx")
|
|
|
|
needsUnwrap = False
|
|
argsPost = []
|
|
if isConstructor:
|
|
needsUnwrap = True
|
|
needsUnwrappedVar = False
|
|
unwrappedVar = "obj"
|
|
elif descriptor.interface.isJSImplemented():
|
|
if not idlNode.isStatic():
|
|
needsUnwrap = True
|
|
needsUnwrappedVar = True
|
|
argsPost.append("js::GetObjectCompartment(unwrappedObj ? *unwrappedObj : obj)")
|
|
elif needScopeObject(returnType, arguments, self.extendedAttributes,
|
|
descriptor.wrapperCache, True,
|
|
idlNode.getExtendedAttribute("StoreInSlot")):
|
|
needsUnwrap = True
|
|
needsUnwrappedVar = True
|
|
argsPre.append("unwrappedObj ? *unwrappedObj : obj")
|
|
|
|
if needsUnwrap and needsUnwrappedVar:
|
|
# We cannot assign into obj because it's a Handle, not a
|
|
# MutableHandle, so we need a separate Rooted.
|
|
cgThings.append(CGGeneric("Maybe<JS::Rooted<JSObject*> > unwrappedObj;\n"))
|
|
unwrappedVar = "unwrappedObj.ref()"
|
|
|
|
if idlNode.isMethod() and idlNode.isLegacycaller():
|
|
# If we can have legacycaller with identifier, we can't
|
|
# just use the idlNode to determine whether we're
|
|
# generating code for the legacycaller or not.
|
|
assert idlNode.isIdentifierLess()
|
|
# Pass in our thisVal
|
|
argsPre.append("args.thisv()")
|
|
|
|
ourName = "%s.%s" % (descriptor.interface.identifier.name,
|
|
idlNode.identifier.name)
|
|
if idlNode.isMethod():
|
|
argDescription = "argument %(index)d of " + ourName
|
|
elif setter:
|
|
argDescription = "value being assigned to %s" % ourName
|
|
else:
|
|
assert self.argCount == 0
|
|
|
|
if needsUnwrap:
|
|
# It's very important that we construct our unwrappedObj, if we need
|
|
# to do it, before we might start setting up Rooted things for our
|
|
# arguments, so that we don't violate the stack discipline Rooted
|
|
# depends on.
|
|
cgThings.append(CGGeneric(
|
|
"bool objIsXray = xpc::WrapperFactory::IsXrayWrapper(obj);\n"))
|
|
if needsUnwrappedVar:
|
|
cgThings.append(CGIfWrapper(
|
|
CGGeneric("unwrappedObj.emplace(cx, obj);\n"),
|
|
"objIsXray"))
|
|
|
|
for i in range(argConversionStartsAt, self.argCount):
|
|
cgThings.append(
|
|
CGArgumentConverter(arguments[i], i, self.descriptor,
|
|
argDescription % {"index": i + 1},
|
|
idlNode, invalidEnumValueFatal=not setter,
|
|
lenientFloatCode=lenientFloatCode))
|
|
|
|
# Now that argument processing is done, enforce the LenientFloat stuff
|
|
if lenientFloatCode:
|
|
if setter:
|
|
foundNonFiniteFloatBehavior = "return true;\n"
|
|
else:
|
|
assert idlNode.isMethod()
|
|
foundNonFiniteFloatBehavior = dedent(
|
|
"""
|
|
args.rval().setUndefined();
|
|
return true;
|
|
""")
|
|
cgThings.append(CGGeneric(fill(
|
|
"""
|
|
if (foundNonFiniteFloat) {
|
|
$*{returnSteps}
|
|
}
|
|
""",
|
|
returnSteps=foundNonFiniteFloatBehavior)))
|
|
|
|
if needsUnwrap:
|
|
# Something depends on having the unwrapped object, so unwrap it now.
|
|
xraySteps = []
|
|
# XXXkhuey we should be able to MOZ_ASSERT that ${obj} is
|
|
# not null.
|
|
xraySteps.append(
|
|
CGGeneric(fill(
|
|
"""
|
|
${obj} = js::CheckedUnwrap(${obj});
|
|
if (!${obj}) {
|
|
return false;
|
|
}
|
|
""",
|
|
obj=unwrappedVar)))
|
|
if isConstructor:
|
|
# If we're called via an xray, we need to enter the underlying
|
|
# object's compartment and then wrap up all of our arguments into
|
|
# that compartment as needed. This is all happening after we've
|
|
# already done the conversions from JS values to WebIDL (C++)
|
|
# values, so we only need to worry about cases where there are 'any'
|
|
# or 'object' types, or other things that we represent as actual
|
|
# JSAPI types, present. Effectively, we're emulating a
|
|
# CrossCompartmentWrapper, but working with the C++ types, not the
|
|
# original list of JS::Values.
|
|
cgThings.append(CGGeneric("Maybe<JSAutoCompartment> ac;\n"))
|
|
xraySteps.append(CGGeneric("ac.emplace(cx, obj);\n"))
|
|
xraySteps.append(CGGeneric(dedent(
|
|
"""
|
|
if (!JS_WrapObject(cx, &desiredProto)) {
|
|
return false;
|
|
}
|
|
""")))
|
|
xraySteps.extend(
|
|
wrapArgIntoCurrentCompartment(arg, argname, isMember=False)
|
|
for arg, argname in self.getArguments())
|
|
|
|
cgThings.append(
|
|
CGIfWrapper(CGList(xraySteps),
|
|
"objIsXray"))
|
|
|
|
if (idlNode.getExtendedAttribute('CEReactions') is not None and
|
|
not getter):
|
|
cgThings.append(CGGeneric(dedent(
|
|
"""
|
|
Maybe<AutoCEReaction> ceReaction;
|
|
DocGroup* docGroup = self->GetDocGroup();
|
|
if (docGroup) {
|
|
ceReaction.emplace(docGroup->CustomElementReactionsStack(), cx);
|
|
}
|
|
""")))
|
|
|
|
# If this is a method that was generated by a maplike/setlike
|
|
# interface, use the maplike/setlike generator to fill in the body.
|
|
# Otherwise, use CGCallGenerator to call the native method.
|
|
if idlNode.isMethod() and idlNode.isMaplikeOrSetlikeOrIterableMethod():
|
|
if (idlNode.maplikeOrSetlikeOrIterable.isMaplike() or
|
|
idlNode.maplikeOrSetlikeOrIterable.isSetlike()):
|
|
cgThings.append(CGMaplikeOrSetlikeMethodGenerator(descriptor,
|
|
idlNode.maplikeOrSetlikeOrIterable,
|
|
idlNode.identifier.name))
|
|
else:
|
|
cgThings.append(CGIterableMethodGenerator(descriptor,
|
|
idlNode.maplikeOrSetlikeOrIterable,
|
|
idlNode.identifier.name))
|
|
else:
|
|
cgThings.append(CGCallGenerator(
|
|
self.isFallible(),
|
|
idlNode.getExtendedAttribute('NeedsSubjectPrincipal'),
|
|
needsCallerType(idlNode),
|
|
self.getArguments(), argsPre, returnType,
|
|
self.extendedAttributes, descriptor,
|
|
nativeMethodName,
|
|
static, argsPost=argsPost, resultVar=resultVar))
|
|
|
|
if useCounterName:
|
|
# Generate a telemetry call for when [UseCounter] is used.
|
|
code = "SetDocumentAndPageUseCounter(cx, obj, eUseCounter_%s);\n" % useCounterName
|
|
cgThings.append(CGGeneric(code))
|
|
|
|
self.cgRoot = CGList(cgThings)
|
|
|
|
def getArguments(self):
|
|
return [(a, "arg" + str(i)) for i, a in enumerate(self.arguments)]
|
|
|
|
def isFallible(self):
|
|
return 'infallible' not in self.extendedAttributes
|
|
|
|
def wrap_return_value(self):
|
|
wrapCode = ""
|
|
|
|
returnsNewObject = memberReturnsNewObject(self.idlNode)
|
|
if (returnsNewObject and
|
|
(self.returnType.isGeckoInterface() or
|
|
self.returnType.isPromise())):
|
|
wrapCode += dedent(
|
|
"""
|
|
static_assert(!IsPointer<decltype(result)>::value,
|
|
"NewObject implies that we need to keep the object alive with a strong reference.");
|
|
""")
|
|
|
|
setSlot = self.idlNode.isAttr() and self.idlNode.slotIndices is not None
|
|
if setSlot:
|
|
# For attributes in slots, we want to do some
|
|
# post-processing once we've wrapped them.
|
|
successCode = "break;\n"
|
|
else:
|
|
successCode = None
|
|
|
|
resultTemplateValues = {
|
|
'jsvalRef': 'args.rval()',
|
|
'jsvalHandle': 'args.rval()',
|
|
'returnsNewObject': returnsNewObject,
|
|
'isConstructorRetval': self.isConstructor,
|
|
'successCode': successCode,
|
|
# 'obj' in this dictionary is the thing whose compartment we are
|
|
# trying to do the to-JS conversion in. We're going to put that
|
|
# thing in a variable named "conversionScope" if setSlot is true.
|
|
# Otherwise, just use "obj" for lack of anything better.
|
|
'obj': "conversionScope" if setSlot else "obj"
|
|
}
|
|
try:
|
|
wrapCode += wrapForType(self.returnType, self.descriptor, resultTemplateValues)
|
|
except MethodNotNewObjectError, err:
|
|
assert not returnsNewObject
|
|
raise TypeError("%s being returned from non-NewObject method or property %s.%s" %
|
|
(err.typename,
|
|
self.descriptor.interface.identifier.name,
|
|
self.idlNode.identifier.name))
|
|
if setSlot:
|
|
# When using a slot on the Xray expando, we need to make sure that
|
|
# our initial conversion to a JS::Value is done in the caller
|
|
# compartment. When using a slot on our reflector, we want to do
|
|
# the conversion in the compartment of that reflector (that is,
|
|
# slotStorage). In both cases we want to make sure that we finally
|
|
# set up args.rval() to be in the caller compartment. We also need
|
|
# to make sure that the conversion steps happen inside a do/while
|
|
# that they can break out of on success.
|
|
#
|
|
# Of course we always have to wrap the value into the slotStorage
|
|
# compartment before we store it in slotStorage.
|
|
|
|
# postConversionSteps are the steps that run while we're still in
|
|
# the compartment we do our conversion in but after we've finished
|
|
# the initial conversion into args.rval().
|
|
postConversionSteps = ""
|
|
if needsContainsHack(self.idlNode):
|
|
# Define a .contains on the object that has the same value as
|
|
# .includes; needed for backwards compat in extensions as we
|
|
# migrate some DOMStringLists to FrozenArray.
|
|
postConversionSteps += dedent(
|
|
"""
|
|
if (args.rval().isObject() && nsContentUtils::ThreadsafeIsCallerChrome()) {
|
|
JS::Rooted<JSObject*> rvalObj(cx, &args.rval().toObject());
|
|
JS::Rooted<JS::Value> includesVal(cx);
|
|
if (!JS_GetProperty(cx, rvalObj, "includes", &includesVal) ||
|
|
!JS_DefineProperty(cx, rvalObj, "contains", includesVal, JSPROP_ENUMERATE)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
""")
|
|
if self.idlNode.getExtendedAttribute("Frozen"):
|
|
assert self.idlNode.type.isSequence() or self.idlNode.type.isDictionary()
|
|
freezeValue = CGGeneric(
|
|
"JS::Rooted<JSObject*> rvalObj(cx, &args.rval().toObject());\n"
|
|
"if (!JS_FreezeObject(cx, rvalObj)) {\n"
|
|
" return false;\n"
|
|
"}\n")
|
|
if self.idlNode.type.nullable():
|
|
freezeValue = CGIfWrapper(freezeValue,
|
|
"args.rval().isObject()")
|
|
postConversionSteps += freezeValue.define()
|
|
|
|
# slotStorageSteps are steps that run once we have entered the
|
|
# slotStorage compartment.
|
|
slotStorageSteps= fill(
|
|
"""
|
|
// Make a copy so that we don't do unnecessary wrapping on args.rval().
|
|
JS::Rooted<JS::Value> storedVal(cx, args.rval());
|
|
if (!${maybeWrap}(cx, &storedVal)) {
|
|
return false;
|
|
}
|
|
js::SetReservedSlot(slotStorage, slotIndex, storedVal);
|
|
""",
|
|
maybeWrap=getMaybeWrapValueFuncForType(self.idlNode.type))
|
|
|
|
checkForXray = mayUseXrayExpandoSlots(self.descriptor, self.idlNode)
|
|
|
|
# For the case of Cached attributes, go ahead and preserve our
|
|
# wrapper if needed. We need to do this because otherwise the
|
|
# wrapper could get garbage-collected and the cached value would
|
|
# suddenly disappear, but the whole premise of cached values is that
|
|
# they never change without explicit action on someone's part. We
|
|
# don't do this for StoreInSlot, since those get dealt with during
|
|
# wrapper setup, and failure would involve us trying to clear an
|
|
# already-preserved wrapper.
|
|
if (self.idlNode.getExtendedAttribute("Cached") and
|
|
self.descriptor.wrapperCache):
|
|
preserveWrapper = dedent(
|
|
"""
|
|
PreserveWrapper(self);
|
|
""")
|
|
if checkForXray:
|
|
preserveWrapper = fill(
|
|
"""
|
|
if (!isXray) {
|
|
// In the Xray case we don't need to do this, because getting the
|
|
// expando object already preserved our wrapper.
|
|
$*{preserveWrapper}
|
|
}
|
|
""",
|
|
preserveWrapper=preserveWrapper)
|
|
slotStorageSteps += preserveWrapper
|
|
|
|
if checkForXray:
|
|
conversionScope = "isXray ? obj : slotStorage"
|
|
else:
|
|
conversionScope = "slotStorage"
|
|
|
|
wrapCode = fill(
|
|
"""
|
|
{
|
|
JS::Rooted<JSObject*> conversionScope(cx, ${conversionScope});
|
|
JSAutoCompartment ac(cx, conversionScope);
|
|
do { // block we break out of when done wrapping
|
|
$*{wrapCode}
|
|
} while (0);
|
|
$*{postConversionSteps}
|
|
}
|
|
{ // And now store things in the compartment of our slotStorage.
|
|
JSAutoCompartment ac(cx, slotStorage);
|
|
$*{slotStorageSteps}
|
|
}
|
|
// And now make sure args.rval() is in the caller compartment
|
|
return ${maybeWrap}(cx, args.rval());
|
|
""",
|
|
conversionScope=conversionScope,
|
|
wrapCode=wrapCode,
|
|
postConversionSteps=postConversionSteps,
|
|
slotStorageSteps=slotStorageSteps,
|
|
maybeWrap=getMaybeWrapValueFuncForType(self.idlNode.type))
|
|
return wrapCode
|
|
|
|
def define(self):
|
|
return (self.cgRoot.define() + self.wrap_return_value())
|
|
|
|
|
|
class CGSwitch(CGList):
|
|
"""
|
|
A class to generate code for a switch statement.
|
|
|
|
Takes three constructor arguments: an expression, a list of cases,
|
|
and an optional default.
|
|
|
|
Each case is a CGCase. The default is a CGThing for the body of
|
|
the default case, if any.
|
|
"""
|
|
def __init__(self, expression, cases, default=None):
|
|
CGList.__init__(self, [CGIndenter(c) for c in cases])
|
|
self.prepend(CGGeneric("switch (" + expression + ") {\n"))
|
|
if default is not None:
|
|
self.append(
|
|
CGIndenter(
|
|
CGWrapper(
|
|
CGIndenter(default),
|
|
pre="default: {\n",
|
|
post=" break;\n}\n")))
|
|
|
|
self.append(CGGeneric("}\n"))
|
|
|
|
|
|
class CGCase(CGList):
|
|
"""
|
|
A class to generate code for a case statement.
|
|
|
|
Takes three constructor arguments: an expression, a CGThing for
|
|
the body (allowed to be None if there is no body), and an optional
|
|
argument (defaulting to False) for whether to fall through.
|
|
"""
|
|
def __init__(self, expression, body, fallThrough=False):
|
|
CGList.__init__(self, [])
|
|
self.append(CGGeneric("case " + expression + ": {\n"))
|
|
bodyList = CGList([body])
|
|
if fallThrough:
|
|
bodyList.append(CGGeneric("MOZ_FALLTHROUGH;\n"))
|
|
else:
|
|
bodyList.append(CGGeneric("break;\n"))
|
|
self.append(CGIndenter(bodyList))
|
|
self.append(CGGeneric("}\n"))
|
|
|
|
|
|
class CGMethodCall(CGThing):
|
|
"""
|
|
A class to generate selection of a method signature from a set of
|
|
signatures and generation of a call to that signature.
|
|
"""
|
|
def __init__(self, nativeMethodName, static, descriptor, method,
|
|
isConstructor=False, constructorName=None):
|
|
CGThing.__init__(self)
|
|
|
|
if isConstructor:
|
|
assert constructorName is not None
|
|
methodName = constructorName
|
|
else:
|
|
methodName = "%s.%s" % (descriptor.interface.identifier.name, method.identifier.name)
|
|
argDesc = "argument %d of " + methodName
|
|
|
|
if method.getExtendedAttribute("UseCounter"):
|
|
useCounterName = methodName.replace(".", "_")
|
|
else:
|
|
useCounterName = None
|
|
|
|
if method.isStatic():
|
|
nativeType = descriptor.nativeType
|
|
staticTypeOverride = PropertyDefiner.getStringAttr(method, "StaticClassOverride")
|
|
if (staticTypeOverride):
|
|
nativeType = staticTypeOverride
|
|
nativeMethodName = "%s::%s" % (nativeType, nativeMethodName)
|
|
|
|
def requiredArgCount(signature):
|
|
arguments = signature[1]
|
|
if len(arguments) == 0:
|
|
return 0
|
|
requiredArgs = len(arguments)
|
|
while requiredArgs and arguments[requiredArgs-1].optional:
|
|
requiredArgs -= 1
|
|
return requiredArgs
|
|
|
|
def getPerSignatureCall(signature, argConversionStartsAt=0):
|
|
return CGPerSignatureCall(signature[0], signature[1],
|
|
nativeMethodName, static, descriptor,
|
|
method,
|
|
argConversionStartsAt=argConversionStartsAt,
|
|
isConstructor=isConstructor,
|
|
useCounterName=useCounterName)
|
|
|
|
signatures = method.signatures()
|
|
if len(signatures) == 1:
|
|
# Special case: we can just do a per-signature method call
|
|
# here for our one signature and not worry about switching
|
|
# on anything.
|
|
signature = signatures[0]
|
|
self.cgRoot = CGList([getPerSignatureCall(signature)])
|
|
requiredArgs = requiredArgCount(signature)
|
|
|
|
# Skip required arguments check for maplike/setlike interfaces, as
|
|
# they can have arguments which are not passed, and are treated as
|
|
# if undefined had been explicitly passed.
|
|
if requiredArgs > 0 and not method.isMaplikeOrSetlikeOrIterableMethod():
|
|
code = fill(
|
|
"""
|
|
if (MOZ_UNLIKELY(args.length() < ${requiredArgs})) {
|
|
return ThrowErrorMessage(cx, MSG_MISSING_ARGUMENTS, "${methodName}");
|
|
}
|
|
""",
|
|
requiredArgs=requiredArgs,
|
|
methodName=methodName)
|
|
self.cgRoot.prepend(CGGeneric(code))
|
|
return
|
|
|
|
# Need to find the right overload
|
|
maxArgCount = method.maxArgCount
|
|
allowedArgCounts = method.allowedArgCounts
|
|
|
|
argCountCases = []
|
|
for argCountIdx, argCount in enumerate(allowedArgCounts):
|
|
possibleSignatures = method.signaturesForArgCount(argCount)
|
|
|
|
# Try to optimize away cases when the next argCount in the list
|
|
# will have the same code as us; if it does, we can fall through to
|
|
# that case.
|
|
if argCountIdx+1 < len(allowedArgCounts):
|
|
nextPossibleSignatures = method.signaturesForArgCount(allowedArgCounts[argCountIdx+1])
|
|
else:
|
|
nextPossibleSignatures = None
|
|
if possibleSignatures == nextPossibleSignatures:
|
|
# Same set of signatures means we better have the same
|
|
# distinguishing index. So we can in fact just fall through to
|
|
# the next case here.
|
|
assert (len(possibleSignatures) == 1 or
|
|
(method.distinguishingIndexForArgCount(argCount) ==
|
|
method.distinguishingIndexForArgCount(allowedArgCounts[argCountIdx+1])))
|
|
argCountCases.append(CGCase(str(argCount), None, True))
|
|
continue
|
|
|
|
if len(possibleSignatures) == 1:
|
|
# easy case!
|
|
signature = possibleSignatures[0]
|
|
argCountCases.append(
|
|
CGCase(str(argCount), getPerSignatureCall(signature)))
|
|
continue
|
|
|
|
distinguishingIndex = method.distinguishingIndexForArgCount(argCount)
|
|
|
|
def distinguishingArgument(signature):
|
|
args = signature[1]
|
|
if distinguishingIndex < len(args):
|
|
return args[distinguishingIndex]
|
|
assert args[-1].variadic
|
|
return args[-1]
|
|
|
|
def distinguishingType(signature):
|
|
return distinguishingArgument(signature).type
|
|
|
|
for sig in possibleSignatures:
|
|
# We should not have "any" args at distinguishingIndex,
|
|
# since we have multiple possible signatures remaining,
|
|
# but "any" is never distinguishable from anything else.
|
|
assert not distinguishingType(sig).isAny()
|
|
# We can't handle unions at the distinguishing index.
|
|
if distinguishingType(sig).isUnion():
|
|
raise TypeError("No support for unions as distinguishing "
|
|
"arguments yet: %s" %
|
|
distinguishingArgument(sig).location)
|
|
# We don't support variadics as the distinguishingArgument yet.
|
|
# If you want to add support, consider this case:
|
|
#
|
|
# void(long... foo);
|
|
# void(long bar, Int32Array baz);
|
|
#
|
|
# in which we have to convert argument 0 to long before picking
|
|
# an overload... but all the variadic stuff needs to go into a
|
|
# single array in case we pick that overload, so we have to have
|
|
# machinery for converting argument 0 to long and then either
|
|
# placing it in the variadic bit or not. Or something. We may
|
|
# be able to loosen this restriction if the variadic arg is in
|
|
# fact at distinguishingIndex, perhaps. Would need to
|
|
# double-check.
|
|
if distinguishingArgument(sig).variadic:
|
|
raise TypeError("No support for variadics as distinguishing "
|
|
"arguments yet: %s" %
|
|
distinguishingArgument(sig).location)
|
|
|
|
# Convert all our arguments up to the distinguishing index.
|
|
# Doesn't matter which of the possible signatures we use, since
|
|
# they all have the same types up to that point; just use
|
|
# possibleSignatures[0]
|
|
caseBody = [CGArgumentConverter(possibleSignatures[0][1][i],
|
|
i, descriptor,
|
|
argDesc % (i + 1), method)
|
|
for i in range(0, distinguishingIndex)]
|
|
|
|
# Select the right overload from our set.
|
|
distinguishingArg = "args[%d]" % distinguishingIndex
|
|
|
|
def tryCall(signature, indent, isDefinitelyObject=False,
|
|
isNullOrUndefined=False):
|
|
assert not isDefinitelyObject or not isNullOrUndefined
|
|
assert isDefinitelyObject or isNullOrUndefined
|
|
if isDefinitelyObject:
|
|
failureCode = "break;\n"
|
|
else:
|
|
failureCode = None
|
|
type = distinguishingType(signature)
|
|
# The argument at index distinguishingIndex can't possibly be
|
|
# unset here, because we've already checked that argc is large
|
|
# enough that we can examine this argument. But note that we
|
|
# still want to claim that optional arguments are optional, in
|
|
# case undefined was passed in.
|
|
argIsOptional = distinguishingArgument(signature).canHaveMissingValue()
|
|
testCode = instantiateJSToNativeConversion(
|
|
getJSToNativeConversionInfo(type, descriptor,
|
|
failureCode=failureCode,
|
|
isDefinitelyObject=isDefinitelyObject,
|
|
isNullOrUndefined=isNullOrUndefined,
|
|
isOptional=argIsOptional,
|
|
sourceDescription=(argDesc % (distinguishingIndex + 1))),
|
|
{
|
|
"declName": "arg%d" % distinguishingIndex,
|
|
"holderName": ("arg%d" % distinguishingIndex) + "_holder",
|
|
"val": distinguishingArg,
|
|
"obj": "obj",
|
|
"haveValue": "args.hasDefined(%d)" % distinguishingIndex,
|
|
"passedToJSImpl": toStringBool(isJSImplementedDescriptor(descriptor))
|
|
},
|
|
checkForValue=argIsOptional)
|
|
caseBody.append(CGIndenter(testCode, indent))
|
|
|
|
# If we got this far, we know we unwrapped to the right
|
|
# C++ type, so just do the call. Start conversion with
|
|
# distinguishingIndex + 1, since we already converted
|
|
# distinguishingIndex.
|
|
caseBody.append(CGIndenter(
|
|
getPerSignatureCall(signature, distinguishingIndex + 1),
|
|
indent))
|
|
|
|
def hasConditionalConversion(type):
|
|
"""
|
|
Return whether the argument conversion for this type will be
|
|
conditional on the type of incoming JS value. For example, for
|
|
interface types the conversion is conditional on the incoming
|
|
value being isObject().
|
|
|
|
For the types for which this returns false, we do not have to
|
|
output extra isUndefined() or isNullOrUndefined() cases, because
|
|
null/undefined values will just fall through into our
|
|
unconditional conversion.
|
|
"""
|
|
if type.isString() or type.isEnum():
|
|
return False
|
|
if type.isBoolean():
|
|
distinguishingTypes = (distinguishingType(s) for s in
|
|
possibleSignatures)
|
|
return any(t.isString() or t.isEnum() or t.isNumeric()
|
|
for t in distinguishingTypes)
|
|
if type.isNumeric():
|
|
distinguishingTypes = (distinguishingType(s) for s in
|
|
possibleSignatures)
|
|
return any(t.isString() or t.isEnum()
|
|
for t in distinguishingTypes)
|
|
return True
|
|
|
|
def needsNullOrUndefinedCase(type):
|
|
"""
|
|
Return true if the type needs a special isNullOrUndefined() case
|
|
"""
|
|
return ((type.nullable() and
|
|
hasConditionalConversion(type)) or
|
|
type.isDictionary())
|
|
|
|
# First check for undefined and optional distinguishing arguments
|
|
# and output a special branch for that case. Note that we don't
|
|
# use distinguishingArgument here because we actualy want to
|
|
# exclude variadic arguments. Also note that we skip this check if
|
|
# we plan to output a isNullOrUndefined() special case for this
|
|
# argument anyway, since that will subsume our isUndefined() check.
|
|
# This is safe, because there can be at most one nullable
|
|
# distinguishing argument, so if we're it we'll definitely get
|
|
# picked up by the nullable handling. Also, we can skip this check
|
|
# if the argument has an unconditional conversion later on.
|
|
undefSigs = [s for s in possibleSignatures if
|
|
distinguishingIndex < len(s[1]) and
|
|
s[1][distinguishingIndex].optional and
|
|
hasConditionalConversion(s[1][distinguishingIndex].type) and
|
|
not needsNullOrUndefinedCase(s[1][distinguishingIndex].type)]
|
|
# Can't have multiple signatures with an optional argument at the
|
|
# same index.
|
|
assert len(undefSigs) < 2
|
|
if len(undefSigs) > 0:
|
|
caseBody.append(CGGeneric("if (%s.isUndefined()) {\n" %
|
|
distinguishingArg))
|
|
tryCall(undefSigs[0], 2, isNullOrUndefined=True)
|
|
caseBody.append(CGGeneric("}\n"))
|
|
|
|
# Next, check for null or undefined. That means looking for
|
|
# nullable arguments at the distinguishing index and outputting a
|
|
# separate branch for them. But if the nullable argument has an
|
|
# unconditional conversion, we don't need to do that. The reason
|
|
# for that is that at most one argument at the distinguishing index
|
|
# is nullable (since two nullable arguments are not
|
|
# distinguishable), and null/undefined values will always fall
|
|
# through to the unconditional conversion we have, if any, since
|
|
# they will fail whatever the conditions on the input value are for
|
|
# our other conversions.
|
|
nullOrUndefSigs = [s for s in possibleSignatures
|
|
if needsNullOrUndefinedCase(distinguishingType(s))]
|
|
# Can't have multiple nullable types here
|
|
assert len(nullOrUndefSigs) < 2
|
|
if len(nullOrUndefSigs) > 0:
|
|
caseBody.append(CGGeneric("if (%s.isNullOrUndefined()) {\n" %
|
|
distinguishingArg))
|
|
tryCall(nullOrUndefSigs[0], 2, isNullOrUndefined=True)
|
|
caseBody.append(CGGeneric("}\n"))
|
|
|
|
# Now check for distinguishingArg being various kinds of objects.
|
|
# The spec says to check for the following things in order:
|
|
# 1) A platform object that's not a platform array object, being
|
|
# passed to an interface or "object" arg.
|
|
# 2) A Date object being passed to a Date or "object" arg.
|
|
# 3) A RegExp object being passed to a RegExp or "object" arg.
|
|
# 4) A callable object being passed to a callback or "object" arg.
|
|
# 5) An iterable object being passed to a sequence arg.
|
|
# 6) Any non-Date and non-RegExp object being passed to a
|
|
# array or callback interface or dictionary or
|
|
# "object" arg.
|
|
|
|
# First grab all the overloads that have a non-callback interface
|
|
# (which includes typed arrays and arraybuffers) at the
|
|
# distinguishing index. We can also include the ones that have an
|
|
# "object" here, since if those are present no other object-typed
|
|
# argument will be.
|
|
objectSigs = [
|
|
s for s in possibleSignatures
|
|
if (distinguishingType(s).isObject() or
|
|
distinguishingType(s).isNonCallbackInterface())]
|
|
|
|
# And all the overloads that take Date
|
|
objectSigs.extend(s for s in possibleSignatures
|
|
if distinguishingType(s).isDate())
|
|
|
|
# And all the overloads that take callbacks
|
|
objectSigs.extend(s for s in possibleSignatures
|
|
if distinguishingType(s).isCallback())
|
|
|
|
# And all the overloads that take sequences
|
|
objectSigs.extend(s for s in possibleSignatures
|
|
if distinguishingType(s).isSequence())
|
|
|
|
# Now append all the overloads that take a dictionary or callback
|
|
# interface or record. There should be only one of these!
|
|
genericObjectSigs = [
|
|
s for s in possibleSignatures
|
|
if (distinguishingType(s).isDictionary() or
|
|
distinguishingType(s).isRecord() or
|
|
distinguishingType(s).isCallbackInterface())]
|
|
assert len(genericObjectSigs) <= 1
|
|
objectSigs.extend(genericObjectSigs)
|
|
|
|
# There might be more than one thing in objectSigs; we need to check
|
|
# which ones we unwrap to.
|
|
if len(objectSigs) > 0:
|
|
# Here it's enough to guard on our argument being an object. The
|
|
# code for unwrapping non-callback interfaces, typed arrays,
|
|
# sequences, and Dates will just bail out and move on to
|
|
# the next overload if the object fails to unwrap correctly,
|
|
# while "object" accepts any object anyway. We could even not
|
|
# do the isObject() check up front here, but in cases where we
|
|
# have multiple object overloads it makes sense to do it only
|
|
# once instead of for each overload. That will also allow the
|
|
# unwrapping test to skip having to do codegen for the
|
|
# null-or-undefined case, which we already handled above.
|
|
caseBody.append(CGGeneric("if (%s.isObject()) {\n" %
|
|
distinguishingArg))
|
|
for sig in objectSigs:
|
|
caseBody.append(CGIndenter(CGGeneric("do {\n")))
|
|
# Indent by 4, since we need to indent further
|
|
# than our "do" statement
|
|
tryCall(sig, 4, isDefinitelyObject=True)
|
|
caseBody.append(CGIndenter(CGGeneric("} while (0);\n")))
|
|
|
|
caseBody.append(CGGeneric("}\n"))
|
|
|
|
# Now we only have to consider booleans, numerics, and strings. If
|
|
# we only have one of them, then we can just output it. But if not,
|
|
# then we need to output some of the cases conditionally: if we have
|
|
# a string overload, then boolean and numeric are conditional, and
|
|
# if not then boolean is conditional if we have a numeric overload.
|
|
def findUniqueSignature(filterLambda):
|
|
sigs = filter(filterLambda, possibleSignatures)
|
|
assert len(sigs) < 2
|
|
if len(sigs) > 0:
|
|
return sigs[0]
|
|
return None
|
|
|
|
stringSignature = findUniqueSignature(
|
|
lambda s: (distinguishingType(s).isString() or
|
|
distinguishingType(s).isEnum()))
|
|
numericSignature = findUniqueSignature(
|
|
lambda s: distinguishingType(s).isNumeric())
|
|
booleanSignature = findUniqueSignature(
|
|
lambda s: distinguishingType(s).isBoolean())
|
|
|
|
if stringSignature or numericSignature:
|
|
booleanCondition = "%s.isBoolean()"
|
|
else:
|
|
booleanCondition = None
|
|
|
|
if stringSignature:
|
|
numericCondition = "%s.isNumber()"
|
|
else:
|
|
numericCondition = None
|
|
|
|
def addCase(sig, condition):
|
|
sigCode = getPerSignatureCall(sig, distinguishingIndex)
|
|
if condition:
|
|
sigCode = CGIfWrapper(sigCode,
|
|
condition % distinguishingArg)
|
|
caseBody.append(sigCode)
|
|
|
|
if booleanSignature:
|
|
addCase(booleanSignature, booleanCondition)
|
|
if numericSignature:
|
|
addCase(numericSignature, numericCondition)
|
|
if stringSignature:
|
|
addCase(stringSignature, None)
|
|
|
|
if (not booleanSignature and not numericSignature and
|
|
not stringSignature):
|
|
# Just throw; we have no idea what we're supposed to
|
|
# do with this.
|
|
caseBody.append(CGGeneric(
|
|
'return ThrowErrorMessage(cx, MSG_OVERLOAD_RESOLUTION_FAILED, "%d", "%d", "%s");\n' %
|
|
(distinguishingIndex + 1, argCount, methodName)))
|
|
|
|
argCountCases.append(CGCase(str(argCount), CGList(caseBody)))
|
|
|
|
overloadCGThings = []
|
|
overloadCGThings.append(
|
|
CGGeneric("unsigned argcount = std::min(args.length(), %du);\n" %
|
|
maxArgCount))
|
|
overloadCGThings.append(
|
|
CGSwitch("argcount",
|
|
argCountCases,
|
|
CGGeneric('return ThrowErrorMessage(cx, MSG_MISSING_ARGUMENTS, "%s");\n' %
|
|
methodName)))
|
|
overloadCGThings.append(
|
|
CGGeneric('MOZ_CRASH("We have an always-returning default case");\n'
|
|
'return false;\n'))
|
|
self.cgRoot = CGList(overloadCGThings)
|
|
|
|
def define(self):
|
|
return self.cgRoot.define()
|
|
|
|
|
|
class CGGetterCall(CGPerSignatureCall):
|
|
"""
|
|
A class to generate a native object getter call for a particular IDL
|
|
getter.
|
|
"""
|
|
def __init__(self, returnType, nativeMethodName, descriptor, attr):
|
|
if attr.getExtendedAttribute("UseCounter"):
|
|
useCounterName = "%s_%s_getter" % (descriptor.interface.identifier.name,
|
|
attr.identifier.name)
|
|
else:
|
|
useCounterName = None
|
|
if attr.isStatic():
|
|
nativeMethodName = "%s::%s" % (descriptor.nativeType, nativeMethodName)
|
|
CGPerSignatureCall.__init__(self, returnType, [], nativeMethodName,
|
|
attr.isStatic(), descriptor, attr,
|
|
getter=True, useCounterName=useCounterName)
|
|
|
|
|
|
class CGNavigatorGetterCall(CGPerSignatureCall):
|
|
"""
|
|
A class to generate a native object getter call for an IDL getter for a
|
|
property generated by NavigatorProperty.
|
|
"""
|
|
def __init__(self, returnType, _, descriptor, attr):
|
|
nativeMethodName = "%s::ConstructNavigatorObject" % (toBindingNamespace(returnType.inner.identifier.name))
|
|
CGPerSignatureCall.__init__(self, returnType, [], nativeMethodName,
|
|
True, descriptor, attr, getter=True)
|
|
|
|
def getArguments(self):
|
|
# The navigator object should be associated with the global of
|
|
# the navigator it's coming from, which will be the global of
|
|
# the object whose slot it gets cached in. That's stored in
|
|
# "slotStorage".
|
|
return [(FakeArgument(BuiltinTypes[IDLBuiltinType.Types.object],
|
|
self.idlNode),
|
|
"slotStorage")]
|
|
|
|
|
|
class FakeIdentifier():
|
|
def __init__(self, name):
|
|
self.name = name
|
|
|
|
|
|
class FakeArgument():
|
|
"""
|
|
A class that quacks like an IDLArgument. This is used to make
|
|
setters look like method calls or for special operations.
|
|
"""
|
|
def __init__(self, type, interfaceMember, name="arg", allowTreatNonCallableAsNull=False):
|
|
self.type = type
|
|
self.optional = False
|
|
self.variadic = False
|
|
self.defaultValue = None
|
|
self._allowTreatNonCallableAsNull = allowTreatNonCallableAsNull
|
|
# For FakeArguments generated by maplike/setlike convenience functions,
|
|
# we won't have an interfaceMember to pass in.
|
|
if interfaceMember:
|
|
self.treatNullAs = interfaceMember.treatNullAs
|
|
else:
|
|
self.treatNullAs = "Default"
|
|
if isinstance(interfaceMember, IDLAttribute):
|
|
self.enforceRange = interfaceMember.enforceRange
|
|
self.clamp = interfaceMember.clamp
|
|
else:
|
|
self.enforceRange = False
|
|
self.clamp = False
|
|
|
|
self.identifier = FakeIdentifier(name)
|
|
|
|
def allowTreatNonCallableAsNull(self):
|
|
return self._allowTreatNonCallableAsNull
|
|
|
|
def canHaveMissingValue(self):
|
|
return False
|
|
|
|
|
|
class CGSetterCall(CGPerSignatureCall):
|
|
"""
|
|
A class to generate a native object setter call for a particular IDL
|
|
setter.
|
|
"""
|
|
def __init__(self, argType, nativeMethodName, descriptor, attr):
|
|
if attr.getExtendedAttribute("UseCounter"):
|
|
useCounterName = "%s_%s_setter" % (descriptor.interface.identifier.name,
|
|
attr.identifier.name)
|
|
else:
|
|
useCounterName = None
|
|
if attr.isStatic():
|
|
nativeMethodName = "%s::%s" % (descriptor.nativeType, nativeMethodName)
|
|
CGPerSignatureCall.__init__(self, None,
|
|
[FakeArgument(argType, attr, allowTreatNonCallableAsNull=True)],
|
|
nativeMethodName, attr.isStatic(),
|
|
descriptor, attr, setter=True, useCounterName=useCounterName)
|
|
|
|
def wrap_return_value(self):
|
|
attr = self.idlNode
|
|
if self.descriptor.wrapperCache and attr.slotIndices is not None:
|
|
if attr.getExtendedAttribute("StoreInSlot"):
|
|
args = "cx, self"
|
|
else:
|
|
args = "self"
|
|
clearSlot = ("%s(%s);\n" %
|
|
(MakeClearCachedValueNativeName(self.idlNode), args))
|
|
else:
|
|
clearSlot = ""
|
|
|
|
# We have no return value
|
|
return ("\n"
|
|
"%s"
|
|
"return true;\n" % clearSlot)
|
|
|
|
|
|
class CGAbstractBindingMethod(CGAbstractStaticMethod):
|
|
"""
|
|
Common class to generate the JSNatives for all our methods, getters, and
|
|
setters. This will generate the function declaration and unwrap the
|
|
|this| object. Subclasses are expected to override the generate_code
|
|
function to do the rest of the work. This function should return a
|
|
CGThing which is already properly indented.
|
|
|
|
getThisObj should be code for getting a JSObject* for the binding
|
|
object. If this is None, we will auto-generate code based on
|
|
descriptor to do the right thing. "" can be passed in if the
|
|
binding object is already stored in 'obj'.
|
|
|
|
callArgs should be code for getting a JS::CallArgs into a variable
|
|
called 'args'. This can be "" if there is already such a variable
|
|
around.
|
|
|
|
If allowCrossOriginThis is true, then this-unwrapping will first do an
|
|
UncheckedUnwrap and after that operate on the result.
|
|
"""
|
|
def __init__(self, descriptor, name, args, unwrapFailureCode=None,
|
|
getThisObj=None,
|
|
callArgs="JS::CallArgs args = JS::CallArgsFromVp(argc, vp);\n",
|
|
allowCrossOriginThis=False):
|
|
CGAbstractStaticMethod.__init__(self, descriptor, name, "bool", args)
|
|
|
|
if unwrapFailureCode is None:
|
|
self.unwrapFailureCode = 'return ThrowErrorMessage(cx, MSG_THIS_DOES_NOT_IMPLEMENT_INTERFACE, "Value", "%s");\n' % descriptor.interface.identifier.name
|
|
else:
|
|
self.unwrapFailureCode = unwrapFailureCode
|
|
|
|
if getThisObj == "":
|
|
self.getThisObj = None
|
|
else:
|
|
if getThisObj is None:
|
|
if descriptor.interface.isOnGlobalProtoChain():
|
|
ensureCondition = "!args.thisv().isNullOrUndefined() && !args.thisv().isObject()"
|
|
getThisObj = "args.thisv().isObject() ? &args.thisv().toObject() : js::GetGlobalForObjectCrossCompartment(&args.callee())"
|
|
else:
|
|
ensureCondition = "!args.thisv().isObject()"
|
|
getThisObj = "&args.thisv().toObject()"
|
|
unwrapFailureCode = self.unwrapFailureCode % {'securityError': 'false'}
|
|
ensureThisObj = CGIfWrapper(CGGeneric(unwrapFailureCode),
|
|
ensureCondition)
|
|
else:
|
|
ensureThisObj = None
|
|
self.getThisObj = CGList(
|
|
[ensureThisObj,
|
|
CGGeneric("JS::Rooted<JSObject*> obj(cx, %s);\n" %
|
|
getThisObj)])
|
|
self.callArgs = callArgs
|
|
self.allowCrossOriginThis = allowCrossOriginThis
|
|
|
|
def definition_body(self):
|
|
body = self.callArgs
|
|
if self.getThisObj is not None:
|
|
body += self.getThisObj.define() + "\n"
|
|
body += "%s* self;\n" % self.descriptor.nativeType
|
|
body += dedent(
|
|
"""
|
|
JS::Rooted<JS::Value> rootSelf(cx, JS::ObjectValue(*obj));
|
|
""")
|
|
|
|
# Our descriptor might claim that we're not castable, simply because
|
|
# we're someone's consequential interface. But for this-unwrapping, we
|
|
# know that we're the real deal. So fake a descriptor here for
|
|
# consumption by CastableObjectUnwrapper.
|
|
body += str(CastableObjectUnwrapper(
|
|
self.descriptor,
|
|
"rootSelf",
|
|
"&rootSelf",
|
|
"self",
|
|
self.unwrapFailureCode,
|
|
allowCrossOriginObj=self.allowCrossOriginThis))
|
|
|
|
return body + self.generate_code().define()
|
|
|
|
def generate_code(self):
|
|
assert False # Override me
|
|
|
|
|
|
class CGAbstractStaticBindingMethod(CGAbstractStaticMethod):
|
|
"""
|
|
Common class to generate the JSNatives for all our static methods, getters
|
|
and setters. This will generate the function declaration and unwrap the
|
|
global object. Subclasses are expected to override the generate_code
|
|
function to do the rest of the work. This function should return a
|
|
CGThing which is already properly indented.
|
|
"""
|
|
def __init__(self, descriptor, name):
|
|
CGAbstractStaticMethod.__init__(self, descriptor, name, "bool",
|
|
JSNativeArguments())
|
|
|
|
def definition_body(self):
|
|
# Make sure that "obj" is in the same compartment as "cx", since we'll
|
|
# later use it to wrap return values.
|
|
unwrap = dedent("""
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
JS::Rooted<JSObject*> obj(cx, &args.callee());
|
|
|
|
""")
|
|
return unwrap + self.generate_code().define()
|
|
|
|
def generate_code(self):
|
|
assert False # Override me
|
|
|
|
|
|
def MakeNativeName(name):
|
|
return name[0].upper() + IDLToCIdentifier(name[1:])
|
|
|
|
|
|
class CGGenericMethod(CGAbstractBindingMethod):
|
|
"""
|
|
A class for generating the C++ code for an IDL method.
|
|
|
|
If allowCrossOriginThis is true, then this-unwrapping will first do an
|
|
UncheckedUnwrap and after that operate on the result.
|
|
"""
|
|
def __init__(self, descriptor, allowCrossOriginThis=False):
|
|
unwrapFailureCode = (
|
|
'return ThrowInvalidThis(cx, args, %%(securityError)s, "%s");\n' %
|
|
descriptor.interface.identifier.name)
|
|
name = "genericCrossOriginMethod" if allowCrossOriginThis else "genericMethod"
|
|
CGAbstractBindingMethod.__init__(self, descriptor, name,
|
|
JSNativeArguments(),
|
|
unwrapFailureCode=unwrapFailureCode,
|
|
allowCrossOriginThis=allowCrossOriginThis)
|
|
|
|
def generate_code(self):
|
|
return CGGeneric(dedent("""
|
|
const JSJitInfo *info = FUNCTION_VALUE_TO_JITINFO(args.calleev());
|
|
MOZ_ASSERT(info->type() == JSJitInfo::Method);
|
|
JSJitMethodOp method = info->method;
|
|
bool ok = method(cx, obj, self, JSJitMethodCallArgs(args));
|
|
#ifdef DEBUG
|
|
if (ok) {
|
|
AssertReturnTypeMatchesJitinfo(info, args.rval());
|
|
}
|
|
#endif
|
|
return ok;
|
|
"""))
|
|
|
|
|
|
class CGGenericPromiseReturningMethod(CGAbstractBindingMethod):
|
|
"""
|
|
A class for generating the C++ code for an IDL method that returns a Promise.
|
|
|
|
Does not handle cross-origin this.
|
|
"""
|
|
def __init__(self, descriptor):
|
|
unwrapFailureCode = dedent("""
|
|
ThrowInvalidThis(cx, args, %%(securityError)s, "%s");\n
|
|
return ConvertExceptionToPromise(cx, xpc::XrayAwareCalleeGlobal(callee),
|
|
args.rval());\n""" %
|
|
descriptor.interface.identifier.name)
|
|
|
|
name = "genericPromiseReturningMethod"
|
|
customCallArgs = dedent("""
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
// Make sure to save the callee before someone maybe messes with rval().
|
|
JS::Rooted<JSObject*> callee(cx, &args.callee());
|
|
""")
|
|
|
|
CGAbstractBindingMethod.__init__(self, descriptor, name,
|
|
JSNativeArguments(),
|
|
callArgs=customCallArgs,
|
|
unwrapFailureCode=unwrapFailureCode)
|
|
|
|
def generate_code(self):
|
|
return CGGeneric(dedent("""
|
|
const JSJitInfo *info = FUNCTION_VALUE_TO_JITINFO(args.calleev());
|
|
MOZ_ASSERT(info->type() == JSJitInfo::Method);
|
|
JSJitMethodOp method = info->method;
|
|
bool ok = method(cx, obj, self, JSJitMethodCallArgs(args));
|
|
if (ok) {
|
|
#ifdef DEBUG
|
|
AssertReturnTypeMatchesJitinfo(info, args.rval());
|
|
#endif
|
|
return true;
|
|
}
|
|
|
|
MOZ_ASSERT(info->returnType() == JSVAL_TYPE_OBJECT);
|
|
return ConvertExceptionToPromise(cx, xpc::XrayAwareCalleeGlobal(callee),
|
|
args.rval());
|
|
"""))
|
|
|
|
|
|
class CGSpecializedMethod(CGAbstractStaticMethod):
|
|
"""
|
|
A class for generating the C++ code for a specialized method that the JIT
|
|
can call with lower overhead.
|
|
"""
|
|
def __init__(self, descriptor, method):
|
|
self.method = method
|
|
name = CppKeywords.checkMethodName(IDLToCIdentifier(method.identifier.name))
|
|
args = [Argument('JSContext*', 'cx'),
|
|
Argument('JS::Handle<JSObject*>', 'obj'),
|
|
Argument('%s*' % descriptor.nativeType, 'self'),
|
|
Argument('const JSJitMethodCallArgs&', 'args')]
|
|
CGAbstractStaticMethod.__init__(self, descriptor, name, 'bool', args)
|
|
|
|
def definition_body(self):
|
|
nativeName = CGSpecializedMethod.makeNativeName(self.descriptor,
|
|
self.method)
|
|
return CGMethodCall(nativeName, self.method.isStatic(), self.descriptor,
|
|
self.method).define()
|
|
|
|
@staticmethod
|
|
def makeNativeName(descriptor, method):
|
|
name = method.identifier.name
|
|
return MakeNativeName(descriptor.binaryNameFor(name))
|
|
|
|
|
|
class CGMethodPromiseWrapper(CGAbstractStaticMethod):
|
|
"""
|
|
A class for generating a wrapper around another method that will
|
|
convert exceptions to promises.
|
|
"""
|
|
def __init__(self, descriptor, methodToWrap):
|
|
self.method = methodToWrap
|
|
name = self.makeName(methodToWrap.name)
|
|
args = list(methodToWrap.args)
|
|
CGAbstractStaticMethod.__init__(self, descriptor, name, 'bool', args)
|
|
|
|
def definition_body(self):
|
|
return fill(
|
|
"""
|
|
// Make sure to save the callee before someone maybe messes
|
|
// with rval().
|
|
JS::Rooted<JSObject*> callee(cx, &args.callee());
|
|
bool ok = ${methodName}(${args});
|
|
if (ok) {
|
|
return true;
|
|
}
|
|
return ConvertExceptionToPromise(cx, xpc::XrayAwareCalleeGlobal(callee),
|
|
args.rval());
|
|
""",
|
|
methodName=self.method.name,
|
|
args=", ".join(arg.name for arg in self.args))
|
|
|
|
@staticmethod
|
|
def makeName(methodName):
|
|
return methodName + "_promiseWrapper"
|
|
|
|
|
|
class CGJsonifierMethod(CGSpecializedMethod):
|
|
def __init__(self, descriptor, method):
|
|
assert method.isJsonifier()
|
|
CGSpecializedMethod.__init__(self, descriptor, method)
|
|
|
|
def definition_body(self):
|
|
ret = dedent("""
|
|
JS::Rooted<JSObject*> result(cx, JS_NewPlainObject(cx));
|
|
if (!result) {
|
|
return false;
|
|
}
|
|
""")
|
|
|
|
jsonDescriptors = [self.descriptor]
|
|
interface = self.descriptor.interface.parent
|
|
while interface:
|
|
descriptor = self.descriptor.getDescriptor(interface.identifier.name)
|
|
if descriptor.operations['Jsonifier']:
|
|
jsonDescriptors.append(descriptor)
|
|
interface = interface.parent
|
|
|
|
# Iterate the array in reverse: oldest ancestor first
|
|
for descriptor in jsonDescriptors[::-1]:
|
|
ret += fill(
|
|
"""
|
|
if (!${parentclass}::JsonifyAttributes(cx, obj, self, result)) {
|
|
return false;
|
|
}
|
|
""",
|
|
parentclass=toBindingNamespace(descriptor.name)
|
|
)
|
|
ret += ('args.rval().setObject(*result);\n'
|
|
'return true;\n')
|
|
return ret
|
|
|
|
|
|
class CGLegacyCallHook(CGAbstractBindingMethod):
|
|
"""
|
|
Call hook for our object
|
|
"""
|
|
def __init__(self, descriptor):
|
|
self._legacycaller = descriptor.operations["LegacyCaller"]
|
|
# Our "self" is actually the callee in this case, not the thisval.
|
|
CGAbstractBindingMethod.__init__(
|
|
self, descriptor, LEGACYCALLER_HOOK_NAME,
|
|
JSNativeArguments(), getThisObj="&args.callee()")
|
|
|
|
def define(self):
|
|
if not self._legacycaller:
|
|
return ""
|
|
return CGAbstractBindingMethod.define(self)
|
|
|
|
def generate_code(self):
|
|
name = self._legacycaller.identifier.name
|
|
nativeName = MakeNativeName(self.descriptor.binaryNameFor(name))
|
|
return CGMethodCall(nativeName, False, self.descriptor,
|
|
self._legacycaller)
|
|
|
|
|
|
class CGResolveHook(CGAbstractClassHook):
|
|
"""
|
|
Resolve hook for objects that have the NeedResolve extended attribute.
|
|
"""
|
|
def __init__(self, descriptor):
|
|
assert descriptor.interface.getExtendedAttribute("NeedResolve")
|
|
|
|
args = [Argument('JSContext*', 'cx'),
|
|
Argument('JS::Handle<JSObject*>', 'obj'),
|
|
Argument('JS::Handle<jsid>', 'id'),
|
|
Argument('bool*', 'resolvedp')]
|
|
CGAbstractClassHook.__init__(self, descriptor, RESOLVE_HOOK_NAME,
|
|
"bool", args)
|
|
|
|
def generate_code(self):
|
|
return dedent("""
|
|
JS::Rooted<JS::PropertyDescriptor> desc(cx);
|
|
if (!self->DoResolve(cx, obj, id, &desc)) {
|
|
return false;
|
|
}
|
|
if (!desc.object()) {
|
|
return true;
|
|
}
|
|
// If desc.value() is undefined, then the DoResolve call
|
|
// has already defined it on the object. Don't try to also
|
|
// define it.
|
|
if (!desc.value().isUndefined()) {
|
|
desc.attributesRef() |= JSPROP_RESOLVING;
|
|
if (!JS_DefinePropertyById(cx, obj, id, desc)) {
|
|
return false;
|
|
}
|
|
}
|
|
*resolvedp = true;
|
|
return true;
|
|
""")
|
|
|
|
def definition_body(self):
|
|
if self.descriptor.isGlobal():
|
|
# Resolve standard classes
|
|
prefix = dedent("""
|
|
if (!ResolveGlobal(cx, obj, id, resolvedp)) {
|
|
return false;
|
|
}
|
|
if (*resolvedp) {
|
|
return true;
|
|
}
|
|
|
|
""")
|
|
else:
|
|
prefix = ""
|
|
return prefix + CGAbstractClassHook.definition_body(self)
|
|
|
|
|
|
class CGMayResolveHook(CGAbstractStaticMethod):
|
|
"""
|
|
Resolve hook for objects that have the NeedResolve extended attribute.
|
|
"""
|
|
def __init__(self, descriptor):
|
|
assert descriptor.interface.getExtendedAttribute("NeedResolve")
|
|
|
|
args = [Argument('const JSAtomState&', 'names'),
|
|
Argument('jsid', 'id'),
|
|
Argument('JSObject*', 'maybeObj')]
|
|
CGAbstractStaticMethod.__init__(self, descriptor, MAY_RESOLVE_HOOK_NAME,
|
|
"bool", args)
|
|
|
|
def definition_body(self):
|
|
if self.descriptor.isGlobal():
|
|
# Check whether this would resolve as a standard class.
|
|
prefix = dedent("""
|
|
if (MayResolveGlobal(names, id, maybeObj)) {
|
|
return true;
|
|
}
|
|
|
|
""")
|
|
else:
|
|
prefix = ""
|
|
return (prefix +
|
|
"return %s::MayResolve(id);\n" % self.descriptor.nativeType)
|
|
|
|
|
|
class CGEnumerateHook(CGAbstractBindingMethod):
|
|
"""
|
|
Enumerate hook for objects with custom hooks.
|
|
"""
|
|
def __init__(self, descriptor):
|
|
assert descriptor.interface.getExtendedAttribute("NeedResolve")
|
|
|
|
args = [Argument('JSContext*', 'cx'),
|
|
Argument('JS::Handle<JSObject*>', 'obj')]
|
|
# Our "self" is actually the "obj" argument in this case, not the thisval.
|
|
CGAbstractBindingMethod.__init__(
|
|
self, descriptor, ENUMERATE_HOOK_NAME,
|
|
args, getThisObj="", callArgs="")
|
|
|
|
def generate_code(self):
|
|
return CGGeneric(dedent("""
|
|
AutoTArray<nsString, 8> names;
|
|
binding_detail::FastErrorResult rv;
|
|
self->GetOwnPropertyNames(cx, names, rv);
|
|
if (rv.MaybeSetPendingException(cx)) {
|
|
return false;
|
|
}
|
|
bool dummy;
|
|
for (uint32_t i = 0; i < names.Length(); ++i) {
|
|
if (!JS_HasUCProperty(cx, obj, names[i].get(), names[i].Length(), &dummy)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
"""))
|
|
|
|
def definition_body(self):
|
|
if self.descriptor.isGlobal():
|
|
# Enumerate standard classes
|
|
prefix = dedent("""
|
|
if (!EnumerateGlobal(cx, obj)) {
|
|
return false;
|
|
}
|
|
|
|
""")
|
|
else:
|
|
prefix = ""
|
|
return prefix + CGAbstractBindingMethod.definition_body(self)
|
|
|
|
|
|
class CppKeywords():
|
|
"""
|
|
A class for checking if method names declared in webidl
|
|
are not in conflict with C++ keywords.
|
|
"""
|
|
keywords = frozenset([
|
|
'alignas', 'alignof', 'and', 'and_eq', 'asm', 'assert', 'auto', 'bitand', 'bitor', 'bool',
|
|
'break', 'case', 'catch', 'char', 'char16_t', 'char32_t', 'class', 'compl', 'const',
|
|
'constexpr', 'const_cast', 'continue', 'decltype', 'default', 'delete', 'do', 'double',
|
|
'dynamic_cast', 'else', 'enum', 'explicit', 'export', 'extern', 'false', 'final', 'float',
|
|
'for', 'friend', 'goto', 'if', 'inline', 'int', 'long', 'mutable', 'namespace', 'new',
|
|
'noexcept', 'not', 'not_eq', 'nullptr', 'operator', 'or', 'or_eq', 'override', 'private',
|
|
'protected', 'public', 'register', 'reinterpret_cast', 'return', 'short', 'signed',
|
|
'sizeof', 'static', 'static_assert', 'static_cast', 'struct', 'switch', 'template', 'this',
|
|
'thread_local', 'throw', 'true', 'try', 'typedef', 'typeid', 'typename', 'union',
|
|
'unsigned', 'using', 'virtual', 'void', 'volatile', 'wchar_t', 'while', 'xor', 'xor_eq'])
|
|
|
|
@staticmethod
|
|
def checkMethodName(name):
|
|
# Double '_' because 'assert' and '_assert' cannot be used in MS2013 compiler.
|
|
# Bug 964892 and bug 963560.
|
|
if name in CppKeywords.keywords:
|
|
name = '_' + name + '_'
|
|
return name
|
|
|
|
|
|
class CGStaticMethod(CGAbstractStaticBindingMethod):
|
|
"""
|
|
A class for generating the C++ code for an IDL static method.
|
|
"""
|
|
def __init__(self, descriptor, method):
|
|
self.method = method
|
|
name = CppKeywords.checkMethodName(IDLToCIdentifier(method.identifier.name))
|
|
CGAbstractStaticBindingMethod.__init__(self, descriptor, name)
|
|
|
|
def generate_code(self):
|
|
nativeName = CGSpecializedMethod.makeNativeName(self.descriptor,
|
|
self.method)
|
|
return CGMethodCall(nativeName, True, self.descriptor, self.method)
|
|
|
|
|
|
class CGGenericGetter(CGAbstractBindingMethod):
|
|
"""
|
|
A class for generating the C++ code for an IDL attribute getter.
|
|
"""
|
|
def __init__(self, descriptor, lenientThis=False, allowCrossOriginThis=False):
|
|
if lenientThis:
|
|
name = "genericLenientGetter"
|
|
unwrapFailureCode = dedent("""
|
|
MOZ_ASSERT(!JS_IsExceptionPending(cx));
|
|
if (!ReportLenientThisUnwrappingFailure(cx, &args.callee())) {
|
|
return false;
|
|
}
|
|
args.rval().set(JS::UndefinedValue());
|
|
return true;
|
|
""")
|
|
else:
|
|
if allowCrossOriginThis:
|
|
name = "genericCrossOriginGetter"
|
|
else:
|
|
name = "genericGetter"
|
|
unwrapFailureCode = (
|
|
'return ThrowInvalidThis(cx, args, %%(securityError)s, "%s");\n' %
|
|
descriptor.interface.identifier.name)
|
|
CGAbstractBindingMethod.__init__(self, descriptor, name, JSNativeArguments(),
|
|
unwrapFailureCode,
|
|
allowCrossOriginThis=allowCrossOriginThis)
|
|
|
|
def generate_code(self):
|
|
return CGGeneric(dedent("""
|
|
const JSJitInfo *info = FUNCTION_VALUE_TO_JITINFO(args.calleev());
|
|
MOZ_ASSERT(info->type() == JSJitInfo::Getter);
|
|
JSJitGetterOp getter = info->getter;
|
|
bool ok = getter(cx, obj, self, JSJitGetterCallArgs(args));
|
|
#ifdef DEBUG
|
|
if (ok) {
|
|
AssertReturnTypeMatchesJitinfo(info, args.rval());
|
|
}
|
|
#endif
|
|
return ok;
|
|
"""))
|
|
|
|
|
|
class CGSpecializedGetter(CGAbstractStaticMethod):
|
|
"""
|
|
A class for generating the code for a specialized attribute getter
|
|
that the JIT can call with lower overhead.
|
|
"""
|
|
def __init__(self, descriptor, attr):
|
|
self.attr = attr
|
|
name = 'get_' + IDLToCIdentifier(attr.identifier.name)
|
|
args = [
|
|
Argument('JSContext*', 'cx'),
|
|
Argument('JS::Handle<JSObject*>', 'obj'),
|
|
Argument('%s*' % descriptor.nativeType, 'self'),
|
|
Argument('JSJitGetterCallArgs', 'args')
|
|
]
|
|
CGAbstractStaticMethod.__init__(self, descriptor, name, "bool", args)
|
|
|
|
def definition_body(self):
|
|
if self.attr.isMaplikeOrSetlikeAttr():
|
|
# If the interface is maplike/setlike, there will be one getter
|
|
# method for the size property of the backing object. Due to having
|
|
# to unpack the backing object from the slot, this requires its own
|
|
# generator.
|
|
return getMaplikeOrSetlikeSizeGetterBody(self.descriptor, self.attr)
|
|
nativeName = CGSpecializedGetter.makeNativeName(self.descriptor,
|
|
self.attr)
|
|
if self.attr.slotIndices is not None:
|
|
if self.descriptor.hasXPConnectImpls:
|
|
raise TypeError("Interface '%s' has XPConnect impls, so we "
|
|
"can't use our slot for property '%s'!" %
|
|
(self.descriptor.interface.identifier.name,
|
|
self.attr.identifier.name))
|
|
|
|
# We're going to store this return value in a slot on some object,
|
|
# to cache it. The question is, which object? For dictionary and
|
|
# sequence return values, we want to use a slot on the Xray expando
|
|
# if we're called via Xrays, and a slot on our reflector otherwise.
|
|
# On the other hand, when dealing with some interfacce types
|
|
# (navigator properties, window.document) we want to avoid calling
|
|
# the getter more than once. In the case of navigator properties
|
|
# that's because the getter actually creates a new object each time.
|
|
# In the case of window.document, it's because the getter can start
|
|
# returning null, which would get hidden in he non-Xray case by the
|
|
# fact that it's [StoreOnSlot], so the cached version is always
|
|
# around.
|
|
#
|
|
# The upshot is that we use the reflector slot for any getter whose
|
|
# type is a gecko interface, whether we're called via Xrays or not.
|
|
# Since [Cached] and [StoreInSlot] cannot be used with "NewObject",
|
|
# we know that in the interface type case the returned object is
|
|
# wrappercached. So creating Xrays to it is reasonable.
|
|
if mayUseXrayExpandoSlots(self.descriptor, self.attr):
|
|
prefix = fill(
|
|
"""
|
|
// Have to either root across the getter call or reget after.
|
|
bool isXray;
|
|
JS::Rooted<JSObject*> slotStorage(cx, GetCachedSlotStorageObject(cx, obj, &isXray));
|
|
if (!slotStorage) {
|
|
return false;
|
|
}
|
|
const size_t slotIndex = isXray ? ${xraySlotIndex} : ${slotIndex};
|
|
""",
|
|
xraySlotIndex=memberXrayExpandoReservedSlot(self.attr,
|
|
self.descriptor),
|
|
slotIndex=memberReservedSlot(self.attr, self.descriptor))
|
|
else:
|
|
prefix = fill(
|
|
"""
|
|
// Have to either root across the getter call or reget after.
|
|
JS::Rooted<JSObject*> slotStorage(cx, js::UncheckedUnwrap(obj, /* stopAtWindowProxy = */ false));
|
|
MOZ_ASSERT(IsDOMObject(slotStorage));
|
|
const size_t slotIndex = ${slotIndex};
|
|
""",
|
|
slotIndex=memberReservedSlot(self.attr, self.descriptor))
|
|
|
|
prefix += fill(
|
|
"""
|
|
MOZ_ASSERT(JSCLASS_RESERVED_SLOTS(js::GetObjectClass(slotStorage)) > slotIndex);
|
|
{
|
|
// Scope for cachedVal
|
|
JS::Value cachedVal = js::GetReservedSlot(slotStorage, slotIndex);
|
|
if (!cachedVal.isUndefined()) {
|
|
args.rval().set(cachedVal);
|
|
// The cached value is in the compartment of slotStorage,
|
|
// so wrap into the caller compartment as needed.
|
|
return ${maybeWrap}(cx, args.rval());
|
|
}
|
|
}
|
|
|
|
""",
|
|
maybeWrap=getMaybeWrapValueFuncForType(self.attr.type))
|
|
else:
|
|
prefix = ""
|
|
|
|
if self.attr.navigatorObjectGetter:
|
|
cgGetterCall = CGNavigatorGetterCall
|
|
else:
|
|
cgGetterCall = CGGetterCall
|
|
return (prefix +
|
|
cgGetterCall(self.attr.type, nativeName,
|
|
self.descriptor, self.attr).define())
|
|
|
|
@staticmethod
|
|
def makeNativeName(descriptor, attr):
|
|
name = attr.identifier.name
|
|
nativeName = MakeNativeName(descriptor.binaryNameFor(name))
|
|
_, resultOutParam, _, _, _ = getRetvalDeclarationForType(attr.type,
|
|
descriptor)
|
|
infallible = ('infallible' in
|
|
descriptor.getExtendedAttributes(attr, getter=True))
|
|
if resultOutParam or attr.type.nullable() or not infallible:
|
|
nativeName = "Get" + nativeName
|
|
return nativeName
|
|
|
|
|
|
class CGStaticGetter(CGAbstractStaticBindingMethod):
|
|
"""
|
|
A class for generating the C++ code for an IDL static attribute getter.
|
|
"""
|
|
def __init__(self, descriptor, attr):
|
|
self.attr = attr
|
|
name = 'get_' + IDLToCIdentifier(attr.identifier.name)
|
|
CGAbstractStaticBindingMethod.__init__(self, descriptor, name)
|
|
|
|
def generate_code(self):
|
|
nativeName = CGSpecializedGetter.makeNativeName(self.descriptor,
|
|
self.attr)
|
|
return CGGetterCall(self.attr.type, nativeName, self.descriptor,
|
|
self.attr)
|
|
|
|
|
|
class CGGenericSetter(CGAbstractBindingMethod):
|
|
"""
|
|
A class for generating the C++ code for an IDL attribute setter.
|
|
"""
|
|
def __init__(self, descriptor, lenientThis=False, allowCrossOriginThis=False):
|
|
if lenientThis:
|
|
name = "genericLenientSetter"
|
|
unwrapFailureCode = dedent("""
|
|
MOZ_ASSERT(!JS_IsExceptionPending(cx));
|
|
if (!ReportLenientThisUnwrappingFailure(cx, &args.callee())) {
|
|
return false;
|
|
}
|
|
args.rval().set(JS::UndefinedValue());
|
|
return true;
|
|
""")
|
|
else:
|
|
if allowCrossOriginThis:
|
|
name = "genericCrossOriginSetter"
|
|
else:
|
|
name = "genericSetter"
|
|
unwrapFailureCode = (
|
|
'return ThrowInvalidThis(cx, args, %%(securityError)s, "%s");\n' %
|
|
descriptor.interface.identifier.name)
|
|
|
|
CGAbstractBindingMethod.__init__(self, descriptor, name, JSNativeArguments(),
|
|
unwrapFailureCode,
|
|
allowCrossOriginThis=allowCrossOriginThis)
|
|
|
|
def generate_code(self):
|
|
return CGGeneric(fill(
|
|
"""
|
|
if (args.length() == 0) {
|
|
return ThrowErrorMessage(cx, MSG_MISSING_ARGUMENTS, "${name} attribute setter");
|
|
}
|
|
const JSJitInfo *info = FUNCTION_VALUE_TO_JITINFO(args.calleev());
|
|
MOZ_ASSERT(info->type() == JSJitInfo::Setter);
|
|
JSJitSetterOp setter = info->setter;
|
|
if (!setter(cx, obj, self, JSJitSetterCallArgs(args))) {
|
|
return false;
|
|
}
|
|
args.rval().setUndefined();
|
|
#ifdef DEBUG
|
|
AssertReturnTypeMatchesJitinfo(info, args.rval());
|
|
#endif
|
|
return true;
|
|
""",
|
|
name=self.descriptor.interface.identifier.name))
|
|
|
|
|
|
class CGSpecializedSetter(CGAbstractStaticMethod):
|
|
"""
|
|
A class for generating the code for a specialized attribute setter
|
|
that the JIT can call with lower overhead.
|
|
"""
|
|
def __init__(self, descriptor, attr):
|
|
self.attr = attr
|
|
name = 'set_' + IDLToCIdentifier(attr.identifier.name)
|
|
args = [Argument('JSContext*', 'cx'),
|
|
Argument('JS::Handle<JSObject*>', 'obj'),
|
|
Argument('%s*' % descriptor.nativeType, 'self'),
|
|
Argument('JSJitSetterCallArgs', 'args')]
|
|
CGAbstractStaticMethod.__init__(self, descriptor, name, "bool", args)
|
|
|
|
def definition_body(self):
|
|
nativeName = CGSpecializedSetter.makeNativeName(self.descriptor,
|
|
self.attr)
|
|
return CGSetterCall(self.attr.type, nativeName, self.descriptor,
|
|
self.attr).define()
|
|
|
|
@staticmethod
|
|
def makeNativeName(descriptor, attr):
|
|
name = attr.identifier.name
|
|
return "Set" + MakeNativeName(descriptor.binaryNameFor(name))
|
|
|
|
|
|
class CGStaticSetter(CGAbstractStaticBindingMethod):
|
|
"""
|
|
A class for generating the C++ code for an IDL static attribute setter.
|
|
"""
|
|
def __init__(self, descriptor, attr):
|
|
self.attr = attr
|
|
name = 'set_' + IDLToCIdentifier(attr.identifier.name)
|
|
CGAbstractStaticBindingMethod.__init__(self, descriptor, name)
|
|
|
|
def generate_code(self):
|
|
nativeName = CGSpecializedSetter.makeNativeName(self.descriptor,
|
|
self.attr)
|
|
checkForArg = CGGeneric(fill(
|
|
"""
|
|
if (args.length() == 0) {
|
|
return ThrowErrorMessage(cx, MSG_MISSING_ARGUMENTS, "${name} setter");
|
|
}
|
|
""",
|
|
name=self.attr.identifier.name))
|
|
call = CGSetterCall(self.attr.type, nativeName, self.descriptor,
|
|
self.attr)
|
|
return CGList([checkForArg, call])
|
|
|
|
|
|
class CGSpecializedForwardingSetter(CGSpecializedSetter):
|
|
"""
|
|
A class for generating the code for a specialized attribute setter with
|
|
PutForwards that the JIT can call with lower overhead.
|
|
"""
|
|
def __init__(self, descriptor, attr):
|
|
CGSpecializedSetter.__init__(self, descriptor, attr)
|
|
|
|
def definition_body(self):
|
|
attrName = self.attr.identifier.name
|
|
forwardToAttrName = self.attr.getExtendedAttribute("PutForwards")[0]
|
|
# JS_GetProperty and JS_SetProperty can only deal with ASCII
|
|
assert all(ord(c) < 128 for c in attrName)
|
|
assert all(ord(c) < 128 for c in forwardToAttrName)
|
|
return fill(
|
|
"""
|
|
JS::Rooted<JS::Value> v(cx);
|
|
if (!JS_GetProperty(cx, obj, "${attr}", &v)) {
|
|
return false;
|
|
}
|
|
|
|
if (!v.isObject()) {
|
|
return ThrowErrorMessage(cx, MSG_NOT_OBJECT, "${interface}.${attr}");
|
|
}
|
|
|
|
JS::Rooted<JSObject*> targetObj(cx, &v.toObject());
|
|
return JS_SetProperty(cx, targetObj, "${forwardToAttrName}", args[0]);
|
|
""",
|
|
attr=attrName,
|
|
interface=self.descriptor.interface.identifier.name,
|
|
forwardToAttrName=forwardToAttrName)
|
|
|
|
|
|
class CGSpecializedReplaceableSetter(CGSpecializedSetter):
|
|
"""
|
|
A class for generating the code for a specialized attribute setter with
|
|
Replaceable that the JIT can call with lower overhead.
|
|
"""
|
|
def __init__(self, descriptor, attr):
|
|
CGSpecializedSetter.__init__(self, descriptor, attr)
|
|
|
|
def definition_body(self):
|
|
attrName = self.attr.identifier.name
|
|
# JS_DefineProperty can only deal with ASCII
|
|
assert all(ord(c) < 128 for c in attrName)
|
|
return ('return JS_DefineProperty(cx, obj, "%s", args[0], JSPROP_ENUMERATE);\n' %
|
|
attrName)
|
|
|
|
|
|
class CGSpecializedLenientSetter(CGSpecializedSetter):
|
|
"""
|
|
A class for generating the code for a specialized attribute setter with
|
|
LenientSetter that the JIT can call with lower overhead.
|
|
"""
|
|
def __init__(self, descriptor, attr):
|
|
CGSpecializedSetter.__init__(self, descriptor, attr)
|
|
|
|
def definition_body(self):
|
|
attrName = self.attr.identifier.name
|
|
# JS_DefineProperty can only deal with ASCII
|
|
assert all(ord(c) < 128 for c in attrName)
|
|
return dedent("""
|
|
DeprecationWarning(cx, obj, nsIDocument::eLenientSetter);
|
|
return true;
|
|
""")
|
|
|
|
|
|
def memberReturnsNewObject(member):
|
|
return member.getExtendedAttribute("NewObject") is not None
|
|
|
|
|
|
class CGMemberJITInfo(CGThing):
|
|
"""
|
|
A class for generating the JITInfo for a property that points to
|
|
our specialized getter and setter.
|
|
"""
|
|
def __init__(self, descriptor, member):
|
|
self.member = member
|
|
self.descriptor = descriptor
|
|
|
|
def declare(self):
|
|
return ""
|
|
|
|
def defineJitInfo(self, infoName, opName, opType, infallible, movable,
|
|
eliminatable, aliasSet, alwaysInSlot, lazilyInSlot,
|
|
slotIndex, returnTypes, args):
|
|
"""
|
|
aliasSet is a JSJitInfo::AliasSet value, without the "JSJitInfo::" bit.
|
|
|
|
args is None if we don't want to output argTypes for some
|
|
reason (e.g. we have overloads or we're not a method) and
|
|
otherwise an iterable of the arguments for this method.
|
|
"""
|
|
assert(not movable or aliasSet != "AliasEverything") # Can't move write-aliasing things
|
|
assert(not alwaysInSlot or movable) # Things always in slots had better be movable
|
|
assert(not eliminatable or aliasSet != "AliasEverything") # Can't eliminate write-aliasing things
|
|
assert(not alwaysInSlot or eliminatable) # Things always in slots had better be eliminatable
|
|
|
|
def jitInfoInitializer(isTypedMethod):
|
|
initializer = fill(
|
|
"""
|
|
{
|
|
{ ${opName} },
|
|
{ prototypes::id::${name} },
|
|
{ PrototypeTraits<prototypes::id::${name}>::Depth },
|
|
JSJitInfo::${opType},
|
|
JSJitInfo::${aliasSet}, /* aliasSet. Not relevant for setters. */
|
|
${returnType}, /* returnType. Not relevant for setters. */
|
|
${isInfallible}, /* isInfallible. False in setters. */
|
|
${isMovable}, /* isMovable. Not relevant for setters. */
|
|
${isEliminatable}, /* isEliminatable. Not relevant for setters. */
|
|
${isAlwaysInSlot}, /* isAlwaysInSlot. Only relevant for getters. */
|
|
${isLazilyCachedInSlot}, /* isLazilyCachedInSlot. Only relevant for getters. */
|
|
${isTypedMethod}, /* isTypedMethod. Only relevant for methods. */
|
|
${slotIndex} /* Reserved slot index, if we're stored in a slot, else 0. */
|
|
}
|
|
""",
|
|
opName=opName,
|
|
name=self.descriptor.name,
|
|
opType=opType,
|
|
aliasSet=aliasSet,
|
|
returnType=reduce(CGMemberJITInfo.getSingleReturnType, returnTypes,
|
|
""),
|
|
isInfallible=toStringBool(infallible),
|
|
isMovable=toStringBool(movable),
|
|
isEliminatable=toStringBool(eliminatable),
|
|
isAlwaysInSlot=toStringBool(alwaysInSlot),
|
|
isLazilyCachedInSlot=toStringBool(lazilyInSlot),
|
|
isTypedMethod=toStringBool(isTypedMethod),
|
|
slotIndex=slotIndex)
|
|
return initializer.rstrip()
|
|
|
|
slotAssert = fill(
|
|
"""
|
|
static_assert(${slotIndex} <= JSJitInfo::maxSlotIndex, "We won't fit");
|
|
static_assert(${slotIndex} < ${classReservedSlots}, "There is no slot for us");
|
|
""",
|
|
slotIndex=slotIndex,
|
|
classReservedSlots=INSTANCE_RESERVED_SLOTS + self.descriptor.interface.totalMembersInSlots)
|
|
if args is not None:
|
|
argTypes = "%s_argTypes" % infoName
|
|
args = [CGMemberJITInfo.getJSArgType(arg.type) for arg in args]
|
|
args.append("JSJitInfo::ArgTypeListEnd")
|
|
argTypesDecl = (
|
|
"static const JSJitInfo::ArgType %s[] = { %s };\n" %
|
|
(argTypes, ", ".join(args)))
|
|
return fill(
|
|
"""
|
|
$*{argTypesDecl}
|
|
static const JSTypedMethodJitInfo ${infoName} = {
|
|
${jitInfo},
|
|
${argTypes}
|
|
};
|
|
$*{slotAssert}
|
|
""",
|
|
argTypesDecl=argTypesDecl,
|
|
infoName=infoName,
|
|
jitInfo=indent(jitInfoInitializer(True)),
|
|
argTypes=argTypes,
|
|
slotAssert=slotAssert)
|
|
|
|
return fill(
|
|
"""
|
|
static const JSJitInfo ${infoName} = ${jitInfo};
|
|
$*{slotAssert}
|
|
""",
|
|
infoName=infoName,
|
|
jitInfo=jitInfoInitializer(False),
|
|
slotAssert=slotAssert)
|
|
|
|
def define(self):
|
|
if self.member.isAttr():
|
|
getterinfo = ("%s_getterinfo" %
|
|
IDLToCIdentifier(self.member.identifier.name))
|
|
# We need the cast here because JSJitGetterOp has a "void* self"
|
|
# while we have the right type.
|
|
getter = ("(JSJitGetterOp)get_%s" %
|
|
IDLToCIdentifier(self.member.identifier.name))
|
|
getterinfal = "infallible" in self.descriptor.getExtendedAttributes(self.member, getter=True)
|
|
|
|
movable = self.mayBeMovable() and getterinfal
|
|
eliminatable = self.mayBeEliminatable() and getterinfal
|
|
aliasSet = self.aliasSet()
|
|
|
|
getterinfal = getterinfal and infallibleForMember(self.member, self.member.type, self.descriptor)
|
|
isAlwaysInSlot = self.member.getExtendedAttribute("StoreInSlot")
|
|
if self.member.slotIndices is not None:
|
|
assert isAlwaysInSlot or self.member.getExtendedAttribute("Cached")
|
|
isLazilyCachedInSlot = not isAlwaysInSlot
|
|
slotIndex = memberReservedSlot(self.member, self.descriptor)
|
|
# We'll statically assert that this is not too big in
|
|
# CGUpdateMemberSlotsMethod, in the case when
|
|
# isAlwaysInSlot is true.
|
|
else:
|
|
isLazilyCachedInSlot = False
|
|
slotIndex = "0"
|
|
|
|
result = self.defineJitInfo(getterinfo, getter, "Getter",
|
|
getterinfal, movable, eliminatable,
|
|
aliasSet, isAlwaysInSlot,
|
|
isLazilyCachedInSlot, slotIndex,
|
|
[self.member.type], None)
|
|
if (not self.member.readonly or
|
|
self.member.getExtendedAttribute("PutForwards") is not None or
|
|
self.member.getExtendedAttribute("Replaceable") is not None or
|
|
self.member.getExtendedAttribute("LenientSetter") is not None):
|
|
setterinfo = ("%s_setterinfo" %
|
|
IDLToCIdentifier(self.member.identifier.name))
|
|
# Actually a JSJitSetterOp, but JSJitGetterOp is first in the
|
|
# union.
|
|
setter = ("(JSJitGetterOp)set_%s" %
|
|
IDLToCIdentifier(self.member.identifier.name))
|
|
# Setters are always fallible, since they have to do a typed unwrap.
|
|
result += self.defineJitInfo(setterinfo, setter, "Setter",
|
|
False, False, False, "AliasEverything",
|
|
False, False, "0",
|
|
[BuiltinTypes[IDLBuiltinType.Types.void]],
|
|
None)
|
|
return result
|
|
if self.member.isMethod():
|
|
methodinfo = ("%s_methodinfo" %
|
|
IDLToCIdentifier(self.member.identifier.name))
|
|
name = CppKeywords.checkMethodName(
|
|
IDLToCIdentifier(self.member.identifier.name))
|
|
if self.member.returnsPromise():
|
|
name = CGMethodPromiseWrapper.makeName(name)
|
|
# Actually a JSJitMethodOp, but JSJitGetterOp is first in the union.
|
|
method = ("(JSJitGetterOp)%s" % name)
|
|
|
|
# Methods are infallible if they are infallible, have no arguments
|
|
# to unwrap, and have a return type that's infallible to wrap up for
|
|
# return.
|
|
sigs = self.member.signatures()
|
|
if len(sigs) != 1:
|
|
# Don't handle overloading. If there's more than one signature,
|
|
# one of them must take arguments.
|
|
methodInfal = False
|
|
args = None
|
|
movable = False
|
|
eliminatable = False
|
|
else:
|
|
sig = sigs[0]
|
|
# For methods that affect nothing, it's OK to set movable to our
|
|
# notion of infallible on the C++ side, without considering
|
|
# argument conversions, since argument conversions that can
|
|
# reliably throw would be effectful anyway and the jit doesn't
|
|
# move effectful things.
|
|
hasInfallibleImpl = "infallible" in self.descriptor.getExtendedAttributes(self.member)
|
|
movable = self.mayBeMovable() and hasInfallibleImpl
|
|
eliminatable = self.mayBeEliminatable() and hasInfallibleImpl
|
|
# XXXbz can we move the smarts about fallibility due to arg
|
|
# conversions into the JIT, using our new args stuff?
|
|
if (len(sig[1]) != 0 or
|
|
not infallibleForMember(self.member, sig[0], self.descriptor)):
|
|
# We have arguments or our return-value boxing can fail
|
|
methodInfal = False
|
|
else:
|
|
methodInfal = hasInfallibleImpl
|
|
# For now, only bother to output args if we're side-effect-free.
|
|
if self.member.affects == "Nothing":
|
|
args = sig[1]
|
|
else:
|
|
args = None
|
|
|
|
aliasSet = self.aliasSet()
|
|
result = self.defineJitInfo(methodinfo, method, "Method",
|
|
methodInfal, movable, eliminatable,
|
|
aliasSet, False, False, "0",
|
|
[s[0] for s in sigs], args)
|
|
return result
|
|
raise TypeError("Illegal member type to CGPropertyJITInfo")
|
|
|
|
def mayBeMovable(self):
|
|
"""
|
|
Returns whether this attribute or method may be movable, just
|
|
based on Affects/DependsOn annotations.
|
|
"""
|
|
affects = self.member.affects
|
|
dependsOn = self.member.dependsOn
|
|
assert affects in IDLInterfaceMember.AffectsValues
|
|
assert dependsOn in IDLInterfaceMember.DependsOnValues
|
|
# Things that are DependsOn=DeviceState are not movable, because we
|
|
# don't want them coalesced with each other or loop-hoisted, since
|
|
# their return value can change even if nothing is going on from our
|
|
# point of view.
|
|
return (affects == "Nothing" and
|
|
(dependsOn != "Everything" and dependsOn != "DeviceState"))
|
|
|
|
def mayBeEliminatable(self):
|
|
"""
|
|
Returns whether this attribute or method may be eliminatable, just
|
|
based on Affects/DependsOn annotations.
|
|
"""
|
|
# dependsOn shouldn't affect this decision at all, except in jitinfo we
|
|
# have no way to express "Depends on everything, affects nothing",
|
|
# because we only have three alias set values: AliasNone ("depends on
|
|
# nothing, affects nothing"), AliasDOMSets ("depends on DOM sets,
|
|
# affects nothing"), AliasEverything ("depends on everything, affects
|
|
# everything"). So the [Affects=Nothing, DependsOn=Everything] case
|
|
# gets encoded as AliasEverything and defineJitInfo asserts that if our
|
|
# alias state is AliasEverything then we're not eliminatable (because it
|
|
# thinks we might have side-effects at that point). Bug 1155796 is
|
|
# tracking possible solutions for this.
|
|
affects = self.member.affects
|
|
dependsOn = self.member.dependsOn
|
|
assert affects in IDLInterfaceMember.AffectsValues
|
|
assert dependsOn in IDLInterfaceMember.DependsOnValues
|
|
return affects == "Nothing" and dependsOn != "Everything"
|
|
|
|
def aliasSet(self):
|
|
"""
|
|
Returns the alias set to store in the jitinfo. This may not be the
|
|
effective alias set the JIT uses, depending on whether we have enough
|
|
information about our args to allow the JIT to prove that effectful
|
|
argument conversions won't happen.
|
|
"""
|
|
dependsOn = self.member.dependsOn
|
|
assert dependsOn in IDLInterfaceMember.DependsOnValues
|
|
|
|
if dependsOn == "Nothing" or dependsOn == "DeviceState":
|
|
assert self.member.affects == "Nothing"
|
|
return "AliasNone"
|
|
|
|
if dependsOn == "DOMState":
|
|
assert self.member.affects == "Nothing"
|
|
return "AliasDOMSets"
|
|
|
|
return "AliasEverything"
|
|
|
|
@staticmethod
|
|
def getJSReturnTypeTag(t):
|
|
if t.nullable():
|
|
# Sometimes it might return null, sometimes not
|
|
return "JSVAL_TYPE_UNKNOWN"
|
|
if t.isVoid():
|
|
# No return, every time
|
|
return "JSVAL_TYPE_UNDEFINED"
|
|
if t.isSequence():
|
|
return "JSVAL_TYPE_OBJECT"
|
|
if t.isRecord():
|
|
return "JSVAL_TYPE_OBJECT"
|
|
if t.isPromise():
|
|
return "JSVAL_TYPE_OBJECT"
|
|
if t.isGeckoInterface():
|
|
return "JSVAL_TYPE_OBJECT"
|
|
if t.isString():
|
|
return "JSVAL_TYPE_STRING"
|
|
if t.isEnum():
|
|
return "JSVAL_TYPE_STRING"
|
|
if t.isCallback():
|
|
return "JSVAL_TYPE_OBJECT"
|
|
if t.isAny():
|
|
# The whole point is to return various stuff
|
|
return "JSVAL_TYPE_UNKNOWN"
|
|
if t.isObject():
|
|
return "JSVAL_TYPE_OBJECT"
|
|
if t.isSpiderMonkeyInterface():
|
|
return "JSVAL_TYPE_OBJECT"
|
|
if t.isUnion():
|
|
u = t.unroll()
|
|
if u.hasNullableType:
|
|
# Might be null or not
|
|
return "JSVAL_TYPE_UNKNOWN"
|
|
return reduce(CGMemberJITInfo.getSingleReturnType,
|
|
u.flatMemberTypes, "")
|
|
if t.isDictionary():
|
|
return "JSVAL_TYPE_OBJECT"
|
|
if t.isDate():
|
|
return "JSVAL_TYPE_OBJECT"
|
|
if not t.isPrimitive():
|
|
raise TypeError("No idea what type " + str(t) + " is.")
|
|
tag = t.tag()
|
|
if tag == IDLType.Tags.bool:
|
|
return "JSVAL_TYPE_BOOLEAN"
|
|
if tag in [IDLType.Tags.int8, IDLType.Tags.uint8,
|
|
IDLType.Tags.int16, IDLType.Tags.uint16,
|
|
IDLType.Tags.int32]:
|
|
return "JSVAL_TYPE_INT32"
|
|
if tag in [IDLType.Tags.int64, IDLType.Tags.uint64,
|
|
IDLType.Tags.unrestricted_float, IDLType.Tags.float,
|
|
IDLType.Tags.unrestricted_double, IDLType.Tags.double]:
|
|
# These all use JS_NumberValue, which can return int or double.
|
|
# But TI treats "double" as meaning "int or double", so we're
|
|
# good to return JSVAL_TYPE_DOUBLE here.
|
|
return "JSVAL_TYPE_DOUBLE"
|
|
if tag != IDLType.Tags.uint32:
|
|
raise TypeError("No idea what type " + str(t) + " is.")
|
|
# uint32 is sometimes int and sometimes double.
|
|
return "JSVAL_TYPE_DOUBLE"
|
|
|
|
@staticmethod
|
|
def getSingleReturnType(existingType, t):
|
|
type = CGMemberJITInfo.getJSReturnTypeTag(t)
|
|
if existingType == "":
|
|
# First element of the list; just return its type
|
|
return type
|
|
|
|
if type == existingType:
|
|
return existingType
|
|
if ((type == "JSVAL_TYPE_DOUBLE" and
|
|
existingType == "JSVAL_TYPE_INT32") or
|
|
(existingType == "JSVAL_TYPE_DOUBLE" and
|
|
type == "JSVAL_TYPE_INT32")):
|
|
# Promote INT32 to DOUBLE as needed
|
|
return "JSVAL_TYPE_DOUBLE"
|
|
# Different types
|
|
return "JSVAL_TYPE_UNKNOWN"
|
|
|
|
@staticmethod
|
|
def getJSArgType(t):
|
|
assert not t.isVoid()
|
|
if t.nullable():
|
|
# Sometimes it might return null, sometimes not
|
|
return "JSJitInfo::ArgType(JSJitInfo::Null | %s)" % CGMemberJITInfo.getJSArgType(t.inner)
|
|
if t.isSequence():
|
|
return "JSJitInfo::Object"
|
|
if t.isPromise():
|
|
return "JSJitInfo::Object"
|
|
if t.isGeckoInterface():
|
|
return "JSJitInfo::Object"
|
|
if t.isString():
|
|
return "JSJitInfo::String"
|
|
if t.isEnum():
|
|
return "JSJitInfo::String"
|
|
if t.isCallback():
|
|
return "JSJitInfo::Object"
|
|
if t.isAny():
|
|
# The whole point is to return various stuff
|
|
return "JSJitInfo::Any"
|
|
if t.isObject():
|
|
return "JSJitInfo::Object"
|
|
if t.isSpiderMonkeyInterface():
|
|
return "JSJitInfo::Object"
|
|
if t.isUnion():
|
|
u = t.unroll()
|
|
type = "JSJitInfo::Null" if u.hasNullableType else ""
|
|
return ("JSJitInfo::ArgType(%s)" %
|
|
reduce(CGMemberJITInfo.getSingleArgType,
|
|
u.flatMemberTypes, type))
|
|
if t.isDictionary():
|
|
return "JSJitInfo::Object"
|
|
if t.isDate():
|
|
return "JSJitInfo::Object"
|
|
if not t.isPrimitive():
|
|
raise TypeError("No idea what type " + str(t) + " is.")
|
|
tag = t.tag()
|
|
if tag == IDLType.Tags.bool:
|
|
return "JSJitInfo::Boolean"
|
|
if tag in [IDLType.Tags.int8, IDLType.Tags.uint8,
|
|
IDLType.Tags.int16, IDLType.Tags.uint16,
|
|
IDLType.Tags.int32]:
|
|
return "JSJitInfo::Integer"
|
|
if tag in [IDLType.Tags.int64, IDLType.Tags.uint64,
|
|
IDLType.Tags.unrestricted_float, IDLType.Tags.float,
|
|
IDLType.Tags.unrestricted_double, IDLType.Tags.double]:
|
|
# These all use JS_NumberValue, which can return int or double.
|
|
# But TI treats "double" as meaning "int or double", so we're
|
|
# good to return JSVAL_TYPE_DOUBLE here.
|
|
return "JSJitInfo::Double"
|
|
if tag != IDLType.Tags.uint32:
|
|
raise TypeError("No idea what type " + str(t) + " is.")
|
|
# uint32 is sometimes int and sometimes double.
|
|
return "JSJitInfo::Double"
|
|
|
|
@staticmethod
|
|
def getSingleArgType(existingType, t):
|
|
type = CGMemberJITInfo.getJSArgType(t)
|
|
if existingType == "":
|
|
# First element of the list; just return its type
|
|
return type
|
|
|
|
if type == existingType:
|
|
return existingType
|
|
return "%s | %s" % (existingType, type)
|
|
|
|
|
|
class CGStaticMethodJitinfo(CGGeneric):
|
|
"""
|
|
A class for generating the JITInfo for a promise-returning static method.
|
|
"""
|
|
def __init__(self, method):
|
|
CGGeneric.__init__(
|
|
self,
|
|
"\n"
|
|
"static const JSJitInfo %s_methodinfo = {\n"
|
|
" { (JSJitGetterOp)%s },\n"
|
|
" { prototypes::id::_ID_Count }, { 0 }, JSJitInfo::StaticMethod,\n"
|
|
" JSJitInfo::AliasEverything, JSVAL_TYPE_MISSING, false, false,\n"
|
|
" false, false, 0\n"
|
|
"};\n" %
|
|
(IDLToCIdentifier(method.identifier.name),
|
|
CppKeywords.checkMethodName(
|
|
IDLToCIdentifier(method.identifier.name))))
|
|
|
|
|
|
def getEnumValueName(value):
|
|
# Some enum values can be empty strings. Others might have weird
|
|
# characters in them. Deal with the former by returning "_empty",
|
|
# deal with possible name collisions from that by throwing if the
|
|
# enum value is actually "_empty", and throw on any value
|
|
# containing non-ASCII chars for now. Replace all chars other than
|
|
# [0-9A-Za-z_] with '_'.
|
|
if re.match("[^\x20-\x7E]", value):
|
|
raise SyntaxError('Enum value "' + value + '" contains non-ASCII characters')
|
|
if re.match("^[0-9]", value):
|
|
return '_' + value
|
|
value = re.sub(r'[^0-9A-Za-z_]', '_', value)
|
|
if re.match("^_[A-Z]|__", value):
|
|
raise SyntaxError('Enum value "' + value + '" is reserved by the C++ spec')
|
|
if value == "_empty":
|
|
raise SyntaxError('"_empty" is not an IDL enum value we support yet')
|
|
if value == "":
|
|
return "_empty"
|
|
nativeName = MakeNativeName(value)
|
|
if nativeName == "EndGuard_":
|
|
raise SyntaxError('Enum value "' + value + '" cannot be used because it'
|
|
' collides with our internal EndGuard_ value. Please'
|
|
' rename our internal EndGuard_ to something else')
|
|
return nativeName
|
|
|
|
class CGEnumToJSValue(CGAbstractMethod):
|
|
def __init__(self, enum):
|
|
enumType = enum.identifier.name
|
|
self.stringsArray = enumType + "Values::" + ENUM_ENTRY_VARIABLE_NAME
|
|
CGAbstractMethod.__init__(self, None, "ToJSValue", "bool",
|
|
[Argument("JSContext*", "aCx"),
|
|
Argument(enumType, "aArgument"),
|
|
Argument("JS::MutableHandle<JS::Value>",
|
|
"aValue")])
|
|
|
|
def definition_body(self):
|
|
return fill(
|
|
"""
|
|
MOZ_ASSERT(uint32_t(aArgument) < ArrayLength(${strings}));
|
|
JSString* resultStr =
|
|
JS_NewStringCopyN(aCx, ${strings}[uint32_t(aArgument)].value,
|
|
${strings}[uint32_t(aArgument)].length);
|
|
if (!resultStr) {
|
|
return false;
|
|
}
|
|
aValue.setString(resultStr);
|
|
return true;
|
|
""",
|
|
strings=self.stringsArray)
|
|
|
|
|
|
class CGEnum(CGThing):
|
|
def __init__(self, enum):
|
|
CGThing.__init__(self)
|
|
self.enum = enum
|
|
strings = CGNamespace(
|
|
self.stringsNamespace(),
|
|
CGGeneric(declare=("extern const EnumEntry %s[%d];\n" %
|
|
(ENUM_ENTRY_VARIABLE_NAME, self.nEnumStrings())),
|
|
define=fill(
|
|
"""
|
|
extern const EnumEntry ${name}[${count}] = {
|
|
$*{entries}
|
|
{ nullptr, 0 }
|
|
};
|
|
""",
|
|
name=ENUM_ENTRY_VARIABLE_NAME,
|
|
count=self.nEnumStrings(),
|
|
entries=''.join('{"%s", %d},\n' % (val, len(val))
|
|
for val in self.enum.values()))))
|
|
toJSValue = CGEnumToJSValue(enum)
|
|
self.cgThings = CGList([strings, toJSValue], "\n")
|
|
|
|
def stringsNamespace(self):
|
|
return self.enum.identifier.name + "Values"
|
|
|
|
def nEnumStrings(self):
|
|
return len(self.enum.values()) + 1
|
|
|
|
def declare(self):
|
|
decl = fill(
|
|
"""
|
|
enum class ${name} : uint32_t {
|
|
$*{enums}
|
|
EndGuard_
|
|
};
|
|
""",
|
|
name=self.enum.identifier.name,
|
|
enums=",\n".join(map(getEnumValueName, self.enum.values())) + ",\n")
|
|
strings = CGNamespace(self.stringsNamespace(),
|
|
CGGeneric(declare="extern const EnumEntry %s[%d];\n"
|
|
% (ENUM_ENTRY_VARIABLE_NAME, self.nEnumStrings())))
|
|
return decl + "\n" + self.cgThings.declare()
|
|
|
|
def define(self):
|
|
return self.cgThings.define()
|
|
|
|
def deps(self):
|
|
return self.enum.getDeps()
|
|
|
|
|
|
def getUnionAccessorSignatureType(type, descriptorProvider):
|
|
"""
|
|
Returns the types that are used in the getter and setter signatures for
|
|
union types
|
|
"""
|
|
# Flat member types have already unwrapped nullables.
|
|
assert not type.nullable()
|
|
|
|
# Promise types can never appear in unions, because Promise is not
|
|
# distinguishable from anything.
|
|
assert not type.isPromise()
|
|
|
|
if type.isSequence() or type.isRecord():
|
|
if type.isSequence():
|
|
wrapperType = "Sequence"
|
|
else:
|
|
wrapperType = "Record"
|
|
# We don't use the returned template here, so it's OK to just pass no
|
|
# sourceDescription.
|
|
elementInfo = getJSToNativeConversionInfo(type.inner,
|
|
descriptorProvider,
|
|
isMember=wrapperType)
|
|
if wrapperType == "Sequence":
|
|
innerType = elementInfo.declType
|
|
else:
|
|
innerType = [recordKeyDeclType(type), elementInfo.declType]
|
|
|
|
return CGTemplatedType(wrapperType, innerType,
|
|
isConst=True, isReference=True)
|
|
|
|
# Nested unions are unwrapped automatically into our flatMemberTypes.
|
|
assert not type.isUnion()
|
|
|
|
if type.isGeckoInterface():
|
|
descriptor = descriptorProvider.getDescriptor(
|
|
type.unroll().inner.identifier.name)
|
|
typeName = CGGeneric(descriptor.nativeType)
|
|
# Allow null pointers for old-binding classes.
|
|
if type.unroll().inner.isExternal():
|
|
typeName = CGWrapper(typeName, post="*")
|
|
else:
|
|
typeName = CGWrapper(typeName, post="&")
|
|
return typeName
|
|
|
|
if type.isSpiderMonkeyInterface():
|
|
typeName = CGGeneric(type.name)
|
|
return CGWrapper(typeName, post=" const &")
|
|
|
|
if type.isDOMString() or type.isUSVString():
|
|
return CGGeneric("const nsAString&")
|
|
|
|
if type.isByteString():
|
|
return CGGeneric("const nsCString&")
|
|
|
|
if type.isEnum():
|
|
return CGGeneric(type.inner.identifier.name)
|
|
|
|
if type.isCallback():
|
|
return CGGeneric("%s&" % type.unroll().callback.identifier.name)
|
|
|
|
if type.isAny():
|
|
return CGGeneric("JS::Value")
|
|
|
|
if type.isObject():
|
|
return CGGeneric("JSObject*")
|
|
|
|
if type.isDictionary():
|
|
return CGGeneric("const %s&" % type.inner.identifier.name)
|
|
|
|
if not type.isPrimitive():
|
|
raise TypeError("Need native type for argument type '%s'" % str(type))
|
|
|
|
return CGGeneric(builtinNames[type.tag()])
|
|
|
|
|
|
def getUnionTypeTemplateVars(unionType, type, descriptorProvider,
|
|
ownsMembers=False):
|
|
name = getUnionMemberName(type)
|
|
holderName = "m" + name + "Holder"
|
|
|
|
# By the time tryNextCode is invoked, we're guaranteed the union has been
|
|
# constructed as some type, since we've been trying to convert into the
|
|
# corresponding member.
|
|
prefix = "" if ownsMembers else "mUnion."
|
|
tryNextCode = ("$*{destroyHolder}\n"
|
|
"%sDestroy%s();\n"
|
|
"tryNext = true;\n"
|
|
"return true;\n" % (prefix, name))
|
|
|
|
conversionInfo = getJSToNativeConversionInfo(
|
|
type, descriptorProvider, failureCode=tryNextCode,
|
|
isDefinitelyObject=not type.isDictionary(),
|
|
isMember=("OwningUnion" if ownsMembers else None),
|
|
sourceDescription="member of %s" % unionType)
|
|
|
|
if conversionInfo.holderType is not None:
|
|
assert not ownsMembers
|
|
destroyHolder = "%s.reset();\n" % holderName
|
|
else:
|
|
destroyHolder = ""
|
|
|
|
ctorNeedsCx = conversionInfo.declArgs == "cx"
|
|
ctorArgs = "cx" if ctorNeedsCx else ""
|
|
|
|
structType = conversionInfo.declType.define()
|
|
externalType = getUnionAccessorSignatureType(type, descriptorProvider).define()
|
|
|
|
if type.isObject():
|
|
if ownsMembers:
|
|
body = dedent("""
|
|
MOZ_ASSERT(mType == eUninitialized);
|
|
mValue.mObject.SetValue(obj);
|
|
mType = eObject;
|
|
""")
|
|
else:
|
|
body = dedent("""
|
|
MOZ_ASSERT(mUnion.mType == mUnion.eUninitialized);
|
|
mUnion.mValue.mObject.SetValue(cx, obj);
|
|
mUnion.mType = mUnion.eObject;
|
|
""")
|
|
|
|
# It's a bit sketchy to do the security check after setting the value,
|
|
# but it keeps the code cleaner and lets us avoid rooting |obj| over the
|
|
# call to CallerSubsumes().
|
|
body = body + dedent("""
|
|
if (passedToJSImpl && !CallerSubsumes(obj)) {
|
|
ThrowErrorMessage(cx, MSG_PERMISSION_DENIED_TO_PASS_ARG, "%s");
|
|
return false;
|
|
}
|
|
return true;
|
|
""")
|
|
|
|
setter = ClassMethod("SetToObject", "bool",
|
|
[Argument("JSContext*", "cx"),
|
|
Argument("JSObject*", "obj"),
|
|
Argument("bool", "passedToJSImpl", default="false")],
|
|
inline=True, bodyInHeader=True,
|
|
body=body)
|
|
|
|
else:
|
|
# Important: we need to not have our declName involve
|
|
# maybe-GCing operations.
|
|
if conversionInfo.holderType is not None:
|
|
holderArgs = conversionInfo.holderArgs
|
|
if holderArgs is None:
|
|
holderArgs = ""
|
|
initHolder = "%s.emplace(%s);\n" % (holderName, holderArgs)
|
|
else:
|
|
initHolder = ""
|
|
|
|
jsConversion = fill(
|
|
initHolder + conversionInfo.template,
|
|
val="value",
|
|
maybeMutableVal="value",
|
|
declName="memberSlot",
|
|
holderName=(holderName if ownsMembers else "%s.ref()" % holderName),
|
|
destroyHolder=destroyHolder,
|
|
passedToJSImpl="passedToJSImpl")
|
|
|
|
jsConversion = fill(
|
|
"""
|
|
tryNext = false;
|
|
{ // scope for memberSlot
|
|
${structType}& memberSlot = RawSetAs${name}(${ctorArgs});
|
|
$*{jsConversion}
|
|
}
|
|
return true;
|
|
""",
|
|
structType=structType,
|
|
name=name,
|
|
ctorArgs=ctorArgs,
|
|
jsConversion=jsConversion)
|
|
|
|
if ownsMembers:
|
|
handleType = "JS::Handle<JS::Value>"
|
|
else:
|
|
handleType = "JS::MutableHandle<JS::Value>"
|
|
|
|
setter = ClassMethod("TrySetTo" + name, "bool",
|
|
[Argument("JSContext*", "cx"),
|
|
Argument(handleType, "value"),
|
|
Argument("bool&", "tryNext"),
|
|
Argument("bool", "passedToJSImpl", default="false")],
|
|
inline=not ownsMembers,
|
|
bodyInHeader=not ownsMembers,
|
|
body=jsConversion)
|
|
|
|
return {
|
|
"name": name,
|
|
"structType": structType,
|
|
"externalType": externalType,
|
|
"setter": setter,
|
|
"holderType": conversionInfo.holderType.define() if conversionInfo.holderType else None,
|
|
"ctorArgs": ctorArgs,
|
|
"ctorArgList": [Argument("JSContext*", "cx")] if ctorNeedsCx else []
|
|
}
|
|
|
|
|
|
class CGUnionStruct(CGThing):
|
|
def __init__(self, type, descriptorProvider, ownsMembers=False):
|
|
CGThing.__init__(self)
|
|
self.type = type.unroll()
|
|
self.descriptorProvider = descriptorProvider
|
|
self.ownsMembers = ownsMembers
|
|
self.struct = self.getStruct()
|
|
|
|
def declare(self):
|
|
return self.struct.declare()
|
|
|
|
def define(self):
|
|
return self.struct.define()
|
|
|
|
def deps(self):
|
|
return self.type.getDeps()
|
|
|
|
def getStruct(self):
|
|
|
|
members = [ClassMember("mType", "Type", body="eUninitialized"),
|
|
ClassMember("mValue", "Value")]
|
|
ctor = ClassConstructor([], bodyInHeader=True, visibility="public",
|
|
explicit=True)
|
|
|
|
methods = []
|
|
enumValues = ["eUninitialized"]
|
|
toJSValCases = [CGCase("eUninitialized", CGGeneric("return false;\n"))]
|
|
destructorCases = [CGCase("eUninitialized", None)]
|
|
assignmentCases = [
|
|
CGCase("eUninitialized",
|
|
CGGeneric('MOZ_ASSERT(mType == eUninitialized,\n'
|
|
' "We need to destroy ourselves?");\n'))]
|
|
traceCases = []
|
|
unionValues = []
|
|
if self.type.hasNullableType:
|
|
enumValues.append("eNull")
|
|
methods.append(ClassMethod("IsNull", "bool", [], const=True, inline=True,
|
|
body="return mType == eNull;\n",
|
|
bodyInHeader=True))
|
|
methods.append(ClassMethod("SetNull", "void", [], inline=True,
|
|
body=("Uninit();\n"
|
|
"mType = eNull;\n"),
|
|
bodyInHeader=True))
|
|
destructorCases.append(CGCase("eNull", None))
|
|
assignmentCases.append(CGCase("eNull",
|
|
CGGeneric("MOZ_ASSERT(mType == eUninitialized);\n"
|
|
"mType = eNull;\n")))
|
|
toJSValCases.append(CGCase("eNull", CGGeneric("rval.setNull();\n"
|
|
"return true;\n")))
|
|
|
|
hasObjectType = any(t.isObject() for t in self.type.flatMemberTypes)
|
|
for t in self.type.flatMemberTypes:
|
|
vars = getUnionTypeTemplateVars(self.type,
|
|
t, self.descriptorProvider,
|
|
ownsMembers=self.ownsMembers)
|
|
if vars["name"] != "Object" or self.ownsMembers:
|
|
body = fill(
|
|
"""
|
|
if (mType == e${name}) {
|
|
return mValue.m${name}.Value();
|
|
}
|
|
%s
|
|
mType = e${name};
|
|
return mValue.m${name}.SetValue(${ctorArgs});
|
|
""",
|
|
**vars)
|
|
|
|
# bodyInHeader must be false for return values because they own
|
|
# their union members and we don't want include headers in
|
|
# UnionTypes.h just to call Addref/Release
|
|
methods.append(ClassMethod(
|
|
"RawSetAs" + vars["name"],
|
|
vars["structType"] + "&",
|
|
vars["ctorArgList"],
|
|
bodyInHeader=not self.ownsMembers,
|
|
body=body % "MOZ_ASSERT(mType == eUninitialized);"))
|
|
uninit = "Uninit();"
|
|
if hasObjectType and not self.ownsMembers:
|
|
uninit = 'MOZ_ASSERT(mType != eObject, "This will not play well with Rooted");\n' + uninit
|
|
methods.append(ClassMethod(
|
|
"SetAs" + vars["name"],
|
|
vars["structType"] + "&",
|
|
vars["ctorArgList"],
|
|
bodyInHeader=not self.ownsMembers,
|
|
body=body % uninit))
|
|
if self.ownsMembers:
|
|
methods.append(vars["setter"])
|
|
# Provide a SetStringData() method to support string defaults.
|
|
if t.isByteString():
|
|
methods.append(
|
|
ClassMethod("SetStringData", "void",
|
|
[Argument("const nsCString::char_type*", "aData"),
|
|
Argument("nsCString::size_type", "aLength")],
|
|
inline=True, bodyInHeader=True,
|
|
body="RawSetAs%s().Assign(aData, aLength);\n" % t.name))
|
|
elif t.isString():
|
|
methods.append(
|
|
ClassMethod("SetStringData", "void",
|
|
[Argument("const nsString::char_type*", "aData"),
|
|
Argument("nsString::size_type", "aLength")],
|
|
inline=True, bodyInHeader=True,
|
|
body="RawSetAs%s().Assign(aData, aLength);\n" % t.name))
|
|
|
|
body = fill(
|
|
"""
|
|
MOZ_ASSERT(Is${name}(), "Wrong type!");
|
|
mValue.m${name}.Destroy();
|
|
mType = eUninitialized;
|
|
""",
|
|
**vars)
|
|
methods.append(ClassMethod("Destroy" + vars["name"],
|
|
"void",
|
|
[],
|
|
visibility="private",
|
|
bodyInHeader=not self.ownsMembers,
|
|
body=body))
|
|
|
|
body = fill("return mType == e${name};\n", **vars)
|
|
methods.append(ClassMethod("Is" + vars["name"],
|
|
"bool",
|
|
[],
|
|
const=True,
|
|
bodyInHeader=True,
|
|
body=body))
|
|
|
|
body = fill(
|
|
"""
|
|
MOZ_ASSERT(Is${name}(), "Wrong type!");
|
|
return mValue.m${name}.Value();
|
|
""",
|
|
**vars)
|
|
# The non-const version of GetAs* returns our internal type
|
|
getterReturnType = "%s&" % vars["structType"]
|
|
methods.append(ClassMethod("GetAs" + vars["name"],
|
|
getterReturnType,
|
|
[],
|
|
bodyInHeader=True,
|
|
body=body))
|
|
# The const version of GetAs* returns our internal type
|
|
# for owning unions, but our external type for non-owning
|
|
# ones.
|
|
if self.ownsMembers:
|
|
getterReturnType = "%s const &" % vars["structType"]
|
|
else:
|
|
getterReturnType = vars["externalType"]
|
|
methods.append(ClassMethod("GetAs" + vars["name"],
|
|
getterReturnType,
|
|
[],
|
|
const=True,
|
|
bodyInHeader=True,
|
|
body=body))
|
|
|
|
unionValues.append(
|
|
fill("UnionMember<${structType} > m${name}", **vars))
|
|
enumValues.append("e" + vars["name"])
|
|
|
|
skipToJSVal = False
|
|
try:
|
|
toJSValCases.append(
|
|
CGCase("e" + vars["name"],
|
|
self.getConversionToJS(vars, t)))
|
|
except MethodNotNewObjectError:
|
|
# If we can't have a ToJSVal() because one of our members can
|
|
# only be returned from [NewObject] methods, then just skip
|
|
# generating ToJSVal.
|
|
skipToJSVal = True
|
|
destructorCases.append(
|
|
CGCase("e" + vars["name"],
|
|
CGGeneric("Destroy%s();\n" % vars["name"])))
|
|
assignmentCases.append(
|
|
CGCase("e" + vars["name"],
|
|
CGGeneric("SetAs%s() = aOther.GetAs%s();\n" %
|
|
(vars["name"], vars["name"]))))
|
|
if self.ownsMembers and typeNeedsRooting(t):
|
|
if t.isObject():
|
|
traceCases.append(
|
|
CGCase("e" + vars["name"],
|
|
CGGeneric('JS::UnsafeTraceRoot(trc, %s, "%s");\n' %
|
|
("&mValue.m" + vars["name"] + ".Value()",
|
|
"mValue.m" + vars["name"]))))
|
|
elif t.isDictionary():
|
|
traceCases.append(
|
|
CGCase("e" + vars["name"],
|
|
CGGeneric("mValue.m%s.Value().TraceDictionary(trc);\n" %
|
|
vars["name"])))
|
|
elif t.isSequence():
|
|
traceCases.append(
|
|
CGCase("e" + vars["name"],
|
|
CGGeneric("DoTraceSequence(trc, mValue.m%s.Value());\n" %
|
|
vars["name"])))
|
|
elif t.isRecord():
|
|
traceCases.append(
|
|
CGCase("e" + vars["name"],
|
|
CGGeneric("TraceRecord(trc, mValue.m%s.Value());\n" %
|
|
vars["name"])))
|
|
else:
|
|
assert t.isSpiderMonkeyInterface()
|
|
traceCases.append(
|
|
CGCase("e" + vars["name"],
|
|
CGGeneric("mValue.m%s.Value().TraceSelf(trc);\n" %
|
|
vars["name"])))
|
|
|
|
dtor = CGSwitch("mType", destructorCases).define()
|
|
|
|
methods.append(ClassMethod("Uninit", "void", [],
|
|
visibility="public", body=dtor,
|
|
bodyInHeader=not self.ownsMembers,
|
|
inline=not self.ownsMembers))
|
|
|
|
if not skipToJSVal:
|
|
methods.append(
|
|
ClassMethod(
|
|
"ToJSVal",
|
|
"bool",
|
|
[
|
|
Argument("JSContext*", "cx"),
|
|
Argument("JS::Handle<JSObject*>", "scopeObj"),
|
|
Argument("JS::MutableHandle<JS::Value>", "rval")
|
|
],
|
|
body=CGSwitch("mType", toJSValCases,
|
|
default=CGGeneric("return false;\n")).define() + "\nreturn false;\n",
|
|
const=True))
|
|
|
|
constructors = [ctor]
|
|
selfName = CGUnionStruct.unionTypeName(self.type, self.ownsMembers)
|
|
if self.ownsMembers:
|
|
if traceCases:
|
|
traceBody = CGSwitch("mType", traceCases,
|
|
default=CGGeneric("")).define()
|
|
else:
|
|
traceBody = ""
|
|
methods.append(ClassMethod("TraceUnion", "void",
|
|
[Argument("JSTracer*", "trc")],
|
|
body=traceBody))
|
|
if CGUnionStruct.isUnionCopyConstructible(self.type):
|
|
constructors.append(
|
|
ClassConstructor(
|
|
[Argument("const %s&" % selfName, "aOther")],
|
|
bodyInHeader=True,
|
|
visibility="public",
|
|
explicit=True,
|
|
body="*this = aOther;\n"))
|
|
methods.append(ClassMethod(
|
|
"operator=", "void",
|
|
[Argument("const %s&" % selfName, "aOther")],
|
|
body=CGSwitch("aOther.mType", assignmentCases).define()))
|
|
disallowCopyConstruction = False
|
|
else:
|
|
disallowCopyConstruction = True
|
|
else:
|
|
disallowCopyConstruction = True
|
|
|
|
if self.ownsMembers:
|
|
friend = " friend void ImplCycleCollectionUnlink(%s& aUnion);\n" % CGUnionStruct.unionTypeName(self.type, True)
|
|
else:
|
|
friend = " friend class %sArgument;\n" % str(self.type)
|
|
|
|
bases = [ClassBase("AllOwningUnionBase")] if self.ownsMembers else []
|
|
return CGClass(selfName,
|
|
bases=bases,
|
|
members=members,
|
|
constructors=constructors,
|
|
methods=methods,
|
|
disallowCopyConstruction=disallowCopyConstruction,
|
|
extradeclarations=friend,
|
|
destructor=ClassDestructor(visibility="public",
|
|
body="Uninit();\n",
|
|
bodyInHeader=True),
|
|
enums=[ClassEnum("Type", enumValues, visibility="private")],
|
|
unions=[ClassUnion("Value", unionValues, visibility="private")])
|
|
|
|
def getConversionToJS(self, templateVars, type):
|
|
assert not type.nullable() # flatMemberTypes never has nullable types
|
|
val = "mValue.m%(name)s.Value()" % templateVars
|
|
wrapCode = wrapForType(
|
|
type, self.descriptorProvider,
|
|
{
|
|
"jsvalRef": "rval",
|
|
"jsvalHandle": "rval",
|
|
"obj": "scopeObj",
|
|
"result": val,
|
|
"typedArraysAreStructs": True
|
|
})
|
|
return CGGeneric(wrapCode)
|
|
|
|
@staticmethod
|
|
def isUnionCopyConstructible(type):
|
|
return all(isTypeCopyConstructible(t) for t in type.flatMemberTypes)
|
|
|
|
@staticmethod
|
|
def unionTypeName(type, ownsMembers):
|
|
"""
|
|
Returns a string name for this known union type.
|
|
"""
|
|
assert type.isUnion() and not type.nullable()
|
|
return ("Owning" if ownsMembers else "") + type.name
|
|
|
|
@staticmethod
|
|
def unionTypeDecl(type, ownsMembers):
|
|
"""
|
|
Returns a string for declaring this possibly-nullable union type.
|
|
"""
|
|
assert type.isUnion()
|
|
nullable = type.nullable()
|
|
if nullable:
|
|
type = type.inner
|
|
decl = CGGeneric(CGUnionStruct.unionTypeName(type, ownsMembers))
|
|
if nullable:
|
|
decl = CGTemplatedType("Nullable", decl)
|
|
return decl.define()
|
|
|
|
|
|
class CGUnionConversionStruct(CGThing):
|
|
def __init__(self, type, descriptorProvider):
|
|
CGThing.__init__(self)
|
|
self.type = type.unroll()
|
|
self.descriptorProvider = descriptorProvider
|
|
|
|
def declare(self):
|
|
|
|
structName = str(self.type)
|
|
members = [ClassMember("mUnion", structName + "&",
|
|
body="const_cast<%s&>(aUnion)" % structName)]
|
|
# Argument needs to be a const ref because that's all Maybe<> allows
|
|
ctor = ClassConstructor([Argument("const %s&" % structName, "aUnion")],
|
|
bodyInHeader=True,
|
|
visibility="public",
|
|
explicit=True)
|
|
methods = []
|
|
|
|
if self.type.hasNullableType:
|
|
methods.append(ClassMethod("SetNull", "bool", [],
|
|
body=("MOZ_ASSERT(mUnion.mType == mUnion.eUninitialized);\n"
|
|
"mUnion.mType = mUnion.eNull;\n"
|
|
"return true;\n"),
|
|
inline=True, bodyInHeader=True))
|
|
|
|
for t in self.type.flatMemberTypes:
|
|
vars = getUnionTypeTemplateVars(self.type,
|
|
t, self.descriptorProvider)
|
|
methods.append(vars["setter"])
|
|
if vars["name"] != "Object":
|
|
body = fill(
|
|
"""
|
|
MOZ_ASSERT(mUnion.mType == mUnion.eUninitialized);
|
|
mUnion.mType = mUnion.e${name};
|
|
return mUnion.mValue.m${name}.SetValue(${ctorArgs});
|
|
""",
|
|
**vars)
|
|
methods.append(ClassMethod("RawSetAs" + vars["name"],
|
|
vars["structType"] + "&",
|
|
vars["ctorArgList"],
|
|
bodyInHeader=True,
|
|
body=body,
|
|
visibility="private"))
|
|
# Provide a SetStringData() method to support string defaults.
|
|
if t.isByteString():
|
|
methods.append(
|
|
ClassMethod("SetStringData", "void",
|
|
[Argument("const nsDependentCString::char_type*", "aData"),
|
|
Argument("nsDependentCString::size_type", "aLength")],
|
|
inline=True, bodyInHeader=True,
|
|
body="RawSetAs%s().Rebind(aData, aLength);\n" % t.name))
|
|
elif t.isString():
|
|
methods.append(
|
|
ClassMethod("SetStringData", "void",
|
|
[Argument("const nsDependentString::char_type*", "aData"),
|
|
Argument("nsDependentString::size_type", "aLength")],
|
|
inline=True, bodyInHeader=True,
|
|
body="RawSetAs%s().Rebind(aData, aLength);\n" % t.name))
|
|
|
|
if vars["holderType"] is not None:
|
|
holderType = CGTemplatedType("Maybe",
|
|
CGGeneric(vars["holderType"])).define()
|
|
members.append(ClassMember("m%sHolder" % vars["name"],
|
|
holderType))
|
|
|
|
return CGClass(structName + "Argument",
|
|
members=members,
|
|
constructors=[ctor],
|
|
methods=methods,
|
|
disallowCopyConstruction=True).declare()
|
|
|
|
def define(self):
|
|
return ""
|
|
|
|
def deps(self):
|
|
return set()
|
|
|
|
|
|
class ClassItem:
|
|
""" Use with CGClass """
|
|
def __init__(self, name, visibility):
|
|
self.name = name
|
|
self.visibility = visibility
|
|
|
|
def declare(self, cgClass):
|
|
assert False
|
|
|
|
def define(self, cgClass):
|
|
assert False
|
|
|
|
|
|
class ClassBase(ClassItem):
|
|
def __init__(self, name, visibility='public'):
|
|
ClassItem.__init__(self, name, visibility)
|
|
|
|
def declare(self, cgClass):
|
|
return '%s %s' % (self.visibility, self.name)
|
|
|
|
def define(self, cgClass):
|
|
# Only in the header
|
|
return ''
|
|
|
|
|
|
class ClassMethod(ClassItem):
|
|
def __init__(self, name, returnType, args, inline=False, static=False,
|
|
virtual=False, const=False, bodyInHeader=False,
|
|
templateArgs=None, visibility='public', body=None,
|
|
breakAfterReturnDecl="\n",
|
|
breakAfterSelf="\n", override=False):
|
|
"""
|
|
override indicates whether to flag the method as override
|
|
"""
|
|
assert not override or virtual
|
|
assert not (override and static)
|
|
self.returnType = returnType
|
|
self.args = args
|
|
self.inline = inline or bodyInHeader
|
|
self.static = static
|
|
self.virtual = virtual
|
|
self.const = const
|
|
self.bodyInHeader = bodyInHeader
|
|
self.templateArgs = templateArgs
|
|
self.body = body
|
|
self.breakAfterReturnDecl = breakAfterReturnDecl
|
|
self.breakAfterSelf = breakAfterSelf
|
|
self.override = override
|
|
ClassItem.__init__(self, name, visibility)
|
|
|
|
def getDecorators(self, declaring):
|
|
decorators = []
|
|
if self.inline:
|
|
decorators.append('inline')
|
|
if declaring:
|
|
if self.static:
|
|
decorators.append('static')
|
|
if self.virtual:
|
|
decorators.append('virtual')
|
|
if decorators:
|
|
return ' '.join(decorators) + ' '
|
|
return ''
|
|
|
|
def getBody(self):
|
|
# Override me or pass a string to constructor
|
|
assert self.body is not None
|
|
return self.body
|
|
|
|
def declare(self, cgClass):
|
|
templateClause = ('template <%s>\n' % ', '.join(self.templateArgs)
|
|
if self.bodyInHeader and self.templateArgs else '')
|
|
args = ', '.join([a.declare() for a in self.args])
|
|
if self.bodyInHeader:
|
|
body = indent(self.getBody())
|
|
body = '\n{\n' + body + '}\n'
|
|
else:
|
|
body = ';\n'
|
|
|
|
return fill(
|
|
"${templateClause}${decorators}${returnType}${breakAfterReturnDecl}"
|
|
"${name}(${args})${const}${override}${body}"
|
|
"${breakAfterSelf}",
|
|
templateClause=templateClause,
|
|
decorators=self.getDecorators(True),
|
|
returnType=self.returnType,
|
|
breakAfterReturnDecl=self.breakAfterReturnDecl,
|
|
name=self.name,
|
|
args=args,
|
|
const=' const' if self.const else '',
|
|
override=' override' if self.override else '',
|
|
body=body,
|
|
breakAfterSelf=self.breakAfterSelf)
|
|
|
|
def define(self, cgClass):
|
|
if self.bodyInHeader:
|
|
return ''
|
|
|
|
templateArgs = cgClass.templateArgs
|
|
if templateArgs:
|
|
if cgClass.templateSpecialization:
|
|
templateArgs = \
|
|
templateArgs[len(cgClass.templateSpecialization):]
|
|
|
|
if templateArgs:
|
|
templateClause = \
|
|
'template <%s>\n' % ', '.join([str(a) for a in templateArgs])
|
|
else:
|
|
templateClause = ''
|
|
|
|
return fill(
|
|
"""
|
|
${templateClause}${decorators}${returnType}
|
|
${className}::${name}(${args})${const}
|
|
{
|
|
$*{body}
|
|
}
|
|
""",
|
|
templateClause=templateClause,
|
|
decorators=self.getDecorators(False),
|
|
returnType=self.returnType,
|
|
className=cgClass.getNameString(),
|
|
name=self.name,
|
|
args=', '.join([a.define() for a in self.args]),
|
|
const=' const' if self.const else '',
|
|
body=self.getBody())
|
|
|
|
|
|
class ClassUsingDeclaration(ClassItem):
|
|
"""
|
|
Used for importing a name from a base class into a CGClass
|
|
|
|
baseClass is the name of the base class to import the name from
|
|
|
|
name is the name to import
|
|
|
|
visibility determines the visibility of the name (public,
|
|
protected, private), defaults to public.
|
|
"""
|
|
def __init__(self, baseClass, name, visibility='public'):
|
|
self.baseClass = baseClass
|
|
ClassItem.__init__(self, name, visibility)
|
|
|
|
def declare(self, cgClass):
|
|
return "using %s::%s;\n\n" % (self.baseClass, self.name)
|
|
|
|
def define(self, cgClass):
|
|
return ''
|
|
|
|
|
|
class ClassConstructor(ClassItem):
|
|
"""
|
|
Used for adding a constructor to a CGClass.
|
|
|
|
args is a list of Argument objects that are the arguments taken by the
|
|
constructor.
|
|
|
|
inline should be True if the constructor should be marked inline.
|
|
|
|
bodyInHeader should be True if the body should be placed in the class
|
|
declaration in the header.
|
|
|
|
visibility determines the visibility of the constructor (public,
|
|
protected, private), defaults to private.
|
|
|
|
explicit should be True if the constructor should be marked explicit.
|
|
|
|
baseConstructors is a list of strings containing calls to base constructors,
|
|
defaults to None.
|
|
|
|
body contains a string with the code for the constructor, defaults to empty.
|
|
"""
|
|
def __init__(self, args, inline=False, bodyInHeader=False,
|
|
visibility="private", explicit=False, constexpr=False, baseConstructors=None,
|
|
body=""):
|
|
assert not (inline and constexpr)
|
|
assert not (bodyInHeader and constexpr)
|
|
self.args = args
|
|
self.inline = inline or bodyInHeader
|
|
self.bodyInHeader = bodyInHeader or constexpr
|
|
self.explicit = explicit
|
|
self.constexpr = constexpr
|
|
self.baseConstructors = baseConstructors or []
|
|
self.body = body
|
|
ClassItem.__init__(self, None, visibility)
|
|
|
|
def getDecorators(self, declaring):
|
|
decorators = []
|
|
if self.explicit:
|
|
decorators.append('explicit')
|
|
if self.inline and declaring:
|
|
decorators.append('inline')
|
|
if self.constexpr and declaring:
|
|
decorators.append('constexpr')
|
|
if decorators:
|
|
return ' '.join(decorators) + ' '
|
|
return ''
|
|
|
|
def getInitializationList(self, cgClass):
|
|
items = [str(c) for c in self.baseConstructors]
|
|
for m in cgClass.members:
|
|
if not m.static:
|
|
initialize = m.body
|
|
if initialize:
|
|
items.append(m.name + "(" + initialize + ")")
|
|
|
|
if len(items) > 0:
|
|
return '\n : ' + ',\n '.join(items)
|
|
return ''
|
|
|
|
def getBody(self):
|
|
return self.body
|
|
|
|
def declare(self, cgClass):
|
|
args = ', '.join([a.declare() for a in self.args])
|
|
if self.bodyInHeader:
|
|
body = self.getInitializationList(cgClass) + '\n{\n' + indent(self.getBody()) + '}\n'
|
|
else:
|
|
body = ';\n'
|
|
|
|
return fill(
|
|
"${decorators}${className}(${args})${body}\n",
|
|
decorators=self.getDecorators(True),
|
|
className=cgClass.getNameString(),
|
|
args=args,
|
|
body=body)
|
|
|
|
def define(self, cgClass):
|
|
if self.bodyInHeader:
|
|
return ''
|
|
|
|
return fill(
|
|
"""
|
|
${decorators}
|
|
${className}::${className}(${args})${initializationList}
|
|
{
|
|
$*{body}
|
|
}
|
|
""",
|
|
decorators=self.getDecorators(False),
|
|
className=cgClass.getNameString(),
|
|
args=', '.join([a.define() for a in self.args]),
|
|
initializationList=self.getInitializationList(cgClass),
|
|
body=self.getBody())
|
|
|
|
|
|
class ClassDestructor(ClassItem):
|
|
"""
|
|
Used for adding a destructor to a CGClass.
|
|
|
|
inline should be True if the destructor should be marked inline.
|
|
|
|
bodyInHeader should be True if the body should be placed in the class
|
|
declaration in the header.
|
|
|
|
visibility determines the visibility of the destructor (public,
|
|
protected, private), defaults to private.
|
|
|
|
body contains a string with the code for the destructor, defaults to empty.
|
|
|
|
virtual determines whether the destructor is virtual, defaults to False.
|
|
"""
|
|
def __init__(self, inline=False, bodyInHeader=False,
|
|
visibility="private", body='', virtual=False):
|
|
self.inline = inline or bodyInHeader
|
|
self.bodyInHeader = bodyInHeader
|
|
self.body = body
|
|
self.virtual = virtual
|
|
ClassItem.__init__(self, None, visibility)
|
|
|
|
def getDecorators(self, declaring):
|
|
decorators = []
|
|
if self.virtual and declaring:
|
|
decorators.append('virtual')
|
|
if self.inline and declaring:
|
|
decorators.append('inline')
|
|
if decorators:
|
|
return ' '.join(decorators) + ' '
|
|
return ''
|
|
|
|
def getBody(self):
|
|
return self.body
|
|
|
|
def declare(self, cgClass):
|
|
if self.bodyInHeader:
|
|
body = '\n{\n' + indent(self.getBody()) + '}\n'
|
|
else:
|
|
body = ';\n'
|
|
|
|
return fill(
|
|
"${decorators}~${className}()${body}\n",
|
|
decorators=self.getDecorators(True),
|
|
className=cgClass.getNameString(),
|
|
body=body)
|
|
|
|
def define(self, cgClass):
|
|
if self.bodyInHeader:
|
|
return ''
|
|
return fill(
|
|
"""
|
|
${decorators}
|
|
${className}::~${className}()
|
|
{
|
|
$*{body}
|
|
}
|
|
""",
|
|
decorators=self.getDecorators(False),
|
|
className=cgClass.getNameString(),
|
|
body=self.getBody())
|
|
|
|
|
|
class ClassMember(ClassItem):
|
|
def __init__(self, name, type, visibility="private", static=False,
|
|
body=None, hasIgnoreInitCheckFlag=False):
|
|
self.type = type
|
|
self.static = static
|
|
self.body = body
|
|
self.hasIgnoreInitCheckFlag = hasIgnoreInitCheckFlag;
|
|
ClassItem.__init__(self, name, visibility)
|
|
|
|
def declare(self, cgClass):
|
|
return '%s%s%s %s;\n' % ('static ' if self.static else '',
|
|
'MOZ_INIT_OUTSIDE_CTOR '
|
|
if self.hasIgnoreInitCheckFlag else '',
|
|
self.type, self.name)
|
|
|
|
def define(self, cgClass):
|
|
if not self.static:
|
|
return ''
|
|
if self.body:
|
|
body = " = " + self.body
|
|
else:
|
|
body = ""
|
|
return '%s %s::%s%s;\n' % (self.type, cgClass.getNameString(),
|
|
self.name, body)
|
|
|
|
|
|
class ClassTypedef(ClassItem):
|
|
def __init__(self, name, type, visibility="public"):
|
|
self.type = type
|
|
ClassItem.__init__(self, name, visibility)
|
|
|
|
def declare(self, cgClass):
|
|
return 'typedef %s %s;\n' % (self.type, self.name)
|
|
|
|
def define(self, cgClass):
|
|
# Only goes in the header
|
|
return ''
|
|
|
|
|
|
class ClassEnum(ClassItem):
|
|
def __init__(self, name, entries, values=None, visibility="public"):
|
|
self.entries = entries
|
|
self.values = values
|
|
ClassItem.__init__(self, name, visibility)
|
|
|
|
def declare(self, cgClass):
|
|
entries = []
|
|
for i in range(0, len(self.entries)):
|
|
if not self.values or i >= len(self.values):
|
|
entry = '%s' % self.entries[i]
|
|
else:
|
|
entry = '%s = %s' % (self.entries[i], self.values[i])
|
|
entries.append(entry)
|
|
name = '' if not self.name else ' ' + self.name
|
|
return 'enum%s\n{\n%s\n};\n' % (name, indent(',\n'.join(entries)))
|
|
|
|
def define(self, cgClass):
|
|
# Only goes in the header
|
|
return ''
|
|
|
|
|
|
class ClassUnion(ClassItem):
|
|
def __init__(self, name, entries, visibility="public"):
|
|
self.entries = [entry + ";\n" for entry in entries]
|
|
ClassItem.__init__(self, name, visibility)
|
|
|
|
def declare(self, cgClass):
|
|
return "union %s\n{\n%s\n};\n" % (self.name, indent(''.join(self.entries)))
|
|
|
|
def define(self, cgClass):
|
|
# Only goes in the header
|
|
return ''
|
|
|
|
|
|
class CGClass(CGThing):
|
|
def __init__(self, name, bases=[], members=[], constructors=[],
|
|
destructor=None, methods=[],
|
|
typedefs=[], enums=[], unions=[], templateArgs=[],
|
|
templateSpecialization=[], isStruct=False,
|
|
disallowCopyConstruction=False, indent='',
|
|
decorators='',
|
|
extradeclarations='',
|
|
extradefinitions=''):
|
|
CGThing.__init__(self)
|
|
self.name = name
|
|
self.bases = bases
|
|
self.members = members
|
|
self.constructors = constructors
|
|
# We store our single destructor in a list, since all of our
|
|
# code wants lists of members.
|
|
self.destructors = [destructor] if destructor else []
|
|
self.methods = methods
|
|
self.typedefs = typedefs
|
|
self.enums = enums
|
|
self.unions = unions
|
|
self.templateArgs = templateArgs
|
|
self.templateSpecialization = templateSpecialization
|
|
self.isStruct = isStruct
|
|
self.disallowCopyConstruction = disallowCopyConstruction
|
|
self.indent = indent
|
|
self.defaultVisibility = 'public' if isStruct else 'private'
|
|
self.decorators = decorators
|
|
self.extradeclarations = extradeclarations
|
|
self.extradefinitions = extradefinitions
|
|
|
|
def getNameString(self):
|
|
className = self.name
|
|
if self.templateSpecialization:
|
|
className += '<%s>' % ', '.join([str(a)
|
|
for a in self.templateSpecialization])
|
|
return className
|
|
|
|
def declare(self):
|
|
result = ''
|
|
if self.templateArgs:
|
|
templateArgs = [a.declare() for a in self.templateArgs]
|
|
templateArgs = templateArgs[len(self.templateSpecialization):]
|
|
result += ('template <%s>\n' %
|
|
','.join([str(a) for a in templateArgs]))
|
|
|
|
type = 'struct' if self.isStruct else 'class'
|
|
|
|
if self.templateSpecialization:
|
|
specialization = \
|
|
'<%s>' % ', '.join([str(a) for a in self.templateSpecialization])
|
|
else:
|
|
specialization = ''
|
|
|
|
myself = '%s %s%s' % (type, self.name, specialization)
|
|
if self.decorators != '':
|
|
myself += " " + self.decorators
|
|
result += myself
|
|
|
|
if self.bases:
|
|
inherit = ' : '
|
|
result += inherit
|
|
# Grab our first base
|
|
baseItems = [CGGeneric(b.declare(self)) for b in self.bases]
|
|
bases = baseItems[:1]
|
|
# Indent the rest
|
|
bases.extend(CGIndenter(b, len(myself) + len(inherit))
|
|
for b in baseItems[1:])
|
|
result += ",\n".join(b.define() for b in bases)
|
|
|
|
result += '\n{\n'
|
|
|
|
result += self.extradeclarations
|
|
|
|
def declareMembers(cgClass, memberList, defaultVisibility):
|
|
members = {'private': [], 'protected': [], 'public': []}
|
|
|
|
for member in memberList:
|
|
members[member.visibility].append(member)
|
|
|
|
if defaultVisibility == 'public':
|
|
order = ['public', 'protected', 'private']
|
|
else:
|
|
order = ['private', 'protected', 'public']
|
|
|
|
result = ''
|
|
|
|
lastVisibility = defaultVisibility
|
|
for visibility in order:
|
|
list = members[visibility]
|
|
if list:
|
|
if visibility != lastVisibility:
|
|
result += visibility + ':\n'
|
|
for member in list:
|
|
result += indent(member.declare(cgClass))
|
|
lastVisibility = visibility
|
|
return (result, lastVisibility)
|
|
|
|
if self.disallowCopyConstruction:
|
|
class DisallowedCopyConstructor(object):
|
|
def __init__(self):
|
|
self.visibility = "private"
|
|
|
|
def declare(self, cgClass):
|
|
name = cgClass.getNameString()
|
|
return ("%s(const %s&) = delete;\n"
|
|
"void operator=(const %s&) = delete;\n" % (name, name, name))
|
|
|
|
disallowedCopyConstructors = [DisallowedCopyConstructor()]
|
|
else:
|
|
disallowedCopyConstructors = []
|
|
|
|
order = [self.enums, self.unions,
|
|
self.typedefs, self.members,
|
|
self.constructors + disallowedCopyConstructors,
|
|
self.destructors, self.methods]
|
|
|
|
lastVisibility = self.defaultVisibility
|
|
pieces = []
|
|
for memberList in order:
|
|
code, lastVisibility = declareMembers(self, memberList, lastVisibility)
|
|
|
|
if code:
|
|
code = code.rstrip() + "\n" # remove extra blank lines at the end
|
|
pieces.append(code)
|
|
|
|
result += '\n'.join(pieces)
|
|
result += '};\n'
|
|
result = indent(result, len(self.indent))
|
|
return result
|
|
|
|
def define(self):
|
|
def defineMembers(cgClass, memberList, itemCount, separator=''):
|
|
result = ''
|
|
for member in memberList:
|
|
if itemCount != 0:
|
|
result = result + separator
|
|
definition = member.define(cgClass)
|
|
if definition:
|
|
# Member variables would only produce empty lines here.
|
|
result += definition
|
|
itemCount += 1
|
|
return (result, itemCount)
|
|
|
|
order = [(self.members, ''), (self.constructors, '\n'),
|
|
(self.destructors, '\n'), (self.methods, '\n')]
|
|
|
|
result = self.extradefinitions
|
|
itemCount = 0
|
|
for memberList, separator in order:
|
|
memberString, itemCount = defineMembers(self, memberList,
|
|
itemCount, separator)
|
|
result = result + memberString
|
|
return result
|
|
|
|
|
|
class CGResolveOwnProperty(CGAbstractStaticMethod):
|
|
def __init__(self, descriptor):
|
|
args = [Argument('JSContext*', 'cx'),
|
|
Argument('JS::Handle<JSObject*>', 'wrapper'),
|
|
Argument('JS::Handle<JSObject*>', 'obj'),
|
|
Argument('JS::Handle<jsid>', 'id'),
|
|
Argument('JS::MutableHandle<JS::PropertyDescriptor>', 'desc'),
|
|
]
|
|
CGAbstractStaticMethod.__init__(self, descriptor, "ResolveOwnProperty",
|
|
"bool", args)
|
|
|
|
def definition_body(self):
|
|
return "return js::GetProxyHandler(obj)->getOwnPropertyDescriptor(cx, wrapper, id, desc);\n"
|
|
|
|
|
|
class CGResolveOwnPropertyViaResolve(CGAbstractBindingMethod):
|
|
"""
|
|
An implementation of Xray ResolveOwnProperty stuff for things that have a
|
|
resolve hook.
|
|
"""
|
|
def __init__(self, descriptor):
|
|
args = [Argument('JSContext*', 'cx'),
|
|
Argument('JS::Handle<JSObject*>', 'wrapper'),
|
|
Argument('JS::Handle<JSObject*>', 'obj'),
|
|
Argument('JS::Handle<jsid>', 'id'),
|
|
Argument('JS::MutableHandle<JS::PropertyDescriptor>', 'desc')]
|
|
CGAbstractBindingMethod.__init__(self, descriptor,
|
|
"ResolveOwnPropertyViaResolve",
|
|
args, getThisObj="",
|
|
callArgs="")
|
|
|
|
def generate_code(self):
|
|
return CGGeneric(dedent("""
|
|
{
|
|
// Since we're dealing with an Xray, do the resolve on the
|
|
// underlying object first. That gives it a chance to
|
|
// define properties on the actual object as needed, and
|
|
// then use the fact that it created the objects as a flag
|
|
// to avoid re-resolving the properties if someone deletes
|
|
// them.
|
|
JSAutoCompartment ac(cx, obj);
|
|
JS::Rooted<JS::PropertyDescriptor> objDesc(cx);
|
|
if (!self->DoResolve(cx, obj, id, &objDesc)) {
|
|
return false;
|
|
}
|
|
// If desc.value() is undefined, then the DoResolve call
|
|
// has already defined the property on the object. Don't
|
|
// try to also define it.
|
|
if (objDesc.object() &&
|
|
!objDesc.value().isUndefined() &&
|
|
!JS_DefinePropertyById(cx, obj, id, objDesc)) {
|
|
return false;
|
|
}
|
|
}
|
|
return self->DoResolve(cx, wrapper, id, desc);
|
|
"""))
|
|
|
|
|
|
class CGEnumerateOwnProperties(CGAbstractStaticMethod):
|
|
def __init__(self, descriptor):
|
|
args = [Argument('JSContext*', 'cx'),
|
|
Argument('JS::Handle<JSObject*>', 'wrapper'),
|
|
Argument('JS::Handle<JSObject*>', 'obj'),
|
|
Argument('JS::AutoIdVector&', 'props')]
|
|
CGAbstractStaticMethod.__init__(self, descriptor,
|
|
"EnumerateOwnProperties", "bool", args)
|
|
|
|
def definition_body(self):
|
|
return "return js::GetProxyHandler(obj)->ownPropertyKeys(cx, wrapper, props);\n"
|
|
|
|
|
|
class CGEnumerateOwnPropertiesViaGetOwnPropertyNames(CGAbstractBindingMethod):
|
|
"""
|
|
An implementation of Xray EnumerateOwnProperties stuff for things
|
|
that have a resolve hook.
|
|
"""
|
|
def __init__(self, descriptor):
|
|
args = [Argument('JSContext*', 'cx'),
|
|
Argument('JS::Handle<JSObject*>', 'wrapper'),
|
|
Argument('JS::Handle<JSObject*>', 'obj'),
|
|
Argument('JS::AutoIdVector&', 'props')]
|
|
CGAbstractBindingMethod.__init__(self, descriptor,
|
|
"EnumerateOwnPropertiesViaGetOwnPropertyNames",
|
|
args, getThisObj="",
|
|
callArgs="")
|
|
|
|
def generate_code(self):
|
|
return CGGeneric(dedent("""
|
|
AutoTArray<nsString, 8> names;
|
|
binding_detail::FastErrorResult rv;
|
|
self->GetOwnPropertyNames(cx, names, rv);
|
|
if (rv.MaybeSetPendingException(cx)) {
|
|
return false;
|
|
}
|
|
// OK to pass null as "proxy" because it's ignored if
|
|
// shadowPrototypeProperties is true
|
|
return AppendNamedPropertyIds(cx, nullptr, names, true, props);
|
|
"""))
|
|
|
|
|
|
class CGPrototypeTraitsClass(CGClass):
|
|
def __init__(self, descriptor, indent=''):
|
|
templateArgs = [Argument('prototypes::ID', 'PrototypeID')]
|
|
templateSpecialization = ['prototypes::id::' + descriptor.name]
|
|
enums = [ClassEnum('', ['Depth'],
|
|
[descriptor.interface.inheritanceDepth()])]
|
|
CGClass.__init__(self, 'PrototypeTraits', indent=indent,
|
|
templateArgs=templateArgs,
|
|
templateSpecialization=templateSpecialization,
|
|
enums=enums, isStruct=True)
|
|
|
|
def deps(self):
|
|
return set()
|
|
|
|
|
|
class CGClassForwardDeclare(CGThing):
|
|
def __init__(self, name, isStruct=False):
|
|
CGThing.__init__(self)
|
|
self.name = name
|
|
self.isStruct = isStruct
|
|
|
|
def declare(self):
|
|
type = 'struct' if self.isStruct else 'class'
|
|
return '%s %s;\n' % (type, self.name)
|
|
|
|
def define(self):
|
|
# Header only
|
|
return ''
|
|
|
|
def deps(self):
|
|
return set()
|
|
|
|
|
|
class CGProxySpecialOperation(CGPerSignatureCall):
|
|
"""
|
|
Base class for classes for calling an indexed or named special operation
|
|
(don't use this directly, use the derived classes below).
|
|
|
|
If checkFound is False, will just assert that the prop is found instead of
|
|
checking that it is before wrapping the value.
|
|
|
|
resultVar: See the docstring for CGCallGenerator.
|
|
|
|
foundVar: For getters and deleters, the generated code can also set a bool
|
|
variable, declared by the caller, if the given indexed or named property
|
|
already existed. If the caller wants this, it should pass the name of the
|
|
bool variable as the foundVar keyword argument to the constructor. The
|
|
caller is responsible for declaring the variable and initializing it to
|
|
false.
|
|
"""
|
|
def __init__(self, descriptor, operation, checkFound=True,
|
|
argumentHandleValue=None, resultVar=None, foundVar=None):
|
|
self.checkFound = checkFound
|
|
self.foundVar = foundVar or "found"
|
|
|
|
nativeName = MakeNativeName(descriptor.binaryNameFor(operation))
|
|
operation = descriptor.operations[operation]
|
|
assert len(operation.signatures()) == 1
|
|
signature = operation.signatures()[0]
|
|
|
|
returnType, arguments = signature
|
|
|
|
# We pass len(arguments) as the final argument so that the
|
|
# CGPerSignatureCall won't do any argument conversion of its own.
|
|
CGPerSignatureCall.__init__(self, returnType, arguments, nativeName,
|
|
False, descriptor, operation,
|
|
len(arguments), resultVar=resultVar,
|
|
objectName="proxy")
|
|
|
|
if operation.isSetter() or operation.isCreator():
|
|
# arguments[0] is the index or name of the item that we're setting.
|
|
argument = arguments[1]
|
|
info = getJSToNativeConversionInfo(
|
|
argument.type, descriptor,
|
|
treatNullAs=argument.treatNullAs,
|
|
sourceDescription=("value being assigned to %s setter" %
|
|
descriptor.interface.identifier.name))
|
|
if argumentHandleValue is None:
|
|
argumentHandleValue = "desc.value()"
|
|
rootedValue = fill(
|
|
"""
|
|
JS::Rooted<JS::Value> rootedValue(cx, ${argumentHandleValue});
|
|
""",
|
|
argumentHandleValue = argumentHandleValue)
|
|
templateValues = {
|
|
"declName": argument.identifier.name,
|
|
"holderName": argument.identifier.name + "_holder",
|
|
"val": argumentHandleValue,
|
|
"maybeMutableVal": "&rootedValue",
|
|
"obj": "obj",
|
|
"passedToJSImpl": "false"
|
|
}
|
|
self.cgRoot.prepend(instantiateJSToNativeConversion(info, templateValues))
|
|
# rootedValue needs to come before the conversion, so we
|
|
# need to prepend it last.
|
|
self.cgRoot.prepend(CGGeneric(rootedValue))
|
|
elif operation.isGetter() or operation.isDeleter():
|
|
if foundVar is None:
|
|
self.cgRoot.prepend(CGGeneric("bool found = false;\n"))
|
|
|
|
def getArguments(self):
|
|
args = [(a, a.identifier.name) for a in self.arguments]
|
|
if self.idlNode.isGetter() or self.idlNode.isDeleter():
|
|
args.append((FakeArgument(BuiltinTypes[IDLBuiltinType.Types.boolean],
|
|
self.idlNode),
|
|
self.foundVar))
|
|
return args
|
|
|
|
def wrap_return_value(self):
|
|
if not self.idlNode.isGetter() or self.templateValues is None:
|
|
return ""
|
|
|
|
wrap = CGGeneric(wrapForType(self.returnType, self.descriptor, self.templateValues))
|
|
if self.checkFound:
|
|
wrap = CGIfWrapper(wrap, self.foundVar)
|
|
else:
|
|
wrap = CGList([CGGeneric("MOZ_ASSERT(" + self.foundVar + ");\n"), wrap])
|
|
return "\n" + wrap.define()
|
|
|
|
|
|
class CGProxyIndexedOperation(CGProxySpecialOperation):
|
|
"""
|
|
Class to generate a call to an indexed operation.
|
|
|
|
If doUnwrap is False, the caller is responsible for making sure a variable
|
|
named 'self' holds the C++ object somewhere where the code we generate
|
|
will see it.
|
|
|
|
If checkFound is False, will just assert that the prop is found instead of
|
|
checking that it is before wrapping the value.
|
|
|
|
resultVar: See the docstring for CGCallGenerator.
|
|
|
|
foundVar: See the docstring for CGProxySpecialOperation.
|
|
"""
|
|
def __init__(self, descriptor, name, doUnwrap=True, checkFound=True,
|
|
argumentHandleValue=None, resultVar=None, foundVar=None):
|
|
self.doUnwrap = doUnwrap
|
|
CGProxySpecialOperation.__init__(self, descriptor, name, checkFound,
|
|
argumentHandleValue=argumentHandleValue,
|
|
resultVar=resultVar,
|
|
foundVar=foundVar)
|
|
|
|
def define(self):
|
|
# Our first argument is the id we're getting.
|
|
argName = self.arguments[0].identifier.name
|
|
if argName == "index":
|
|
# We already have our index in a variable with that name
|
|
setIndex = ""
|
|
else:
|
|
setIndex = "uint32_t %s = index;\n" % argName
|
|
if self.doUnwrap:
|
|
unwrap = "%s* self = UnwrapProxy(proxy);\n" % self.descriptor.nativeType
|
|
else:
|
|
unwrap = ""
|
|
return (setIndex + unwrap +
|
|
CGProxySpecialOperation.define(self))
|
|
|
|
|
|
class CGProxyIndexedGetter(CGProxyIndexedOperation):
|
|
"""
|
|
Class to generate a call to an indexed getter. If templateValues is not None
|
|
the returned value will be wrapped with wrapForType using templateValues.
|
|
|
|
If doUnwrap is False, the caller is responsible for making sure a variable
|
|
named 'self' holds the C++ object somewhere where the code we generate
|
|
will see it.
|
|
|
|
If checkFound is False, will just assert that the prop is found instead of
|
|
checking that it is before wrapping the value.
|
|
|
|
foundVar: See the docstring for CGProxySpecialOperation.
|
|
"""
|
|
def __init__(self, descriptor, templateValues=None, doUnwrap=True,
|
|
checkFound=True, foundVar=None):
|
|
self.templateValues = templateValues
|
|
CGProxyIndexedOperation.__init__(self, descriptor, 'IndexedGetter',
|
|
doUnwrap, checkFound, foundVar=foundVar)
|
|
|
|
|
|
class CGProxyIndexedPresenceChecker(CGProxyIndexedGetter):
|
|
"""
|
|
Class to generate a call that checks whether an indexed property exists.
|
|
|
|
For now, we just delegate to CGProxyIndexedGetter
|
|
|
|
foundVar: See the docstring for CGProxySpecialOperation.
|
|
"""
|
|
def __init__(self, descriptor, foundVar):
|
|
CGProxyIndexedGetter.__init__(self, descriptor, foundVar=foundVar)
|
|
self.cgRoot.append(CGGeneric("(void)result;\n"))
|
|
|
|
|
|
class CGProxyIndexedSetter(CGProxyIndexedOperation):
|
|
"""
|
|
Class to generate a call to an indexed setter.
|
|
"""
|
|
def __init__(self, descriptor, argumentHandleValue=None):
|
|
CGProxyIndexedOperation.__init__(self, descriptor, 'IndexedSetter',
|
|
argumentHandleValue=argumentHandleValue)
|
|
|
|
|
|
class CGProxyNamedOperation(CGProxySpecialOperation):
|
|
"""
|
|
Class to generate a call to a named operation.
|
|
|
|
'value' is the jsval to use for the name; None indicates that it should be
|
|
gotten from the property id.
|
|
|
|
resultVar: See the docstring for CGCallGenerator.
|
|
|
|
foundVar: See the docstring for CGProxySpecialOperation.
|
|
"""
|
|
def __init__(self, descriptor, name, value=None, argumentHandleValue=None,
|
|
resultVar=None, foundVar=None):
|
|
CGProxySpecialOperation.__init__(self, descriptor, name,
|
|
argumentHandleValue=argumentHandleValue,
|
|
resultVar=resultVar,
|
|
foundVar=foundVar)
|
|
self.value = value
|
|
|
|
def define(self):
|
|
# Our first argument is the id we're getting.
|
|
argName = self.arguments[0].identifier.name
|
|
if argName == "id":
|
|
# deal with the name collision
|
|
decls = "JS::Rooted<jsid> id_(cx, id);\n"
|
|
idName = "id_"
|
|
else:
|
|
decls = ""
|
|
idName = "id"
|
|
|
|
decls += "binding_detail::FakeString %s;\n" % argName
|
|
|
|
main = fill(
|
|
"""
|
|
${nativeType}* self = UnwrapProxy(proxy);
|
|
$*{op}
|
|
""",
|
|
nativeType=self.descriptor.nativeType,
|
|
op=CGProxySpecialOperation.define(self))
|
|
|
|
if self.value is None:
|
|
return fill(
|
|
"""
|
|
$*{decls}
|
|
bool isSymbol;
|
|
if (!ConvertIdToString(cx, ${idName}, ${argName}, isSymbol)) {
|
|
return false;
|
|
}
|
|
if (!isSymbol) {
|
|
$*{main}
|
|
}
|
|
""",
|
|
decls=decls,
|
|
idName=idName,
|
|
argName=argName,
|
|
main=main)
|
|
|
|
# Sadly, we have to set up nameVal even if we have an atom id,
|
|
# because we don't know for sure, and we can end up needing it
|
|
# so it needs to be higher up the stack. Using a Maybe here
|
|
# seems like probable overkill.
|
|
return fill(
|
|
"""
|
|
$*{decls}
|
|
JS::Rooted<JS::Value> nameVal(cx, ${value});
|
|
if (!nameVal.isSymbol()) {
|
|
if (!ConvertJSValueToString(cx, nameVal, eStringify, eStringify,
|
|
${argName})) {
|
|
return false;
|
|
}
|
|
$*{main}
|
|
}
|
|
""",
|
|
decls=decls,
|
|
value=self.value,
|
|
argName=argName,
|
|
main=main)
|
|
|
|
|
|
class CGProxyNamedGetter(CGProxyNamedOperation):
|
|
"""
|
|
Class to generate a call to an named getter. If templateValues is not None
|
|
the returned value will be wrapped with wrapForType using templateValues.
|
|
'value' is the jsval to use for the name; None indicates that it should be
|
|
gotten from the property id.
|
|
|
|
foundVar: See the docstring for CGProxySpecialOperation.
|
|
"""
|
|
def __init__(self, descriptor, templateValues=None, value=None,
|
|
foundVar=None):
|
|
self.templateValues = templateValues
|
|
CGProxyNamedOperation.__init__(self, descriptor, 'NamedGetter', value,
|
|
foundVar=foundVar)
|
|
|
|
|
|
class CGProxyNamedPresenceChecker(CGProxyNamedGetter):
|
|
"""
|
|
Class to generate a call that checks whether a named property exists.
|
|
|
|
For now, we just delegate to CGProxyNamedGetter
|
|
|
|
foundVar: See the docstring for CGProxySpecialOperation.
|
|
"""
|
|
def __init__(self, descriptor, foundVar=None):
|
|
CGProxyNamedGetter.__init__(self, descriptor, foundVar=foundVar)
|
|
self.cgRoot.append(CGGeneric("(void)result;\n"))
|
|
|
|
|
|
class CGProxyNamedSetter(CGProxyNamedOperation):
|
|
"""
|
|
Class to generate a call to a named setter.
|
|
"""
|
|
def __init__(self, descriptor, argumentHandleValue=None):
|
|
CGProxyNamedOperation.__init__(self, descriptor, 'NamedSetter',
|
|
argumentHandleValue=argumentHandleValue)
|
|
|
|
|
|
class CGProxyNamedDeleter(CGProxyNamedOperation):
|
|
"""
|
|
Class to generate a call to a named deleter.
|
|
|
|
resultVar: See the docstring for CGCallGenerator.
|
|
|
|
foundVar: See the docstring for CGProxySpecialOperation.
|
|
"""
|
|
def __init__(self, descriptor, resultVar=None, foundVar=None):
|
|
CGProxyNamedOperation.__init__(self, descriptor, 'NamedDeleter',
|
|
resultVar=resultVar,
|
|
foundVar=foundVar)
|
|
|
|
|
|
class CGProxyIsProxy(CGAbstractMethod):
|
|
def __init__(self, descriptor):
|
|
args = [Argument('JSObject*', 'obj')]
|
|
CGAbstractMethod.__init__(self, descriptor, "IsProxy", "bool", args, alwaysInline=True)
|
|
|
|
def declare(self):
|
|
return ""
|
|
|
|
def definition_body(self):
|
|
return "return js::IsProxy(obj) && js::GetProxyHandler(obj) == DOMProxyHandler::getInstance();\n"
|
|
|
|
|
|
class CGProxyUnwrap(CGAbstractMethod):
|
|
def __init__(self, descriptor):
|
|
args = [Argument('JSObject*', 'obj')]
|
|
CGAbstractMethod.__init__(self, descriptor, "UnwrapProxy", descriptor.nativeType + '*', args, alwaysInline=True)
|
|
|
|
def declare(self):
|
|
return ""
|
|
|
|
def definition_body(self):
|
|
return fill(
|
|
"""
|
|
MOZ_ASSERT(js::IsProxy(obj));
|
|
if (js::GetProxyHandler(obj) != DOMProxyHandler::getInstance()) {
|
|
MOZ_ASSERT(xpc::WrapperFactory::IsXrayWrapper(obj));
|
|
obj = js::UncheckedUnwrap(obj);
|
|
}
|
|
MOZ_ASSERT(IsProxy(obj));
|
|
return static_cast<${type}*>(js::GetProxyPrivate(obj).toPrivate());
|
|
""",
|
|
type=self.descriptor.nativeType)
|
|
|
|
|
|
class CGDOMJSProxyHandler_getOwnPropDescriptor(ClassMethod):
|
|
def __init__(self, descriptor):
|
|
args = [Argument('JSContext*', 'cx'),
|
|
Argument('JS::Handle<JSObject*>', 'proxy'),
|
|
Argument('JS::Handle<jsid>', 'id'),
|
|
Argument('bool', 'ignoreNamedProps'),
|
|
Argument('JS::MutableHandle<JS::PropertyDescriptor>', 'desc')]
|
|
ClassMethod.__init__(self, "getOwnPropDescriptor", "bool", args,
|
|
virtual=True, override=True, const=True)
|
|
self.descriptor = descriptor
|
|
|
|
def getBody(self):
|
|
indexedGetter = self.descriptor.operations['IndexedGetter']
|
|
indexedSetter = self.descriptor.operations['IndexedSetter']
|
|
|
|
if self.descriptor.supportsIndexedProperties():
|
|
readonly = toStringBool(indexedSetter is None)
|
|
fillDescriptor = "FillPropertyDescriptor(desc, proxy, %s);\nreturn true;\n" % readonly
|
|
templateValues = {
|
|
'jsvalRef': 'desc.value()',
|
|
'jsvalHandle': 'desc.value()',
|
|
'obj': 'proxy',
|
|
'successCode': fillDescriptor
|
|
}
|
|
getIndexed = fill(
|
|
"""
|
|
uint32_t index = GetArrayIndexFromId(cx, id);
|
|
if (IsArrayIndex(index)) {
|
|
$*{callGetter}
|
|
}
|
|
|
|
""",
|
|
callGetter=CGProxyIndexedGetter(self.descriptor, templateValues).define())
|
|
else:
|
|
getIndexed = ""
|
|
|
|
if self.descriptor.supportsNamedProperties():
|
|
operations = self.descriptor.operations
|
|
readonly = toStringBool(operations['NamedSetter'] is None)
|
|
fillDescriptor = (
|
|
"FillPropertyDescriptor(desc, proxy, %s, %s);\n"
|
|
"return true;\n" %
|
|
(readonly,
|
|
toStringBool(self.descriptor.namedPropertiesEnumerable)))
|
|
templateValues = {'jsvalRef': 'desc.value()', 'jsvalHandle': 'desc.value()',
|
|
'obj': 'proxy', 'successCode': fillDescriptor}
|
|
|
|
computeCondition = dedent("""
|
|
bool hasOnProto;
|
|
if (!HasPropertyOnPrototype(cx, proxy, id, &hasOnProto)) {
|
|
return false;
|
|
}
|
|
callNamedGetter = !hasOnProto;
|
|
""")
|
|
if self.descriptor.interface.getExtendedAttribute('OverrideBuiltins'):
|
|
computeCondition = fill(
|
|
"""
|
|
if (!isXray) {
|
|
callNamedGetter = true;
|
|
} else {
|
|
$*{hasOnProto}
|
|
}
|
|
""",
|
|
hasOnProto=computeCondition)
|
|
|
|
outerCondition = "!ignoreNamedProps"
|
|
if self.descriptor.supportsIndexedProperties():
|
|
outerCondition = "!IsArrayIndex(index) && " + outerCondition
|
|
|
|
namedGetCode = CGProxyNamedGetter(self.descriptor,
|
|
templateValues).define()
|
|
namedGet = fill("""
|
|
bool callNamedGetter = false;
|
|
if (${outerCondition}) {
|
|
$*{computeCondition}
|
|
}
|
|
if (callNamedGetter) {
|
|
$*{namedGetCode}
|
|
}
|
|
""",
|
|
outerCondition=outerCondition,
|
|
computeCondition=computeCondition,
|
|
namedGetCode=namedGetCode)
|
|
namedGet += "\n"
|
|
else:
|
|
namedGet = ""
|
|
|
|
return fill(
|
|
"""
|
|
bool isXray = xpc::WrapperFactory::IsXrayWrapper(proxy);
|
|
$*{getIndexed}
|
|
JS::Rooted<JSObject*> expando(cx);
|
|
if (!isXray && (expando = GetExpandoObject(proxy))) {
|
|
if (!JS_GetOwnPropertyDescriptorById(cx, expando, id, desc)) {
|
|
return false;
|
|
}
|
|
if (desc.object()) {
|
|
// Pretend the property lives on the wrapper.
|
|
desc.object().set(proxy);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
$*{namedGet}
|
|
desc.object().set(nullptr);
|
|
return true;
|
|
""",
|
|
getIndexed=getIndexed,
|
|
namedGet=namedGet)
|
|
|
|
|
|
class CGDOMJSProxyHandler_defineProperty(ClassMethod):
|
|
def __init__(self, descriptor):
|
|
# The usual convention is to name the ObjectOpResult out-parameter
|
|
# `result`, but that name is a bit overloaded around here.
|
|
args = [Argument('JSContext*', 'cx'),
|
|
Argument('JS::Handle<JSObject*>', 'proxy'),
|
|
Argument('JS::Handle<jsid>', 'id'),
|
|
Argument('JS::Handle<JS::PropertyDescriptor>', 'desc'),
|
|
Argument('JS::ObjectOpResult&', 'opresult'),
|
|
Argument('bool*', 'defined')]
|
|
ClassMethod.__init__(self, "defineProperty", "bool", args, virtual=True, override=True, const=True)
|
|
self.descriptor = descriptor
|
|
|
|
def getBody(self):
|
|
set = ""
|
|
|
|
indexedSetter = self.descriptor.operations['IndexedSetter']
|
|
if indexedSetter:
|
|
if self.descriptor.operations['IndexedCreator'] is not indexedSetter:
|
|
raise TypeError("Can't handle creator that's different from the setter")
|
|
set += fill(
|
|
"""
|
|
uint32_t index = GetArrayIndexFromId(cx, id);
|
|
if (IsArrayIndex(index)) {
|
|
*defined = true;
|
|
$*{callSetter}
|
|
return opresult.succeed();
|
|
}
|
|
""",
|
|
callSetter=CGProxyIndexedSetter(self.descriptor).define())
|
|
elif self.descriptor.supportsIndexedProperties():
|
|
# We allow untrusted content to prevent Xrays from setting a
|
|
# property if that property is an indexed property and we have no
|
|
# indexed setter. That's how the object would normally behave if
|
|
# you tried to set the property on it. That means we don't need to
|
|
# do anything special for Xrays here.
|
|
set += dedent(
|
|
"""
|
|
if (IsArrayIndex(GetArrayIndexFromId(cx, id))) {
|
|
*defined = true;
|
|
return opresult.failNoIndexedSetter();
|
|
}
|
|
""")
|
|
|
|
namedSetter = self.descriptor.operations['NamedSetter']
|
|
if namedSetter:
|
|
if self.descriptor.hasUnforgeableMembers:
|
|
raise TypeError("Can't handle a named setter on an interface "
|
|
"that has unforgeables. Figure out how that "
|
|
"should work!")
|
|
if self.descriptor.operations['NamedCreator'] is not namedSetter:
|
|
raise TypeError("Can't handle creator that's different from the setter")
|
|
# If we support indexed properties, we won't get down here for
|
|
# indices, so we can just do our setter unconditionally here.
|
|
set += fill(
|
|
"""
|
|
*defined = true;
|
|
$*{callSetter}
|
|
|
|
return opresult.succeed();
|
|
""",
|
|
callSetter=CGProxyNamedSetter(self.descriptor).define())
|
|
else:
|
|
# We allow untrusted content to prevent Xrays from setting a
|
|
# property if that property is already a named property on the
|
|
# object and we have no named setter. That's how the object would
|
|
# normally behave if you tried to set the property on it. That
|
|
# means we don't need to do anything special for Xrays here.
|
|
if self.descriptor.supportsNamedProperties():
|
|
set += fill(
|
|
"""
|
|
bool found = false;
|
|
$*{presenceChecker}
|
|
|
|
if (found) {
|
|
*defined = true;
|
|
return opresult.failNoNamedSetter();
|
|
}
|
|
""",
|
|
presenceChecker=CGProxyNamedPresenceChecker(self.descriptor, foundVar="found").define())
|
|
set += ("return mozilla::dom::DOMProxyHandler::defineProperty(%s);\n" %
|
|
", ".join(a.name for a in self.args))
|
|
return set
|
|
|
|
|
|
def getDeleterBody(descriptor, type, foundVar=None):
|
|
"""
|
|
type should be "Named" or "Indexed"
|
|
|
|
The possible outcomes:
|
|
- an error happened (the emitted code returns false)
|
|
- own property not found (foundVar=false, deleteSucceeded=true)
|
|
- own property found and deleted (foundVar=true, deleteSucceeded=true)
|
|
- own property found but can't be deleted (foundVar=true, deleteSucceeded=false)
|
|
"""
|
|
assert type in ("Named", "Indexed")
|
|
deleter = descriptor.operations[type + 'Deleter']
|
|
if deleter:
|
|
assert type == "Named"
|
|
assert foundVar is not None
|
|
if descriptor.hasUnforgeableMembers:
|
|
raise TypeError("Can't handle a deleter on an interface "
|
|
"that has unforgeables. Figure out how "
|
|
"that should work!")
|
|
# See if the deleter method is fallible.
|
|
t = deleter.signatures()[0][0]
|
|
if t.isPrimitive() and not t.nullable() and t.tag() == IDLType.Tags.bool:
|
|
# The deleter method has a boolean return value. When a
|
|
# property is found, the return value indicates whether it
|
|
# was successfully deleted.
|
|
setDS = fill(
|
|
"""
|
|
if (!${foundVar}) {
|
|
deleteSucceeded = true;
|
|
}
|
|
""",
|
|
foundVar=foundVar)
|
|
else:
|
|
# No boolean return value: if a property is found,
|
|
# deleting it always succeeds.
|
|
setDS = "deleteSucceeded = true;\n"
|
|
|
|
body = (CGProxyNamedDeleter(descriptor,
|
|
resultVar="deleteSucceeded",
|
|
foundVar=foundVar).define() +
|
|
setDS)
|
|
elif getattr(descriptor, "supports%sProperties" % type)():
|
|
presenceCheckerClass = globals()["CGProxy%sPresenceChecker" % type]
|
|
foundDecl = ""
|
|
if foundVar is None:
|
|
foundVar = "found"
|
|
foundDecl = "bool found = false;\n"
|
|
body = fill(
|
|
"""
|
|
$*{foundDecl}
|
|
$*{presenceChecker}
|
|
deleteSucceeded = !${foundVar};
|
|
""",
|
|
foundDecl=foundDecl,
|
|
presenceChecker=presenceCheckerClass(descriptor, foundVar=foundVar).define(),
|
|
foundVar=foundVar)
|
|
else:
|
|
body = None
|
|
return body
|
|
|
|
|
|
class CGDeleteNamedProperty(CGAbstractStaticMethod):
|
|
def __init__(self, descriptor):
|
|
args = [Argument('JSContext*', 'cx'),
|
|
Argument('JS::Handle<JSObject*>', 'xray'),
|
|
Argument('JS::Handle<JSObject*>', 'proxy'),
|
|
Argument('JS::Handle<jsid>', 'id'),
|
|
Argument('JS::ObjectOpResult&', 'opresult')]
|
|
CGAbstractStaticMethod.__init__(self, descriptor, "DeleteNamedProperty",
|
|
"bool", args)
|
|
|
|
def definition_body(self):
|
|
return fill(
|
|
"""
|
|
MOZ_ASSERT(xpc::WrapperFactory::IsXrayWrapper(xray));
|
|
MOZ_ASSERT(js::IsProxy(proxy));
|
|
MOZ_ASSERT(!xpc::WrapperFactory::IsXrayWrapper(proxy));
|
|
JSAutoCompartment ac(cx, proxy);
|
|
bool deleteSucceeded;
|
|
bool found = false;
|
|
$*{namedBody}
|
|
if (!found || deleteSucceeded) {
|
|
return opresult.succeed();
|
|
}
|
|
return opresult.failCantDelete();
|
|
""",
|
|
namedBody=getDeleterBody(self.descriptor, "Named", foundVar="found"))
|
|
|
|
|
|
class CGDOMJSProxyHandler_delete(ClassMethod):
|
|
def __init__(self, descriptor):
|
|
args = [Argument('JSContext*', 'cx'),
|
|
Argument('JS::Handle<JSObject*>', 'proxy'),
|
|
Argument('JS::Handle<jsid>', 'id'),
|
|
Argument('JS::ObjectOpResult&', 'opresult')]
|
|
ClassMethod.__init__(self, "delete_", "bool", args,
|
|
virtual=True, override=True, const=True)
|
|
self.descriptor = descriptor
|
|
|
|
def getBody(self):
|
|
delete = dedent("""
|
|
MOZ_ASSERT(!xpc::WrapperFactory::IsXrayWrapper(proxy),
|
|
"Should not have a XrayWrapper here");
|
|
|
|
""")
|
|
|
|
indexedBody = getDeleterBody(self.descriptor, "Indexed")
|
|
if indexedBody is not None:
|
|
delete += fill(
|
|
"""
|
|
uint32_t index = GetArrayIndexFromId(cx, id);
|
|
if (IsArrayIndex(index)) {
|
|
bool deleteSucceeded;
|
|
$*{indexedBody}
|
|
return deleteSucceeded ? opresult.succeed() : opresult.failCantDelete();
|
|
}
|
|
""",
|
|
indexedBody=indexedBody)
|
|
|
|
namedBody = getDeleterBody(self.descriptor, "Named", foundVar="found")
|
|
if namedBody is not None:
|
|
delete += dedent(
|
|
"""
|
|
// Try named delete only if the named property visibility
|
|
// algorithm says the property is visible.
|
|
bool tryNamedDelete = true;
|
|
{ // Scope for expando
|
|
JS::Rooted<JSObject*> expando(cx, DOMProxyHandler::GetExpandoObject(proxy));
|
|
if (expando) {
|
|
bool hasProp;
|
|
if (!JS_HasPropertyById(cx, expando, id, &hasProp)) {
|
|
return false;
|
|
}
|
|
tryNamedDelete = !hasProp;
|
|
}
|
|
}
|
|
""")
|
|
|
|
if not self.descriptor.interface.getExtendedAttribute('OverrideBuiltins'):
|
|
delete += dedent(
|
|
"""
|
|
if (tryNamedDelete) {
|
|
bool hasOnProto;
|
|
if (!HasPropertyOnPrototype(cx, proxy, id, &hasOnProto)) {
|
|
return false;
|
|
}
|
|
tryNamedDelete = !hasOnProto;
|
|
}
|
|
""")
|
|
|
|
# We always return above for an index id in the case when we support
|
|
# indexed properties, so we can just treat the id as a name
|
|
# unconditionally here.
|
|
delete += fill(
|
|
"""
|
|
if (tryNamedDelete) {
|
|
bool found = false;
|
|
bool deleteSucceeded;
|
|
$*{namedBody}
|
|
if (found) {
|
|
return deleteSucceeded ? opresult.succeed() : opresult.failCantDelete();
|
|
}
|
|
}
|
|
""",
|
|
namedBody=namedBody)
|
|
|
|
delete += dedent("""
|
|
|
|
return dom::DOMProxyHandler::delete_(cx, proxy, id, opresult);
|
|
""")
|
|
|
|
return delete
|
|
|
|
|
|
class CGDOMJSProxyHandler_ownPropNames(ClassMethod):
|
|
def __init__(self, descriptor, ):
|
|
args = [Argument('JSContext*', 'cx'),
|
|
Argument('JS::Handle<JSObject*>', 'proxy'),
|
|
Argument('unsigned', 'flags'),
|
|
Argument('JS::AutoIdVector&', 'props')]
|
|
ClassMethod.__init__(self, "ownPropNames", "bool", args,
|
|
virtual=True, override=True, const=True)
|
|
self.descriptor = descriptor
|
|
|
|
def getBody(self):
|
|
# Per spec, we do indices, then named props, then everything else
|
|
if self.descriptor.supportsIndexedProperties():
|
|
addIndices = dedent("""
|
|
|
|
uint32_t length = UnwrapProxy(proxy)->Length();
|
|
MOZ_ASSERT(int32_t(length) >= 0);
|
|
for (int32_t i = 0; i < int32_t(length); ++i) {
|
|
if (!props.append(INT_TO_JSID(i))) {
|
|
return false;
|
|
}
|
|
}
|
|
""")
|
|
else:
|
|
addIndices = ""
|
|
|
|
if self.descriptor.supportsNamedProperties():
|
|
if self.descriptor.interface.getExtendedAttribute('OverrideBuiltins'):
|
|
shadow = "!isXray"
|
|
else:
|
|
shadow = "false"
|
|
addNames = fill(
|
|
"""
|
|
nsTArray<nsString> names;
|
|
UnwrapProxy(proxy)->GetSupportedNames(names);
|
|
if (!AppendNamedPropertyIds(cx, proxy, names, ${shadow}, props)) {
|
|
return false;
|
|
}
|
|
""",
|
|
shadow=shadow)
|
|
if not self.descriptor.namedPropertiesEnumerable:
|
|
addNames = CGIfWrapper(CGGeneric(addNames),
|
|
"flags & JSITER_HIDDEN").define()
|
|
addNames = "\n" + addNames
|
|
else:
|
|
addNames = ""
|
|
|
|
return fill(
|
|
"""
|
|
bool isXray = xpc::WrapperFactory::IsXrayWrapper(proxy);
|
|
$*{addIndices}
|
|
$*{addNames}
|
|
|
|
JS::Rooted<JSObject*> expando(cx);
|
|
if (!isXray && (expando = DOMProxyHandler::GetExpandoObject(proxy)) &&
|
|
!js::GetPropertyKeys(cx, expando, flags, &props)) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
""",
|
|
addIndices=addIndices,
|
|
addNames=addNames)
|
|
|
|
|
|
class CGDOMJSProxyHandler_hasOwn(ClassMethod):
|
|
def __init__(self, descriptor):
|
|
args = [Argument('JSContext*', 'cx'),
|
|
Argument('JS::Handle<JSObject*>', 'proxy'),
|
|
Argument('JS::Handle<jsid>', 'id'),
|
|
Argument('bool*', 'bp')]
|
|
ClassMethod.__init__(self, "hasOwn", "bool", args,
|
|
virtual=True, override=True, const=True)
|
|
self.descriptor = descriptor
|
|
|
|
def getBody(self):
|
|
if self.descriptor.supportsIndexedProperties():
|
|
indexed = fill(
|
|
"""
|
|
uint32_t index = GetArrayIndexFromId(cx, id);
|
|
if (IsArrayIndex(index)) {
|
|
bool found = false;
|
|
$*{presenceChecker}
|
|
|
|
*bp = found;
|
|
return true;
|
|
}
|
|
|
|
""",
|
|
presenceChecker=CGProxyIndexedPresenceChecker(self.descriptor, foundVar="found").define())
|
|
else:
|
|
indexed = ""
|
|
|
|
if self.descriptor.supportsNamedProperties():
|
|
# If we support indexed properties we always return above for index
|
|
# property names, so no need to check for those here.
|
|
named = fill(
|
|
"""
|
|
bool found = false;
|
|
$*{presenceChecker}
|
|
|
|
*bp = found;
|
|
""",
|
|
presenceChecker=CGProxyNamedPresenceChecker(self.descriptor, foundVar="found").define())
|
|
if not self.descriptor.interface.getExtendedAttribute('OverrideBuiltins'):
|
|
named = fill(
|
|
"""
|
|
bool hasOnProto;
|
|
if (!HasPropertyOnPrototype(cx, proxy, id, &hasOnProto)) {
|
|
return false;
|
|
}
|
|
if (!hasOnProto) {
|
|
$*{protoLacksProperty}
|
|
return true;
|
|
}
|
|
""",
|
|
protoLacksProperty=named)
|
|
named += "*bp = false;\n"
|
|
else:
|
|
named += "\n"
|
|
else:
|
|
named = "*bp = false;\n"
|
|
|
|
return fill(
|
|
"""
|
|
MOZ_ASSERT(!xpc::WrapperFactory::IsXrayWrapper(proxy),
|
|
"Should not have a XrayWrapper here");
|
|
|
|
$*{indexed}
|
|
|
|
JS::Rooted<JSObject*> expando(cx, GetExpandoObject(proxy));
|
|
if (expando) {
|
|
bool b = true;
|
|
bool ok = JS_HasPropertyById(cx, expando, id, &b);
|
|
*bp = !!b;
|
|
if (!ok || *bp) {
|
|
return ok;
|
|
}
|
|
}
|
|
|
|
$*{named}
|
|
return true;
|
|
""",
|
|
indexed=indexed,
|
|
named=named)
|
|
|
|
|
|
class CGDOMJSProxyHandler_get(ClassMethod):
|
|
def __init__(self, descriptor):
|
|
args = [Argument('JSContext*', 'cx'),
|
|
Argument('JS::Handle<JSObject*>', 'proxy'),
|
|
Argument('JS::Handle<JS::Value>', 'receiver'),
|
|
Argument('JS::Handle<jsid>', 'id'),
|
|
Argument('JS::MutableHandle<JS::Value>', 'vp')]
|
|
ClassMethod.__init__(self, "get", "bool", args,
|
|
virtual=True, override=True, const=True)
|
|
self.descriptor = descriptor
|
|
|
|
def getBody(self):
|
|
getUnforgeableOrExpando = dedent("""
|
|
{ // Scope for expando
|
|
JS::Rooted<JSObject*> expando(cx, DOMProxyHandler::GetExpandoObject(proxy));
|
|
if (expando) {
|
|
bool hasProp;
|
|
if (!JS_HasPropertyById(cx, expando, id, &hasProp)) {
|
|
return false;
|
|
}
|
|
|
|
if (hasProp) {
|
|
// Forward the get to the expando object, but our receiver is whatever our
|
|
// receiver is.
|
|
return JS_ForwardGetPropertyTo(cx, expando, id, receiver, vp);
|
|
}
|
|
}
|
|
}
|
|
""")
|
|
|
|
templateValues = {'jsvalRef': 'vp', 'jsvalHandle': 'vp', 'obj': 'proxy'}
|
|
|
|
if self.descriptor.supportsIndexedProperties():
|
|
getIndexedOrExpando = fill(
|
|
"""
|
|
uint32_t index = GetArrayIndexFromId(cx, id);
|
|
if (IsArrayIndex(index)) {
|
|
$*{callGetter}
|
|
// Even if we don't have this index, we don't forward the
|
|
// get on to our expando object.
|
|
} else {
|
|
$*{getUnforgeableOrExpando}
|
|
}
|
|
""",
|
|
callGetter=CGProxyIndexedGetter(self.descriptor, templateValues).define(),
|
|
getUnforgeableOrExpando=getUnforgeableOrExpando)
|
|
else:
|
|
getIndexedOrExpando = getUnforgeableOrExpando
|
|
|
|
if self.descriptor.supportsNamedProperties():
|
|
getNamed = CGProxyNamedGetter(self.descriptor, templateValues)
|
|
if self.descriptor.supportsIndexedProperties():
|
|
getNamed = CGIfWrapper(getNamed, "!IsArrayIndex(index)")
|
|
getNamed = getNamed.define() + "\n"
|
|
else:
|
|
getNamed = ""
|
|
|
|
getOnPrototype = dedent("""
|
|
bool foundOnPrototype;
|
|
if (!GetPropertyOnPrototype(cx, proxy, receiver, id, &foundOnPrototype, vp)) {
|
|
return false;
|
|
}
|
|
|
|
if (foundOnPrototype) {
|
|
return true;
|
|
}
|
|
|
|
""")
|
|
if self.descriptor.interface.getExtendedAttribute('OverrideBuiltins'):
|
|
getNamed = getNamed + getOnPrototype
|
|
else:
|
|
getNamed = getOnPrototype + getNamed
|
|
|
|
return fill(
|
|
"""
|
|
MOZ_ASSERT(!xpc::WrapperFactory::IsXrayWrapper(proxy),
|
|
"Should not have a XrayWrapper here");
|
|
|
|
$*{indexedOrExpando}
|
|
|
|
$*{named}
|
|
vp.setUndefined();
|
|
return true;
|
|
""",
|
|
indexedOrExpando=getIndexedOrExpando,
|
|
named=getNamed)
|
|
|
|
|
|
class CGDOMJSProxyHandler_setCustom(ClassMethod):
|
|
def __init__(self, descriptor):
|
|
args = [Argument('JSContext*', 'cx'),
|
|
Argument('JS::Handle<JSObject*>', 'proxy'),
|
|
Argument('JS::Handle<jsid>', 'id'),
|
|
Argument('JS::Handle<JS::Value>', 'v'),
|
|
Argument('bool*', 'done')]
|
|
ClassMethod.__init__(self, "setCustom", "bool", args, virtual=True, override=True, const=True)
|
|
self.descriptor = descriptor
|
|
|
|
def getBody(self):
|
|
assertion = ("MOZ_ASSERT(!xpc::WrapperFactory::IsXrayWrapper(proxy),\n"
|
|
' "Should not have a XrayWrapper here");\n')
|
|
|
|
# Correctness first. If we have a NamedSetter and [OverrideBuiltins],
|
|
# always call the NamedSetter and never do anything else.
|
|
namedSetter = self.descriptor.operations['NamedSetter']
|
|
if (namedSetter is not None and
|
|
self.descriptor.interface.getExtendedAttribute('OverrideBuiltins')):
|
|
# Check assumptions.
|
|
if self.descriptor.supportsIndexedProperties():
|
|
raise ValueError("In interface " + self.descriptor.name + ": " +
|
|
"Can't cope with [OverrideBuiltins] and an indexed getter")
|
|
if self.descriptor.operations['NamedCreator'] is not namedSetter:
|
|
raise ValueError("In interface " + self.descriptor.name + ": " +
|
|
"Can't cope with named setter that is not also a named creator")
|
|
if self.descriptor.hasUnforgeableMembers:
|
|
raise ValueError("In interface " + self.descriptor.name + ": " +
|
|
"Can't cope with [OverrideBuiltins] and unforgeable members")
|
|
|
|
callSetter = CGProxyNamedSetter(self.descriptor, argumentHandleValue="v")
|
|
return (assertion +
|
|
callSetter.define() +
|
|
"*done = true;\n"
|
|
"return true;\n")
|
|
|
|
# As an optimization, if we are going to call an IndexedSetter, go
|
|
# ahead and call it and have done.
|
|
indexedSetter = self.descriptor.operations['IndexedSetter']
|
|
if indexedSetter is not None:
|
|
if self.descriptor.operations['IndexedCreator'] is not indexedSetter:
|
|
raise ValueError("In interface " + self.descriptor.name + ": " +
|
|
"Can't cope with indexed setter that is not " +
|
|
"also an indexed creator")
|
|
setIndexed = fill(
|
|
"""
|
|
uint32_t index = GetArrayIndexFromId(cx, id);
|
|
if (IsArrayIndex(index)) {
|
|
$*{callSetter}
|
|
*done = true;
|
|
return true;
|
|
}
|
|
|
|
""",
|
|
callSetter=CGProxyIndexedSetter(self.descriptor,
|
|
argumentHandleValue="v").define())
|
|
else:
|
|
setIndexed = ""
|
|
|
|
return (assertion +
|
|
setIndexed +
|
|
"*done = false;\n"
|
|
"return true;\n")
|
|
|
|
|
|
class CGDOMJSProxyHandler_className(ClassMethod):
|
|
def __init__(self, descriptor):
|
|
args = [Argument('JSContext*', 'cx'),
|
|
Argument('JS::Handle<JSObject*>', 'proxy')]
|
|
ClassMethod.__init__(self, "className", "const char*", args,
|
|
virtual=True, override=True, const=True)
|
|
self.descriptor = descriptor
|
|
|
|
def getBody(self):
|
|
return 'return "%s";\n' % self.descriptor.name
|
|
|
|
|
|
class CGDOMJSProxyHandler_finalizeInBackground(ClassMethod):
|
|
def __init__(self, descriptor):
|
|
args = [Argument('const JS::Value&', 'priv')]
|
|
ClassMethod.__init__(self, "finalizeInBackground", "bool", args,
|
|
virtual=True, override=True, const=True)
|
|
self.descriptor = descriptor
|
|
|
|
def getBody(self):
|
|
return "return false;\n"
|
|
|
|
|
|
class CGDOMJSProxyHandler_finalize(ClassMethod):
|
|
def __init__(self, descriptor):
|
|
args = [Argument('JSFreeOp*', 'fop'), Argument('JSObject*', 'proxy')]
|
|
ClassMethod.__init__(self, "finalize", "void", args,
|
|
virtual=True, override=True, const=True)
|
|
self.descriptor = descriptor
|
|
|
|
def getBody(self):
|
|
return (("%s* self = UnwrapPossiblyNotInitializedDOMObject<%s>(proxy);\n" %
|
|
(self.descriptor.nativeType, self.descriptor.nativeType)) +
|
|
finalizeHook(self.descriptor, FINALIZE_HOOK_NAME, self.args[0].name).define())
|
|
|
|
|
|
class CGDOMJSProxyHandler_getElements(ClassMethod):
|
|
def __init__(self, descriptor):
|
|
assert descriptor.supportsIndexedProperties()
|
|
|
|
args = [Argument('JSContext*', 'cx'),
|
|
Argument('JS::Handle<JSObject*>', 'proxy'),
|
|
Argument('uint32_t', 'begin'),
|
|
Argument('uint32_t', 'end'),
|
|
Argument('js::ElementAdder*', 'adder')]
|
|
ClassMethod.__init__(self, "getElements", "bool", args, virtual=True, override=True, const=True)
|
|
self.descriptor = descriptor
|
|
|
|
def getBody(self):
|
|
# Just like ownPropertyKeys we'll assume that we have no holes, so
|
|
# we have all properties from 0 to length. If that ever changes
|
|
# (unlikely), we'll need to do something a bit more clever with how we
|
|
# forward on to our ancestor.
|
|
|
|
templateValues = {
|
|
'jsvalRef': 'temp',
|
|
'jsvalHandle': '&temp',
|
|
'obj': 'proxy',
|
|
'successCode': ("if (!adder->append(cx, temp)) return false;\n"
|
|
"continue;\n")
|
|
}
|
|
get = CGProxyIndexedGetter(self.descriptor, templateValues, False, False).define()
|
|
|
|
return fill(
|
|
"""
|
|
JS::Rooted<JS::Value> temp(cx);
|
|
MOZ_ASSERT(!xpc::WrapperFactory::IsXrayWrapper(proxy),
|
|
"Should not have a XrayWrapper here");
|
|
|
|
${nativeType}* self = UnwrapProxy(proxy);
|
|
uint32_t length = self->Length();
|
|
// Compute the end of the indices we'll get ourselves
|
|
uint32_t ourEnd = std::max(begin, std::min(end, length));
|
|
|
|
for (uint32_t index = begin; index < ourEnd; ++index) {
|
|
$*{get}
|
|
}
|
|
|
|
if (end > ourEnd) {
|
|
JS::Rooted<JSObject*> proto(cx);
|
|
if (!js::GetObjectProto(cx, proxy, &proto)) {
|
|
return false;
|
|
}
|
|
return js::GetElementsWithAdder(cx, proto, proxy, ourEnd, end, adder);
|
|
}
|
|
|
|
return true;
|
|
""",
|
|
nativeType=self.descriptor.nativeType,
|
|
get=get)
|
|
|
|
|
|
class CGDOMJSProxyHandler_getInstance(ClassMethod):
|
|
def __init__(self):
|
|
ClassMethod.__init__(self, "getInstance", "const DOMProxyHandler*", [], static=True)
|
|
|
|
def getBody(self):
|
|
return dedent("""
|
|
static const DOMProxyHandler instance;
|
|
return &instance;
|
|
""")
|
|
|
|
|
|
class CGDOMJSProxyHandler_getPrototypeIfOrdinary(ClassMethod):
|
|
def __init__(self):
|
|
args = [Argument('JSContext*', 'cx'),
|
|
Argument('JS::Handle<JSObject*>', 'proxy'),
|
|
Argument('bool*', 'isOrdinary'),
|
|
Argument('JS::MutableHandle<JSObject*>', 'proto')]
|
|
|
|
ClassMethod.__init__(self, "getPrototypeIfOrdinary", "bool", args,
|
|
virtual=True, override=True, const=True)
|
|
|
|
def getBody(self):
|
|
return dedent("""
|
|
*isOrdinary = false;
|
|
return true;
|
|
""")
|
|
|
|
|
|
class CGDOMJSProxyHandler_call(ClassMethod):
|
|
def __init__(self):
|
|
args = [Argument('JSContext*', 'cx'),
|
|
Argument('JS::Handle<JSObject*>', 'proxy'),
|
|
Argument('const JS::CallArgs&', 'args')]
|
|
|
|
ClassMethod.__init__(self, "call", "bool", args, virtual=True, override=True, const=True)
|
|
|
|
def getBody(self):
|
|
return fill(
|
|
"""
|
|
return js::ForwardToNative(cx, ${legacyCaller}, args);
|
|
""",
|
|
legacyCaller=LEGACYCALLER_HOOK_NAME)
|
|
|
|
|
|
class CGDOMJSProxyHandler_isCallable(ClassMethod):
|
|
def __init__(self):
|
|
ClassMethod.__init__(self, "isCallable", "bool",
|
|
[Argument('JSObject*', 'obj')],
|
|
virtual=True, override=True, const=True)
|
|
|
|
def getBody(self):
|
|
return dedent("""
|
|
return true;
|
|
""")
|
|
|
|
|
|
class CGDOMJSProxyHandler(CGClass):
|
|
def __init__(self, descriptor):
|
|
assert (descriptor.supportsIndexedProperties() or
|
|
descriptor.supportsNamedProperties() or
|
|
descriptor.hasNonOrdinaryGetPrototypeOf())
|
|
methods = [CGDOMJSProxyHandler_getOwnPropDescriptor(descriptor),
|
|
CGDOMJSProxyHandler_defineProperty(descriptor),
|
|
ClassUsingDeclaration("mozilla::dom::DOMProxyHandler",
|
|
"defineProperty"),
|
|
CGDOMJSProxyHandler_ownPropNames(descriptor),
|
|
CGDOMJSProxyHandler_hasOwn(descriptor),
|
|
CGDOMJSProxyHandler_get(descriptor),
|
|
CGDOMJSProxyHandler_className(descriptor),
|
|
CGDOMJSProxyHandler_finalizeInBackground(descriptor),
|
|
CGDOMJSProxyHandler_finalize(descriptor),
|
|
CGDOMJSProxyHandler_getInstance(),
|
|
CGDOMJSProxyHandler_delete(descriptor)]
|
|
constructors = [
|
|
ClassConstructor(
|
|
[],
|
|
constexpr=True,
|
|
visibility="public",
|
|
explicit=True)
|
|
]
|
|
|
|
if descriptor.supportsIndexedProperties():
|
|
methods.append(CGDOMJSProxyHandler_getElements(descriptor))
|
|
if (descriptor.operations['IndexedSetter'] is not None or
|
|
(descriptor.operations['NamedSetter'] is not None and
|
|
descriptor.interface.getExtendedAttribute('OverrideBuiltins'))):
|
|
methods.append(CGDOMJSProxyHandler_setCustom(descriptor))
|
|
if descriptor.hasNonOrdinaryGetPrototypeOf():
|
|
methods.append(CGDOMJSProxyHandler_getPrototypeIfOrdinary())
|
|
if descriptor.operations['LegacyCaller']:
|
|
methods.append(CGDOMJSProxyHandler_call())
|
|
methods.append(CGDOMJSProxyHandler_isCallable())
|
|
|
|
if descriptor.interface.getExtendedAttribute('OverrideBuiltins'):
|
|
parentClass = 'ShadowingDOMProxyHandler'
|
|
else:
|
|
parentClass = 'mozilla::dom::DOMProxyHandler'
|
|
|
|
CGClass.__init__(self, 'DOMProxyHandler',
|
|
bases=[ClassBase(parentClass)],
|
|
constructors=constructors,
|
|
methods=methods)
|
|
|
|
|
|
class CGDOMJSProxyHandlerDeclarer(CGThing):
|
|
"""
|
|
A class for declaring a DOMProxyHandler.
|
|
"""
|
|
def __init__(self, handlerThing):
|
|
self.handlerThing = handlerThing
|
|
|
|
def declare(self):
|
|
# Our class declaration should happen when we're defining
|
|
return ""
|
|
|
|
def define(self):
|
|
return self.handlerThing.declare()
|
|
|
|
|
|
class CGDOMJSProxyHandlerDefiner(CGThing):
|
|
"""
|
|
A class for defining a DOMProxyHandler.
|
|
"""
|
|
def __init__(self, handlerThing):
|
|
self.handlerThing = handlerThing
|
|
|
|
def declare(self):
|
|
return ""
|
|
|
|
def define(self):
|
|
return self.handlerThing.define()
|
|
|
|
|
|
def stripTrailingWhitespace(text):
|
|
tail = '\n' if text.endswith('\n') else ''
|
|
lines = text.splitlines()
|
|
return '\n'.join(line.rstrip() for line in lines) + tail
|
|
|
|
|
|
class MemberProperties:
|
|
def __init__(self):
|
|
self.isGenericMethod = False
|
|
self.isCrossOriginMethod = False
|
|
self.isPromiseReturningMethod = False
|
|
self.isGenericGetter = False
|
|
self.isLenientGetter = False
|
|
self.isCrossOriginGetter = False
|
|
self.isGenericSetter = False
|
|
self.isLenientSetter = False
|
|
self.isCrossOriginSetter = False
|
|
self.isJsonifier = False
|
|
|
|
|
|
def memberProperties(m, descriptor):
|
|
props = MemberProperties()
|
|
if m.isMethod():
|
|
if m == descriptor.operations['Jsonifier']:
|
|
props.isGenericMethod = descriptor.needsSpecialGenericOps()
|
|
props.isJsonifier = True
|
|
elif (not m.isIdentifierLess() or m == descriptor.operations['Stringifier']):
|
|
if not m.isStatic() and descriptor.interface.hasInterfacePrototypeObject():
|
|
if descriptor.needsSpecialGenericOps():
|
|
if m.returnsPromise():
|
|
props.isPromiseReturningMethod = True
|
|
else:
|
|
props.isGenericMethod = True
|
|
if m.getExtendedAttribute("CrossOriginCallable"):
|
|
props.isCrossOriginMethod = True
|
|
elif m.isAttr():
|
|
if not m.isStatic() and descriptor.interface.hasInterfacePrototypeObject():
|
|
if m.hasLenientThis():
|
|
props.isLenientGetter = True
|
|
elif m.getExtendedAttribute("CrossOriginReadable"):
|
|
props.isCrossOriginGetter = True
|
|
elif descriptor.needsSpecialGenericOps():
|
|
props.isGenericGetter = True
|
|
if not m.readonly:
|
|
if not m.isStatic() and descriptor.interface.hasInterfacePrototypeObject():
|
|
if m.hasLenientThis():
|
|
props.isLenientSetter = True
|
|
elif IsCrossOriginWritable(m, descriptor):
|
|
props.isCrossOriginSetter = True
|
|
elif descriptor.needsSpecialGenericOps():
|
|
props.isGenericSetter = True
|
|
elif m.getExtendedAttribute("PutForwards"):
|
|
if IsCrossOriginWritable(m, descriptor):
|
|
props.isCrossOriginSetter = True
|
|
elif descriptor.needsSpecialGenericOps():
|
|
props.isGenericSetter = True
|
|
elif (m.getExtendedAttribute("Replaceable") or
|
|
m.getExtendedAttribute("LenientSetter")):
|
|
if descriptor.needsSpecialGenericOps():
|
|
props.isGenericSetter = True
|
|
|
|
return props
|
|
|
|
|
|
class CGDescriptor(CGThing):
|
|
def __init__(self, descriptor):
|
|
CGThing.__init__(self)
|
|
|
|
assert not descriptor.concrete or descriptor.interface.hasInterfacePrototypeObject()
|
|
|
|
self._deps = descriptor.interface.getDeps()
|
|
|
|
cgThings = []
|
|
cgThings.append(CGGeneric(declare="typedef %s NativeType;\n" %
|
|
descriptor.nativeType))
|
|
parent = descriptor.interface.parent
|
|
if parent:
|
|
cgThings.append(CGGeneric("static_assert(IsRefcounted<NativeType>::value == IsRefcounted<%s::NativeType>::value,\n"
|
|
" \"Can't inherit from an interface with a different ownership model.\");\n" %
|
|
toBindingNamespace(descriptor.parentPrototypeName)))
|
|
|
|
# These are set to true if at least one non-static
|
|
# method/getter/setter or jsonifier exist on the interface.
|
|
(hasMethod, hasGetter, hasLenientGetter, hasSetter, hasLenientSetter,
|
|
hasPromiseReturningMethod) = False, False, False, False, False, False
|
|
jsonifierMethod = None
|
|
crossOriginMethods, crossOriginGetters, crossOriginSetters = set(), set(), set()
|
|
unscopableNames = list()
|
|
for n in descriptor.interface.namedConstructors:
|
|
cgThings.append(CGClassConstructor(descriptor, n,
|
|
NamedConstructorName(n)))
|
|
for m in descriptor.interface.members:
|
|
if m.isMethod() and m.identifier.name == 'queryInterface':
|
|
continue
|
|
|
|
props = memberProperties(m, descriptor)
|
|
|
|
if m.isMethod():
|
|
if m.getExtendedAttribute("Unscopable"):
|
|
assert not m.isStatic()
|
|
unscopableNames.append(m.identifier.name)
|
|
if props.isJsonifier:
|
|
jsonifierMethod = m
|
|
elif not m.isIdentifierLess() or m == descriptor.operations['Stringifier']:
|
|
if m.isStatic():
|
|
assert descriptor.interface.hasInterfaceObject()
|
|
cgThings.append(CGStaticMethod(descriptor, m))
|
|
if m.returnsPromise():
|
|
cgThings.append(CGStaticMethodJitinfo(m))
|
|
elif descriptor.interface.hasInterfacePrototypeObject():
|
|
specializedMethod = CGSpecializedMethod(descriptor, m)
|
|
cgThings.append(specializedMethod)
|
|
if m.returnsPromise():
|
|
cgThings.append(CGMethodPromiseWrapper(descriptor, specializedMethod))
|
|
cgThings.append(CGMemberJITInfo(descriptor, m))
|
|
if props.isCrossOriginMethod:
|
|
crossOriginMethods.add(m.identifier.name)
|
|
# If we've hit the maplike/setlike member itself, go ahead and
|
|
# generate its convenience functions.
|
|
elif m.isMaplikeOrSetlike():
|
|
cgThings.append(CGMaplikeOrSetlikeHelperGenerator(descriptor, m))
|
|
elif m.isAttr():
|
|
if m.stringifier:
|
|
raise TypeError("Stringifier attributes not supported yet. "
|
|
"See bug 824857.\n"
|
|
"%s" % m.location)
|
|
if m.getExtendedAttribute("Unscopable"):
|
|
assert not m.isStatic()
|
|
unscopableNames.append(m.identifier.name)
|
|
if m.isStatic():
|
|
assert descriptor.interface.hasInterfaceObject()
|
|
cgThings.append(CGStaticGetter(descriptor, m))
|
|
elif descriptor.interface.hasInterfacePrototypeObject():
|
|
if isNonExposedNavigatorObjectGetter(m, descriptor):
|
|
continue
|
|
cgThings.append(CGSpecializedGetter(descriptor, m))
|
|
if props.isCrossOriginGetter:
|
|
crossOriginGetters.add(m.identifier.name)
|
|
if not m.readonly:
|
|
if m.isStatic():
|
|
assert descriptor.interface.hasInterfaceObject()
|
|
cgThings.append(CGStaticSetter(descriptor, m))
|
|
elif descriptor.interface.hasInterfacePrototypeObject():
|
|
cgThings.append(CGSpecializedSetter(descriptor, m))
|
|
if props.isCrossOriginSetter:
|
|
crossOriginSetters.add(m.identifier.name)
|
|
elif m.getExtendedAttribute("PutForwards"):
|
|
cgThings.append(CGSpecializedForwardingSetter(descriptor, m))
|
|
if props.isCrossOriginSetter:
|
|
crossOriginSetters.add(m.identifier.name)
|
|
elif m.getExtendedAttribute("Replaceable"):
|
|
cgThings.append(CGSpecializedReplaceableSetter(descriptor, m))
|
|
elif m.getExtendedAttribute("LenientSetter"):
|
|
cgThings.append(CGSpecializedLenientSetter(descriptor, m))
|
|
if (not m.isStatic() and
|
|
descriptor.interface.hasInterfacePrototypeObject()):
|
|
cgThings.append(CGMemberJITInfo(descriptor, m))
|
|
|
|
hasMethod = hasMethod or props.isGenericMethod
|
|
hasPromiseReturningMethod = (hasPromiseReturningMethod or
|
|
props.isPromiseReturningMethod)
|
|
hasGetter = hasGetter or props.isGenericGetter
|
|
hasLenientGetter = hasLenientGetter or props.isLenientGetter
|
|
hasSetter = hasSetter or props.isGenericSetter
|
|
hasLenientSetter = hasLenientSetter or props.isLenientSetter
|
|
|
|
if jsonifierMethod:
|
|
cgThings.append(CGJsonifyAttributesMethod(descriptor))
|
|
cgThings.append(CGJsonifierMethod(descriptor, jsonifierMethod))
|
|
cgThings.append(CGMemberJITInfo(descriptor, jsonifierMethod))
|
|
if hasMethod:
|
|
cgThings.append(CGGenericMethod(descriptor))
|
|
if hasPromiseReturningMethod:
|
|
cgThings.append(CGGenericPromiseReturningMethod(descriptor))
|
|
if len(crossOriginMethods):
|
|
cgThings.append(CGGenericMethod(descriptor,
|
|
allowCrossOriginThis=True))
|
|
if hasGetter:
|
|
cgThings.append(CGGenericGetter(descriptor))
|
|
if hasLenientGetter:
|
|
cgThings.append(CGGenericGetter(descriptor, lenientThis=True))
|
|
if len(crossOriginGetters):
|
|
cgThings.append(CGGenericGetter(descriptor,
|
|
allowCrossOriginThis=True))
|
|
if hasSetter:
|
|
cgThings.append(CGGenericSetter(descriptor))
|
|
if hasLenientSetter:
|
|
cgThings.append(CGGenericSetter(descriptor, lenientThis=True))
|
|
if len(crossOriginSetters):
|
|
cgThings.append(CGGenericSetter(descriptor,
|
|
allowCrossOriginThis=True))
|
|
|
|
if descriptor.interface.isNavigatorProperty():
|
|
cgThings.append(CGConstructNavigatorObject(descriptor))
|
|
|
|
if descriptor.concrete and not descriptor.proxy:
|
|
if wantsAddProperty(descriptor):
|
|
cgThings.append(CGAddPropertyHook(descriptor))
|
|
|
|
# Always have a finalize hook, regardless of whether the class
|
|
# wants a custom hook.
|
|
cgThings.append(CGClassFinalizeHook(descriptor))
|
|
|
|
if descriptor.concrete and descriptor.wrapperCache:
|
|
cgThings.append(CGClassObjectMovedHook(descriptor))
|
|
|
|
# Generate the _ClearCachedFooValue methods before the property arrays that use them.
|
|
if descriptor.interface.isJSImplemented():
|
|
for m in clearableCachedAttrs(descriptor):
|
|
cgThings.append(CGJSImplClearCachedValueMethod(descriptor, m))
|
|
|
|
# Need to output our generated hasinstance bits before
|
|
# PropertyArrays tries to use them.
|
|
if (descriptor.interface.hasInterfaceObject() and
|
|
NeedsGeneratedHasInstance(descriptor)):
|
|
cgThings.append(CGHasInstanceHook(descriptor))
|
|
|
|
properties = PropertyArrays(descriptor)
|
|
cgThings.append(CGGeneric(define=str(properties)))
|
|
cgThings.append(CGNativeProperties(descriptor, properties))
|
|
|
|
if descriptor.interface.hasInterfaceObject():
|
|
cgThings.append(CGClassConstructor(descriptor,
|
|
descriptor.interface.ctor()))
|
|
cgThings.append(CGInterfaceObjectJSClass(descriptor, properties))
|
|
cgThings.append(CGNamedConstructors(descriptor))
|
|
|
|
cgThings.append(CGLegacyCallHook(descriptor))
|
|
if descriptor.interface.getExtendedAttribute("NeedResolve"):
|
|
cgThings.append(CGResolveHook(descriptor))
|
|
cgThings.append(CGMayResolveHook(descriptor))
|
|
cgThings.append(CGEnumerateHook(descriptor))
|
|
|
|
if descriptor.hasNamedPropertiesObject:
|
|
cgThings.append(CGGetNamedPropertiesObjectMethod(descriptor))
|
|
|
|
if descriptor.interface.hasInterfacePrototypeObject():
|
|
cgThings.append(CGPrototypeJSClass(descriptor, properties))
|
|
|
|
if ((descriptor.interface.hasInterfaceObject() or descriptor.interface.isNavigatorProperty()) and
|
|
not descriptor.interface.isExternal() and
|
|
descriptor.isExposedConditionally()):
|
|
cgThings.append(CGConstructorEnabled(descriptor))
|
|
|
|
if descriptor.registersGlobalNamesOnWindow:
|
|
cgThings.append(CGDefineDOMInterfaceMethod(descriptor))
|
|
|
|
if (descriptor.interface.hasMembersInSlots() and
|
|
descriptor.interface.hasChildInterfaces()):
|
|
raise TypeError("We don't support members in slots on "
|
|
"non-leaf interfaces like %s" %
|
|
descriptor.interface.identifier.name)
|
|
|
|
if descriptor.concrete:
|
|
if descriptor.proxy:
|
|
if descriptor.interface.totalMembersInSlots != 0:
|
|
raise TypeError("We can't have extra reserved slots for "
|
|
"proxy interface %s" %
|
|
descriptor.interface.identifier.name)
|
|
cgThings.append(CGGeneric(fill(
|
|
"""
|
|
static_assert(IsBaseOf<nsISupports, ${nativeType} >::value,
|
|
"We don't support non-nsISupports native classes for "
|
|
"proxy-based bindings yet");
|
|
|
|
""",
|
|
nativeType=descriptor.nativeType)))
|
|
if not descriptor.wrapperCache:
|
|
raise TypeError("We need a wrappercache to support expandos for proxy-based "
|
|
"bindings (" + descriptor.name + ")")
|
|
handlerThing = CGDOMJSProxyHandler(descriptor)
|
|
cgThings.append(CGDOMJSProxyHandlerDeclarer(handlerThing))
|
|
cgThings.append(CGProxyIsProxy(descriptor))
|
|
cgThings.append(CGProxyUnwrap(descriptor))
|
|
cgThings.append(CGDOMJSProxyHandlerDefiner(handlerThing))
|
|
cgThings.append(CGDOMProxyJSClass(descriptor))
|
|
else:
|
|
cgThings.append(CGDOMJSClass(descriptor))
|
|
cgThings.append(CGGetJSClassMethod(descriptor))
|
|
if descriptor.interface.hasMembersInSlots():
|
|
cgThings.append(CGUpdateMemberSlotsMethod(descriptor))
|
|
|
|
if descriptor.isGlobal():
|
|
assert descriptor.wrapperCache
|
|
cgThings.append(CGWrapGlobalMethod(descriptor, properties))
|
|
elif descriptor.wrapperCache:
|
|
cgThings.append(CGWrapWithCacheMethod(descriptor, properties))
|
|
cgThings.append(CGWrapMethod(descriptor))
|
|
else:
|
|
cgThings.append(CGWrapNonWrapperCacheMethod(descriptor,
|
|
properties))
|
|
|
|
# Set up our Xray callbacks as needed. This needs to come
|
|
# after we have our DOMProxyHandler defined.
|
|
if descriptor.wantsXrays:
|
|
if descriptor.concrete and descriptor.proxy:
|
|
cgThings.append(CGResolveOwnProperty(descriptor))
|
|
cgThings.append(CGEnumerateOwnProperties(descriptor))
|
|
if descriptor.needsXrayNamedDeleterHook():
|
|
cgThings.append(CGDeleteNamedProperty(descriptor))
|
|
elif descriptor.needsXrayResolveHooks():
|
|
cgThings.append(CGResolveOwnPropertyViaResolve(descriptor))
|
|
cgThings.append(CGEnumerateOwnPropertiesViaGetOwnPropertyNames(descriptor))
|
|
if descriptor.wantsXrayExpandoClass:
|
|
cgThings.append(CGXrayExpandoJSClass(descriptor))
|
|
|
|
# Now that we have our ResolveOwnProperty/EnumerateOwnProperties stuff
|
|
# done, set up our NativePropertyHooks.
|
|
cgThings.append(CGNativePropertyHooks(descriptor, properties))
|
|
|
|
# If we're not wrappercached, we don't know how to clear our
|
|
# cached values, since we can't get at the JSObject.
|
|
if descriptor.wrapperCache:
|
|
cgThings.extend(CGClearCachedValueMethod(descriptor, m) for
|
|
m in clearableCachedAttrs(descriptor))
|
|
|
|
haveUnscopables = (len(unscopableNames) != 0 and
|
|
descriptor.interface.hasInterfacePrototypeObject())
|
|
if haveUnscopables:
|
|
cgThings.append(
|
|
CGList([CGGeneric("static const char* const unscopableNames[] = {"),
|
|
CGIndenter(CGList([CGGeneric('"%s"' % name) for
|
|
name in unscopableNames] +
|
|
[CGGeneric("nullptr")], ",\n")),
|
|
CGGeneric("};\n")], "\n"))
|
|
|
|
# CGCreateInterfaceObjectsMethod needs to come after our
|
|
# CGDOMJSClass and unscopables, if any.
|
|
cgThings.append(CGCreateInterfaceObjectsMethod(descriptor, properties,
|
|
haveUnscopables))
|
|
|
|
# CGGetProtoObjectMethod and CGGetConstructorObjectMethod need
|
|
# to come after CGCreateInterfaceObjectsMethod.
|
|
if descriptor.interface.hasInterfacePrototypeObject():
|
|
cgThings.append(CGGetProtoObjectHandleMethod(descriptor))
|
|
if descriptor.interface.hasChildInterfaces():
|
|
cgThings.append(CGGetProtoObjectMethod(descriptor))
|
|
if descriptor.interface.hasInterfaceObject():
|
|
cgThings.append(CGGetConstructorObjectHandleMethod(descriptor))
|
|
cgThings.append(CGGetConstructorObjectMethod(descriptor))
|
|
|
|
# See whether we need we need to generate an IsPermitted method
|
|
if crossOriginGetters or crossOriginSetters or crossOriginMethods:
|
|
cgThings.append(CGIsPermittedMethod(descriptor,
|
|
crossOriginGetters,
|
|
crossOriginSetters,
|
|
crossOriginMethods))
|
|
|
|
cgThings = CGList((CGIndenter(t, declareOnly=True) for t in cgThings), "\n")
|
|
cgThings = CGWrapper(cgThings, pre='\n', post='\n')
|
|
self.cgRoot = CGWrapper(CGNamespace(toBindingNamespace(descriptor.name),
|
|
cgThings),
|
|
post='\n')
|
|
|
|
def declare(self):
|
|
return self.cgRoot.declare()
|
|
|
|
def define(self):
|
|
return self.cgRoot.define()
|
|
|
|
def deps(self):
|
|
return self._deps
|
|
|
|
|
|
class CGNamespacedEnum(CGThing):
|
|
def __init__(self, namespace, enumName, names, values, comment=""):
|
|
|
|
if not values:
|
|
values = []
|
|
|
|
# Account for explicit enum values.
|
|
entries = []
|
|
for i in range(0, len(names)):
|
|
if len(values) > i and values[i] is not None:
|
|
entry = "%s = %s" % (names[i], values[i])
|
|
else:
|
|
entry = names[i]
|
|
entries.append(entry)
|
|
|
|
# Append a Count.
|
|
entries.append('_' + enumName + '_Count')
|
|
|
|
# Indent.
|
|
entries = [' ' + e for e in entries]
|
|
|
|
# Build the enum body.
|
|
enumstr = comment + 'enum %s : uint16_t\n{\n%s\n};\n' % (enumName, ',\n'.join(entries))
|
|
curr = CGGeneric(declare=enumstr)
|
|
|
|
# Add some whitespace padding.
|
|
curr = CGWrapper(curr, pre='\n', post='\n')
|
|
|
|
# Add the namespace.
|
|
curr = CGNamespace(namespace, curr)
|
|
|
|
# Add the typedef
|
|
typedef = '\ntypedef %s::%s %s;\n\n' % (namespace, enumName, enumName)
|
|
curr = CGList([curr, CGGeneric(declare=typedef)])
|
|
|
|
# Save the result.
|
|
self.node = curr
|
|
|
|
def declare(self):
|
|
return self.node.declare()
|
|
|
|
def define(self):
|
|
return ""
|
|
|
|
|
|
def initIdsClassMethod(identifiers, atomCacheName):
|
|
idinit = ['!atomsCache->%s.init(cx, "%s")' %
|
|
(CGDictionary.makeIdName(id),
|
|
id)
|
|
for id in identifiers]
|
|
idinit.reverse()
|
|
body = fill(
|
|
"""
|
|
MOZ_ASSERT(!*reinterpret_cast<jsid**>(atomsCache));
|
|
|
|
// Initialize these in reverse order so that any failure leaves the first one
|
|
// uninitialized.
|
|
if (${idinit}) {
|
|
return false;
|
|
}
|
|
return true;
|
|
""",
|
|
idinit=" ||\n ".join(idinit))
|
|
return ClassMethod("InitIds", "bool", [
|
|
Argument("JSContext*", "cx"),
|
|
Argument("%s*" % atomCacheName, "atomsCache")
|
|
], static=True, body=body, visibility="private")
|
|
|
|
|
|
class CGDictionary(CGThing):
|
|
def __init__(self, dictionary, descriptorProvider):
|
|
self.dictionary = dictionary
|
|
self.descriptorProvider = descriptorProvider
|
|
self.needToInitIds = len(dictionary.members) > 0
|
|
self.memberInfo = [
|
|
(member,
|
|
getJSToNativeConversionInfo(
|
|
member.type,
|
|
descriptorProvider,
|
|
isEnforceRange=member.enforceRange,
|
|
isClamp=member.clamp,
|
|
isMember="Dictionary",
|
|
isOptional=member.canHaveMissingValue(),
|
|
defaultValue=member.defaultValue,
|
|
sourceDescription=self.getMemberSourceDescription(member)))
|
|
for member in dictionary.members]
|
|
|
|
# If we have a union member containing something in the same
|
|
# file as us, bail: the C++ includes won't work out.
|
|
for member in dictionary.members:
|
|
type = member.type.unroll()
|
|
if type.isUnion():
|
|
for t in type.flatMemberTypes:
|
|
if (t.isDictionary() and
|
|
CGHeaders.getDeclarationFilename(t.inner) ==
|
|
CGHeaders.getDeclarationFilename(dictionary)):
|
|
raise TypeError(
|
|
"Dictionary contains a union that contains a "
|
|
"dictionary in the same WebIDL file. This won't "
|
|
"compile. Move the inner dictionary to a "
|
|
"different file.\n%s\n%s" %
|
|
(t.location, t.inner.location))
|
|
self.structs = self.getStructs()
|
|
|
|
def declare(self):
|
|
return self.structs.declare()
|
|
|
|
def define(self):
|
|
return self.structs.define()
|
|
|
|
def base(self):
|
|
if self.dictionary.parent:
|
|
return self.makeClassName(self.dictionary.parent)
|
|
return "DictionaryBase"
|
|
|
|
def initMethod(self):
|
|
"""
|
|
This function outputs the body of the Init() method for the dictionary.
|
|
|
|
For the most part, this is some bookkeeping for our atoms so
|
|
we can avoid atomizing strings all the time, then we just spit
|
|
out the getMemberConversion() output for each member,
|
|
separated by newlines.
|
|
|
|
"""
|
|
body = dedent("""
|
|
// Passing a null JSContext is OK only if we're initing from null,
|
|
// Since in that case we will not have to do any property gets
|
|
MOZ_ASSERT_IF(!cx, val.isNull());
|
|
""")
|
|
|
|
if self.needToInitIds:
|
|
body += fill(
|
|
"""
|
|
${dictName}Atoms* atomsCache = nullptr;
|
|
if (cx) {
|
|
atomsCache = GetAtomCache<${dictName}Atoms>(cx);
|
|
if (!*reinterpret_cast<jsid**>(atomsCache) && !InitIds(cx, atomsCache)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
""",
|
|
dictName=self.makeClassName(self.dictionary))
|
|
|
|
if self.dictionary.parent:
|
|
body += fill(
|
|
"""
|
|
// Per spec, we init the parent's members first
|
|
if (!${dictName}::Init(cx, val)) {
|
|
return false;
|
|
}
|
|
|
|
""",
|
|
dictName=self.makeClassName(self.dictionary.parent))
|
|
else:
|
|
body += dedent(
|
|
"""
|
|
{ // scope for isConvertible
|
|
bool isConvertible;
|
|
if (!IsConvertibleToDictionary(cx, val, &isConvertible)) {
|
|
return false;
|
|
}
|
|
if (!isConvertible) {
|
|
return ThrowErrorMessage(cx, MSG_NOT_DICTIONARY, sourceDescription);
|
|
}
|
|
}
|
|
|
|
""")
|
|
|
|
memberInits = [self.getMemberConversion(m).define()
|
|
for m in self.memberInfo]
|
|
if memberInits:
|
|
body += fill(
|
|
"""
|
|
bool isNull = val.isNullOrUndefined();
|
|
// We only need these if !isNull, in which case we have |cx|.
|
|
Maybe<JS::Rooted<JSObject *> > object;
|
|
Maybe<JS::Rooted<JS::Value> > temp;
|
|
if (!isNull) {
|
|
MOZ_ASSERT(cx);
|
|
object.emplace(cx, &val.toObject());
|
|
temp.emplace(cx);
|
|
}
|
|
$*{memberInits}
|
|
""",
|
|
memberInits="\n".join(memberInits))
|
|
|
|
body += "return true;\n"
|
|
|
|
return ClassMethod("Init", "bool", [
|
|
Argument('JSContext*', 'cx'),
|
|
Argument('JS::Handle<JS::Value>', 'val'),
|
|
Argument('const char*', 'sourceDescription', default='"Value"'),
|
|
Argument('bool', 'passedToJSImpl', default='false')
|
|
], body=body)
|
|
|
|
def initFromJSONMethod(self):
|
|
return ClassMethod(
|
|
"Init", "bool",
|
|
[Argument('const nsAString&', 'aJSON')],
|
|
body=dedent("""
|
|
AutoJSAPI jsapi;
|
|
JSObject* cleanGlobal = SimpleGlobalObject::Create(SimpleGlobalObject::GlobalType::BindingDetail);
|
|
if (!cleanGlobal) {
|
|
return false;
|
|
}
|
|
if (!jsapi.Init(cleanGlobal)) {
|
|
return false;
|
|
}
|
|
JSContext* cx = jsapi.cx();
|
|
JS::Rooted<JS::Value> json(cx);
|
|
bool ok = ParseJSON(cx, aJSON, &json);
|
|
NS_ENSURE_TRUE(ok, false);
|
|
return Init(cx, json);
|
|
"""))
|
|
|
|
def toJSONMethod(self):
|
|
return ClassMethod(
|
|
"ToJSON", "bool",
|
|
[Argument('nsAString&', 'aJSON')],
|
|
body=dedent("""
|
|
AutoJSAPI jsapi;
|
|
jsapi.Init();
|
|
JSContext *cx = jsapi.cx();
|
|
// It's safe to use UnprivilegedJunkScopeOrWorkerGlobal here
|
|
// because we'll only be creating objects, in ways that have no
|
|
// side-effects, followed by a call to JS::ToJSONMaybeSafely,
|
|
// which likewise guarantees no side-effects for the sorts of
|
|
// things we will pass it.
|
|
JSAutoCompartment ac(cx, binding_detail::UnprivilegedJunkScopeOrWorkerGlobal());
|
|
JS::Rooted<JS::Value> val(cx);
|
|
if (!ToObjectInternal(cx, &val)) {
|
|
return false;
|
|
}
|
|
JS::Rooted<JSObject*> obj(cx, &val.toObject());
|
|
return StringifyToJSON(cx, obj, aJSON);
|
|
"""), const=True)
|
|
|
|
def toObjectInternalMethod(self):
|
|
body = ""
|
|
if self.needToInitIds:
|
|
body += fill(
|
|
"""
|
|
${dictName}Atoms* atomsCache = GetAtomCache<${dictName}Atoms>(cx);
|
|
if (!*reinterpret_cast<jsid**>(atomsCache) && !InitIds(cx, atomsCache)) {
|
|
return false;
|
|
}
|
|
|
|
""",
|
|
dictName=self.makeClassName(self.dictionary))
|
|
|
|
if self.dictionary.parent:
|
|
body += fill(
|
|
"""
|
|
// Per spec, we define the parent's members first
|
|
if (!${dictName}::ToObjectInternal(cx, rval)) {
|
|
return false;
|
|
}
|
|
JS::Rooted<JSObject*> obj(cx, &rval.toObject());
|
|
|
|
""",
|
|
dictName=self.makeClassName(self.dictionary.parent))
|
|
else:
|
|
body += dedent(
|
|
"""
|
|
JS::Rooted<JSObject*> obj(cx, JS_NewPlainObject(cx));
|
|
if (!obj) {
|
|
return false;
|
|
}
|
|
rval.set(JS::ObjectValue(*obj));
|
|
|
|
""")
|
|
|
|
if self.memberInfo:
|
|
body += "\n".join(self.getMemberDefinition(m).define()
|
|
for m in self.memberInfo)
|
|
body += "\nreturn true;\n"
|
|
|
|
return ClassMethod("ToObjectInternal", "bool", [
|
|
Argument('JSContext*', 'cx'),
|
|
Argument('JS::MutableHandle<JS::Value>', 'rval'),
|
|
], const=True, body=body)
|
|
|
|
def initIdsMethod(self):
|
|
assert self.needToInitIds
|
|
return initIdsClassMethod([m.identifier.name for m in self.dictionary.members],
|
|
"%sAtoms" % self.makeClassName(self.dictionary))
|
|
|
|
def traceDictionaryMethod(self):
|
|
body = ""
|
|
if self.dictionary.parent:
|
|
cls = self.makeClassName(self.dictionary.parent)
|
|
body += "%s::TraceDictionary(trc);\n" % cls
|
|
|
|
memberTraces = [self.getMemberTrace(m)
|
|
for m in self.dictionary.members
|
|
if typeNeedsRooting(m.type)]
|
|
|
|
if memberTraces:
|
|
body += "\n".join(memberTraces)
|
|
|
|
return ClassMethod("TraceDictionary", "void", [
|
|
Argument("JSTracer*", "trc"),
|
|
], body=body)
|
|
|
|
def assignmentOperator(self):
|
|
body = CGList([])
|
|
if self.dictionary.parent:
|
|
body.append(CGGeneric(
|
|
"%s::operator=(aOther);\n" %
|
|
self.makeClassName(self.dictionary.parent)))
|
|
for m, _ in self.memberInfo:
|
|
memberName = self.makeMemberName(m.identifier.name)
|
|
if m.canHaveMissingValue():
|
|
memberAssign = CGGeneric(fill(
|
|
"""
|
|
${name}.Reset();
|
|
if (aOther.${name}.WasPassed()) {
|
|
${name}.Construct(aOther.${name}.Value());
|
|
}
|
|
""",
|
|
name=memberName))
|
|
else:
|
|
memberAssign = CGGeneric(
|
|
"%s = aOther.%s;\n" % (memberName, memberName))
|
|
body.append(memberAssign)
|
|
return ClassMethod(
|
|
"operator=", "void",
|
|
[Argument("const %s&" % self.makeClassName(self.dictionary),
|
|
"aOther")],
|
|
body=body.define())
|
|
|
|
def getStructs(self):
|
|
d = self.dictionary
|
|
selfName = self.makeClassName(d)
|
|
members = [ClassMember(self.makeMemberName(m[0].identifier.name),
|
|
self.getMemberType(m),
|
|
visibility="public",
|
|
body=self.getMemberInitializer(m),
|
|
hasIgnoreInitCheckFlag=True)
|
|
for m in self.memberInfo]
|
|
if d.parent:
|
|
# We always want to init our parent with our non-initializing
|
|
# constructor arg, because either we're about to init ourselves (and
|
|
# hence our parent) or we don't want any init happening.
|
|
baseConstructors = [
|
|
"%s(%s)" % (self.makeClassName(d.parent),
|
|
self.getNonInitializingCtorArg())
|
|
]
|
|
else:
|
|
baseConstructors = None
|
|
ctors = [
|
|
ClassConstructor(
|
|
[],
|
|
visibility="public",
|
|
baseConstructors=baseConstructors,
|
|
body=(
|
|
"// Safe to pass a null context if we pass a null value\n"
|
|
"Init(nullptr, JS::NullHandleValue);\n")),
|
|
ClassConstructor(
|
|
[Argument("const FastDictionaryInitializer&", "")],
|
|
visibility="public",
|
|
baseConstructors=baseConstructors,
|
|
explicit=True,
|
|
bodyInHeader=True,
|
|
body='// Do nothing here; this is used by our "Fast" subclass\n')
|
|
]
|
|
methods = []
|
|
|
|
if self.needToInitIds:
|
|
methods.append(self.initIdsMethod())
|
|
|
|
methods.append(self.initMethod())
|
|
canBeRepresentedAsJSON = self.dictionarySafeToJSONify(self.dictionary)
|
|
if canBeRepresentedAsJSON:
|
|
methods.append(self.initFromJSONMethod())
|
|
try:
|
|
methods.append(self.toObjectInternalMethod())
|
|
if canBeRepresentedAsJSON:
|
|
methods.append(self.toJSONMethod())
|
|
except MethodNotNewObjectError:
|
|
# If we can't have a ToObjectInternal() because one of our members
|
|
# can only be returned from [NewObject] methods, then just skip
|
|
# generating ToObjectInternal() and ToJSON (since the latter depens
|
|
# on the former).
|
|
pass
|
|
methods.append(self.traceDictionaryMethod())
|
|
|
|
if CGDictionary.isDictionaryCopyConstructible(d):
|
|
disallowCopyConstruction = False
|
|
# Note: no base constructors because our operator= will
|
|
# deal with that.
|
|
ctors.append(ClassConstructor([Argument("const %s&" % selfName,
|
|
"aOther")],
|
|
bodyInHeader=True,
|
|
visibility="public",
|
|
explicit=True,
|
|
body="*this = aOther;\n"))
|
|
methods.append(self.assignmentOperator())
|
|
else:
|
|
disallowCopyConstruction = True
|
|
|
|
struct = CGClass(selfName,
|
|
bases=[ClassBase(self.base())],
|
|
members=members,
|
|
constructors=ctors,
|
|
methods=methods,
|
|
isStruct=True,
|
|
disallowCopyConstruction=disallowCopyConstruction)
|
|
|
|
fastDictionaryCtor = ClassConstructor(
|
|
[],
|
|
visibility="public",
|
|
bodyInHeader=True,
|
|
baseConstructors=["%s(%s)" %
|
|
(selfName,
|
|
self.getNonInitializingCtorArg())],
|
|
body="// Doesn't matter what int we pass to the parent constructor\n")
|
|
|
|
fastStruct = CGClass("Fast" + selfName,
|
|
bases=[ClassBase(selfName)],
|
|
constructors=[fastDictionaryCtor],
|
|
isStruct=True)
|
|
|
|
return CGList([struct,
|
|
CGNamespace('binding_detail', fastStruct)],
|
|
"\n")
|
|
|
|
def deps(self):
|
|
return self.dictionary.getDeps()
|
|
|
|
@staticmethod
|
|
def makeDictionaryName(dictionary):
|
|
return dictionary.identifier.name
|
|
|
|
def makeClassName(self, dictionary):
|
|
return self.makeDictionaryName(dictionary)
|
|
|
|
@staticmethod
|
|
def makeMemberName(name):
|
|
return "m" + name[0].upper() + IDLToCIdentifier(name[1:])
|
|
|
|
def getMemberType(self, memberInfo):
|
|
_, conversionInfo = memberInfo
|
|
# We can't handle having a holderType here
|
|
assert conversionInfo.holderType is None
|
|
declType = conversionInfo.declType
|
|
if conversionInfo.dealWithOptional:
|
|
declType = CGTemplatedType("Optional", declType)
|
|
return declType.define()
|
|
|
|
def getMemberConversion(self, memberInfo):
|
|
"""
|
|
A function that outputs the initialization of a single dictionary
|
|
member from the given dictionary value.
|
|
|
|
We start with our conversionInfo, which tells us how to
|
|
convert a JS::Value to whatever type this member is. We
|
|
substiture the template from the conversionInfo with values
|
|
that point to our "temp" JS::Value and our member (which is
|
|
the C++ value we want to produce). The output is a string of
|
|
code to do the conversion. We store this string in
|
|
conversionReplacements["convert"].
|
|
|
|
Now we have three different ways we might use (or skip) this
|
|
string of code, depending on whether the value is required,
|
|
optional with default value, or optional without default
|
|
value. We set up a template in the 'conversion' variable for
|
|
exactly how to do this, then substitute into it from the
|
|
conversionReplacements dictionary.
|
|
"""
|
|
member, conversionInfo = memberInfo
|
|
replacements = {
|
|
"val": "temp.ref()",
|
|
"maybeMutableVal": "temp.ptr()",
|
|
"declName": self.makeMemberName(member.identifier.name),
|
|
# We need a holder name for external interfaces, but
|
|
# it's scoped down to the conversion so we can just use
|
|
# anything we want.
|
|
"holderName": "holder",
|
|
"passedToJSImpl": "passedToJSImpl"
|
|
}
|
|
# We can't handle having a holderType here
|
|
assert conversionInfo.holderType is None
|
|
if conversionInfo.dealWithOptional:
|
|
replacements["declName"] = "(" + replacements["declName"] + ".Value())"
|
|
if member.defaultValue:
|
|
replacements["haveValue"] = "!isNull && !temp->isUndefined()"
|
|
|
|
propId = self.makeIdName(member.identifier.name)
|
|
propGet = ("JS_GetPropertyById(cx, *object, atomsCache->%s, temp.ptr())" %
|
|
propId)
|
|
|
|
conversionReplacements = {
|
|
"prop": self.makeMemberName(member.identifier.name),
|
|
"convert": string.Template(conversionInfo.template).substitute(replacements),
|
|
"propGet": propGet
|
|
}
|
|
# The conversion code will only run where a default value or a value passed
|
|
# by the author needs to get converted, so we can remember if we have any
|
|
# members present here.
|
|
conversionReplacements["convert"] += "mIsAnyMemberPresent = true;\n"
|
|
setTempValue = CGGeneric(dedent(
|
|
"""
|
|
if (!${propGet}) {
|
|
return false;
|
|
}
|
|
"""))
|
|
conditions = getConditionList(member, "cx", "*object")
|
|
if len(conditions) != 0:
|
|
setTempValue = CGIfElseWrapper(conditions.define(),
|
|
setTempValue,
|
|
CGGeneric("temp->setUndefined();\n"))
|
|
setTempValue = CGIfWrapper(setTempValue, "!isNull")
|
|
conversion = setTempValue.define()
|
|
if member.defaultValue:
|
|
if (member.type.isUnion() and
|
|
(not member.type.nullable() or
|
|
not isinstance(member.defaultValue, IDLNullValue))):
|
|
# Since this has a default value, it might have been initialized
|
|
# already. Go ahead and uninit it before we try to init it
|
|
# again.
|
|
memberName = self.makeMemberName(member.identifier.name)
|
|
if member.type.nullable():
|
|
conversion += fill(
|
|
"""
|
|
if (!${memberName}.IsNull()) {
|
|
${memberName}.Value().Uninit();
|
|
}
|
|
""",
|
|
memberName=memberName)
|
|
else:
|
|
conversion += "%s.Uninit();\n" % memberName
|
|
conversion += "${convert}"
|
|
elif not conversionInfo.dealWithOptional:
|
|
# We're required, but have no default value. Make sure
|
|
# that we throw if we have no value provided.
|
|
conversion += dedent(
|
|
"""
|
|
if (!isNull && !temp->isUndefined()) {
|
|
${convert}
|
|
} else if (cx) {
|
|
// Don't error out if we have no cx. In that
|
|
// situation the caller is default-constructing us and we'll
|
|
// just assume they know what they're doing.
|
|
return ThrowErrorMessage(cx, MSG_MISSING_REQUIRED_DICTIONARY_MEMBER,
|
|
"%s");
|
|
}
|
|
""" % self.getMemberSourceDescription(member))
|
|
conversionReplacements["convert"] = indent(conversionReplacements["convert"]).rstrip()
|
|
else:
|
|
conversion += (
|
|
"if (!isNull && !temp->isUndefined()) {\n"
|
|
" ${prop}.Construct();\n"
|
|
"${convert}"
|
|
"}\n")
|
|
conversionReplacements["convert"] = indent(conversionReplacements["convert"])
|
|
|
|
return CGGeneric(
|
|
string.Template(conversion).substitute(conversionReplacements))
|
|
|
|
def getMemberDefinition(self, memberInfo):
|
|
member = memberInfo[0]
|
|
declType = memberInfo[1].declType
|
|
memberLoc = self.makeMemberName(member.identifier.name)
|
|
if not member.canHaveMissingValue():
|
|
memberData = memberLoc
|
|
else:
|
|
# The data is inside the Optional<>
|
|
memberData = "%s.InternalValue()" % memberLoc
|
|
|
|
# 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
|
|
if (member.identifier.name in
|
|
["constructor", "toSource", "toString", "toLocaleString", "valueOf",
|
|
"hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable",
|
|
"__defineGetter__", "__defineSetter__", "__lookupGetter__",
|
|
"__lookupSetter__", "__proto__"]):
|
|
raise TypeError("'%s' member of %s dictionary shadows "
|
|
"a property of Object.prototype, and Xrays to "
|
|
"Object can't handle that.\n"
|
|
"%s" %
|
|
(member.identifier.name,
|
|
self.dictionary.identifier.name,
|
|
member.location))
|
|
|
|
propDef = (
|
|
'JS_DefinePropertyById(cx, obj, atomsCache->%s, temp, JSPROP_ENUMERATE)' %
|
|
self.makeIdName(member.identifier.name))
|
|
|
|
innerTemplate = wrapForType(
|
|
member.type, self.descriptorProvider,
|
|
{
|
|
'result': "currentValue",
|
|
'successCode': ("if (!%s) {\n"
|
|
" return false;\n"
|
|
"}\n"
|
|
"break;\n" % propDef),
|
|
'jsvalRef': "temp",
|
|
'jsvalHandle': "&temp",
|
|
'returnsNewObject': False,
|
|
# 'obj' can just be allowed to be the string "obj", since that
|
|
# will be our dictionary object, which is presumably itself in
|
|
# the right scope.
|
|
'typedArraysAreStructs': True
|
|
})
|
|
conversion = CGGeneric(innerTemplate)
|
|
conversion = CGWrapper(conversion,
|
|
pre=("JS::Rooted<JS::Value> temp(cx);\n"
|
|
"%s const & currentValue = %s;\n" %
|
|
(declType.define(), memberData)
|
|
))
|
|
|
|
# Now make sure that our successCode can actually break out of the
|
|
# conversion. This incidentally gives us a scope for 'temp' and
|
|
# 'currentValue'.
|
|
conversion = CGWrapper(
|
|
CGIndenter(conversion),
|
|
pre=("do {\n"
|
|
" // block for our 'break' successCode and scope for 'temp' and 'currentValue'\n"),
|
|
post="} while(0);\n")
|
|
if member.canHaveMissingValue():
|
|
# Only do the conversion if we have a value
|
|
conversion = CGIfWrapper(conversion, "%s.WasPassed()" % memberLoc)
|
|
conditions = getConditionList(member, "cx", "obj")
|
|
if len(conditions) != 0:
|
|
conversion = CGIfWrapper(conversion, conditions.define())
|
|
return conversion
|
|
|
|
def getMemberTrace(self, member):
|
|
type = member.type
|
|
assert typeNeedsRooting(type)
|
|
memberLoc = self.makeMemberName(member.identifier.name)
|
|
if not member.canHaveMissingValue():
|
|
memberData = memberLoc
|
|
else:
|
|
# The data is inside the Optional<>
|
|
memberData = "%s.Value()" % memberLoc
|
|
|
|
memberName = "%s.%s" % (self.makeClassName(self.dictionary),
|
|
memberLoc)
|
|
|
|
if type.isObject():
|
|
trace = CGGeneric('JS::UnsafeTraceRoot(trc, %s, "%s");\n' %
|
|
("&"+memberData, memberName))
|
|
if type.nullable():
|
|
trace = CGIfWrapper(trace, memberData)
|
|
elif type.isAny():
|
|
trace = CGGeneric('JS::UnsafeTraceRoot(trc, %s, "%s");\n' %
|
|
("&"+memberData, memberName))
|
|
elif (type.isSequence() or type.isDictionary() or
|
|
type.isSpiderMonkeyInterface() or type.isUnion()):
|
|
if type.nullable():
|
|
memberNullable = memberData
|
|
memberData = "%s.Value()" % memberData
|
|
if type.isSequence():
|
|
trace = CGGeneric('DoTraceSequence(trc, %s);\n' % memberData)
|
|
elif type.isDictionary():
|
|
trace = CGGeneric('%s.TraceDictionary(trc);\n' % memberData)
|
|
elif type.isUnion():
|
|
trace = CGGeneric('%s.TraceUnion(trc);\n' % memberData)
|
|
else:
|
|
assert type.isSpiderMonkeyInterface()
|
|
trace = CGGeneric('%s.TraceSelf(trc);\n' % memberData)
|
|
if type.nullable():
|
|
trace = CGIfWrapper(trace, "!%s.IsNull()" % memberNullable)
|
|
elif type.isRecord():
|
|
# If you implement this, add a record<DOMString, object> to
|
|
# TestInterfaceJSDictionary and test it in test_bug1036214.html
|
|
# to make sure we end up with the correct security properties.
|
|
assert False
|
|
else:
|
|
assert False # unknown type
|
|
|
|
if member.canHaveMissingValue():
|
|
trace = CGIfWrapper(trace, "%s.WasPassed()" % memberLoc)
|
|
|
|
return trace.define()
|
|
|
|
def getMemberInitializer(self, memberInfo):
|
|
"""
|
|
Get the right initializer for the member. Most members don't need one,
|
|
but we need to pre-initialize 'any' and 'object' that have a default
|
|
value, so they're safe to trace at all times.
|
|
"""
|
|
member, _ = memberInfo
|
|
if member.canHaveMissingValue():
|
|
# Allowed missing value means no need to set it up front, since it's
|
|
# inside an Optional and won't get traced until it's actually set
|
|
# up.
|
|
return None
|
|
type = member.type
|
|
if type.isAny():
|
|
return "JS::UndefinedValue()"
|
|
if type.isObject():
|
|
return "nullptr"
|
|
if type.isDictionary():
|
|
# When we construct ourselves, we don't want to init our member
|
|
# dictionaries. Either we're being constructed-but-not-initialized
|
|
# ourselves (and then we don't want to init them) or we're about to
|
|
# init ourselves and then we'll init them anyway.
|
|
return CGDictionary.getNonInitializingCtorArg()
|
|
return None
|
|
|
|
def getMemberSourceDescription(self, member):
|
|
return ("'%s' member of %s" %
|
|
(member.identifier.name, self.dictionary.identifier.name))
|
|
|
|
@staticmethod
|
|
def makeIdName(name):
|
|
return IDLToCIdentifier(name) + "_id"
|
|
|
|
@staticmethod
|
|
def getNonInitializingCtorArg():
|
|
return "FastDictionaryInitializer()"
|
|
|
|
@staticmethod
|
|
def isDictionaryCopyConstructible(dictionary):
|
|
if (dictionary.parent and
|
|
not CGDictionary.isDictionaryCopyConstructible(dictionary.parent)):
|
|
return False
|
|
return all(isTypeCopyConstructible(m.type) for m in dictionary.members)
|
|
|
|
@staticmethod
|
|
def typeSafeToJSONify(type):
|
|
"""
|
|
Determine whether the given type is safe to convert to JSON. The
|
|
restriction is that this needs to be safe while in a global controlled
|
|
by an adversary, and "safe" means no side-effects when the JS
|
|
representation of this type is converted to JSON. That means that we
|
|
have to be pretty restrictive about what things we can allow. For
|
|
example, "object" is out, because it may have accessor properties on it.
|
|
"""
|
|
if type.nullable():
|
|
# Converting null to JSON is always OK.
|
|
return CGDictionary.typeSafeToJSONify(type.inner)
|
|
|
|
if type.isSequence():
|
|
# Sequences are arrays we create ourselves, with no holes. They
|
|
# should be safe if their contents are safe, as long as we suppress
|
|
# invocation of .toJSON on objects.
|
|
return CGDictionary.typeSafeToJSONify(type.inner)
|
|
|
|
if type.isUnion():
|
|
# OK if everything in it is ok.
|
|
return all(CGDictionary.typeSafeToJSONify(t)
|
|
for t in type.flatMemberTypes)
|
|
|
|
if type.isDictionary():
|
|
# OK if the dictionary is OK
|
|
return CGDictionary.dictionarySafeToJSONify(type.inner)
|
|
|
|
if type.isString() or type.isEnum():
|
|
# Strings are always OK.
|
|
return True
|
|
|
|
if type.isPrimitive():
|
|
# Primitives (numbers and booleans) are ok, as long as
|
|
# they're not unrestricted float/double.
|
|
return not type.isFloat() or not type.isUnrestricted()
|
|
|
|
return False
|
|
|
|
@staticmethod
|
|
def dictionarySafeToJSONify(dictionary):
|
|
# The dictionary itself is OK, so we're good if all our types are.
|
|
return all(CGDictionary.typeSafeToJSONify(m.type)
|
|
for m in dictionary.members)
|
|
|
|
|
|
class CGRegisterWorkerBindings(CGAbstractMethod):
|
|
def __init__(self, config):
|
|
CGAbstractMethod.__init__(self, None, 'RegisterWorkerBindings', 'bool',
|
|
[Argument('JSContext*', 'aCx'),
|
|
Argument('JS::Handle<JSObject*>', 'aObj')])
|
|
self.config = config
|
|
|
|
def definition_body(self):
|
|
descriptors = self.config.getDescriptors(hasInterfaceObject=True,
|
|
isExposedInAnyWorker=True,
|
|
register=True)
|
|
conditions = []
|
|
for desc in descriptors:
|
|
bindingNS = toBindingNamespace(desc.name)
|
|
condition = "!%s::GetConstructorObject(aCx)" % bindingNS
|
|
if desc.isExposedConditionally():
|
|
condition = (
|
|
"%s::ConstructorEnabled(aCx, aObj) && " % bindingNS
|
|
+ condition)
|
|
conditions.append(condition)
|
|
lines = [CGIfWrapper(CGGeneric("return false;\n"), condition) for
|
|
condition in conditions]
|
|
lines.append(CGGeneric("return true;\n"))
|
|
return CGList(lines, "\n").define()
|
|
|
|
class CGRegisterWorkerDebuggerBindings(CGAbstractMethod):
|
|
def __init__(self, config):
|
|
CGAbstractMethod.__init__(self, None, 'RegisterWorkerDebuggerBindings', 'bool',
|
|
[Argument('JSContext*', 'aCx'),
|
|
Argument('JS::Handle<JSObject*>', 'aObj')])
|
|
self.config = config
|
|
|
|
def definition_body(self):
|
|
descriptors = self.config.getDescriptors(hasInterfaceObject=True,
|
|
isExposedInWorkerDebugger=True,
|
|
register=True)
|
|
conditions = []
|
|
for desc in descriptors:
|
|
bindingNS = toBindingNamespace(desc.name)
|
|
condition = "!%s::GetConstructorObject(aCx)" % bindingNS
|
|
if desc.isExposedConditionally():
|
|
condition = (
|
|
"%s::ConstructorEnabled(aCx, aObj) && " % bindingNS
|
|
+ condition)
|
|
conditions.append(condition)
|
|
lines = [CGIfWrapper(CGGeneric("return false;\n"), condition) for
|
|
condition in conditions]
|
|
lines.append(CGGeneric("return true;\n"))
|
|
return CGList(lines, "\n").define()
|
|
|
|
class CGRegisterWorkletBindings(CGAbstractMethod):
|
|
def __init__(self, config):
|
|
CGAbstractMethod.__init__(self, None, 'RegisterWorkletBindings', 'bool',
|
|
[Argument('JSContext*', 'aCx'),
|
|
Argument('JS::Handle<JSObject*>', 'aObj')])
|
|
self.config = config
|
|
|
|
def definition_body(self):
|
|
descriptors = self.config.getDescriptors(hasInterfaceObject=True,
|
|
isExposedInAnyWorklet=True,
|
|
register=True)
|
|
conditions = []
|
|
for desc in descriptors:
|
|
bindingNS = toBindingNamespace(desc.name)
|
|
condition = "!%s::GetConstructorObject(aCx)" % bindingNS
|
|
if desc.isExposedConditionally():
|
|
condition = (
|
|
"%s::ConstructorEnabled(aCx, aObj) && " % bindingNS
|
|
+ condition)
|
|
conditions.append(condition)
|
|
lines = [CGIfWrapper(CGGeneric("return false;\n"), condition) for
|
|
condition in conditions]
|
|
lines.append(CGGeneric("return true;\n"))
|
|
return CGList(lines, "\n").define()
|
|
|
|
class CGResolveSystemBinding(CGAbstractMethod):
|
|
def __init__(self, config):
|
|
CGAbstractMethod.__init__(self, None, 'ResolveSystemBinding', 'bool',
|
|
[Argument('JSContext*', 'aCx'),
|
|
Argument('JS::Handle<JSObject*>', 'aObj'),
|
|
Argument('JS::Handle<jsid>', 'aId'),
|
|
Argument('bool*', 'aResolvedp')])
|
|
self.config = config
|
|
|
|
def definition_body(self):
|
|
descriptors = self.config.getDescriptors(hasInterfaceObject=True,
|
|
isExposedInSystemGlobals=True,
|
|
register=True)
|
|
|
|
def descNameToId(name):
|
|
return "s%s_id" % name
|
|
jsidNames = [descNameToId(desc.name) for desc in descriptors]
|
|
jsidDecls = CGList(CGGeneric("static jsid %s;\n" % name)
|
|
for name in jsidNames)
|
|
|
|
jsidInits = CGList(
|
|
(CGIfWrapper(
|
|
CGGeneric("return false;\n"),
|
|
'!AtomizeAndPinJSString(aCx, %s, "%s")' %
|
|
(descNameToId(desc.name), desc.interface.identifier.name))
|
|
for desc in descriptors),
|
|
"\n")
|
|
jsidInits.append(CGGeneric("idsInited = true;\n"))
|
|
jsidInits = CGIfWrapper(jsidInits, "!idsInited")
|
|
jsidInits = CGList([CGGeneric("static bool idsInited = false;\n"),
|
|
jsidInits])
|
|
|
|
definitions = CGList([], "\n")
|
|
for desc in descriptors:
|
|
bindingNS = toBindingNamespace(desc.name)
|
|
defineCode = "!%s::GetConstructorObject(aCx)" % bindingNS
|
|
defineCode = CGIfWrapper(CGGeneric("return false;\n"), defineCode)
|
|
defineCode = CGList([defineCode,
|
|
CGGeneric("*aResolvedp = true;\n")])
|
|
|
|
condition = "JSID_IS_VOID(aId) || aId == %s" % descNameToId(desc.name)
|
|
if desc.isExposedConditionally():
|
|
condition = "(%s) && %s::ConstructorEnabled(aCx, aObj)" % (condition, bindingNS)
|
|
|
|
definitions.append(CGIfWrapper(defineCode, condition))
|
|
|
|
return CGList([CGGeneric("MOZ_ASSERT(NS_IsMainThread());\n"),
|
|
jsidDecls,
|
|
jsidInits,
|
|
definitions,
|
|
CGGeneric("return true;\n")],
|
|
"\n").define()
|
|
|
|
|
|
def getGlobalNames(config):
|
|
names = []
|
|
for desc in config.getDescriptors(registersGlobalNamesOnWindow=True):
|
|
names.append((desc.name, desc))
|
|
names.extend((n.identifier.name, desc) for n in desc.interface.namedConstructors)
|
|
return names
|
|
|
|
class CGGlobalNamesString(CGGeneric):
|
|
def __init__(self, config):
|
|
globalNames = getGlobalNames(config)
|
|
currentOffset = 0
|
|
strings = []
|
|
for (name, _) in globalNames:
|
|
strings.append('/* %i */ "%s\\0"' % (currentOffset, name))
|
|
currentOffset += len(name) + 1 # Add trailing null.
|
|
define = fill("""
|
|
const uint32_t WebIDLGlobalNameHash::sCount = ${count};
|
|
|
|
const char WebIDLGlobalNameHash::sNames[] =
|
|
$*{strings}
|
|
|
|
""",
|
|
count=len(globalNames),
|
|
strings="\n".join(strings) + ";\n")
|
|
|
|
CGGeneric.__init__(self, define=define)
|
|
|
|
|
|
class CGRegisterGlobalNames(CGAbstractMethod):
|
|
def __init__(self, config):
|
|
CGAbstractMethod.__init__(self, None, 'RegisterWebIDLGlobalNames',
|
|
'void', [])
|
|
self.config = config
|
|
|
|
def definition_body(self):
|
|
def getCheck(desc):
|
|
if not desc.isExposedConditionally():
|
|
return "nullptr"
|
|
return "%sBinding::ConstructorEnabled" % desc.name
|
|
|
|
define = ""
|
|
currentOffset = 0
|
|
for (name, desc) in getGlobalNames(self.config):
|
|
length = len(name)
|
|
define += "WebIDLGlobalNameHash::Register(%i, %i, %sBinding::DefineDOMInterface, %s);\n" % (currentOffset, length, desc.name, getCheck(desc))
|
|
currentOffset += length + 1 # Add trailing null.
|
|
return define
|
|
|
|
|
|
def dependencySortObjects(objects, dependencyGetter, nameGetter):
|
|
"""
|
|
Sort IDL objects with dependencies on each other such that if A
|
|
depends on B then B will come before A. This is needed for
|
|
declaring C++ classes in the right order, for example. Objects
|
|
that have no dependencies are just sorted by name.
|
|
|
|
objects should be something that can produce a set of objects
|
|
(e.g. a set, iterator, list, etc).
|
|
|
|
dependencyGetter is something that, given an object, should return
|
|
the set of objects it depends on.
|
|
"""
|
|
# XXXbz this will fail if we have two webidl files F1 and F2 such that F1
|
|
# declares an object which depends on an object in F2, and F2 declares an
|
|
# object (possibly a different one!) that depends on an object in F1. The
|
|
# good news is that I expect this to never happen.
|
|
sortedObjects = []
|
|
objects = set(objects)
|
|
while len(objects) != 0:
|
|
# Find the dictionaries that don't depend on anything else
|
|
# anymore and move them over.
|
|
toMove = [o for o in objects if
|
|
len(dependencyGetter(o) & objects) == 0]
|
|
if len(toMove) == 0:
|
|
raise TypeError("Loop in dependency graph\n" +
|
|
"\n".join(o.location for o in objects))
|
|
objects = objects - set(toMove)
|
|
sortedObjects.extend(sorted(toMove, key=nameGetter))
|
|
return sortedObjects
|
|
|
|
|
|
class ForwardDeclarationBuilder:
|
|
"""
|
|
Create a canonical representation of a set of namespaced forward
|
|
declarations.
|
|
"""
|
|
def __init__(self):
|
|
"""
|
|
The set of declarations is represented as a tree of nested namespaces.
|
|
Each tree node has a set of declarations |decls| and a dict |children|.
|
|
Each declaration is a pair consisting of the class name and a boolean
|
|
that is true iff the class is really a struct. |children| maps the
|
|
names of inner namespaces to the declarations in that namespace.
|
|
"""
|
|
self.decls = set()
|
|
self.children = {}
|
|
|
|
def _ensureNonTemplateType(self, type):
|
|
if "<" in type:
|
|
# This is a templated type. We don't really know how to
|
|
# forward-declare those, and trying to do it naively is not going to
|
|
# go well (e.g. we may have :: characters inside the type we're
|
|
# templated on!). Just bail out.
|
|
raise TypeError("Attempt to use ForwardDeclarationBuilder on "
|
|
"templated type %s. We don't know how to do that "
|
|
"yet." % type)
|
|
|
|
def _listAdd(self, namespaces, name, isStruct=False):
|
|
"""
|
|
Add a forward declaration, where |namespaces| is a list of namespaces.
|
|
|name| should not contain any other namespaces.
|
|
"""
|
|
if namespaces:
|
|
child = self.children.setdefault(namespaces[0], ForwardDeclarationBuilder())
|
|
child._listAdd(namespaces[1:], name, isStruct)
|
|
else:
|
|
assert '::' not in name
|
|
self.decls.add((name, isStruct))
|
|
|
|
def addInMozillaDom(self, name, isStruct=False):
|
|
"""
|
|
Add a forward declaration to the mozilla::dom:: namespace. |name| should not
|
|
contain any other namespaces.
|
|
"""
|
|
self._ensureNonTemplateType(name);
|
|
self._listAdd(["mozilla", "dom"], name, isStruct)
|
|
|
|
def add(self, nativeType, isStruct=False):
|
|
"""
|
|
Add a forward declaration, where |nativeType| is a string containing
|
|
the type and its namespaces, in the usual C++ way.
|
|
"""
|
|
self._ensureNonTemplateType(nativeType);
|
|
components = nativeType.split('::')
|
|
self._listAdd(components[:-1], components[-1], isStruct)
|
|
|
|
def _build(self, atTopLevel):
|
|
"""
|
|
Return a codegenerator for the forward declarations.
|
|
"""
|
|
decls = []
|
|
if self.decls:
|
|
decls.append(CGList([CGClassForwardDeclare(cname, isStruct)
|
|
for cname, isStruct in sorted(self.decls)]))
|
|
for namespace, child in sorted(self.children.iteritems()):
|
|
decls.append(CGNamespace(namespace, child._build(atTopLevel=False), declareOnly=True))
|
|
|
|
cg = CGList(decls, "\n")
|
|
if not atTopLevel and len(decls) + len(self.decls) > 1:
|
|
cg = CGWrapper(cg, pre='\n', post='\n')
|
|
return cg
|
|
|
|
def build(self):
|
|
return self._build(atTopLevel=True)
|
|
|
|
def forwardDeclareForType(self, t, config):
|
|
t = t.unroll()
|
|
if t.isGeckoInterface():
|
|
name = t.inner.identifier.name
|
|
try:
|
|
desc = config.getDescriptor(name)
|
|
self.add(desc.nativeType)
|
|
except NoSuchDescriptorError:
|
|
pass
|
|
|
|
# Note: Spidermonkey interfaces are typedefs, so can't be
|
|
# forward-declared
|
|
elif t.isPromise():
|
|
self.addInMozillaDom("Promise")
|
|
elif t.isCallback():
|
|
self.addInMozillaDom(t.callback.identifier.name)
|
|
elif t.isDictionary():
|
|
self.addInMozillaDom(t.inner.identifier.name, isStruct=True)
|
|
elif t.isCallbackInterface():
|
|
self.addInMozillaDom(t.inner.identifier.name)
|
|
elif t.isUnion():
|
|
# Forward declare both the owning and non-owning version,
|
|
# since we don't know which one we might want
|
|
self.addInMozillaDom(CGUnionStruct.unionTypeName(t, False))
|
|
self.addInMozillaDom(CGUnionStruct.unionTypeName(t, True))
|
|
elif t.isRecord():
|
|
self.forwardDeclareForType(t.inner, config)
|
|
# Don't need to do anything for void, primitive, string, any or object.
|
|
# There may be some other cases we are missing.
|
|
|
|
|
|
class CGForwardDeclarations(CGWrapper):
|
|
"""
|
|
Code generate the forward declarations for a header file.
|
|
additionalDeclarations is a list of tuples containing a classname and a
|
|
boolean. If the boolean is true we will declare a struct, otherwise we'll
|
|
declare a class.
|
|
"""
|
|
def __init__(self, config, descriptors, callbacks,
|
|
dictionaries, callbackInterfaces, additionalDeclarations=[]):
|
|
builder = ForwardDeclarationBuilder()
|
|
|
|
# Needed for at least Wrap.
|
|
for d in descriptors:
|
|
# If this is a generated iterator interface, we only create these
|
|
# in the generated bindings, and don't need to forward declare.
|
|
if d.interface.isIteratorInterface():
|
|
continue
|
|
builder.add(d.nativeType)
|
|
# If we're an interface and we have a maplike/setlike declaration,
|
|
# we'll have helper functions exposed to the native side of our
|
|
# bindings, which will need to show up in the header. If either of
|
|
# our key/value types are interfaces, they'll be passed as
|
|
# arguments to helper functions, and they'll need to be forward
|
|
# declared in the header.
|
|
if d.interface.maplikeOrSetlikeOrIterable:
|
|
if d.interface.maplikeOrSetlikeOrIterable.hasKeyType():
|
|
builder.forwardDeclareForType(d.interface.maplikeOrSetlikeOrIterable.keyType,
|
|
config)
|
|
if d.interface.maplikeOrSetlikeOrIterable.hasValueType():
|
|
builder.forwardDeclareForType(d.interface.maplikeOrSetlikeOrIterable.valueType,
|
|
config)
|
|
|
|
# We just about always need NativePropertyHooks
|
|
builder.addInMozillaDom("NativePropertyHooks", isStruct=True)
|
|
builder.addInMozillaDom("ProtoAndIfaceCache")
|
|
# Add the atoms cache type, even if we don't need it.
|
|
for d in descriptors:
|
|
# Iterators have native types that are template classes, so
|
|
# creating an 'Atoms' cache type doesn't work for them, and is one
|
|
# of the cases where we don't need it anyways.
|
|
if d.interface.isIteratorInterface():
|
|
continue
|
|
builder.add(d.nativeType + "Atoms", isStruct=True)
|
|
|
|
for callback in callbacks:
|
|
builder.addInMozillaDom(callback.identifier.name)
|
|
for t in getTypesFromCallback(callback):
|
|
builder.forwardDeclareForType(t, config)
|
|
|
|
for d in callbackInterfaces:
|
|
builder.add(d.nativeType)
|
|
builder.add(d.nativeType + "Atoms", isStruct=True)
|
|
for t in getTypesFromDescriptor(d):
|
|
builder.forwardDeclareForType(t, config)
|
|
if d.hasCEReactions():
|
|
builder.addInMozillaDom("DocGroup")
|
|
|
|
for d in dictionaries:
|
|
if len(d.members) > 0:
|
|
builder.addInMozillaDom(d.identifier.name + "Atoms", isStruct=True)
|
|
for t in getTypesFromDictionary(d):
|
|
builder.forwardDeclareForType(t, config)
|
|
|
|
for className, isStruct in additionalDeclarations:
|
|
builder.add(className, isStruct=isStruct)
|
|
|
|
CGWrapper.__init__(self, builder.build())
|
|
|
|
|
|
class CGBindingRoot(CGThing):
|
|
"""
|
|
Root codegen class for binding generation. Instantiate the class, and call
|
|
declare or define to generate header or cpp code (respectively).
|
|
"""
|
|
def __init__(self, config, prefix, webIDLFile):
|
|
bindingHeaders = dict.fromkeys((
|
|
'mozilla/dom/NonRefcountedDOMObject.h',
|
|
),
|
|
True)
|
|
bindingDeclareHeaders = dict.fromkeys((
|
|
'mozilla/dom/BindingDeclarations.h',
|
|
'mozilla/dom/Nullable.h',
|
|
'mozilla/ErrorResult.h',
|
|
),
|
|
True)
|
|
|
|
descriptors = config.getDescriptors(webIDLFile=webIDLFile,
|
|
hasInterfaceOrInterfacePrototypeObject=True)
|
|
|
|
unionTypes = UnionsForFile(config, webIDLFile)
|
|
|
|
(unionHeaders, unionImplheaders, unionDeclarations, traverseMethods,
|
|
unlinkMethods, unionStructs) = UnionTypes(unionTypes, config)
|
|
|
|
bindingDeclareHeaders.update(dict.fromkeys(unionHeaders, True))
|
|
bindingHeaders.update(dict.fromkeys(unionImplheaders, True))
|
|
bindingDeclareHeaders["mozilla/dom/UnionMember.h"] = len(unionStructs) > 0
|
|
bindingDeclareHeaders["mozilla/dom/FakeString.h"] = len(unionStructs) > 0
|
|
# BindingUtils.h is only needed for SetToObject.
|
|
# If it stops being inlined or stops calling CallerSubsumes
|
|
# both this bit and the bit in UnionTypes can be removed.
|
|
bindingDeclareHeaders["mozilla/dom/BindingUtils.h"] = any(d.isObject() for t in unionTypes
|
|
for d in t.flatMemberTypes)
|
|
bindingDeclareHeaders["mozilla/dom/IterableIterator.h"] = any(d.interface.isIteratorInterface() or
|
|
d.interface.isIterable() for d in descriptors)
|
|
|
|
def descriptorHasCrossOriginProperties(desc):
|
|
def hasCrossOriginProperty(m):
|
|
props = memberProperties(m, desc)
|
|
return (props.isCrossOriginMethod or
|
|
props.isCrossOriginGetter or
|
|
props.isCrossOriginSetter)
|
|
|
|
return any(hasCrossOriginProperty(m) for m in desc.interface.members)
|
|
|
|
bindingDeclareHeaders["jsapi.h"] = any(descriptorHasCrossOriginProperties(d) for d in descriptors)
|
|
bindingDeclareHeaders["jspubtd.h"] = not bindingDeclareHeaders["jsapi.h"]
|
|
bindingDeclareHeaders["js/RootingAPI.h"] = not bindingDeclareHeaders["jsapi.h"]
|
|
|
|
def descriptorRequiresPreferences(desc):
|
|
iface = desc.interface
|
|
return any(m.getExtendedAttribute("Pref") for m in iface.members + [iface])
|
|
|
|
def descriptorDeprecated(desc):
|
|
iface = desc.interface
|
|
return any(m.getExtendedAttribute("Deprecated") for m in iface.members + [iface])
|
|
|
|
bindingHeaders["nsIDocument.h"] = any(
|
|
descriptorDeprecated(d) for d in descriptors)
|
|
bindingHeaders["mozilla/Preferences.h"] = any(
|
|
descriptorRequiresPreferences(d) for d in descriptors)
|
|
bindingHeaders["mozilla/dom/DOMJSProxyHandler.h"] = any(
|
|
d.concrete and d.proxy for d in descriptors)
|
|
hasCEReactions = any(d.hasCEReactions() for d in descriptors)
|
|
bindingHeaders["mozilla/dom/CustomElementRegistry.h"] = hasCEReactions
|
|
bindingHeaders["mozilla/dom/DocGroup.h"] = hasCEReactions
|
|
|
|
def descriptorHasChromeOnly(desc):
|
|
ctor = desc.interface.ctor()
|
|
|
|
return (any(isChromeOnly(a) or needsContainsHack(a) or
|
|
needsCallerType(a)
|
|
for a in desc.interface.members) or
|
|
desc.interface.getExtendedAttribute("ChromeOnly") is not None or
|
|
# JS-implemented interfaces with an interface object get a
|
|
# chromeonly _create method. And interfaces with an
|
|
# interface object might have a ChromeOnly constructor.
|
|
(desc.interface.hasInterfaceObject() and
|
|
(desc.interface.isJSImplemented() or
|
|
(ctor and isChromeOnly(ctor)))) or
|
|
# JS-implemented interfaces with clearable cached
|
|
# attrs have chromeonly _clearFoo methods.
|
|
(desc.interface.isJSImplemented() and
|
|
any(clearableCachedAttrs(desc))))
|
|
|
|
# XXXkhuey ugly hack but this is going away soon.
|
|
bindingHeaders['xpcprivate.h'] = webIDLFile.endswith("EventTarget.webidl")
|
|
|
|
hasThreadChecks = any(d.hasThreadChecks() for d in descriptors)
|
|
bindingHeaders["nsThreadUtils.h"] = hasThreadChecks
|
|
|
|
dictionaries = config.getDictionaries(webIDLFile)
|
|
|
|
def dictionaryHasChromeOnly(dictionary):
|
|
while dictionary:
|
|
if (any(isChromeOnly(m) for m in dictionary.members)):
|
|
return True
|
|
dictionary = dictionary.parent
|
|
return False
|
|
|
|
bindingHeaders["nsContentUtils.h"] = (
|
|
any(descriptorHasChromeOnly(d) for d in descriptors) or
|
|
any(dictionaryHasChromeOnly(d) for d in dictionaries))
|
|
hasNonEmptyDictionaries = any(
|
|
len(dict.members) > 0 for dict in dictionaries)
|
|
callbacks = config.getCallbacks(webIDLFile)
|
|
callbackDescriptors = config.getDescriptors(webIDLFile=webIDLFile,
|
|
isCallback=True)
|
|
jsImplemented = config.getDescriptors(webIDLFile=webIDLFile,
|
|
isJSImplemented=True)
|
|
bindingDeclareHeaders["nsWeakReference.h"] = jsImplemented
|
|
bindingHeaders["nsIGlobalObject.h"] = jsImplemented
|
|
bindingHeaders["AtomList.h"] = hasNonEmptyDictionaries or jsImplemented or callbackDescriptors
|
|
|
|
def descriptorClearsPropsInSlots(descriptor):
|
|
if not descriptor.wrapperCache:
|
|
return False
|
|
return any(m.isAttr() and m.getExtendedAttribute("StoreInSlot")
|
|
for m in descriptor.interface.members)
|
|
bindingHeaders["nsJSUtils.h"] = any(descriptorClearsPropsInSlots(d) for d in descriptors)
|
|
|
|
# Do codegen for all the enums
|
|
enums = config.getEnums(webIDLFile)
|
|
cgthings = [CGEnum(e) for e in enums]
|
|
|
|
hasCode = (descriptors or callbackDescriptors or dictionaries or
|
|
callbacks)
|
|
bindingHeaders["mozilla/dom/BindingUtils.h"] = hasCode
|
|
bindingHeaders["mozilla/OwningNonNull.h"] = hasCode
|
|
bindingHeaders["mozilla/dom/BindingDeclarations.h"] = (
|
|
not hasCode and enums)
|
|
|
|
bindingHeaders["WrapperFactory.h"] = descriptors
|
|
bindingHeaders["mozilla/dom/DOMJSClass.h"] = descriptors
|
|
bindingHeaders["mozilla/dom/ScriptSettings.h"] = dictionaries # AutoJSAPI
|
|
# Ensure we see our enums in the generated .cpp file, for the ToJSValue
|
|
# method body. Also ensure that we see jsapi.h.
|
|
if enums:
|
|
bindingHeaders[CGHeaders.getDeclarationFilename(enums[0])] = True
|
|
bindingHeaders["jsapi.h"] = True
|
|
|
|
# For things that have [UseCounter]
|
|
def descriptorRequiresTelemetry(desc):
|
|
iface = desc.interface
|
|
return any(m.getExtendedAttribute("UseCounter") for m in iface.members)
|
|
bindingHeaders["mozilla/UseCounter.h"] = any(
|
|
descriptorRequiresTelemetry(d) for d in descriptors)
|
|
bindingHeaders["mozilla/dom/SimpleGlobalObject.h"] = any(
|
|
CGDictionary.dictionarySafeToJSONify(d) for d in dictionaries)
|
|
bindingHeaders["XrayWrapper.h"] = any(
|
|
d.wantsXrays and d.wantsXrayExpandoClass for d in descriptors)
|
|
bindingHeaders["mozilla/dom/XrayExpandoClass.h"] = any(
|
|
d.wantsXrays for d in descriptors)
|
|
|
|
cgthings.extend(traverseMethods)
|
|
cgthings.extend(unlinkMethods)
|
|
|
|
# Do codegen for all the dictionaries. We have to be a bit careful
|
|
# here, because we have to generate these in order from least derived
|
|
# to most derived so that class inheritance works out. We also have to
|
|
# generate members before the dictionary that contains them.
|
|
|
|
def getDependenciesFromType(type):
|
|
if type.isDictionary():
|
|
return set([type.unroll().inner])
|
|
if type.isSequence():
|
|
return getDependenciesFromType(type.unroll())
|
|
if type.isUnion():
|
|
return set([type.unroll()])
|
|
return set()
|
|
|
|
def getDependencies(unionTypeOrDictionary):
|
|
if isinstance(unionTypeOrDictionary, IDLDictionary):
|
|
deps = set()
|
|
if unionTypeOrDictionary.parent:
|
|
deps.add(unionTypeOrDictionary.parent)
|
|
for member in unionTypeOrDictionary.members:
|
|
deps |= getDependenciesFromType(member.type)
|
|
return deps
|
|
|
|
assert unionTypeOrDictionary.isType() and unionTypeOrDictionary.isUnion()
|
|
deps = set()
|
|
for member in unionTypeOrDictionary.flatMemberTypes:
|
|
deps |= getDependenciesFromType(member)
|
|
return deps
|
|
|
|
def getName(unionTypeOrDictionary):
|
|
if isinstance(unionTypeOrDictionary, IDLDictionary):
|
|
return unionTypeOrDictionary.identifier.name
|
|
|
|
assert unionTypeOrDictionary.isType() and unionTypeOrDictionary.isUnion()
|
|
return unionTypeOrDictionary.name
|
|
|
|
for t in dependencySortObjects(dictionaries + unionStructs, getDependencies, getName):
|
|
if t.isDictionary():
|
|
cgthings.append(CGDictionary(t, config))
|
|
else:
|
|
assert t.isUnion()
|
|
cgthings.append(CGUnionStruct(t, config))
|
|
cgthings.append(CGUnionStruct(t, config, True))
|
|
|
|
# Do codegen for all the callbacks.
|
|
cgthings.extend(CGCallbackFunction(c, config) for c in callbacks)
|
|
|
|
cgthings.extend([CGNamespace('binding_detail', CGFastCallback(c))
|
|
for c in callbacks])
|
|
|
|
# Do codegen for all the descriptors
|
|
cgthings.extend([CGDescriptor(x) for x in descriptors])
|
|
|
|
# Do codegen for all the callback interfaces.
|
|
cgthings.extend([CGCallbackInterface(x) for x in callbackDescriptors])
|
|
|
|
cgthings.extend([CGNamespace('binding_detail',
|
|
CGFastCallback(x.interface))
|
|
for x in callbackDescriptors])
|
|
|
|
# Do codegen for JS implemented classes
|
|
def getParentDescriptor(desc):
|
|
if not desc.interface.parent:
|
|
return set()
|
|
return {desc.getDescriptor(desc.interface.parent.identifier.name)}
|
|
for x in dependencySortObjects(jsImplemented, getParentDescriptor,
|
|
lambda d: d.interface.identifier.name):
|
|
cgthings.append(CGCallbackInterface(x, typedArraysAreStructs=True))
|
|
cgthings.append(CGJSImplClass(x))
|
|
|
|
# And make sure we have the right number of newlines at the end
|
|
curr = CGWrapper(CGList(cgthings, "\n\n"), post="\n\n")
|
|
|
|
# Wrap all of that in our namespaces.
|
|
curr = CGNamespace.build(['mozilla', 'dom'],
|
|
CGWrapper(curr, pre="\n"))
|
|
|
|
curr = CGList([CGForwardDeclarations(config, descriptors,
|
|
callbacks,
|
|
dictionaries,
|
|
callbackDescriptors + jsImplemented,
|
|
additionalDeclarations=unionDeclarations),
|
|
curr],
|
|
"\n")
|
|
|
|
# Add header includes.
|
|
bindingHeaders = [header
|
|
for header, include in bindingHeaders.iteritems()
|
|
if include]
|
|
bindingDeclareHeaders = [header
|
|
for header, include in bindingDeclareHeaders.iteritems()
|
|
if include]
|
|
|
|
curr = CGHeaders(descriptors,
|
|
dictionaries,
|
|
callbacks,
|
|
callbackDescriptors,
|
|
bindingDeclareHeaders,
|
|
bindingHeaders,
|
|
prefix,
|
|
curr,
|
|
config,
|
|
jsImplemented)
|
|
|
|
# Add include guards.
|
|
curr = CGIncludeGuard(prefix, curr)
|
|
|
|
# Add the auto-generated comment.
|
|
curr = CGWrapper(
|
|
curr,
|
|
pre=(AUTOGENERATED_WITH_SOURCE_WARNING_COMMENT %
|
|
os.path.basename(webIDLFile)))
|
|
|
|
# Store the final result.
|
|
self.root = curr
|
|
|
|
def declare(self):
|
|
return stripTrailingWhitespace(self.root.declare())
|
|
|
|
def define(self):
|
|
return stripTrailingWhitespace(self.root.define())
|
|
|
|
def deps(self):
|
|
return self.root.deps()
|
|
|
|
|
|
class CGNativeMember(ClassMethod):
|
|
def __init__(self, descriptorProvider, member, name, signature, extendedAttrs,
|
|
breakAfter=True, passJSBitsAsNeeded=True, visibility="public",
|
|
typedArraysAreStructs=True, variadicIsSequence=False,
|
|
resultNotAddRefed=False,
|
|
virtual=False,
|
|
override=False):
|
|
"""
|
|
If typedArraysAreStructs is false, typed arrays will be passed as
|
|
JS::Handle<JSObject*>. If it's true they will be passed as one of the
|
|
dom::TypedArray subclasses.
|
|
|
|
If passJSBitsAsNeeded is false, we don't automatically pass in a
|
|
JSContext* or a JSObject* based on the return and argument types. We
|
|
can still pass it based on 'implicitJSContext' annotations.
|
|
"""
|
|
self.descriptorProvider = descriptorProvider
|
|
self.member = member
|
|
self.extendedAttrs = extendedAttrs
|
|
self.resultAlreadyAddRefed = not resultNotAddRefed
|
|
self.passJSBitsAsNeeded = passJSBitsAsNeeded
|
|
self.typedArraysAreStructs = typedArraysAreStructs
|
|
self.variadicIsSequence = variadicIsSequence
|
|
breakAfterSelf = "\n" if breakAfter else ""
|
|
ClassMethod.__init__(self, name,
|
|
self.getReturnType(signature[0], False),
|
|
self.getArgs(signature[0], signature[1]),
|
|
static=member.isStatic(),
|
|
# Mark our getters, which are attrs that
|
|
# have a non-void return type, as const.
|
|
const=(not member.isStatic() and member.isAttr() and
|
|
not signature[0].isVoid()),
|
|
breakAfterReturnDecl=" ",
|
|
breakAfterSelf=breakAfterSelf,
|
|
visibility=visibility,
|
|
virtual=virtual,
|
|
override=override)
|
|
|
|
def getReturnType(self, type, isMember):
|
|
return self.getRetvalInfo(type, isMember)[0]
|
|
|
|
def getRetvalInfo(self, type, isMember):
|
|
"""
|
|
Returns a tuple:
|
|
|
|
The first element is the type declaration for the retval
|
|
|
|
The second element is a default value that can be used on error returns.
|
|
For cases whose behavior depends on isMember, the second element will be
|
|
None if isMember is true.
|
|
|
|
The third element is a template for actually returning a value stored in
|
|
"${declName}" and "${holderName}". This means actually returning it if
|
|
we're not outparam, else assigning to the "retval" outparam. If
|
|
isMember is true, this can be None, since in that case the caller will
|
|
never examine this value.
|
|
"""
|
|
if type.isVoid():
|
|
return "void", "", ""
|
|
if type.isPrimitive() and type.tag() in builtinNames:
|
|
result = CGGeneric(builtinNames[type.tag()])
|
|
defaultReturnArg = "0"
|
|
if type.nullable():
|
|
result = CGTemplatedType("Nullable", result)
|
|
defaultReturnArg = ""
|
|
return (result.define(),
|
|
"%s(%s)" % (result.define(), defaultReturnArg),
|
|
"return ${declName};\n")
|
|
if type.isDOMString() or type.isUSVString():
|
|
if isMember:
|
|
# No need for a third element in the isMember case
|
|
return "nsString", None, None
|
|
# Outparam
|
|
return "void", "", "aRetVal = ${declName};\n"
|
|
if type.isByteString():
|
|
if isMember:
|
|
# No need for a third element in the isMember case
|
|
return "nsCString", None, None
|
|
# Outparam
|
|
return "void", "", "aRetVal = ${declName};\n"
|
|
if type.isEnum():
|
|
enumName = type.unroll().inner.identifier.name
|
|
if type.nullable():
|
|
enumName = CGTemplatedType("Nullable",
|
|
CGGeneric(enumName)).define()
|
|
defaultValue = "%s()" % enumName
|
|
else:
|
|
defaultValue = "%s(0)" % enumName
|
|
return enumName, defaultValue, "return ${declName};\n"
|
|
if type.isGeckoInterface() or type.isPromise():
|
|
if type.isGeckoInterface():
|
|
iface = type.unroll().inner
|
|
result = CGGeneric(self.descriptorProvider.getDescriptor(
|
|
iface.identifier.name).prettyNativeType)
|
|
else:
|
|
result = CGGeneric("Promise")
|
|
if self.resultAlreadyAddRefed:
|
|
if isMember:
|
|
holder = "RefPtr"
|
|
else:
|
|
holder = "already_AddRefed"
|
|
if memberReturnsNewObject(self.member) or isMember:
|
|
warning = ""
|
|
else:
|
|
warning = "// Return a raw pointer here to avoid refcounting, but make sure it's safe (the object should be kept alive by the callee).\n"
|
|
result = CGWrapper(result,
|
|
pre=("%s%s<" % (warning, holder)),
|
|
post=">")
|
|
else:
|
|
result = CGWrapper(result, post="*")
|
|
# Since we always force an owning type for callback return values,
|
|
# our ${declName} is an OwningNonNull or RefPtr. So we can just
|
|
# .forget() to get our already_AddRefed.
|
|
return result.define(), "nullptr", "return ${declName}.forget();\n"
|
|
if type.isCallback():
|
|
return ("already_AddRefed<%s>" % type.unroll().callback.identifier.name,
|
|
"nullptr", "return ${declName}.forget();\n")
|
|
if type.isAny():
|
|
if isMember:
|
|
# No need for a third element in the isMember case
|
|
return "JS::Value", None, None
|
|
# Outparam
|
|
return "void", "", "aRetVal.set(${declName});\n"
|
|
|
|
if type.isObject():
|
|
if isMember:
|
|
# No need for a third element in the isMember case
|
|
return "JSObject*", None, None
|
|
return "void", "", "aRetVal.set(${declName});\n"
|
|
if type.isSpiderMonkeyInterface():
|
|
if isMember:
|
|
# No need for a third element in the isMember case
|
|
return "JSObject*", None, None
|
|
if type.nullable():
|
|
returnCode = "${declName}.IsNull() ? nullptr : ${declName}.Value().Obj()"
|
|
else:
|
|
returnCode = "${declName}.Obj()"
|
|
return "void", "", "aRetVal.set(%s);\n" % returnCode
|
|
if type.isSequence():
|
|
# If we want to handle sequence-of-sequences return values, we're
|
|
# going to need to fix example codegen to not produce nsTArray<void>
|
|
# for the relevant argument...
|
|
assert not isMember
|
|
# Outparam.
|
|
if type.nullable():
|
|
returnCode = dedent("""
|
|
if (${declName}.IsNull()) {
|
|
aRetVal.SetNull();
|
|
} else {
|
|
aRetVal.SetValue().SwapElements(${declName}.Value());
|
|
}
|
|
""")
|
|
else:
|
|
returnCode = "aRetVal.SwapElements(${declName});\n"
|
|
return "void", "", returnCode
|
|
if type.isRecord():
|
|
# If we want to handle record-of-record return values, we're
|
|
# going to need to fix example codegen to not produce record<void>
|
|
# for the relevant argument...
|
|
assert not isMember
|
|
# In this case we convert directly into our outparam to start with
|
|
return "void", "", ""
|
|
if type.isDate():
|
|
result = CGGeneric("Date")
|
|
if type.nullable():
|
|
result = CGTemplatedType("Nullable", result)
|
|
return (result.define(), "%s()" % result.define(),
|
|
"return ${declName};\n")
|
|
if type.isDictionary():
|
|
if isMember:
|
|
# Only the first member of the tuple matters here, but return
|
|
# bogus values for the others in case someone decides to use
|
|
# them.
|
|
return CGDictionary.makeDictionaryName(type.inner), None, None
|
|
# In this case we convert directly into our outparam to start with
|
|
return "void", "", ""
|
|
if type.isUnion():
|
|
if isMember:
|
|
# Only the first member of the tuple matters here, but return
|
|
# bogus values for the others in case someone decides to use
|
|
# them.
|
|
return CGUnionStruct.unionTypeDecl(type, True), None, None
|
|
# In this case we convert directly into our outparam to start with
|
|
return "void", "", ""
|
|
|
|
raise TypeError("Don't know how to declare return value for %s" %
|
|
type)
|
|
|
|
def getArgs(self, returnType, argList):
|
|
args = [self.getArg(arg) for arg in argList]
|
|
# Now the outparams
|
|
if returnType.isDOMString() or returnType.isUSVString():
|
|
args.append(Argument("nsString&", "aRetVal"))
|
|
elif returnType.isByteString():
|
|
args.append(Argument("nsCString&", "aRetVal"))
|
|
elif returnType.isSequence():
|
|
nullable = returnType.nullable()
|
|
if nullable:
|
|
returnType = returnType.inner
|
|
# And now the actual underlying type
|
|
elementDecl = self.getReturnType(returnType.inner, True)
|
|
type = CGTemplatedType("nsTArray", CGGeneric(elementDecl))
|
|
if nullable:
|
|
type = CGTemplatedType("Nullable", type)
|
|
args.append(Argument("%s&" % type.define(), "aRetVal"))
|
|
elif returnType.isRecord():
|
|
nullable = returnType.nullable()
|
|
if nullable:
|
|
returnType = returnType.inner
|
|
# And now the actual underlying type
|
|
elementDecl = self.getReturnType(returnType.inner, True)
|
|
type = CGTemplatedType("Record", [recordKeyDeclType(returnType),
|
|
CGGeneric(elementDecl)])
|
|
if nullable:
|
|
type = CGTemplatedType("Nullable", type)
|
|
args.append(Argument("%s&" % type.define(), "aRetVal"))
|
|
elif returnType.isDictionary():
|
|
nullable = returnType.nullable()
|
|
if nullable:
|
|
returnType = returnType.inner
|
|
dictType = CGGeneric(CGDictionary.makeDictionaryName(returnType.inner))
|
|
if nullable:
|
|
dictType = CGTemplatedType("Nullable", dictType)
|
|
args.append(Argument("%s&" % dictType.define(), "aRetVal"))
|
|
elif returnType.isUnion():
|
|
args.append(Argument("%s&" %
|
|
CGUnionStruct.unionTypeDecl(returnType, True),
|
|
"aRetVal"))
|
|
elif returnType.isAny():
|
|
args.append(Argument("JS::MutableHandle<JS::Value>", "aRetVal"))
|
|
elif returnType.isObject() or returnType.isSpiderMonkeyInterface():
|
|
args.append(Argument("JS::MutableHandle<JSObject*>", "aRetVal"))
|
|
|
|
# And the nsIPrincipal
|
|
if self.member.getExtendedAttribute('NeedsSubjectPrincipal'):
|
|
# Cheat and assume self.descriptorProvider is a descriptor
|
|
if self.descriptorProvider.interface.isExposedInAnyWorker():
|
|
args.append(Argument("Maybe<nsIPrincipal*>", "aSubjectPrincipal"))
|
|
else:
|
|
args.append(Argument("nsIPrincipal&", "aPrincipal"))
|
|
# And the caller type, if desired.
|
|
if needsCallerType(self.member):
|
|
args.append(Argument("CallerType", "aCallerType"))
|
|
# And the ErrorResult
|
|
if 'infallible' not in self.extendedAttrs:
|
|
# Use aRv so it won't conflict with local vars named "rv"
|
|
args.append(Argument("ErrorResult&", "aRv"))
|
|
# The legacycaller thisval
|
|
if self.member.isMethod() and self.member.isLegacycaller():
|
|
# If it has an identifier, we can't deal with it yet
|
|
assert self.member.isIdentifierLess()
|
|
args.insert(0, Argument("const JS::Value&", "aThisVal"))
|
|
# And jscontext bits.
|
|
if needCx(returnType, argList, self.extendedAttrs,
|
|
self.passJSBitsAsNeeded, self.member.isStatic()):
|
|
args.insert(0, Argument("JSContext*", "cx"))
|
|
if needScopeObject(returnType, argList, self.extendedAttrs,
|
|
self.descriptorProvider.wrapperCache,
|
|
self.passJSBitsAsNeeded,
|
|
self.member.getExtendedAttribute("StoreInSlot")):
|
|
args.insert(1, Argument("JS::Handle<JSObject*>", "obj"))
|
|
# And if we're static, a global
|
|
if self.member.isStatic():
|
|
args.insert(0, Argument("const GlobalObject&", "global"))
|
|
return args
|
|
|
|
def doGetArgType(self, type, optional, isMember):
|
|
"""
|
|
The main work of getArgType. Returns a string type decl, whether this
|
|
is a const ref, as well as whether the type should be wrapped in
|
|
Nullable as needed.
|
|
|
|
isMember can be false or one of the strings "Sequence", "Variadic",
|
|
"Record"
|
|
"""
|
|
if type.isSequence():
|
|
nullable = type.nullable()
|
|
if nullable:
|
|
type = type.inner
|
|
elementType = type.inner
|
|
argType = self.getArgType(elementType, False, "Sequence")[0]
|
|
decl = CGTemplatedType("Sequence", argType)
|
|
return decl.define(), True, True
|
|
|
|
if type.isRecord():
|
|
nullable = type.nullable()
|
|
if nullable:
|
|
type = type.inner
|
|
elementType = type.inner
|
|
argType = self.getArgType(elementType, False, "Record")[0]
|
|
decl = CGTemplatedType("Record", [recordKeyDeclType(type), argType])
|
|
return decl.define(), True, True
|
|
|
|
if type.isUnion():
|
|
# unionTypeDecl will handle nullable types, so return False for
|
|
# auto-wrapping in Nullable
|
|
return CGUnionStruct.unionTypeDecl(type, isMember), True, False
|
|
|
|
if type.isPromise():
|
|
assert not type.nullable()
|
|
if optional or isMember:
|
|
typeDecl = "OwningNonNull<Promise>"
|
|
else:
|
|
typeDecl = "Promise&"
|
|
return (typeDecl, False, False)
|
|
|
|
if type.isGeckoInterface() and not type.isCallbackInterface():
|
|
iface = type.unroll().inner
|
|
argIsPointer = type.nullable() or iface.isExternal()
|
|
forceOwningType = (iface.isCallback() or isMember)
|
|
if argIsPointer:
|
|
if (optional or isMember) and forceOwningType:
|
|
typeDecl = "RefPtr<%s>"
|
|
else:
|
|
typeDecl = "%s*"
|
|
else:
|
|
if optional or isMember:
|
|
if forceOwningType:
|
|
typeDecl = "OwningNonNull<%s>"
|
|
else:
|
|
typeDecl = "NonNull<%s>"
|
|
else:
|
|
typeDecl = "%s&"
|
|
return ((typeDecl %
|
|
self.descriptorProvider.getDescriptor(iface.identifier.name).prettyNativeType),
|
|
False, False)
|
|
|
|
if type.isSpiderMonkeyInterface():
|
|
if not self.typedArraysAreStructs:
|
|
return "JS::Handle<JSObject*>", False, False
|
|
|
|
# Unroll for the name, in case we're nullable.
|
|
return type.unroll().name, True, True
|
|
|
|
if type.isDOMString() or type.isUSVString():
|
|
if isMember:
|
|
declType = "nsString"
|
|
else:
|
|
declType = "nsAString"
|
|
return declType, True, False
|
|
|
|
if type.isByteString():
|
|
declType = "nsCString"
|
|
return declType, True, False
|
|
|
|
if type.isEnum():
|
|
return type.unroll().inner.identifier.name, False, True
|
|
|
|
if type.isCallback() or type.isCallbackInterface():
|
|
forceOwningType = optional or isMember
|
|
if type.nullable():
|
|
if forceOwningType:
|
|
declType = "RefPtr<%s>"
|
|
else:
|
|
declType = "%s*"
|
|
else:
|
|
if forceOwningType:
|
|
declType = "OwningNonNull<%s>"
|
|
else:
|
|
declType = "%s&"
|
|
if type.isCallback():
|
|
name = type.unroll().callback.identifier.name
|
|
else:
|
|
name = type.unroll().inner.identifier.name
|
|
return declType % name, False, False
|
|
|
|
if type.isAny():
|
|
# Don't do the rooting stuff for variadics for now
|
|
if isMember:
|
|
declType = "JS::Value"
|
|
else:
|
|
declType = "JS::Handle<JS::Value>"
|
|
return declType, False, False
|
|
|
|
if type.isObject():
|
|
if isMember:
|
|
declType = "JSObject*"
|
|
else:
|
|
declType = "JS::Handle<JSObject*>"
|
|
return declType, False, False
|
|
|
|
if type.isDictionary():
|
|
typeName = CGDictionary.makeDictionaryName(type.inner)
|
|
return typeName, True, True
|
|
|
|
if type.isDate():
|
|
return "Date", False, True
|
|
|
|
assert type.isPrimitive()
|
|
|
|
return builtinNames[type.tag()], False, True
|
|
|
|
def getArgType(self, type, optional, isMember):
|
|
"""
|
|
Get the type of an argument declaration. Returns the type CGThing, and
|
|
whether this should be a const ref.
|
|
|
|
isMember can be False, "Sequence", or "Variadic"
|
|
"""
|
|
decl, ref, handleNullable = self.doGetArgType(type, optional, isMember)
|
|
decl = CGGeneric(decl)
|
|
if handleNullable and type.nullable():
|
|
decl = CGTemplatedType("Nullable", decl)
|
|
ref = True
|
|
if isMember == "Variadic":
|
|
arrayType = "Sequence" if self.variadicIsSequence else "nsTArray"
|
|
decl = CGTemplatedType(arrayType, decl)
|
|
ref = True
|
|
elif optional:
|
|
# Note: All variadic args claim to be optional, but we can just use
|
|
# empty arrays to represent them not being present.
|
|
decl = CGTemplatedType("Optional", decl)
|
|
ref = True
|
|
return (decl, ref)
|
|
|
|
def getArg(self, arg):
|
|
"""
|
|
Get the full argument declaration for an argument
|
|
"""
|
|
decl, ref = self.getArgType(arg.type, arg.canHaveMissingValue(),
|
|
"Variadic" if arg.variadic else False)
|
|
if ref:
|
|
decl = CGWrapper(decl, pre="const ", post="&")
|
|
|
|
return Argument(decl.define(), arg.identifier.name)
|
|
|
|
def arguments(self):
|
|
return self.member.signatures()[0][1]
|
|
|
|
|
|
class CGExampleMethod(CGNativeMember):
|
|
def __init__(self, descriptor, method, signature, isConstructor, breakAfter=True):
|
|
CGNativeMember.__init__(self, descriptor, method,
|
|
CGSpecializedMethod.makeNativeName(descriptor,
|
|
method),
|
|
signature,
|
|
descriptor.getExtendedAttributes(method),
|
|
breakAfter=breakAfter,
|
|
variadicIsSequence=True)
|
|
|
|
def declare(self, cgClass):
|
|
assert self.member.isMethod()
|
|
# We skip declaring ourselves if this is a maplike/setlike/iterable
|
|
# method, because those get implemented automatically by the binding
|
|
# machinery, so the implementor of the interface doesn't have to worry
|
|
# about it.
|
|
if self.member.isMaplikeOrSetlikeOrIterableMethod():
|
|
return ''
|
|
return CGNativeMember.declare(self, cgClass);
|
|
|
|
def define(self, cgClass):
|
|
return ''
|
|
|
|
|
|
class CGExampleGetter(CGNativeMember):
|
|
def __init__(self, descriptor, attr):
|
|
CGNativeMember.__init__(self, descriptor, attr,
|
|
CGSpecializedGetter.makeNativeName(descriptor,
|
|
attr),
|
|
(attr.type, []),
|
|
descriptor.getExtendedAttributes(attr,
|
|
getter=True))
|
|
|
|
def declare(self, cgClass):
|
|
assert self.member.isAttr()
|
|
# We skip declaring ourselves if this is a maplike/setlike attr (in
|
|
# practice, "size"), because those get implemented automatically by the
|
|
# binding machinery, so the implementor of the interface doesn't have to
|
|
# worry about it.
|
|
if self.member.isMaplikeOrSetlikeAttr():
|
|
return ''
|
|
return CGNativeMember.declare(self, cgClass);
|
|
|
|
def define(self, cgClass):
|
|
return ''
|
|
|
|
|
|
class CGExampleSetter(CGNativeMember):
|
|
def __init__(self, descriptor, attr):
|
|
CGNativeMember.__init__(self, descriptor, attr,
|
|
CGSpecializedSetter.makeNativeName(descriptor,
|
|
attr),
|
|
(BuiltinTypes[IDLBuiltinType.Types.void],
|
|
[FakeArgument(attr.type, attr)]),
|
|
descriptor.getExtendedAttributes(attr,
|
|
setter=True))
|
|
|
|
def define(self, cgClass):
|
|
return ''
|
|
|
|
|
|
class CGBindingImplClass(CGClass):
|
|
"""
|
|
Common codegen for generating a C++ implementation of a WebIDL interface
|
|
"""
|
|
def __init__(self, descriptor, cgMethod, cgGetter, cgSetter, wantGetParent=True, wrapMethodName="WrapObject", skipStaticMethods=False):
|
|
"""
|
|
cgMethod, cgGetter and cgSetter are classes used to codegen methods,
|
|
getters and setters.
|
|
"""
|
|
self.descriptor = descriptor
|
|
self._deps = descriptor.interface.getDeps()
|
|
|
|
iface = descriptor.interface
|
|
|
|
self.methodDecls = []
|
|
|
|
def appendMethod(m, isConstructor=False):
|
|
sigs = m.signatures()
|
|
for s in sigs[:-1]:
|
|
# Don't put a blank line after overloads, until we
|
|
# get to the last one.
|
|
self.methodDecls.append(cgMethod(descriptor, m, s,
|
|
isConstructor,
|
|
breakAfter=False))
|
|
self.methodDecls.append(cgMethod(descriptor, m, sigs[-1],
|
|
isConstructor))
|
|
|
|
if iface.ctor():
|
|
appendMethod(iface.ctor(), isConstructor=True)
|
|
for n in iface.namedConstructors:
|
|
appendMethod(n, isConstructor=True)
|
|
for m in iface.members:
|
|
if m.isMethod():
|
|
if m.isIdentifierLess():
|
|
continue
|
|
if not m.isStatic() or not skipStaticMethods:
|
|
appendMethod(m)
|
|
elif m.isAttr():
|
|
self.methodDecls.append(cgGetter(descriptor, m))
|
|
if not m.readonly:
|
|
self.methodDecls.append(cgSetter(descriptor, m))
|
|
|
|
# Now do the special operations
|
|
def appendSpecialOperation(name, op):
|
|
if op is None:
|
|
return
|
|
if name == "IndexedCreator" or name == "NamedCreator":
|
|
# These are identical to the setters
|
|
return
|
|
assert len(op.signatures()) == 1
|
|
returnType, args = op.signatures()[0]
|
|
# Make a copy of the args, since we plan to modify them.
|
|
args = list(args)
|
|
if op.isGetter() or op.isDeleter():
|
|
# This is a total hack. The '&' belongs with the
|
|
# type, not the name! But it works, and is simpler
|
|
# than trying to somehow make this pretty.
|
|
args.append(FakeArgument(BuiltinTypes[IDLBuiltinType.Types.boolean],
|
|
op, name="&found"))
|
|
if name == "Stringifier":
|
|
if op.isIdentifierLess():
|
|
# XXXbz I wish we were consistent about our renaming here.
|
|
name = "Stringify"
|
|
else:
|
|
# We already added this method
|
|
return
|
|
if name == "LegacyCaller":
|
|
if op.isIdentifierLess():
|
|
# XXXbz I wish we were consistent about our renaming here.
|
|
name = "LegacyCall"
|
|
else:
|
|
# We already added this method
|
|
return
|
|
if name == "Jsonifier":
|
|
# We already added this method
|
|
return
|
|
self.methodDecls.append(
|
|
CGNativeMember(descriptor, op,
|
|
name,
|
|
(returnType, args),
|
|
descriptor.getExtendedAttributes(op)))
|
|
# Sort things by name so we get stable ordering in the output.
|
|
ops = descriptor.operations.items()
|
|
ops.sort(key=lambda x: x[0])
|
|
for name, op in ops:
|
|
appendSpecialOperation(name, op)
|
|
# If we support indexed properties, then we need a Length()
|
|
# method so we know which indices are supported.
|
|
if descriptor.supportsIndexedProperties():
|
|
# But we don't need it if we already have an infallible
|
|
# "length" attribute, which we often do.
|
|
haveLengthAttr = any(
|
|
m for m in iface.members if m.isAttr() and
|
|
CGSpecializedGetter.makeNativeName(descriptor, m) == "Length")
|
|
if not haveLengthAttr:
|
|
self.methodDecls.append(
|
|
CGNativeMember(descriptor, FakeMember(),
|
|
"Length",
|
|
(BuiltinTypes[IDLBuiltinType.Types.unsigned_long],
|
|
[]),
|
|
{"infallible": True}))
|
|
# And if we support named properties we need to be able to
|
|
# enumerate the supported names.
|
|
if descriptor.supportsNamedProperties():
|
|
self.methodDecls.append(
|
|
CGNativeMember(
|
|
descriptor, FakeMember(),
|
|
"GetSupportedNames",
|
|
(IDLSequenceType(None,
|
|
BuiltinTypes[IDLBuiltinType.Types.domstring]),
|
|
[]),
|
|
{"infallible": True}))
|
|
|
|
wrapArgs = [Argument('JSContext*', 'aCx'),
|
|
Argument('JS::Handle<JSObject*>', 'aGivenProto')]
|
|
if not descriptor.wrapperCache:
|
|
wrapReturnType = "bool"
|
|
wrapArgs.append(Argument('JS::MutableHandle<JSObject*>',
|
|
'aReflector'))
|
|
else:
|
|
wrapReturnType = "JSObject*"
|
|
self.methodDecls.insert(0,
|
|
ClassMethod(wrapMethodName, wrapReturnType,
|
|
wrapArgs, virtual=descriptor.wrapperCache,
|
|
breakAfterReturnDecl=" ",
|
|
override=descriptor.wrapperCache,
|
|
body=self.getWrapObjectBody()))
|
|
if descriptor.hasCEReactions():
|
|
self.methodDecls.insert(0,
|
|
ClassMethod("GetDocGroup", "DocGroup*", [],
|
|
const=True,
|
|
breakAfterReturnDecl=" ",
|
|
body=self.getGetDocGroupBody()))
|
|
if wantGetParent:
|
|
self.methodDecls.insert(0,
|
|
ClassMethod("GetParentObject",
|
|
self.getGetParentObjectReturnType(),
|
|
[], const=True,
|
|
breakAfterReturnDecl=" ",
|
|
body=self.getGetParentObjectBody()))
|
|
|
|
# Invoke CGClass.__init__ in any subclasses afterwards to do the actual codegen.
|
|
|
|
def getWrapObjectBody(self):
|
|
return None
|
|
|
|
def getGetParentObjectReturnType(self):
|
|
return ("// TODO: return something sensible here, and change the return type\n"
|
|
"%s*" % self.descriptor.nativeType.split('::')[-1])
|
|
|
|
def getGetParentObjectBody(self):
|
|
return None
|
|
|
|
def getGetDocGroupBody(self):
|
|
return None
|
|
|
|
def deps(self):
|
|
return self._deps
|
|
|
|
|
|
class CGExampleClass(CGBindingImplClass):
|
|
"""
|
|
Codegen for the actual example class implementation for this descriptor
|
|
"""
|
|
def __init__(self, descriptor):
|
|
CGBindingImplClass.__init__(self, descriptor,
|
|
CGExampleMethod, CGExampleGetter, CGExampleSetter,
|
|
wantGetParent=descriptor.wrapperCache)
|
|
|
|
self.parentIface = descriptor.interface.parent
|
|
if self.parentIface:
|
|
self.parentDesc = descriptor.getDescriptor(
|
|
self.parentIface.identifier.name)
|
|
bases = [ClassBase(self.nativeLeafName(self.parentDesc))]
|
|
else:
|
|
bases = [ClassBase("nsISupports /* or NonRefcountedDOMObject if this is a non-refcounted object */")]
|
|
if descriptor.wrapperCache:
|
|
bases.append(ClassBase("nsWrapperCache /* Change wrapperCache in the binding configuration if you don't want this */"))
|
|
|
|
destructorVisibility = "protected"
|
|
if self.parentIface:
|
|
extradeclarations = (
|
|
"public:\n"
|
|
" NS_DECL_ISUPPORTS_INHERITED\n"
|
|
" NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(%s, %s)\n"
|
|
"\n" % (self.nativeLeafName(descriptor),
|
|
self.nativeLeafName(self.parentDesc)))
|
|
else:
|
|
extradeclarations = (
|
|
"public:\n"
|
|
" NS_DECL_CYCLE_COLLECTING_ISUPPORTS\n"
|
|
" NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(%s)\n"
|
|
"\n" % self.nativeLeafName(descriptor))
|
|
|
|
if descriptor.interface.hasChildInterfaces():
|
|
decorators = ""
|
|
else:
|
|
decorators = "final"
|
|
|
|
CGClass.__init__(self, self.nativeLeafName(descriptor),
|
|
bases=bases,
|
|
constructors=[ClassConstructor([],
|
|
visibility="public")],
|
|
destructor=ClassDestructor(visibility=destructorVisibility),
|
|
methods=self.methodDecls,
|
|
decorators=decorators,
|
|
extradeclarations=extradeclarations)
|
|
|
|
def define(self):
|
|
# Just override CGClass and do our own thing
|
|
ctordtor = dedent("""
|
|
${nativeType}::${nativeType}()
|
|
{
|
|
// Add |MOZ_COUNT_CTOR(${nativeType});| for a non-refcounted object.
|
|
}
|
|
|
|
${nativeType}::~${nativeType}()
|
|
{
|
|
// Add |MOZ_COUNT_DTOR(${nativeType});| for a non-refcounted object.
|
|
}
|
|
""")
|
|
|
|
if self.parentIface:
|
|
ccImpl = dedent("""
|
|
|
|
// Only needed for refcounted objects.
|
|
# error "If you don't have members that need cycle collection,
|
|
# then remove all the cycle collection bits from this
|
|
# implementation and the corresponding header. If you do, you
|
|
# want NS_IMPL_CYCLE_COLLECTION_INHERITED(${nativeType},
|
|
# ${parentType}, your, members, here)"
|
|
NS_IMPL_ADDREF_INHERITED(${nativeType}, ${parentType})
|
|
NS_IMPL_RELEASE_INHERITED(${nativeType}, ${parentType})
|
|
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(${nativeType})
|
|
NS_INTERFACE_MAP_END_INHERITING(${parentType})
|
|
|
|
""")
|
|
else:
|
|
ccImpl = dedent("""
|
|
|
|
// Only needed for refcounted objects.
|
|
NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_0(${nativeType})
|
|
NS_IMPL_CYCLE_COLLECTING_ADDREF(${nativeType})
|
|
NS_IMPL_CYCLE_COLLECTING_RELEASE(${nativeType})
|
|
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(${nativeType})
|
|
NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
|
|
NS_INTERFACE_MAP_ENTRY(nsISupports)
|
|
NS_INTERFACE_MAP_END
|
|
|
|
""")
|
|
|
|
if self.descriptor.wrapperCache:
|
|
reflectorArg = ""
|
|
reflectorPassArg = ""
|
|
returnType = "JSObject*"
|
|
else:
|
|
reflectorArg = ", JS::MutableHandle<JSObject*> aReflector"
|
|
reflectorPassArg = ", aReflector"
|
|
returnType = "bool"
|
|
classImpl = ccImpl + ctordtor + "\n" + dedent("""
|
|
${returnType}
|
|
${nativeType}::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto${reflectorArg})
|
|
{
|
|
return ${ifaceName}Binding::Wrap(aCx, this, aGivenProto${reflectorPassArg});
|
|
}
|
|
|
|
""")
|
|
return string.Template(classImpl).substitute(
|
|
ifaceName=self.descriptor.name,
|
|
nativeType=self.nativeLeafName(self.descriptor),
|
|
parentType=self.nativeLeafName(self.parentDesc) if self.parentIface else "",
|
|
returnType=returnType,
|
|
reflectorArg=reflectorArg,
|
|
reflectorPassArg=reflectorPassArg)
|
|
|
|
@staticmethod
|
|
def nativeLeafName(descriptor):
|
|
return descriptor.nativeType.split('::')[-1]
|
|
|
|
|
|
class CGExampleRoot(CGThing):
|
|
"""
|
|
Root codegen class for example implementation generation. Instantiate the
|
|
class and call declare or define to generate header or cpp code,
|
|
respectively.
|
|
"""
|
|
def __init__(self, config, interfaceName):
|
|
descriptor = config.getDescriptor(interfaceName)
|
|
|
|
self.root = CGWrapper(CGExampleClass(descriptor),
|
|
pre="\n", post="\n")
|
|
|
|
self.root = CGNamespace.build(["mozilla", "dom"], self.root)
|
|
|
|
builder = ForwardDeclarationBuilder()
|
|
if descriptor.hasCEReactions():
|
|
builder.addInMozillaDom("DocGroup")
|
|
for member in descriptor.interface.members:
|
|
if not member.isAttr() and not member.isMethod():
|
|
continue
|
|
if member.isStatic():
|
|
builder.addInMozillaDom("GlobalObject")
|
|
if member.isAttr() and not member.isMaplikeOrSetlikeAttr():
|
|
builder.forwardDeclareForType(member.type, config)
|
|
else:
|
|
assert member.isMethod()
|
|
if not member.isMaplikeOrSetlikeOrIterableMethod():
|
|
for sig in member.signatures():
|
|
builder.forwardDeclareForType(sig[0], config)
|
|
for arg in sig[1]:
|
|
builder.forwardDeclareForType(arg.type, config)
|
|
|
|
self.root = CGList([builder.build(),
|
|
self.root], "\n")
|
|
|
|
# Throw in our #includes
|
|
self.root = CGHeaders([], [], [], [],
|
|
["nsWrapperCache.h",
|
|
"nsCycleCollectionParticipant.h",
|
|
"mozilla/Attributes.h",
|
|
"mozilla/ErrorResult.h",
|
|
"mozilla/dom/BindingDeclarations.h",
|
|
"js/TypeDecls.h"],
|
|
["mozilla/dom/%s.h" % interfaceName,
|
|
("mozilla/dom/%s" %
|
|
CGHeaders.getDeclarationFilename(descriptor.interface))], "", self.root)
|
|
|
|
# And now some include guards
|
|
self.root = CGIncludeGuard(interfaceName, self.root)
|
|
|
|
# And our license block comes before everything else
|
|
self.root = CGWrapper(self.root, pre=dedent("""
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim:set ts=2 sw=2 sts=2 et cindent: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
"""))
|
|
|
|
def declare(self):
|
|
return self.root.declare()
|
|
|
|
def define(self):
|
|
return self.root.define()
|
|
|
|
|
|
def jsImplName(name):
|
|
return name + "JSImpl"
|
|
|
|
|
|
class CGJSImplMember(CGNativeMember):
|
|
"""
|
|
Base class for generating code for the members of the implementation class
|
|
for a JS-implemented WebIDL interface.
|
|
"""
|
|
def __init__(self, descriptorProvider, member, name, signature,
|
|
extendedAttrs, breakAfter=True, passJSBitsAsNeeded=True,
|
|
visibility="public", variadicIsSequence=False,
|
|
virtual=False, override=False):
|
|
CGNativeMember.__init__(self, descriptorProvider, member, name,
|
|
signature, extendedAttrs, breakAfter=breakAfter,
|
|
passJSBitsAsNeeded=passJSBitsAsNeeded,
|
|
visibility=visibility,
|
|
variadicIsSequence=variadicIsSequence,
|
|
virtual=virtual,
|
|
override=override)
|
|
self.body = self.getImpl()
|
|
|
|
def getArgs(self, returnType, argList):
|
|
args = CGNativeMember.getArgs(self, returnType, argList)
|
|
args.append(Argument("JSCompartment*", "aCompartment", "nullptr"))
|
|
return args
|
|
|
|
|
|
class CGJSImplMethod(CGJSImplMember):
|
|
"""
|
|
Class for generating code for the methods for a JS-implemented WebIDL
|
|
interface.
|
|
"""
|
|
def __init__(self, descriptor, method, signature, isConstructor, breakAfter=True):
|
|
virtual = False
|
|
override = False
|
|
if (method.identifier.name == "eventListenerWasAdded" or
|
|
method.identifier.name == "eventListenerWasRemoved"):
|
|
virtual = True
|
|
override = True
|
|
|
|
self.signature = signature
|
|
self.descriptor = descriptor
|
|
self.isConstructor = isConstructor
|
|
CGJSImplMember.__init__(self, descriptor, method,
|
|
CGSpecializedMethod.makeNativeName(descriptor,
|
|
method),
|
|
signature,
|
|
descriptor.getExtendedAttributes(method),
|
|
breakAfter=breakAfter,
|
|
variadicIsSequence=True,
|
|
passJSBitsAsNeeded=False,
|
|
virtual=virtual,
|
|
override=override)
|
|
|
|
def getArgs(self, returnType, argList):
|
|
if self.isConstructor:
|
|
# Skip the JSCompartment bits for constructors; it's handled
|
|
# manually in getImpl.
|
|
return CGNativeMember.getArgs(self, returnType, argList)
|
|
return CGJSImplMember.getArgs(self, returnType, argList)
|
|
|
|
def getImpl(self):
|
|
args = self.getArgs(self.signature[0], self.signature[1])
|
|
if not self.isConstructor:
|
|
return 'return mImpl->%s(%s);\n' % (self.name, ", ".join(arg.name for arg in args))
|
|
|
|
assert self.descriptor.interface.isJSImplemented()
|
|
if self.name != 'Constructor':
|
|
raise TypeError("Named constructors are not supported for JS implemented WebIDL. See bug 851287.")
|
|
if len(self.signature[1]) != 0:
|
|
# The first two arguments to the constructor implementation are not
|
|
# arguments to the WebIDL constructor, so don't pass them to __Init()
|
|
assert args[0].argType == 'const GlobalObject&'
|
|
assert args[1].argType == 'JSContext*'
|
|
constructorArgs = [arg.name for arg in args[2:]]
|
|
constructorArgs.append("js::GetObjectCompartment(scopeObj)")
|
|
initCall = fill(
|
|
"""
|
|
// Wrap the object before calling __Init so that __DOM_IMPL__ is available.
|
|
JS::Rooted<JSObject*> scopeObj(cx, globalHolder->GetGlobalJSObject());
|
|
MOZ_ASSERT(js::IsObjectInContextCompartment(scopeObj, cx));
|
|
JS::Rooted<JS::Value> wrappedVal(cx);
|
|
if (!GetOrCreateDOMReflector(cx, impl, &wrappedVal)) {
|
|
//XXX Assertion disabled for now, see bug 991271.
|
|
MOZ_ASSERT(true || JS_IsExceptionPending(cx));
|
|
aRv.Throw(NS_ERROR_UNEXPECTED);
|
|
return nullptr;
|
|
}
|
|
// Initialize the object with the constructor arguments.
|
|
impl->mImpl->__Init(${args});
|
|
if (aRv.Failed()) {
|
|
return nullptr;
|
|
}
|
|
""",
|
|
args=", ".join(constructorArgs))
|
|
else:
|
|
initCall = ""
|
|
return genConstructorBody(self.descriptor, initCall)
|
|
|
|
|
|
def genConstructorBody(descriptor, initCall=""):
|
|
return fill(
|
|
"""
|
|
JS::Rooted<JSObject*> jsImplObj(cx);
|
|
nsCOMPtr<nsIGlobalObject> globalHolder =
|
|
ConstructJSImplementation("${contractId}", global, &jsImplObj, aRv);
|
|
if (aRv.Failed()) {
|
|
return nullptr;
|
|
}
|
|
// Build the C++ implementation.
|
|
RefPtr<${implClass}> impl = new ${implClass}(jsImplObj, globalHolder);
|
|
$*{initCall}
|
|
return impl.forget();
|
|
""",
|
|
contractId=descriptor.interface.getJSImplementation(),
|
|
implClass=descriptor.name,
|
|
initCall=initCall)
|
|
|
|
|
|
# We're always fallible
|
|
def callbackGetterName(attr, descriptor):
|
|
return "Get" + MakeNativeName(
|
|
descriptor.binaryNameFor(attr.identifier.name))
|
|
|
|
|
|
def callbackSetterName(attr, descriptor):
|
|
return "Set" + MakeNativeName(
|
|
descriptor.binaryNameFor(attr.identifier.name))
|
|
|
|
|
|
class CGJSImplClearCachedValueMethod(CGAbstractBindingMethod):
|
|
def __init__(self, descriptor, attr):
|
|
if attr.getExtendedAttribute("StoreInSlot"):
|
|
raise TypeError("[StoreInSlot] is not supported for JS-implemented WebIDL. See bug 1056325.")
|
|
|
|
CGAbstractBindingMethod.__init__(self, descriptor,
|
|
MakeJSImplClearCachedValueNativeName(attr),
|
|
JSNativeArguments())
|
|
self.attr = attr
|
|
|
|
def generate_code(self):
|
|
return CGGeneric(fill(
|
|
"""
|
|
${bindingNamespace}::${fnName}(self);
|
|
args.rval().setUndefined();
|
|
return true;
|
|
""",
|
|
bindingNamespace=toBindingNamespace(self.descriptor.name),
|
|
fnName=MakeClearCachedValueNativeName(self.attr)))
|
|
|
|
|
|
class CGJSImplGetter(CGJSImplMember):
|
|
"""
|
|
Class for generating code for the getters of attributes for a JS-implemented
|
|
WebIDL interface.
|
|
"""
|
|
def __init__(self, descriptor, attr):
|
|
CGJSImplMember.__init__(self, descriptor, attr,
|
|
CGSpecializedGetter.makeNativeName(descriptor,
|
|
attr),
|
|
(attr.type, []),
|
|
descriptor.getExtendedAttributes(attr,
|
|
getter=True),
|
|
passJSBitsAsNeeded=False)
|
|
|
|
def getImpl(self):
|
|
callbackArgs = [arg.name for arg in self.getArgs(self.member.type, [])]
|
|
return 'return mImpl->%s(%s);\n' % (
|
|
callbackGetterName(self.member, self.descriptorProvider),
|
|
", ".join(callbackArgs))
|
|
|
|
|
|
class CGJSImplSetter(CGJSImplMember):
|
|
"""
|
|
Class for generating code for the setters of attributes for a JS-implemented
|
|
WebIDL interface.
|
|
"""
|
|
def __init__(self, descriptor, attr):
|
|
CGJSImplMember.__init__(self, descriptor, attr,
|
|
CGSpecializedSetter.makeNativeName(descriptor,
|
|
attr),
|
|
(BuiltinTypes[IDLBuiltinType.Types.void],
|
|
[FakeArgument(attr.type, attr)]),
|
|
descriptor.getExtendedAttributes(attr,
|
|
setter=True),
|
|
passJSBitsAsNeeded=False)
|
|
|
|
def getImpl(self):
|
|
callbackArgs = [arg.name for arg in self.getArgs(BuiltinTypes[IDLBuiltinType.Types.void],
|
|
[FakeArgument(self.member.type, self.member)])]
|
|
return 'mImpl->%s(%s);\n' % (
|
|
callbackSetterName(self.member, self.descriptorProvider),
|
|
", ".join(callbackArgs))
|
|
|
|
|
|
class CGJSImplClass(CGBindingImplClass):
|
|
def __init__(self, descriptor):
|
|
CGBindingImplClass.__init__(self, descriptor, CGJSImplMethod, CGJSImplGetter, CGJSImplSetter, skipStaticMethods=True)
|
|
|
|
if descriptor.interface.parent:
|
|
parentClass = descriptor.getDescriptor(
|
|
descriptor.interface.parent.identifier.name).jsImplParent
|
|
baseClasses = [ClassBase(parentClass)]
|
|
isupportsDecl = "NS_DECL_ISUPPORTS_INHERITED\n"
|
|
ccDecl = ("NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(%s, %s)\n" %
|
|
(descriptor.name, parentClass))
|
|
constructorBody = dedent("""
|
|
// Make sure we're an nsWrapperCache already
|
|
MOZ_ASSERT(static_cast<nsWrapperCache*>(this));
|
|
// And that our ancestor has not called SetIsNotDOMBinding()
|
|
MOZ_ASSERT(IsDOMBinding());
|
|
""")
|
|
extradefinitions = fill(
|
|
"""
|
|
NS_IMPL_CYCLE_COLLECTION_INHERITED(${ifaceName}, ${parentClass}, mImpl, mParent)
|
|
NS_IMPL_ADDREF_INHERITED(${ifaceName}, ${parentClass})
|
|
NS_IMPL_RELEASE_INHERITED(${ifaceName}, ${parentClass})
|
|
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(${ifaceName})
|
|
NS_INTERFACE_MAP_END_INHERITING(${parentClass})
|
|
""",
|
|
ifaceName=self.descriptor.name,
|
|
parentClass=parentClass)
|
|
else:
|
|
baseClasses = [ClassBase("nsSupportsWeakReference"),
|
|
ClassBase("nsWrapperCache")]
|
|
isupportsDecl = "NS_DECL_CYCLE_COLLECTING_ISUPPORTS\n"
|
|
ccDecl = ("NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(%s)\n" %
|
|
descriptor.name)
|
|
extradefinitions = fill(
|
|
"""
|
|
NS_IMPL_CYCLE_COLLECTION_CLASS(${ifaceName})
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(${ifaceName})
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mImpl)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mParent)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
|
|
tmp->ClearWeakReferences();
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(${ifaceName})
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mImpl)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mParent)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
|
|
NS_IMPL_CYCLE_COLLECTION_TRACE_WRAPPERCACHE(${ifaceName})
|
|
NS_IMPL_CYCLE_COLLECTING_ADDREF(${ifaceName})
|
|
NS_IMPL_CYCLE_COLLECTING_RELEASE(${ifaceName})
|
|
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(${ifaceName})
|
|
NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
|
|
NS_INTERFACE_MAP_ENTRY(nsISupports)
|
|
NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
|
|
NS_INTERFACE_MAP_END
|
|
""",
|
|
ifaceName=self.descriptor.name)
|
|
|
|
extradeclarations = fill(
|
|
"""
|
|
public:
|
|
$*{isupportsDecl}
|
|
$*{ccDecl}
|
|
|
|
private:
|
|
RefPtr<${jsImplName}> mImpl;
|
|
nsCOMPtr<nsIGlobalObject> mParent;
|
|
|
|
""",
|
|
isupportsDecl=isupportsDecl,
|
|
ccDecl=ccDecl,
|
|
jsImplName=jsImplName(descriptor.name))
|
|
|
|
if descriptor.interface.hasChildInterfaces():
|
|
decorators = ""
|
|
# We need a protected virtual destructor our subclasses can use
|
|
destructor = ClassDestructor(virtual=True, visibility="protected")
|
|
else:
|
|
decorators = "final"
|
|
destructor = ClassDestructor(virtual=False, visibility="private")
|
|
|
|
baseConstructors = [
|
|
("mImpl(new %s(nullptr, aJSImplObject, /* aIncumbentGlobal = */ nullptr))" %
|
|
jsImplName(descriptor.name)),
|
|
"mParent(aParent)"]
|
|
parentInterface = descriptor.interface.parent
|
|
while parentInterface:
|
|
if parentInterface.isJSImplemented():
|
|
baseConstructors.insert(
|
|
0, "%s(aJSImplObject, aParent)" % parentClass)
|
|
break
|
|
parentInterface = parentInterface.parent
|
|
if not parentInterface and descriptor.interface.parent:
|
|
# We only have C++ ancestors, so only pass along the window
|
|
baseConstructors.insert(0,
|
|
"%s(aParent)" % parentClass)
|
|
|
|
constructor = ClassConstructor(
|
|
[Argument("JS::Handle<JSObject*>", "aJSImplObject"),
|
|
Argument("nsIGlobalObject*", "aParent")],
|
|
visibility="public",
|
|
baseConstructors=baseConstructors)
|
|
|
|
self.methodDecls.append(
|
|
ClassMethod("_Create",
|
|
"bool",
|
|
JSNativeArguments(),
|
|
static=True,
|
|
body=self.getCreateFromExistingBody()))
|
|
|
|
CGClass.__init__(self, descriptor.name,
|
|
bases=baseClasses,
|
|
constructors=[constructor],
|
|
destructor=destructor,
|
|
methods=self.methodDecls,
|
|
decorators=decorators,
|
|
extradeclarations=extradeclarations,
|
|
extradefinitions=extradefinitions)
|
|
|
|
def getWrapObjectBody(self):
|
|
return fill(
|
|
"""
|
|
JS::Rooted<JSObject*> obj(aCx, ${name}Binding::Wrap(aCx, this, aGivenProto));
|
|
if (!obj) {
|
|
return nullptr;
|
|
}
|
|
|
|
// Now define it on our chrome object
|
|
JSAutoCompartment ac(aCx, mImpl->Callback());
|
|
if (!JS_WrapObject(aCx, &obj)) {
|
|
return nullptr;
|
|
}
|
|
if (!JS_DefineProperty(aCx, mImpl->Callback(), "__DOM_IMPL__", obj, 0)) {
|
|
return nullptr;
|
|
}
|
|
return obj;
|
|
""",
|
|
name=self.descriptor.name)
|
|
|
|
def getGetParentObjectReturnType(self):
|
|
return "nsISupports*"
|
|
|
|
def getGetParentObjectBody(self):
|
|
return "return mParent;\n"
|
|
|
|
def getGetDocGroupBody(self):
|
|
return dedent(
|
|
"""
|
|
nsCOMPtr<nsPIDOMWindowInner> window = do_QueryInterface(mParent);
|
|
if (!window) {
|
|
return nullptr;
|
|
}
|
|
return window->GetDocGroup();
|
|
""")
|
|
|
|
def getCreateFromExistingBody(self):
|
|
# XXXbz we could try to get parts of this (e.g. the argument
|
|
# conversions) auto-generated by somehow creating an IDLMethod and
|
|
# adding it to our interface, but we'd still need to special-case the
|
|
# implementation slightly to have it not try to forward to the JS
|
|
# object...
|
|
return fill(
|
|
"""
|
|
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
|
|
if (args.length() < 2) {
|
|
return ThrowErrorMessage(cx, MSG_MISSING_ARGUMENTS, "${ifaceName}._create");
|
|
}
|
|
if (!args[0].isObject()) {
|
|
return ThrowErrorMessage(cx, MSG_NOT_OBJECT, "Argument 1 of ${ifaceName}._create");
|
|
}
|
|
if (!args[1].isObject()) {
|
|
return ThrowErrorMessage(cx, MSG_NOT_OBJECT, "Argument 2 of ${ifaceName}._create");
|
|
}
|
|
|
|
// GlobalObject will go through wrappers as needed for us, and
|
|
// is simpler than the right UnwrapArg incantation.
|
|
GlobalObject global(cx, &args[0].toObject());
|
|
if (global.Failed()) {
|
|
return false;
|
|
}
|
|
nsCOMPtr<nsIGlobalObject> globalHolder = do_QueryInterface(global.GetAsSupports());
|
|
MOZ_ASSERT(globalHolder);
|
|
JS::Rooted<JSObject*> arg(cx, &args[1].toObject());
|
|
RefPtr<${implName}> impl = new ${implName}(arg, globalHolder);
|
|
MOZ_ASSERT(js::IsObjectInContextCompartment(arg, cx));
|
|
return GetOrCreateDOMReflector(cx, impl, args.rval());
|
|
""",
|
|
ifaceName=self.descriptor.interface.identifier.name,
|
|
implName=self.descriptor.name)
|
|
|
|
|
|
def isJSImplementedDescriptor(descriptorProvider):
|
|
return (isinstance(descriptorProvider, Descriptor) and
|
|
descriptorProvider.interface.isJSImplemented())
|
|
|
|
|
|
class CGCallback(CGClass):
|
|
def __init__(self, idlObject, descriptorProvider, baseName, methods,
|
|
getters=[], setters=[]):
|
|
self.baseName = baseName
|
|
self._deps = idlObject.getDeps()
|
|
self.idlObject = idlObject
|
|
self.name = idlObject.identifier.name
|
|
if isJSImplementedDescriptor(descriptorProvider):
|
|
self.name = jsImplName(self.name)
|
|
# For our public methods that needThisHandling we want most of the
|
|
# same args and the same return type as what CallbackMember
|
|
# generates. So we want to take advantage of all its
|
|
# CGNativeMember infrastructure, but that infrastructure can't deal
|
|
# with templates and most especially template arguments. So just
|
|
# cheat and have CallbackMember compute all those things for us.
|
|
realMethods = []
|
|
for method in methods:
|
|
if not isinstance(method, CallbackMember) or not method.needThisHandling:
|
|
realMethods.append(method)
|
|
else:
|
|
realMethods.extend(self.getMethodImpls(method))
|
|
realMethods.append(
|
|
ClassMethod("operator==", "bool",
|
|
[Argument("const %s&" % self.name, "aOther")],
|
|
inline=True, bodyInHeader=True,
|
|
const=True,
|
|
body=("return %s::operator==(aOther);\n" % baseName)))
|
|
CGClass.__init__(self, self.name,
|
|
bases=[ClassBase(baseName)],
|
|
constructors=self.getConstructors(),
|
|
methods=realMethods+getters+setters)
|
|
|
|
def getConstructors(self):
|
|
if (not self.idlObject.isInterface() and
|
|
not self.idlObject._treatNonObjectAsNull):
|
|
body = "MOZ_ASSERT(JS::IsCallable(mCallback));\n"
|
|
else:
|
|
# Not much we can assert about it, other than not being null, and
|
|
# CallbackObject does that already.
|
|
body = ""
|
|
return [
|
|
ClassConstructor(
|
|
[Argument("JSContext*", "aCx"),
|
|
Argument("JS::Handle<JSObject*>", "aCallback"),
|
|
Argument("nsIGlobalObject*", "aIncumbentGlobal")],
|
|
bodyInHeader=True,
|
|
visibility="public",
|
|
explicit=True,
|
|
baseConstructors=[
|
|
"%s(aCx, aCallback, aIncumbentGlobal)" % self.baseName,
|
|
],
|
|
body=body),
|
|
ClassConstructor(
|
|
[Argument("JSContext*", "aCx"),
|
|
Argument("JS::Handle<JSObject*>", "aCallback"),
|
|
Argument("nsIGlobalObject*", "aIncumbentGlobal"),
|
|
Argument("const FastCallbackConstructor&", "")],
|
|
bodyInHeader=True,
|
|
visibility="public",
|
|
explicit=True,
|
|
baseConstructors=[
|
|
"%s(aCx, aCallback, aIncumbentGlobal, FastCallbackConstructor())" % self.baseName,
|
|
],
|
|
body=body),
|
|
ClassConstructor(
|
|
[Argument("JS::Handle<JSObject*>", "aCallback"),
|
|
Argument("JS::Handle<JSObject*>", "aAsyncStack"),
|
|
Argument("nsIGlobalObject*", "aIncumbentGlobal")],
|
|
bodyInHeader=True,
|
|
visibility="public",
|
|
explicit=True,
|
|
baseConstructors=[
|
|
"%s(aCallback, aAsyncStack, aIncumbentGlobal)" % self.baseName,
|
|
],
|
|
body=body)]
|
|
|
|
def getMethodImpls(self, method):
|
|
assert method.needThisHandling
|
|
args = list(method.args)
|
|
# Strip out the JSContext*/JSObject* args
|
|
# that got added.
|
|
assert args[0].name == "cx" and args[0].argType == "JSContext*"
|
|
assert args[1].name == "aThisVal" and args[1].argType == "JS::Handle<JS::Value>"
|
|
args = args[2:]
|
|
|
|
# Now remember which index the ErrorResult argument is at;
|
|
# we'll need this below.
|
|
assert args[-1].name == "aRv" and args[-1].argType == "ErrorResult&"
|
|
rvIndex = len(args) - 1
|
|
assert rvIndex >= 0
|
|
|
|
# Record the names of all the arguments, so we can use them when we call
|
|
# the private method.
|
|
argnames = [arg.name for arg in args]
|
|
argnamesWithThis = ["s.GetContext()", "thisValJS"] + argnames
|
|
argnamesWithoutThis = ["s.GetContext()", "JS::UndefinedHandleValue"] + argnames
|
|
# Now that we've recorded the argnames for our call to our private
|
|
# method, insert our optional argument for the execution reason.
|
|
args.append(Argument("const char*", "aExecutionReason",
|
|
"nullptr"))
|
|
|
|
# Make copies of the arg list for the two "without rv" overloads. Note
|
|
# that those don't need aExceptionHandling or aCompartment arguments
|
|
# because those would make not sense anyway: the only sane thing to do
|
|
# with exceptions in the "without rv" cases is to report them.
|
|
argsWithoutRv = list(args)
|
|
argsWithoutRv.pop(rvIndex)
|
|
argsWithoutThisAndRv = list(argsWithoutRv)
|
|
|
|
# Add the potional argument for deciding whether the CallSetup should
|
|
# re-throw exceptions on aRv.
|
|
args.append(Argument("ExceptionHandling", "aExceptionHandling",
|
|
"eReportExceptions"))
|
|
# And the argument for communicating when exceptions should really be
|
|
# rethrown. In particular, even when aExceptionHandling is
|
|
# eRethrowExceptions they won't get rethrown if aCompartment is provided
|
|
# and its principal doesn't subsume either the callback or the
|
|
# exception.
|
|
args.append(Argument("JSCompartment*", "aCompartment", "nullptr"))
|
|
# And now insert our template argument.
|
|
argsWithoutThis = list(args)
|
|
args.insert(0, Argument("const T&", "thisVal"))
|
|
argsWithoutRv.insert(0, Argument("const T&", "thisVal"))
|
|
|
|
argnamesWithoutThisAndRv = [arg.name for arg in argsWithoutThisAndRv]
|
|
argnamesWithoutThisAndRv.insert(rvIndex, "rv");
|
|
# If we just leave things like that, and have no actual arguments in the
|
|
# IDL, we will end up trying to call the templated "without rv" overload
|
|
# with "rv" as the thisVal. That's no good. So explicitly append the
|
|
# aExceptionHandling and aCompartment values we need to end up matching
|
|
# the signature of our non-templated "with rv" overload.
|
|
argnamesWithoutThisAndRv.extend(["eReportExceptions", "nullptr"])
|
|
|
|
argnamesWithoutRv = [arg.name for arg in argsWithoutRv]
|
|
# Note that we need to insert at rvIndex + 1, since we inserted a
|
|
# thisVal arg at the start.
|
|
argnamesWithoutRv.insert(rvIndex + 1, "rv")
|
|
|
|
errorReturn = method.getDefaultRetval()
|
|
|
|
setupCall = fill(
|
|
"""
|
|
if (!aExecutionReason) {
|
|
aExecutionReason = "${executionReason}";
|
|
}
|
|
CallSetup s(this, aRv, aExecutionReason, aExceptionHandling, aCompartment);
|
|
if (!s.GetContext()) {
|
|
MOZ_ASSERT(aRv.Failed());
|
|
return${errorReturn};
|
|
}
|
|
""",
|
|
errorReturn=errorReturn,
|
|
executionReason=method.getPrettyName())
|
|
|
|
bodyWithThis = fill(
|
|
"""
|
|
$*{setupCall}
|
|
JS::Rooted<JS::Value> thisValJS(s.GetContext());
|
|
if (!ToJSValue(s.GetContext(), thisVal, &thisValJS)) {
|
|
aRv.Throw(NS_ERROR_FAILURE);
|
|
return${errorReturn};
|
|
}
|
|
return ${methodName}(${callArgs});
|
|
""",
|
|
setupCall=setupCall,
|
|
errorReturn=errorReturn,
|
|
methodName=method.name,
|
|
callArgs=", ".join(argnamesWithThis))
|
|
bodyWithoutThis = fill(
|
|
"""
|
|
$*{setupCall}
|
|
return ${methodName}(${callArgs});
|
|
""",
|
|
setupCall=setupCall,
|
|
errorReturn=errorReturn,
|
|
methodName=method.name,
|
|
callArgs=", ".join(argnamesWithoutThis))
|
|
bodyWithThisWithoutRv = fill(
|
|
"""
|
|
IgnoredErrorResult rv;
|
|
return ${methodName}(${callArgs});
|
|
""",
|
|
methodName=method.name,
|
|
callArgs=", ".join(argnamesWithoutRv))
|
|
bodyWithoutThisAndRv = fill(
|
|
"""
|
|
IgnoredErrorResult rv;
|
|
return ${methodName}(${callArgs});
|
|
""",
|
|
methodName=method.name,
|
|
callArgs=", ".join(argnamesWithoutThisAndRv))
|
|
|
|
return [ClassMethod(method.name, method.returnType, args,
|
|
bodyInHeader=True,
|
|
templateArgs=["typename T"],
|
|
body=bodyWithThis),
|
|
ClassMethod(method.name, method.returnType, argsWithoutThis,
|
|
bodyInHeader=True,
|
|
body=bodyWithoutThis),
|
|
ClassMethod(method.name, method.returnType, argsWithoutRv,
|
|
bodyInHeader=True,
|
|
templateArgs=["typename T"],
|
|
body=bodyWithThisWithoutRv),
|
|
ClassMethod(method.name, method.returnType, argsWithoutThisAndRv,
|
|
bodyInHeader=True,
|
|
body=bodyWithoutThisAndRv),
|
|
method]
|
|
|
|
def deps(self):
|
|
return self._deps
|
|
|
|
|
|
class CGCallbackFunction(CGCallback):
|
|
def __init__(self, callback, descriptorProvider):
|
|
self.callback = callback
|
|
CGCallback.__init__(self, callback, descriptorProvider,
|
|
"CallbackFunction",
|
|
methods=[CallCallback(callback, descriptorProvider)])
|
|
|
|
def getConstructors(self):
|
|
return CGCallback.getConstructors(self) + [
|
|
ClassConstructor(
|
|
[Argument("CallbackFunction*", "aOther")],
|
|
bodyInHeader=True,
|
|
visibility="public",
|
|
explicit=True,
|
|
baseConstructors=["CallbackFunction(aOther)"])]
|
|
|
|
|
|
class CGFastCallback(CGClass):
|
|
def __init__(self, idlObject):
|
|
self._deps = idlObject.getDeps()
|
|
baseName = idlObject.identifier.name
|
|
constructor = ClassConstructor(
|
|
[Argument("JSContext*", "aCx"),
|
|
Argument("JS::Handle<JSObject*>", "aCallback"),
|
|
Argument("nsIGlobalObject*", "aIncumbentGlobal")],
|
|
bodyInHeader=True,
|
|
visibility="public",
|
|
explicit=True,
|
|
baseConstructors=[
|
|
"%s(aCx, aCallback, aIncumbentGlobal, FastCallbackConstructor())" %
|
|
baseName,
|
|
],
|
|
body="")
|
|
|
|
traceMethod = ClassMethod("Trace", "void",
|
|
[Argument("JSTracer*", "aTracer")],
|
|
inline=True,
|
|
bodyInHeader=True,
|
|
visibility="public",
|
|
body="%s::Trace(aTracer);\n" % baseName)
|
|
holdMethod = ClassMethod("HoldJSObjectsIfMoreThanOneOwner", "void",
|
|
[],
|
|
inline=True,
|
|
bodyInHeader=True,
|
|
visibility="public",
|
|
body=(
|
|
"%s::HoldJSObjectsIfMoreThanOneOwner();\n" %
|
|
baseName))
|
|
|
|
CGClass.__init__(self, "Fast%s" % baseName,
|
|
bases=[ClassBase(baseName)],
|
|
constructors=[constructor],
|
|
methods=[traceMethod, holdMethod])
|
|
|
|
def deps(self):
|
|
return self._deps
|
|
|
|
|
|
class CGCallbackInterface(CGCallback):
|
|
def __init__(self, descriptor, typedArraysAreStructs=False):
|
|
iface = descriptor.interface
|
|
attrs = [m for m in iface.members if m.isAttr() and not m.isStatic()]
|
|
getters = [CallbackGetter(a, descriptor, typedArraysAreStructs)
|
|
for a in attrs]
|
|
setters = [CallbackSetter(a, descriptor, typedArraysAreStructs)
|
|
for a in attrs if not a.readonly]
|
|
methods = [m for m in iface.members
|
|
if m.isMethod() and not m.isStatic() and not m.isIdentifierLess()]
|
|
methods = [CallbackOperation(m, sig, descriptor, typedArraysAreStructs)
|
|
for m in methods for sig in m.signatures()]
|
|
if iface.isJSImplemented() and iface.ctor():
|
|
sigs = descriptor.interface.ctor().signatures()
|
|
if len(sigs) != 1:
|
|
raise TypeError("We only handle one constructor. See bug 869268.")
|
|
methods.append(CGJSImplInitOperation(sigs[0], descriptor))
|
|
if any(m.isAttr() or m.isMethod() for m in iface.members) or (iface.isJSImplemented() and iface.ctor()):
|
|
methods.append(initIdsClassMethod([descriptor.binaryNameFor(m.identifier.name)
|
|
for m in iface.members
|
|
if m.isAttr() or m.isMethod()] +
|
|
(["__init"] if iface.isJSImplemented() and iface.ctor() else []),
|
|
iface.identifier.name + "Atoms"))
|
|
CGCallback.__init__(self, iface, descriptor, "CallbackInterface",
|
|
methods, getters=getters, setters=setters)
|
|
|
|
|
|
class FakeMember():
|
|
def __init__(self, name=None):
|
|
self.treatNullAs = "Default"
|
|
if name is not None:
|
|
self.identifier = FakeIdentifier(name)
|
|
|
|
def isStatic(self):
|
|
return False
|
|
|
|
def isAttr(self):
|
|
return False
|
|
|
|
def isMethod(self):
|
|
return False
|
|
|
|
def getExtendedAttribute(self, name):
|
|
# Claim to be a [NewObject] so we can avoid the "return a raw pointer"
|
|
# comments CGNativeMember codegen would otherwise stick in.
|
|
if name == "NewObject":
|
|
return True
|
|
return None
|
|
|
|
|
|
class CallbackMember(CGNativeMember):
|
|
# XXXbz It's OK to use CallbackKnownNotGray for wrapScope because
|
|
# CallSetup already handled the unmark-gray bits for us. we don't have
|
|
# anything better to use for 'obj', really...
|
|
def __init__(self, sig, name, descriptorProvider, needThisHandling,
|
|
rethrowContentException=False, typedArraysAreStructs=False,
|
|
wrapScope='CallbackKnownNotGray()'):
|
|
"""
|
|
needThisHandling is True if we need to be able to accept a specified
|
|
thisObj, False otherwise.
|
|
"""
|
|
assert not rethrowContentException or not needThisHandling
|
|
|
|
self.retvalType = sig[0]
|
|
self.originalSig = sig
|
|
args = sig[1]
|
|
self.argCount = len(args)
|
|
if self.argCount > 0:
|
|
# Check for variadic arguments
|
|
lastArg = args[self.argCount-1]
|
|
if lastArg.variadic:
|
|
self.argCountStr = ("(%d - 1) + %s.Length()" %
|
|
(self.argCount, lastArg.identifier.name))
|
|
else:
|
|
self.argCountStr = "%d" % self.argCount
|
|
self.needThisHandling = needThisHandling
|
|
# If needThisHandling, we generate ourselves as private and the caller
|
|
# will handle generating public versions that handle the "this" stuff.
|
|
visibility = "private" if needThisHandling else "public"
|
|
self.rethrowContentException = rethrowContentException
|
|
|
|
self.wrapScope = wrapScope
|
|
# We don't care, for callback codegen, whether our original member was
|
|
# a method or attribute or whatnot. Just always pass FakeMember()
|
|
# here.
|
|
CGNativeMember.__init__(self, descriptorProvider, FakeMember(),
|
|
name, (self.retvalType, args),
|
|
extendedAttrs={},
|
|
passJSBitsAsNeeded=False,
|
|
visibility=visibility,
|
|
typedArraysAreStructs=typedArraysAreStructs)
|
|
# We have to do all the generation of our body now, because
|
|
# the caller relies on us throwing if we can't manage it.
|
|
self.exceptionCode = ("aRv.Throw(NS_ERROR_UNEXPECTED);\n"
|
|
"return%s;\n" % self.getDefaultRetval())
|
|
self.body = self.getImpl()
|
|
|
|
def getImpl(self):
|
|
setupCall = self.getCallSetup()
|
|
declRval = self.getRvalDecl()
|
|
if self.argCount > 0:
|
|
argvDecl = fill(
|
|
"""
|
|
JS::AutoValueVector argv(cx);
|
|
if (!argv.resize(${argCount})) {
|
|
aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
|
|
return${errorReturn};
|
|
}
|
|
""",
|
|
argCount=self.argCountStr,
|
|
errorReturn=self.getDefaultRetval())
|
|
else:
|
|
# Avoid weird 0-sized arrays
|
|
argvDecl = ""
|
|
convertArgs = self.getArgConversions()
|
|
doCall = self.getCall()
|
|
returnResult = self.getResultConversion()
|
|
|
|
return setupCall + declRval + argvDecl + convertArgs + doCall + returnResult
|
|
|
|
def getResultConversion(self):
|
|
replacements = {
|
|
"val": "rval",
|
|
"holderName": "rvalHolder",
|
|
"declName": "rvalDecl",
|
|
# We actually want to pass in a null scope object here, because
|
|
# wrapping things into our current compartment (that of mCallback)
|
|
# is what we want.
|
|
"obj": "nullptr",
|
|
"passedToJSImpl": "false"
|
|
}
|
|
|
|
if isJSImplementedDescriptor(self.descriptorProvider):
|
|
isCallbackReturnValue = "JSImpl"
|
|
else:
|
|
isCallbackReturnValue = "Callback"
|
|
sourceDescription = "return value of %s" % self.getPrettyName()
|
|
convertType = instantiateJSToNativeConversion(
|
|
getJSToNativeConversionInfo(self.retvalType,
|
|
self.descriptorProvider,
|
|
exceptionCode=self.exceptionCode,
|
|
isCallbackReturnValue=isCallbackReturnValue,
|
|
# Allow returning a callback type that
|
|
# allows non-callable objects.
|
|
allowTreatNonCallableAsNull=True,
|
|
sourceDescription=sourceDescription),
|
|
replacements)
|
|
assignRetval = string.Template(
|
|
self.getRetvalInfo(self.retvalType,
|
|
False)[2]).substitute(replacements)
|
|
type = convertType.define()
|
|
return type + assignRetval
|
|
|
|
def getArgConversions(self):
|
|
# Just reget the arglist from self.originalSig, because our superclasses
|
|
# just have way to many members they like to clobber, so I can't find a
|
|
# safe member name to store it in.
|
|
argConversions = [self.getArgConversion(i, arg)
|
|
for i, arg in enumerate(self.originalSig[1])]
|
|
if not argConversions:
|
|
return "\n"
|
|
|
|
# Do them back to front, so our argc modifications will work
|
|
# correctly, because we examine trailing arguments first.
|
|
argConversions.reverse()
|
|
# Wrap each one in a scope so that any locals it has don't leak out, and
|
|
# also so that we can just "break;" for our successCode.
|
|
argConversions = [CGWrapper(CGIndenter(CGGeneric(c)),
|
|
pre="do {\n",
|
|
post="} while (0);\n")
|
|
for c in argConversions]
|
|
if self.argCount > 0:
|
|
argConversions.insert(0, self.getArgcDecl())
|
|
# And slap them together.
|
|
return CGList(argConversions, "\n").define() + "\n"
|
|
|
|
def getArgConversion(self, i, arg):
|
|
argval = arg.identifier.name
|
|
|
|
if arg.variadic:
|
|
argval = argval + "[idx]"
|
|
jsvalIndex = "%d + idx" % i
|
|
else:
|
|
jsvalIndex = "%d" % i
|
|
if arg.canHaveMissingValue():
|
|
argval += ".Value()"
|
|
if arg.type.isDOMString():
|
|
# XPConnect string-to-JS conversion wants to mutate the string. So
|
|
# let's give it a string it can mutate
|
|
# XXXbz if we try to do a sequence of strings, this will kinda fail.
|
|
result = "mutableStr"
|
|
prepend = "nsString mutableStr(%s);\n" % argval
|
|
else:
|
|
result = argval
|
|
prepend = ""
|
|
|
|
try:
|
|
conversion = prepend + wrapForType(
|
|
arg.type, self.descriptorProvider,
|
|
{
|
|
'result': result,
|
|
'successCode': "continue;\n" if arg.variadic else "break;\n",
|
|
'jsvalRef': "argv[%s]" % jsvalIndex,
|
|
'jsvalHandle': "argv[%s]" % jsvalIndex,
|
|
'obj': self.wrapScope,
|
|
'returnsNewObject': False,
|
|
'exceptionCode': self.exceptionCode,
|
|
'typedArraysAreStructs': self.typedArraysAreStructs
|
|
})
|
|
except MethodNotNewObjectError as err:
|
|
raise TypeError("%s being passed as an argument to %s but is not "
|
|
"wrapper cached, so can't be reliably converted to "
|
|
"a JS object." %
|
|
(err.typename, self.getPrettyName()))
|
|
if arg.variadic:
|
|
conversion = fill(
|
|
"""
|
|
for (uint32_t idx = 0; idx < ${arg}.Length(); ++idx) {
|
|
$*{conversion}
|
|
}
|
|
break;
|
|
""",
|
|
arg=arg.identifier.name,
|
|
conversion=conversion)
|
|
elif arg.canHaveMissingValue():
|
|
conversion = fill(
|
|
"""
|
|
if (${argName}.WasPassed()) {
|
|
$*{conversion}
|
|
} else if (argc == ${iPlus1}) {
|
|
// This is our current trailing argument; reduce argc
|
|
--argc;
|
|
} else {
|
|
argv[${i}].setUndefined();
|
|
}
|
|
""",
|
|
argName=arg.identifier.name,
|
|
conversion=conversion,
|
|
iPlus1=i + 1,
|
|
i=i)
|
|
return conversion
|
|
|
|
def getDefaultRetval(self):
|
|
default = self.getRetvalInfo(self.retvalType, False)[1]
|
|
if len(default) != 0:
|
|
default = " " + default
|
|
return default
|
|
|
|
def getArgs(self, returnType, argList):
|
|
args = CGNativeMember.getArgs(self, returnType, argList)
|
|
if not self.needThisHandling:
|
|
# Since we don't need this handling, we're the actual method that
|
|
# will be called, so we need an aRethrowExceptions argument.
|
|
if not self.rethrowContentException:
|
|
args.append(Argument("const char*", "aExecutionReason",
|
|
"nullptr"))
|
|
args.append(Argument("ExceptionHandling", "aExceptionHandling",
|
|
"eReportExceptions"))
|
|
args.append(Argument("JSCompartment*", "aCompartment", "nullptr"))
|
|
return args
|
|
# We want to allow the caller to pass in a "this" value, as
|
|
# well as a JSContext.
|
|
return [Argument("JSContext*", "cx"),
|
|
Argument("JS::Handle<JS::Value>", "aThisVal")] + args
|
|
|
|
def getCallSetup(self):
|
|
if self.needThisHandling:
|
|
# It's been done for us already
|
|
return ""
|
|
callSetup = "CallSetup s(this, aRv"
|
|
if self.rethrowContentException:
|
|
# getArgs doesn't add the aExceptionHandling argument but does add
|
|
# aCompartment for us.
|
|
callSetup += ', "%s", eRethrowContentExceptions, aCompartment, /* aIsJSImplementedWebIDL = */ ' % self.getPrettyName()
|
|
callSetup += toStringBool(isJSImplementedDescriptor(self.descriptorProvider))
|
|
else:
|
|
callSetup += ', "%s", aExceptionHandling, aCompartment' % self.getPrettyName()
|
|
callSetup += ");\n"
|
|
return fill(
|
|
"""
|
|
$*{callSetup}
|
|
JSContext* cx = s.GetContext();
|
|
if (!cx) {
|
|
MOZ_ASSERT(aRv.Failed());
|
|
return${errorReturn};
|
|
}
|
|
""",
|
|
callSetup=callSetup,
|
|
errorReturn=self.getDefaultRetval())
|
|
|
|
def getArgcDecl(self):
|
|
return CGGeneric("unsigned argc = %s;\n" % self.argCountStr)
|
|
|
|
@staticmethod
|
|
def ensureASCIIName(idlObject):
|
|
type = "attribute" if idlObject.isAttr() else "operation"
|
|
if re.match("[^\x20-\x7E]", idlObject.identifier.name):
|
|
raise SyntaxError('Callback %s name "%s" contains non-ASCII '
|
|
"characters. We can't handle that. %s" %
|
|
(type, idlObject.identifier.name,
|
|
idlObject.location))
|
|
if re.match('"', idlObject.identifier.name):
|
|
raise SyntaxError("Callback %s name '%s' contains "
|
|
"double-quote character. We can't handle "
|
|
"that. %s" %
|
|
(type, idlObject.identifier.name,
|
|
idlObject.location))
|
|
|
|
|
|
class CallbackMethod(CallbackMember):
|
|
def __init__(self, sig, name, descriptorProvider, needThisHandling,
|
|
rethrowContentException=False, typedArraysAreStructs=False):
|
|
CallbackMember.__init__(self, sig, name, descriptorProvider,
|
|
needThisHandling, rethrowContentException,
|
|
typedArraysAreStructs=typedArraysAreStructs)
|
|
|
|
def getRvalDecl(self):
|
|
return "JS::Rooted<JS::Value> rval(cx, JS::UndefinedValue());\n"
|
|
|
|
def getCall(self):
|
|
if self.argCount > 0:
|
|
args = "JS::HandleValueArray::subarray(argv, 0, argc)"
|
|
else:
|
|
args = "JS::HandleValueArray::empty()"
|
|
|
|
return fill(
|
|
"""
|
|
$*{declCallable}
|
|
$*{declThis}
|
|
if (${callGuard}!JS::Call(cx, ${thisVal}, callable,
|
|
${args}, &rval)) {
|
|
aRv.NoteJSContextException(cx);
|
|
return${errorReturn};
|
|
}
|
|
""",
|
|
declCallable=self.getCallableDecl(),
|
|
declThis=self.getThisDecl(),
|
|
callGuard=self.getCallGuard(),
|
|
thisVal=self.getThisVal(),
|
|
args=args,
|
|
errorReturn=self.getDefaultRetval())
|
|
|
|
|
|
class CallCallback(CallbackMethod):
|
|
def __init__(self, callback, descriptorProvider):
|
|
self.callback = callback
|
|
CallbackMethod.__init__(self, callback.signatures()[0], "Call",
|
|
descriptorProvider, needThisHandling=True)
|
|
|
|
def getThisDecl(self):
|
|
return ""
|
|
|
|
def getThisVal(self):
|
|
return "aThisVal"
|
|
|
|
def getCallableDecl(self):
|
|
return "JS::Rooted<JS::Value> callable(cx, JS::ObjectValue(*mCallback));\n"
|
|
|
|
def getPrettyName(self):
|
|
return self.callback.identifier.name
|
|
|
|
def getCallGuard(self):
|
|
if self.callback._treatNonObjectAsNull:
|
|
return "JS::IsCallable(mCallback) && "
|
|
return ""
|
|
|
|
|
|
class CallbackOperationBase(CallbackMethod):
|
|
"""
|
|
Common class for implementing various callback operations.
|
|
"""
|
|
def __init__(self, signature, jsName, nativeName, descriptor,
|
|
singleOperation, rethrowContentException=False,
|
|
typedArraysAreStructs=False):
|
|
self.singleOperation = singleOperation
|
|
self.methodName = descriptor.binaryNameFor(jsName)
|
|
CallbackMethod.__init__(self, signature, nativeName, descriptor,
|
|
singleOperation, rethrowContentException,
|
|
typedArraysAreStructs=typedArraysAreStructs)
|
|
|
|
def getThisDecl(self):
|
|
if not self.singleOperation:
|
|
return "JS::Rooted<JS::Value> thisValue(cx, JS::ObjectValue(*mCallback));\n"
|
|
# This relies on getCallableDecl declaring a boolean
|
|
# isCallable in the case when we're a single-operation
|
|
# interface.
|
|
return dedent("""
|
|
JS::Rooted<JS::Value> thisValue(cx, isCallable ? aThisVal.get()
|
|
: JS::ObjectValue(*mCallback));
|
|
""")
|
|
|
|
def getThisVal(self):
|
|
return "thisValue"
|
|
|
|
def getCallableDecl(self):
|
|
getCallableFromProp = fill(
|
|
"""
|
|
${atomCacheName}* atomsCache = GetAtomCache<${atomCacheName}>(cx);
|
|
if ((!*reinterpret_cast<jsid**>(atomsCache) && !InitIds(cx, atomsCache)) ||
|
|
!GetCallableProperty(cx, atomsCache->${methodAtomName}, &callable)) {
|
|
aRv.Throw(NS_ERROR_UNEXPECTED);
|
|
return${errorReturn};
|
|
}
|
|
""",
|
|
methodAtomName=CGDictionary.makeIdName(self.methodName),
|
|
atomCacheName=self.descriptorProvider.interface.identifier.name + "Atoms",
|
|
errorReturn=self.getDefaultRetval())
|
|
if not self.singleOperation:
|
|
return 'JS::Rooted<JS::Value> callable(cx);\n' + getCallableFromProp
|
|
return fill(
|
|
"""
|
|
bool isCallable = JS::IsCallable(mCallback);
|
|
JS::Rooted<JS::Value> callable(cx);
|
|
if (isCallable) {
|
|
callable = JS::ObjectValue(*mCallback);
|
|
} else {
|
|
$*{getCallableFromProp}
|
|
}
|
|
""",
|
|
getCallableFromProp=getCallableFromProp)
|
|
|
|
def getCallGuard(self):
|
|
return ""
|
|
|
|
|
|
class CallbackOperation(CallbackOperationBase):
|
|
"""
|
|
Codegen actual WebIDL operations on callback interfaces.
|
|
"""
|
|
def __init__(self, method, signature, descriptor, typedArraysAreStructs):
|
|
self.ensureASCIIName(method)
|
|
self.method = method
|
|
jsName = method.identifier.name
|
|
CallbackOperationBase.__init__(self, signature,
|
|
jsName,
|
|
MakeNativeName(descriptor.binaryNameFor(jsName)),
|
|
descriptor, descriptor.interface.isSingleOperationInterface(),
|
|
rethrowContentException=descriptor.interface.isJSImplemented(),
|
|
typedArraysAreStructs=typedArraysAreStructs)
|
|
|
|
def getPrettyName(self):
|
|
return "%s.%s" % (self.descriptorProvider.interface.identifier.name,
|
|
self.method.identifier.name)
|
|
|
|
|
|
class CallbackAccessor(CallbackMember):
|
|
"""
|
|
Shared superclass for CallbackGetter and CallbackSetter.
|
|
"""
|
|
def __init__(self, attr, sig, name, descriptor, typedArraysAreStructs):
|
|
self.ensureASCIIName(attr)
|
|
self.attrName = attr.identifier.name
|
|
CallbackMember.__init__(self, sig, name, descriptor,
|
|
needThisHandling=False,
|
|
rethrowContentException=descriptor.interface.isJSImplemented(),
|
|
typedArraysAreStructs=typedArraysAreStructs)
|
|
|
|
def getPrettyName(self):
|
|
return "%s.%s" % (self.descriptorProvider.interface.identifier.name,
|
|
self.attrName)
|
|
|
|
|
|
class CallbackGetter(CallbackAccessor):
|
|
def __init__(self, attr, descriptor, typedArraysAreStructs):
|
|
CallbackAccessor.__init__(self, attr,
|
|
(attr.type, []),
|
|
callbackGetterName(attr, descriptor),
|
|
descriptor,
|
|
typedArraysAreStructs)
|
|
|
|
def getRvalDecl(self):
|
|
return "JS::Rooted<JS::Value> rval(cx, JS::UndefinedValue());\n"
|
|
|
|
def getCall(self):
|
|
return fill(
|
|
"""
|
|
JS::Rooted<JSObject *> callback(cx, mCallback);
|
|
${atomCacheName}* atomsCache = GetAtomCache<${atomCacheName}>(cx);
|
|
if ((!*reinterpret_cast<jsid**>(atomsCache) && !InitIds(cx, atomsCache)) ||
|
|
!JS_GetPropertyById(cx, callback, atomsCache->${attrAtomName}, &rval)) {
|
|
aRv.Throw(NS_ERROR_UNEXPECTED);
|
|
return${errorReturn};
|
|
}
|
|
""",
|
|
atomCacheName=self.descriptorProvider.interface.identifier.name + "Atoms",
|
|
attrAtomName=CGDictionary.makeIdName(self.descriptorProvider.binaryNameFor(self.attrName)),
|
|
errorReturn=self.getDefaultRetval())
|
|
|
|
|
|
class CallbackSetter(CallbackAccessor):
|
|
def __init__(self, attr, descriptor, typedArraysAreStructs):
|
|
CallbackAccessor.__init__(self, attr,
|
|
(BuiltinTypes[IDLBuiltinType.Types.void],
|
|
[FakeArgument(attr.type, attr)]),
|
|
callbackSetterName(attr, descriptor),
|
|
descriptor, typedArraysAreStructs)
|
|
|
|
def getRvalDecl(self):
|
|
# We don't need an rval
|
|
return ""
|
|
|
|
def getCall(self):
|
|
return fill(
|
|
"""
|
|
MOZ_ASSERT(argv.length() == 1);
|
|
${atomCacheName}* atomsCache = GetAtomCache<${atomCacheName}>(cx);
|
|
if ((!*reinterpret_cast<jsid**>(atomsCache) && !InitIds(cx, atomsCache)) ||
|
|
!JS_SetPropertyById(cx, CallbackKnownNotGray(), atomsCache->${attrAtomName}, argv[0])) {
|
|
aRv.Throw(NS_ERROR_UNEXPECTED);
|
|
return${errorReturn};
|
|
}
|
|
""",
|
|
atomCacheName=self.descriptorProvider.interface.identifier.name + "Atoms",
|
|
attrAtomName=CGDictionary.makeIdName(self.descriptorProvider.binaryNameFor(self.attrName)),
|
|
errorReturn=self.getDefaultRetval())
|
|
|
|
def getArgcDecl(self):
|
|
return None
|
|
|
|
|
|
class CGJSImplInitOperation(CallbackOperationBase):
|
|
"""
|
|
Codegen the __Init() method used to pass along constructor arguments for JS-implemented WebIDL.
|
|
"""
|
|
def __init__(self, sig, descriptor):
|
|
assert sig in descriptor.interface.ctor().signatures()
|
|
CallbackOperationBase.__init__(self, (BuiltinTypes[IDLBuiltinType.Types.void], sig[1]),
|
|
"__init", "__Init", descriptor,
|
|
singleOperation=False,
|
|
rethrowContentException=True,
|
|
typedArraysAreStructs=True)
|
|
|
|
def getPrettyName(self):
|
|
return "__init"
|
|
|
|
|
|
def getMaplikeOrSetlikeErrorReturn(helperImpl):
|
|
"""
|
|
Generate return values based on whether a maplike or setlike generated
|
|
method is an interface method (which returns bool) or a helper function
|
|
(which uses ErrorResult).
|
|
"""
|
|
if helperImpl:
|
|
return dedent(
|
|
"""
|
|
aRv.Throw(NS_ERROR_UNEXPECTED);
|
|
return%s;
|
|
""" % helperImpl.getDefaultRetval())
|
|
return "return false;\n"
|
|
|
|
|
|
def getMaplikeOrSetlikeBackingObject(descriptor, maplikeOrSetlike, helperImpl=None):
|
|
"""
|
|
Generate code to get/create a JS backing object for a maplike/setlike
|
|
declaration from the declaration slot.
|
|
"""
|
|
func_prefix = maplikeOrSetlike.maplikeOrSetlikeOrIterableType.title()
|
|
ret = fill(
|
|
"""
|
|
JS::Rooted<JSObject*> backingObj(cx);
|
|
bool created = false;
|
|
if (!Get${func_prefix}BackingObject(cx, obj, ${slot}, &backingObj, &created)) {
|
|
$*{errorReturn}
|
|
}
|
|
if (created) {
|
|
PreserveWrapper<${selfType}>(self);
|
|
}
|
|
""",
|
|
slot=memberReservedSlot(maplikeOrSetlike, descriptor),
|
|
func_prefix=func_prefix,
|
|
errorReturn=getMaplikeOrSetlikeErrorReturn(helperImpl),
|
|
selfType=descriptor.nativeType)
|
|
return ret
|
|
|
|
|
|
def getMaplikeOrSetlikeSizeGetterBody(descriptor, attr):
|
|
"""
|
|
Creates the body for the size getter method of maplike/setlike interfaces.
|
|
"""
|
|
# We should only have one declaration attribute currently
|
|
assert attr.identifier.name == "size"
|
|
assert attr.isMaplikeOrSetlikeAttr()
|
|
return fill(
|
|
"""
|
|
$*{getBackingObj}
|
|
uint32_t result = JS::${funcPrefix}Size(cx, backingObj);
|
|
MOZ_ASSERT(!JS_IsExceptionPending(cx));
|
|
args.rval().setNumber(result);
|
|
return true;
|
|
""",
|
|
getBackingObj=getMaplikeOrSetlikeBackingObject(descriptor,
|
|
attr.maplikeOrSetlike),
|
|
funcPrefix=attr.maplikeOrSetlike.prefix)
|
|
|
|
|
|
class CGMaplikeOrSetlikeMethodGenerator(CGThing):
|
|
"""
|
|
Creates methods for maplike/setlike interfaces. It is expected that all
|
|
methods will be have a maplike/setlike object attached. Unwrapping/wrapping
|
|
will be taken care of by the usual method generation machinery in
|
|
CGMethodCall/CGPerSignatureCall. Functionality is filled in here instead of
|
|
using CGCallGenerator.
|
|
"""
|
|
def __init__(self, descriptor, maplikeOrSetlike, methodName,
|
|
helperImpl=None):
|
|
CGThing.__init__(self)
|
|
# True if this will be the body of a C++ helper function.
|
|
self.helperImpl = helperImpl
|
|
self.descriptor = descriptor
|
|
self.maplikeOrSetlike = maplikeOrSetlike
|
|
self.cgRoot = CGList([])
|
|
impl_method_name = methodName
|
|
if impl_method_name[0] == "_":
|
|
# double underscore means this is a js-implemented chrome only rw
|
|
# function. Truncate the double underscore so calling the right
|
|
# underlying JSAPI function still works.
|
|
impl_method_name = impl_method_name[2:]
|
|
self.cgRoot.append(CGGeneric(
|
|
getMaplikeOrSetlikeBackingObject(self.descriptor,
|
|
self.maplikeOrSetlike,
|
|
self.helperImpl)))
|
|
self.returnStmt = getMaplikeOrSetlikeErrorReturn(self.helperImpl)
|
|
|
|
# Generates required code for the method. Method descriptions included
|
|
# in definitions below. Throw if we don't have a method to fill in what
|
|
# we're looking for.
|
|
try:
|
|
methodGenerator = getattr(self, impl_method_name)
|
|
except AttributeError:
|
|
raise TypeError("Missing %s method definition '%s'" %
|
|
(self.maplikeOrSetlike.maplikeOrSetlikeType,
|
|
methodName))
|
|
# Method generator returns tuple, containing:
|
|
#
|
|
# - a list of CGThings representing setup code for preparing to call
|
|
# the JS API function
|
|
# - a list of arguments needed for the JS API function we're calling
|
|
# - list of code CGThings needed for return value conversion.
|
|
(setupCode, arguments, setResult) = methodGenerator()
|
|
|
|
# Create the actual method call, and then wrap it with the code to
|
|
# return the value if needed.
|
|
funcName = (self.maplikeOrSetlike.prefix +
|
|
MakeNativeName(impl_method_name))
|
|
# Append the list of setup code CGThings
|
|
self.cgRoot.append(CGList(setupCode))
|
|
# Create the JS API call
|
|
self.cgRoot.append(CGWrapper(
|
|
CGGeneric(fill(
|
|
"""
|
|
if (!JS::${funcName}(${args})) {
|
|
$*{errorReturn}
|
|
}
|
|
""",
|
|
funcName=funcName,
|
|
args=", ".join(["cx", "backingObj"] + arguments),
|
|
errorReturn=self.returnStmt))))
|
|
# Append result conversion
|
|
self.cgRoot.append(CGList(setResult))
|
|
|
|
def mergeTuples(self, a, b):
|
|
"""
|
|
Expecting to take 2 tuples were all elements are lists, append the lists in
|
|
the second tuple to the lists in the first.
|
|
"""
|
|
return tuple([x + y for x, y in zip(a, b)])
|
|
|
|
def appendArgConversion(self, name):
|
|
"""
|
|
Generate code to convert arguments to JS::Values, so they can be
|
|
passed into JSAPI functions.
|
|
"""
|
|
return CGGeneric(fill(
|
|
"""
|
|
JS::Rooted<JS::Value> ${name}Val(cx);
|
|
if (!ToJSValue(cx, ${name}, &${name}Val)) {
|
|
$*{errorReturn}
|
|
}
|
|
""",
|
|
name=name,
|
|
errorReturn=self.returnStmt))
|
|
|
|
def appendKeyArgConversion(self):
|
|
"""
|
|
Generates the key argument for methods. Helper functions will use
|
|
an AutoValueVector, while interface methods have seperate JS::Values.
|
|
"""
|
|
if self.helperImpl:
|
|
return ([], ["argv[0]"], [])
|
|
return ([self.appendArgConversion("arg0")], ["arg0Val"], [])
|
|
|
|
def appendKeyAndValueArgConversion(self):
|
|
"""
|
|
Generates arguments for methods that require a key and value. Helper
|
|
functions will use an AutoValueVector, while interface methods have
|
|
seperate JS::Values.
|
|
"""
|
|
r = self.appendKeyArgConversion()
|
|
if self.helperImpl:
|
|
return self.mergeTuples(r, ([], ["argv[1]"], []))
|
|
return self.mergeTuples(r, ([self.appendArgConversion("arg1")],
|
|
["arg1Val"],
|
|
[]))
|
|
|
|
def appendIteratorResult(self):
|
|
"""
|
|
Generate code to output JSObject* return values, needed for functions that
|
|
return iterators. Iterators cannot currently be wrapped via Xrays. If
|
|
something that would return an iterator is called via Xray, fail early.
|
|
"""
|
|
# TODO: Bug 1173651 - Remove check once bug 1023984 is fixed.
|
|
code = CGGeneric(dedent(
|
|
"""
|
|
// TODO (Bug 1173651): Xrays currently cannot wrap iterators. Change
|
|
// after bug 1023984 is fixed.
|
|
if (xpc::WrapperFactory::IsXrayWrapper(obj)) {
|
|
JS_ReportErrorASCII(cx, "Xray wrapping of iterators not supported.");
|
|
return false;
|
|
}
|
|
JS::Rooted<JSObject*> result(cx);
|
|
JS::Rooted<JS::Value> v(cx);
|
|
"""))
|
|
arguments = "&v"
|
|
setResult = CGGeneric(dedent(
|
|
"""
|
|
result = &v.toObject();
|
|
"""))
|
|
return ([code], [arguments], [setResult])
|
|
|
|
def appendSelfResult(self):
|
|
"""
|
|
Generate code to return the interface object itself.
|
|
"""
|
|
code = CGGeneric(dedent(
|
|
"""
|
|
JS::Rooted<JSObject*> result(cx);
|
|
"""))
|
|
setResult = CGGeneric(dedent(
|
|
"""
|
|
result = obj;
|
|
"""))
|
|
return ([code], [], [setResult])
|
|
|
|
def appendBoolResult(self):
|
|
if self.helperImpl:
|
|
return ([CGGeneric()], ["&aRetVal"], [])
|
|
return ([CGGeneric("bool result;\n")], ["&result"], [])
|
|
|
|
def forEach(self):
|
|
"""
|
|
void forEach(callback c, any thisval);
|
|
|
|
ForEach takes a callback, and a possible value to use as 'this'. The
|
|
callback needs to take value, key, and the interface object
|
|
implementing maplike/setlike. In order to make sure that the third arg
|
|
is our interface object instead of the map/set backing object, we
|
|
create a js function with the callback and original object in its
|
|
storage slots, then use a helper function in BindingUtils to make sure
|
|
the callback is called correctly.
|
|
"""
|
|
assert(not self.helperImpl)
|
|
code = [CGGeneric(dedent(
|
|
"""
|
|
// Create a wrapper function.
|
|
JSFunction* func = js::NewFunctionWithReserved(cx, ForEachHandler, 3, 0, nullptr);
|
|
if (!func) {
|
|
return false;
|
|
}
|
|
JS::Rooted<JSObject*> funcObj(cx, JS_GetFunctionObject(func));
|
|
JS::Rooted<JS::Value> funcVal(cx, JS::ObjectValue(*funcObj));
|
|
js::SetFunctionNativeReserved(funcObj, FOREACH_CALLBACK_SLOT,
|
|
JS::ObjectValue(*arg0));
|
|
js::SetFunctionNativeReserved(funcObj, FOREACH_MAPLIKEORSETLIKEOBJ_SLOT,
|
|
JS::ObjectValue(*obj));
|
|
"""))]
|
|
arguments = ["funcVal", "arg1"]
|
|
return (code, arguments, [])
|
|
|
|
def set(self):
|
|
"""
|
|
object set(key, value);
|
|
|
|
Maplike only function, takes key and sets value to it, returns
|
|
interface object unless being called from a C++ helper.
|
|
"""
|
|
assert self.maplikeOrSetlike.isMaplike()
|
|
r = self.appendKeyAndValueArgConversion()
|
|
if self.helperImpl:
|
|
return r
|
|
return self.mergeTuples(r, self.appendSelfResult())
|
|
|
|
def add(self):
|
|
"""
|
|
object add(value);
|
|
|
|
Setlike only function, adds value to set, returns interface object
|
|
unless being called from a C++ helper
|
|
"""
|
|
assert self.maplikeOrSetlike.isSetlike()
|
|
r = self.appendKeyArgConversion()
|
|
if self.helperImpl:
|
|
return r
|
|
return self.mergeTuples(r, self.appendSelfResult())
|
|
|
|
def get(self):
|
|
"""
|
|
type? get(key);
|
|
|
|
Retrieves a value from a backing object based on the key. Returns value
|
|
if key is in backing object, undefined otherwise.
|
|
"""
|
|
assert self.maplikeOrSetlike.isMaplike()
|
|
r = self.appendKeyArgConversion()
|
|
code = [CGGeneric(dedent(
|
|
"""
|
|
JS::Rooted<JS::Value> result(cx);
|
|
"""))]
|
|
arguments = ["&result"]
|
|
return self.mergeTuples(r, (code, arguments, []))
|
|
|
|
def has(self):
|
|
"""
|
|
bool has(key);
|
|
|
|
Check if an entry exists in the backing object. Returns true if value
|
|
exists in backing object, false otherwise.
|
|
"""
|
|
return self.mergeTuples(self.appendKeyArgConversion(),
|
|
self.appendBoolResult())
|
|
|
|
def keys(self):
|
|
"""
|
|
object keys();
|
|
|
|
Returns new object iterator with all keys from backing object.
|
|
"""
|
|
return self.appendIteratorResult()
|
|
|
|
def values(self):
|
|
"""
|
|
object values();
|
|
|
|
Returns new object iterator with all values from backing object.
|
|
"""
|
|
return self.appendIteratorResult()
|
|
|
|
def entries(self):
|
|
"""
|
|
object entries();
|
|
|
|
Returns new object iterator with all keys and values from backing
|
|
object. Keys will be null for set.
|
|
"""
|
|
return self.appendIteratorResult()
|
|
|
|
def clear(self):
|
|
"""
|
|
void clear();
|
|
|
|
Removes all entries from map/set.
|
|
"""
|
|
return ([], [], [])
|
|
|
|
def delete(self):
|
|
"""
|
|
bool delete(key);
|
|
|
|
Deletes an entry from the backing object. Returns true if value existed
|
|
in backing object, false otherwise.
|
|
"""
|
|
return self.mergeTuples(self.appendKeyArgConversion(),
|
|
self.appendBoolResult())
|
|
|
|
def define(self):
|
|
return self.cgRoot.define()
|
|
|
|
|
|
class CGMaplikeOrSetlikeHelperFunctionGenerator(CallbackMember):
|
|
"""
|
|
Generates code to allow C++ to perform operations on backing objects. Gets
|
|
a context from the binding wrapper, turns arguments into JS::Values (via
|
|
CallbackMember/CGNativeMember argument conversion), then uses
|
|
CGMaplikeOrSetlikeMethodGenerator to generate the body.
|
|
|
|
"""
|
|
|
|
class HelperFunction(CGAbstractMethod):
|
|
"""
|
|
Generates context retrieval code and rooted JSObject for interface for
|
|
CGMaplikeOrSetlikeMethodGenerator to use
|
|
"""
|
|
def __init__(self, descriptor, name, args, code, needsBoolReturn=False):
|
|
self.code = code
|
|
CGAbstractMethod.__init__(self, descriptor, name,
|
|
"bool" if needsBoolReturn else "void",
|
|
args)
|
|
|
|
def definition_body(self):
|
|
return self.code
|
|
|
|
def __init__(self, descriptor, maplikeOrSetlike, name, needsKeyArg=False,
|
|
needsValueArg=False, needsBoolReturn=False):
|
|
args = []
|
|
self.maplikeOrSetlike = maplikeOrSetlike
|
|
self.needsBoolReturn = needsBoolReturn
|
|
if needsKeyArg:
|
|
args.append(FakeArgument(maplikeOrSetlike.keyType, None, 'aKey'))
|
|
if needsValueArg:
|
|
assert needsKeyArg
|
|
args.append(FakeArgument(maplikeOrSetlike.valueType, None, 'aValue'))
|
|
# Run CallbackMember init function to generate argument conversion code.
|
|
# wrapScope is set to 'obj' when generating maplike or setlike helper
|
|
# functions, as we don't have access to the CallbackPreserveColor
|
|
# method.
|
|
CallbackMember.__init__(self,
|
|
[BuiltinTypes[IDLBuiltinType.Types.void], args],
|
|
name, descriptor, False,
|
|
wrapScope='obj')
|
|
# Wrap CallbackMember body code into a CGAbstractMethod to make
|
|
# generation easier.
|
|
self.implMethod = CGMaplikeOrSetlikeHelperFunctionGenerator.HelperFunction(
|
|
descriptor, name, self.args, self.body, needsBoolReturn)
|
|
|
|
def getCallSetup(self):
|
|
return dedent(
|
|
"""
|
|
MOZ_ASSERT(self);
|
|
AutoJSAPI jsapi;
|
|
jsapi.Init();
|
|
JSContext* cx = jsapi.cx();
|
|
// It's safe to use UnprivilegedJunkScopeOrWorkerGlobal here because
|
|
// all we want is to wrap into _some_ scope and then unwrap to find
|
|
// the reflector, and wrapping has no side-effects.
|
|
JSAutoCompartment tempCompartment(cx, binding_detail::UnprivilegedJunkScopeOrWorkerGlobal());
|
|
JS::Rooted<JS::Value> v(cx);
|
|
if(!ToJSValue(cx, self, &v)) {
|
|
aRv.Throw(NS_ERROR_UNEXPECTED);
|
|
return%s;
|
|
}
|
|
// This is a reflector, but due to trying to name things
|
|
// similarly across method generators, it's called obj here.
|
|
JS::Rooted<JSObject*> obj(cx);
|
|
obj = js::UncheckedUnwrap(&v.toObject(), /* stopAtWindowProxy = */ false);
|
|
JSAutoCompartment reflectorCompartment(cx, obj);
|
|
""" % self.getDefaultRetval())
|
|
|
|
def getArgs(self, returnType, argList):
|
|
# We don't need the context or the value. We'll generate those instead.
|
|
args = CGNativeMember.getArgs(self, returnType, argList)
|
|
# Prepend a pointer to the binding object onto the arguments
|
|
return [Argument(self.descriptorProvider.nativeType + "*", "self")] + args
|
|
|
|
def getResultConversion(self):
|
|
if self.needsBoolReturn:
|
|
return "return aRetVal;\n"
|
|
return "return;\n"
|
|
|
|
def getRvalDecl(self):
|
|
if self.needsBoolReturn:
|
|
return "bool aRetVal;\n"
|
|
return ""
|
|
|
|
def getArgcDecl(self):
|
|
# Don't need argc for anything.
|
|
return None
|
|
|
|
def getDefaultRetval(self):
|
|
if self.needsBoolReturn:
|
|
return " false"
|
|
return ""
|
|
|
|
def getCall(self):
|
|
return CGMaplikeOrSetlikeMethodGenerator(self.descriptorProvider,
|
|
self.maplikeOrSetlike,
|
|
self.name.lower(),
|
|
helperImpl=self).define()
|
|
|
|
def getPrettyName(self):
|
|
return self.name
|
|
|
|
def declare(self):
|
|
return self.implMethod.declare()
|
|
|
|
def define(self):
|
|
return self.implMethod.define()
|
|
|
|
|
|
class CGMaplikeOrSetlikeHelperGenerator(CGNamespace):
|
|
"""
|
|
Declares and defines convenience methods for accessing backing objects on
|
|
setlike/maplike interface. Generates function signatures, un/packs
|
|
backing objects from slot, etc.
|
|
"""
|
|
def __init__(self, descriptor, maplikeOrSetlike):
|
|
self.descriptor = descriptor
|
|
# Since iterables are folded in with maplike/setlike, make sure we've
|
|
# got the right type here.
|
|
assert maplikeOrSetlike.isMaplike() or maplikeOrSetlike.isSetlike()
|
|
self.maplikeOrSetlike = maplikeOrSetlike
|
|
self.namespace = "%sHelpers" % (self.maplikeOrSetlike.maplikeOrSetlikeOrIterableType.title())
|
|
self.helpers = [
|
|
CGMaplikeOrSetlikeHelperFunctionGenerator(descriptor,
|
|
maplikeOrSetlike,
|
|
"Clear"),
|
|
CGMaplikeOrSetlikeHelperFunctionGenerator(descriptor,
|
|
maplikeOrSetlike,
|
|
"Delete",
|
|
needsKeyArg=True,
|
|
needsBoolReturn=True),
|
|
CGMaplikeOrSetlikeHelperFunctionGenerator(descriptor,
|
|
maplikeOrSetlike,
|
|
"Has",
|
|
needsKeyArg=True,
|
|
needsBoolReturn=True)]
|
|
if self.maplikeOrSetlike.isMaplike():
|
|
self.helpers.append(
|
|
CGMaplikeOrSetlikeHelperFunctionGenerator(descriptor,
|
|
maplikeOrSetlike,
|
|
"Set",
|
|
needsKeyArg=True,
|
|
needsValueArg=True))
|
|
else:
|
|
assert(self.maplikeOrSetlike.isSetlike())
|
|
self.helpers.append(
|
|
CGMaplikeOrSetlikeHelperFunctionGenerator(descriptor,
|
|
maplikeOrSetlike,
|
|
"Add",
|
|
needsKeyArg=True))
|
|
CGNamespace.__init__(self, self.namespace, CGList(self.helpers))
|
|
|
|
|
|
class CGIterableMethodGenerator(CGGeneric):
|
|
"""
|
|
Creates methods for iterable interfaces. Unwrapping/wrapping
|
|
will be taken care of by the usual method generation machinery in
|
|
CGMethodCall/CGPerSignatureCall. Functionality is filled in here instead of
|
|
using CGCallGenerator.
|
|
"""
|
|
def __init__(self, descriptor, iterable, methodName):
|
|
if methodName == "forEach":
|
|
CGGeneric.__init__(self, fill(
|
|
"""
|
|
if (!JS::IsCallable(arg0)) {
|
|
ThrowErrorMessage(cx, MSG_NOT_CALLABLE, "Argument 1 of ${ifaceName}.forEach");
|
|
return false;
|
|
}
|
|
JS::AutoValueArray<3> callArgs(cx);
|
|
callArgs[2].setObject(*obj);
|
|
JS::Rooted<JS::Value> ignoredReturnVal(cx);
|
|
for (size_t i = 0; i < self->GetIterableLength(); ++i) {
|
|
if (!ToJSValue(cx, self->GetValueAtIndex(i), callArgs[0])) {
|
|
return false;
|
|
}
|
|
if (!ToJSValue(cx, self->GetKeyAtIndex(i), callArgs[1])) {
|
|
return false;
|
|
}
|
|
if (!JS::Call(cx, arg1, arg0, JS::HandleValueArray(callArgs),
|
|
&ignoredReturnVal)) {
|
|
return false;
|
|
}
|
|
}
|
|
""",
|
|
ifaceName=descriptor.interface.identifier.name))
|
|
return
|
|
CGGeneric.__init__(self, fill(
|
|
"""
|
|
typedef ${iterClass} itrType;
|
|
RefPtr<itrType> result(new itrType(self,
|
|
itrType::IterableIteratorType::${itrMethod},
|
|
&${ifaceName}IteratorBinding::Wrap));
|
|
""",
|
|
iterClass=iteratorNativeType(descriptor),
|
|
ifaceName=descriptor.interface.identifier.name,
|
|
itrMethod=methodName.title()))
|
|
|
|
|
|
class GlobalGenRoots():
|
|
"""
|
|
Roots for global codegen.
|
|
|
|
To generate code, call the method associated with the target, and then
|
|
call the appropriate define/declare method.
|
|
"""
|
|
|
|
@staticmethod
|
|
def GeneratedAtomList(config):
|
|
# Atom enum
|
|
dictionaries = config.dictionaries
|
|
|
|
structs = []
|
|
|
|
def memberToAtomCacheMember(binaryNameFor, m):
|
|
binaryMemberName = binaryNameFor(m.identifier.name)
|
|
return ClassMember(CGDictionary.makeIdName(binaryMemberName),
|
|
"PinnedStringId", visibility="public")
|
|
|
|
def buildAtomCacheStructure(idlobj, binaryNameFor, members):
|
|
classMembers = [memberToAtomCacheMember(binaryNameFor, m)
|
|
for m in members]
|
|
structName = idlobj.identifier.name + "Atoms"
|
|
return (structName,
|
|
CGWrapper(CGClass(structName,
|
|
bases=None,
|
|
isStruct=True,
|
|
members=classMembers), post='\n'))
|
|
|
|
for dict in dictionaries:
|
|
if len(dict.members) == 0:
|
|
continue
|
|
|
|
structs.append(buildAtomCacheStructure(dict, lambda x: x, dict.members))
|
|
|
|
for d in (config.getDescriptors(isJSImplemented=True) +
|
|
config.getDescriptors(isCallback=True)):
|
|
members = [m for m in d.interface.members if m.isAttr() or m.isMethod()]
|
|
if d.interface.isJSImplemented() and d.interface.ctor():
|
|
# We'll have an __init() method.
|
|
members.append(FakeMember('__init'))
|
|
if len(members) == 0:
|
|
continue
|
|
|
|
structs.append(buildAtomCacheStructure(d.interface,
|
|
lambda x: d.binaryNameFor(x),
|
|
members))
|
|
|
|
structs.sort()
|
|
generatedStructs = [struct for structName, struct in structs]
|
|
structNames = [structName for structName, struct in structs]
|
|
|
|
mainStruct = CGWrapper(CGClass("PerThreadAtomCache",
|
|
bases=[ClassBase(structName) for structName in structNames],
|
|
isStruct=True),
|
|
post='\n')
|
|
|
|
structs = CGList(generatedStructs + [mainStruct])
|
|
|
|
# Wrap all of that in our namespaces.
|
|
curr = CGNamespace.build(['mozilla', 'dom'],
|
|
CGWrapper(structs, pre='\n'))
|
|
curr = CGWrapper(curr, post='\n')
|
|
|
|
# Add include statement for PinnedStringId.
|
|
declareIncludes = ['mozilla/dom/BindingUtils.h']
|
|
curr = CGHeaders([], [], [], [], declareIncludes, [], 'GeneratedAtomList',
|
|
curr)
|
|
|
|
# Add include guards.
|
|
curr = CGIncludeGuard('GeneratedAtomList', curr)
|
|
|
|
# Add the auto-generated comment.
|
|
curr = CGWrapper(curr, pre=AUTOGENERATED_WARNING_COMMENT)
|
|
|
|
# Done.
|
|
return curr
|
|
|
|
@staticmethod
|
|
def GeneratedEventList(config):
|
|
eventList = CGList([])
|
|
for generatedEvent in config.generatedEvents:
|
|
eventList.append(CGGeneric(declare=("GENERATED_EVENT(%s)\n" % generatedEvent)))
|
|
return eventList
|
|
|
|
@staticmethod
|
|
def PrototypeList(config):
|
|
|
|
# Prototype ID enum.
|
|
descriptorsWithPrototype = config.getDescriptors(hasInterfacePrototypeObject=True)
|
|
protos = [d.name for d in descriptorsWithPrototype]
|
|
idEnum = CGNamespacedEnum('id', 'ID', ['_ID_Start'] + protos,
|
|
[0, '_ID_Start'])
|
|
idEnum = CGList([idEnum])
|
|
|
|
def fieldSizeAssert(amount, jitInfoField, message):
|
|
maxFieldValue = "(uint64_t(1) << (sizeof(((JSJitInfo*)nullptr)->%s) * 8))" % jitInfoField
|
|
return CGGeneric(declare="static_assert(%s < %s, \"%s\");\n\n"
|
|
% (amount, maxFieldValue, message))
|
|
|
|
idEnum.append(fieldSizeAssert("id::_ID_Count", "protoID",
|
|
"Too many prototypes!"))
|
|
|
|
# Wrap all of that in our namespaces.
|
|
idEnum = CGNamespace.build(['mozilla', 'dom', 'prototypes'],
|
|
CGWrapper(idEnum, pre='\n'))
|
|
idEnum = CGWrapper(idEnum, post='\n')
|
|
|
|
curr = CGList([CGGeneric(define="#include <stdint.h>\n\n"),
|
|
idEnum])
|
|
|
|
# Let things know the maximum length of the prototype chain.
|
|
maxMacroName = "MAX_PROTOTYPE_CHAIN_LENGTH"
|
|
maxMacro = CGGeneric(declare="#define " + maxMacroName + " " + str(config.maxProtoChainLength))
|
|
curr.append(CGWrapper(maxMacro, post='\n\n'))
|
|
curr.append(fieldSizeAssert(maxMacroName, "depth",
|
|
"Some inheritance chain is too long!"))
|
|
|
|
# Constructor ID enum.
|
|
constructors = [d.name for d in config.getDescriptors(hasInterfaceObject=True)]
|
|
idEnum = CGNamespacedEnum('id', 'ID', ['_ID_Start'] + constructors,
|
|
['prototypes::id::_ID_Count', '_ID_Start'])
|
|
|
|
# Wrap all of that in our namespaces.
|
|
idEnum = CGNamespace.build(['mozilla', 'dom', 'constructors'],
|
|
CGWrapper(idEnum, pre='\n'))
|
|
idEnum = CGWrapper(idEnum, post='\n')
|
|
|
|
curr.append(idEnum)
|
|
|
|
# Named properties object enum.
|
|
namedPropertiesObjects = [d.name for d in config.getDescriptors(hasNamedPropertiesObject=True)]
|
|
idEnum = CGNamespacedEnum('id', 'ID', ['_ID_Start'] + namedPropertiesObjects,
|
|
['constructors::id::_ID_Count', '_ID_Start'])
|
|
|
|
# Wrap all of that in our namespaces.
|
|
idEnum = CGNamespace.build(['mozilla', 'dom', 'namedpropertiesobjects'],
|
|
CGWrapper(idEnum, pre='\n'))
|
|
idEnum = CGWrapper(idEnum, post='\n')
|
|
|
|
curr.append(idEnum)
|
|
|
|
traitsDecls = [CGGeneric(declare=dedent("""
|
|
template <prototypes::ID PrototypeID>
|
|
struct PrototypeTraits;
|
|
"""))]
|
|
traitsDecls.extend(CGPrototypeTraitsClass(d) for d in descriptorsWithPrototype)
|
|
|
|
ifaceNamesWithProto = [d.interface.identifier.name
|
|
for d in descriptorsWithPrototype]
|
|
traitsDecls.append(CGStringTable("NamesOfInterfacesWithProtos",
|
|
ifaceNamesWithProto))
|
|
|
|
traitsDecl = CGNamespace.build(['mozilla', 'dom'],
|
|
CGList(traitsDecls))
|
|
|
|
curr.append(traitsDecl)
|
|
|
|
# Add include guards.
|
|
curr = CGIncludeGuard('PrototypeList', curr)
|
|
|
|
# Add the auto-generated comment.
|
|
curr = CGWrapper(curr, pre=AUTOGENERATED_WARNING_COMMENT)
|
|
|
|
# Done.
|
|
return curr
|
|
|
|
@staticmethod
|
|
def RegisterBindings(config):
|
|
|
|
curr = CGList([CGGlobalNamesString(config), CGRegisterGlobalNames(config)])
|
|
|
|
# Wrap all of that in our namespaces.
|
|
curr = CGNamespace.build(['mozilla', 'dom'],
|
|
CGWrapper(curr, post='\n'))
|
|
curr = CGWrapper(curr, post='\n')
|
|
|
|
# Add the includes
|
|
defineIncludes = [CGHeaders.getDeclarationFilename(desc.interface)
|
|
for desc in config.getDescriptors(hasInterfaceObject=True,
|
|
isExposedInWindow=True,
|
|
register=True)]
|
|
defineIncludes.append('mozilla/dom/WebIDLGlobalNameHash.h')
|
|
defineIncludes.extend([CGHeaders.getDeclarationFilename(desc.interface)
|
|
for desc in config.getDescriptors(isNavigatorProperty=True,
|
|
register=True)])
|
|
curr = CGHeaders([], [], [], [], [], defineIncludes, 'RegisterBindings',
|
|
curr)
|
|
|
|
# Add include guards.
|
|
curr = CGIncludeGuard('RegisterBindings', curr)
|
|
|
|
# Done.
|
|
return curr
|
|
|
|
@staticmethod
|
|
def RegisterWorkerBindings(config):
|
|
|
|
curr = CGRegisterWorkerBindings(config)
|
|
|
|
# Wrap all of that in our namespaces.
|
|
curr = CGNamespace.build(['mozilla', 'dom'],
|
|
CGWrapper(curr, post='\n'))
|
|
curr = CGWrapper(curr, post='\n')
|
|
|
|
# Add the includes
|
|
defineIncludes = [CGHeaders.getDeclarationFilename(desc.interface)
|
|
for desc in config.getDescriptors(hasInterfaceObject=True,
|
|
register=True,
|
|
isExposedInAnyWorker=True)]
|
|
|
|
curr = CGHeaders([], [], [], [], [], defineIncludes,
|
|
'RegisterWorkerBindings', curr)
|
|
|
|
# Add include guards.
|
|
curr = CGIncludeGuard('RegisterWorkerBindings', curr)
|
|
|
|
# Done.
|
|
return curr
|
|
|
|
@staticmethod
|
|
def RegisterWorkerDebuggerBindings(config):
|
|
|
|
curr = CGRegisterWorkerDebuggerBindings(config)
|
|
|
|
# Wrap all of that in our namespaces.
|
|
curr = CGNamespace.build(['mozilla', 'dom'],
|
|
CGWrapper(curr, post='\n'))
|
|
curr = CGWrapper(curr, post='\n')
|
|
|
|
# Add the includes
|
|
defineIncludes = [CGHeaders.getDeclarationFilename(desc.interface)
|
|
for desc in config.getDescriptors(hasInterfaceObject=True,
|
|
register=True,
|
|
isExposedInWorkerDebugger=True)]
|
|
|
|
curr = CGHeaders([], [], [], [], [], defineIncludes,
|
|
'RegisterWorkerDebuggerBindings', curr)
|
|
|
|
# Add include guards.
|
|
curr = CGIncludeGuard('RegisterWorkerDebuggerBindings', curr)
|
|
|
|
# Done.
|
|
return curr
|
|
|
|
@staticmethod
|
|
def RegisterWorkletBindings(config):
|
|
|
|
curr = CGRegisterWorkletBindings(config)
|
|
|
|
# Wrap all of that in our namespaces.
|
|
curr = CGNamespace.build(['mozilla', 'dom'],
|
|
CGWrapper(curr, post='\n'))
|
|
curr = CGWrapper(curr, post='\n')
|
|
|
|
# Add the includes
|
|
defineIncludes = [CGHeaders.getDeclarationFilename(desc.interface)
|
|
for desc in config.getDescriptors(hasInterfaceObject=True,
|
|
register=True,
|
|
isExposedInAnyWorklet=True)]
|
|
|
|
curr = CGHeaders([], [], [], [], [], defineIncludes,
|
|
'RegisterWorkletBindings', curr)
|
|
|
|
# Add include guards.
|
|
curr = CGIncludeGuard('RegisterWorkletBindings', curr)
|
|
|
|
# Done.
|
|
return curr
|
|
|
|
@staticmethod
|
|
def ResolveSystemBinding(config):
|
|
|
|
curr = CGResolveSystemBinding(config)
|
|
|
|
# Wrap all of that in our namespaces.
|
|
curr = CGNamespace.build(['mozilla', 'dom'],
|
|
CGWrapper(curr, post='\n'))
|
|
curr = CGWrapper(curr, post='\n')
|
|
|
|
# Add the includes
|
|
defineIncludes = [CGHeaders.getDeclarationFilename(desc.interface)
|
|
for desc in config.getDescriptors(hasInterfaceObject=True,
|
|
register=True,
|
|
isExposedInSystemGlobals=True)]
|
|
defineIncludes.append("nsThreadUtils.h") # For NS_IsMainThread
|
|
defineIncludes.append("js/Id.h") # For jsid
|
|
defineIncludes.append("mozilla/dom/BindingUtils.h") # AtomizeAndPinJSString
|
|
|
|
curr = CGHeaders([], [], [], [], [], defineIncludes,
|
|
'ResolveSystemBinding', curr)
|
|
|
|
# Add include guards.
|
|
curr = CGIncludeGuard('ResolveSystemBinding', curr)
|
|
|
|
# Done.
|
|
return curr
|
|
|
|
@staticmethod
|
|
def UnionTypes(config):
|
|
unionTypes = UnionsForFile(config, None)
|
|
(includes, implincludes, declarations,
|
|
traverseMethods, unlinkMethods,
|
|
unionStructs) = UnionTypes(unionTypes, config)
|
|
|
|
unions = CGList(traverseMethods +
|
|
unlinkMethods +
|
|
[CGUnionStruct(t, config) for t in unionStructs] +
|
|
[CGUnionStruct(t, config, True) for t in unionStructs],
|
|
"\n")
|
|
|
|
includes.add("mozilla/OwningNonNull.h")
|
|
includes.add("mozilla/dom/UnionMember.h")
|
|
includes.add("mozilla/dom/BindingDeclarations.h")
|
|
# BindingUtils.h is only needed for SetToObject.
|
|
# If it stops being inlined or stops calling CallerSubsumes
|
|
# both this bit and the bit in CGBindingRoot can be removed.
|
|
includes.add("mozilla/dom/BindingUtils.h")
|
|
implincludes.add("mozilla/dom/PrimitiveConversions.h")
|
|
|
|
# Wrap all of that in our namespaces.
|
|
curr = CGNamespace.build(['mozilla', 'dom'], unions)
|
|
|
|
curr = CGWrapper(curr, post='\n')
|
|
|
|
builder = ForwardDeclarationBuilder()
|
|
for className, isStruct in declarations:
|
|
builder.add(className, isStruct=isStruct)
|
|
|
|
curr = CGList([builder.build(), curr], "\n")
|
|
|
|
curr = CGHeaders([], [], [], [], includes, implincludes, 'UnionTypes',
|
|
curr)
|
|
|
|
# Add include guards.
|
|
curr = CGIncludeGuard('UnionTypes', curr)
|
|
|
|
# Done.
|
|
return curr
|
|
|
|
@staticmethod
|
|
def UnionConversions(config):
|
|
unionTypes = []
|
|
for l in config.unionsPerFilename.itervalues():
|
|
unionTypes.extend(l)
|
|
unionTypes.sort(key=lambda u: u.name)
|
|
headers, unions = UnionConversions(unionTypes,
|
|
config)
|
|
|
|
# Wrap all of that in our namespaces.
|
|
curr = CGNamespace.build(['mozilla', 'dom'], unions)
|
|
|
|
curr = CGWrapper(curr, post='\n')
|
|
|
|
headers.update(["nsDebug.h", "mozilla/dom/UnionTypes.h"])
|
|
curr = CGHeaders([], [], [], [], headers, [], 'UnionConversions', curr)
|
|
|
|
# Add include guards.
|
|
curr = CGIncludeGuard('UnionConversions', curr)
|
|
|
|
# Done.
|
|
return curr
|
|
|
|
|
|
# Code generator for simple events
|
|
class CGEventGetter(CGNativeMember):
|
|
def __init__(self, descriptor, attr):
|
|
ea = descriptor.getExtendedAttributes(attr, getter=True)
|
|
CGNativeMember.__init__(self, descriptor, attr,
|
|
CGSpecializedGetter.makeNativeName(descriptor,
|
|
attr),
|
|
(attr.type, []),
|
|
ea,
|
|
resultNotAddRefed=not attr.type.isSequence())
|
|
self.body = self.getMethodBody()
|
|
|
|
def getArgs(self, returnType, argList):
|
|
if 'infallible' not in self.extendedAttrs:
|
|
raise TypeError("Event code generator does not support [Throws]!")
|
|
if not self.member.isAttr():
|
|
raise TypeError("Event code generator does not support methods")
|
|
if self.member.isStatic():
|
|
raise TypeError("Event code generators does not support static attributes")
|
|
return CGNativeMember.getArgs(self, returnType, argList)
|
|
|
|
def getMethodBody(self):
|
|
type = self.member.type
|
|
memberName = CGDictionary.makeMemberName(self.member.identifier.name)
|
|
if ((type.isPrimitive() and type.tag() in builtinNames) or
|
|
type.isEnum() or
|
|
type.isPromise() or
|
|
type.isGeckoInterface()):
|
|
return "return " + memberName + ";\n"
|
|
if type.isDOMString() or type.isByteString() or type.isUSVString():
|
|
return "aRetVal = " + memberName + ";\n"
|
|
if type.isSpiderMonkeyInterface() or type.isObject():
|
|
return fill(
|
|
"""
|
|
if (${memberName}) {
|
|
JS::ExposeObjectToActiveJS(${memberName});
|
|
}
|
|
aRetVal.set(${memberName});
|
|
return;
|
|
""",
|
|
memberName=memberName)
|
|
if type.isAny():
|
|
return fill(
|
|
"""
|
|
${selfName}(aRetVal);
|
|
""",
|
|
selfName=self.name)
|
|
if type.isUnion():
|
|
return "aRetVal = " + memberName + ";\n"
|
|
if type.isSequence():
|
|
return "aRetVal = " + memberName + ";\n"
|
|
raise TypeError("Event code generator does not support this type!")
|
|
|
|
def declare(self, cgClass):
|
|
if getattr(self.member, "originatingInterface",
|
|
cgClass.descriptor.interface) != cgClass.descriptor.interface:
|
|
return ""
|
|
return CGNativeMember.declare(self, cgClass)
|
|
|
|
def define(self, cgClass):
|
|
if getattr(self.member, "originatingInterface",
|
|
cgClass.descriptor.interface) != cgClass.descriptor.interface:
|
|
return ""
|
|
return CGNativeMember.define(self, cgClass)
|
|
|
|
|
|
class CGEventSetter(CGNativeMember):
|
|
def __init__(self):
|
|
raise TypeError("Event code generator does not support setters!")
|
|
|
|
|
|
class CGEventMethod(CGNativeMember):
|
|
def __init__(self, descriptor, method, signature, isConstructor, breakAfter=True):
|
|
self.isInit = False
|
|
|
|
CGNativeMember.__init__(self, descriptor, method,
|
|
CGSpecializedMethod.makeNativeName(descriptor,
|
|
method),
|
|
signature,
|
|
descriptor.getExtendedAttributes(method),
|
|
breakAfter=breakAfter,
|
|
variadicIsSequence=True)
|
|
self.originalArgs = list(self.args)
|
|
|
|
iface = descriptor.interface
|
|
allowed = isConstructor
|
|
if not allowed and iface.getExtendedAttribute("LegacyEventInit"):
|
|
# Allow it, only if it fits the initFooEvent profile exactly
|
|
# We could check the arg types but it's not worth the effort.
|
|
if (method.identifier.name == "init" + iface.identifier.name and
|
|
signature[1][0].type.isDOMString() and
|
|
signature[1][1].type.isBoolean() and
|
|
signature[1][2].type.isBoolean() and
|
|
# -3 on the left to ignore the type, bubbles, and cancelable parameters
|
|
# -1 on the right to ignore the .trusted property which bleeds through
|
|
# here because it is [Unforgeable].
|
|
len(signature[1]) - 3 == len(filter(lambda x: x.isAttr(), iface.members)) - 1):
|
|
allowed = True
|
|
self.isInit = True
|
|
|
|
if not allowed:
|
|
raise TypeError("Event code generator does not support methods!")
|
|
|
|
def getArgs(self, returnType, argList):
|
|
args = [self.getArg(arg) for arg in argList]
|
|
return args
|
|
|
|
def getArg(self, arg):
|
|
decl, ref = self.getArgType(arg.type,
|
|
arg.canHaveMissingValue(),
|
|
"Variadic" if arg.variadic else False)
|
|
if ref:
|
|
decl = CGWrapper(decl, pre="const ", post="&")
|
|
|
|
name = arg.identifier.name
|
|
name = "a" + name[0].upper() + name[1:]
|
|
return Argument(decl.define(), name)
|
|
|
|
def declare(self, cgClass):
|
|
if self.isInit:
|
|
constructorForNativeCaller = ""
|
|
else:
|
|
self.args = list(self.originalArgs)
|
|
self.args.insert(0, Argument("mozilla::dom::EventTarget*", "aOwner"))
|
|
constructorForNativeCaller = CGNativeMember.declare(self, cgClass)
|
|
|
|
self.args = list(self.originalArgs)
|
|
if needCx(None, self.arguments(), [], considerTypes=True, static=True):
|
|
self.args.insert(0, Argument("JSContext*", "aCx"))
|
|
if not self.isInit:
|
|
self.args.insert(0, Argument("const GlobalObject&", "aGlobal"))
|
|
self.args.append(Argument('ErrorResult&', 'aRv'))
|
|
return constructorForNativeCaller + CGNativeMember.declare(self, cgClass)
|
|
|
|
def defineInit(self, cgClass):
|
|
iface = self.descriptorProvider.interface
|
|
members = ""
|
|
while iface.identifier.name != "Event":
|
|
i = 3 # Skip the boilerplate args: type, bubble,s cancelable.
|
|
for m in iface.members:
|
|
if m.isAttr():
|
|
# We need to initialize all the member variables that do
|
|
# not come from Event.
|
|
if getattr(m, "originatingInterface",
|
|
iface).identifier.name == "Event":
|
|
continue
|
|
name = CGDictionary.makeMemberName(m.identifier.name)
|
|
members += "%s = %s;\n" % (name, self.args[i].name)
|
|
i += 1
|
|
iface = iface.parent
|
|
|
|
self.body = fill(
|
|
"""
|
|
InitEvent(${typeArg}, ${bubblesArg}, ${cancelableArg});
|
|
${members}
|
|
""",
|
|
typeArg=self.args[0].name,
|
|
bubblesArg=self.args[1].name,
|
|
cancelableArg=self.args[2].name,
|
|
members=members)
|
|
|
|
return CGNativeMember.define(self, cgClass)
|
|
|
|
def define(self, cgClass):
|
|
self.args = list(self.originalArgs)
|
|
if self.isInit:
|
|
return self.defineInit(cgClass)
|
|
members = ""
|
|
holdJS = ""
|
|
iface = self.descriptorProvider.interface
|
|
while iface.identifier.name != "Event":
|
|
for m in self.descriptorProvider.getDescriptor(iface.identifier.name).interface.members:
|
|
if m.isAttr():
|
|
# We initialize all the other member variables in the
|
|
# Constructor except those ones coming from the Event.
|
|
if getattr(m, "originatingInterface",
|
|
cgClass.descriptor.interface).identifier.name == "Event":
|
|
continue
|
|
name = CGDictionary.makeMemberName(m.identifier.name)
|
|
if m.type.isSequence():
|
|
# For sequences we may not be able to do a simple
|
|
# assignment because the underlying types may not match.
|
|
# For example, the argument can be a
|
|
# Sequence<OwningNonNull<SomeInterface>> while our
|
|
# member is an nsTArray<RefPtr<SomeInterface>>. So
|
|
# use AppendElements, which is actually a template on
|
|
# the incoming type on nsTArray and does the right thing
|
|
# for this case.
|
|
target = name
|
|
source = "%s.%s" % (self.args[1].name, name)
|
|
sequenceCopy = "e->%s.AppendElements(%s);\n"
|
|
if m.type.nullable():
|
|
sequenceCopy = CGIfWrapper(
|
|
CGGeneric(sequenceCopy),
|
|
"!%s.IsNull()" % source).define()
|
|
target += ".SetValue()"
|
|
source += ".Value()"
|
|
members += sequenceCopy % (target, source)
|
|
elif m.type.isSpiderMonkeyInterface():
|
|
srcname = "%s.%s" % (self.args[1].name, name)
|
|
if m.type.nullable():
|
|
members += fill(
|
|
"""
|
|
if (${srcname}.IsNull()) {
|
|
e->${varname} = nullptr;
|
|
} else {
|
|
e->${varname} = ${srcname}.Value().Obj();
|
|
}
|
|
""",
|
|
varname=name,
|
|
srcname=srcname)
|
|
else:
|
|
members += fill(
|
|
"""
|
|
e->${varname}.set(${srcname}.Obj());
|
|
""",
|
|
varname=name, srcname=srcname)
|
|
else:
|
|
members += "e->%s = %s.%s;\n" % (name, self.args[1].name, name)
|
|
if m.type.isAny() or m.type.isObject() or m.type.isSpiderMonkeyInterface():
|
|
holdJS = "mozilla::HoldJSObjects(e.get());\n"
|
|
iface = iface.parent
|
|
|
|
self.body = fill(
|
|
"""
|
|
RefPtr<${nativeType}> e = new ${nativeType}(aOwner);
|
|
bool trusted = e->Init(aOwner);
|
|
e->InitEvent(${eventType}, ${eventInit}.mBubbles, ${eventInit}.mCancelable);
|
|
$*{members}
|
|
e->SetTrusted(trusted);
|
|
e->SetComposed(${eventInit}.mComposed);
|
|
$*{holdJS}
|
|
return e.forget();
|
|
""",
|
|
nativeType=self.descriptorProvider.nativeType.split('::')[-1],
|
|
eventType=self.args[0].name,
|
|
eventInit=self.args[1].name,
|
|
members=members,
|
|
holdJS=holdJS)
|
|
|
|
self.args.insert(0, Argument("mozilla::dom::EventTarget*", "aOwner"))
|
|
constructorForNativeCaller = CGNativeMember.define(self, cgClass) + "\n"
|
|
self.args = list(self.originalArgs)
|
|
self.body = fill(
|
|
"""
|
|
nsCOMPtr<mozilla::dom::EventTarget> owner = do_QueryInterface(aGlobal.GetAsSupports());
|
|
return Constructor(owner, ${arg0}, ${arg1});
|
|
""",
|
|
arg0=self.args[0].name,
|
|
arg1=self.args[1].name)
|
|
if needCx(None, self.arguments(), [], considerTypes=True, static=True):
|
|
self.args.insert(0, Argument("JSContext*", "aCx"))
|
|
self.args.insert(0, Argument("const GlobalObject&", "aGlobal"))
|
|
self.args.append(Argument('ErrorResult&', 'aRv'))
|
|
return constructorForNativeCaller + CGNativeMember.define(self, cgClass)
|
|
|
|
|
|
class CGEventClass(CGBindingImplClass):
|
|
"""
|
|
Codegen for the actual Event class implementation for this descriptor
|
|
"""
|
|
def __init__(self, descriptor):
|
|
CGBindingImplClass.__init__(self, descriptor, CGEventMethod, CGEventGetter, CGEventSetter, False, "WrapObjectInternal")
|
|
members = []
|
|
extraMethods = []
|
|
for m in descriptor.interface.members:
|
|
if m.isAttr():
|
|
if m.type.isAny():
|
|
# Add a getter that doesn't need a JSContext. Note that we
|
|
# don't need to do this if our originating interface is not
|
|
# the descriptor's interface, because in that case we
|
|
# wouldn't generate the getter that _does_ need a JSContext
|
|
# either.
|
|
extraMethods.append(
|
|
ClassMethod(
|
|
CGSpecializedGetter.makeNativeName(descriptor, m),
|
|
"void",
|
|
[Argument("JS::MutableHandle<JS::Value>",
|
|
"aRetVal")],
|
|
const=True,
|
|
body=fill(
|
|
"""
|
|
JS::ExposeValueToActiveJS(${memberName});
|
|
aRetVal.set(${memberName});
|
|
""",
|
|
memberName=CGDictionary.makeMemberName(m.identifier.name))))
|
|
if getattr(m, "originatingInterface",
|
|
descriptor.interface) != descriptor.interface:
|
|
continue
|
|
nativeType = self.getNativeTypeForIDLType(m.type).define()
|
|
members.append(ClassMember(CGDictionary.makeMemberName(m.identifier.name),
|
|
nativeType,
|
|
visibility="private",
|
|
body="body"))
|
|
|
|
parent = self.descriptor.interface.parent
|
|
self.parentType = self.descriptor.getDescriptor(parent.identifier.name).nativeType.split('::')[-1]
|
|
baseDeclarations = fill(
|
|
"""
|
|
public:
|
|
NS_DECL_ISUPPORTS_INHERITED
|
|
NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(${nativeType}, ${parentType})
|
|
protected:
|
|
virtual ~${nativeType}();
|
|
explicit ${nativeType}(mozilla::dom::EventTarget* aOwner);
|
|
|
|
""",
|
|
nativeType=self.descriptor.nativeType.split('::')[-1],
|
|
parentType=self.parentType)
|
|
|
|
className = descriptor.nativeType.split('::')[-1]
|
|
asConcreteTypeMethod = ClassMethod("As%s" % className,
|
|
"%s*" % className,
|
|
[],
|
|
virtual=True,
|
|
body="return this;\n",
|
|
breakAfterReturnDecl=" ",
|
|
override=True)
|
|
extraMethods.append(asConcreteTypeMethod)
|
|
|
|
CGClass.__init__(self, className,
|
|
bases=[ClassBase(self.parentType)],
|
|
methods=extraMethods+self.methodDecls,
|
|
members=members,
|
|
extradeclarations=baseDeclarations)
|
|
|
|
def getWrapObjectBody(self):
|
|
return "return %sBinding::Wrap(aCx, this, aGivenProto);\n" % self.descriptor.name
|
|
|
|
def implTraverse(self):
|
|
retVal = ""
|
|
for m in self.descriptor.interface.members:
|
|
# Unroll the type so we pick up sequences of interfaces too.
|
|
if m.isAttr() and idlTypeNeedsCycleCollection(m.type):
|
|
retVal += (" NS_IMPL_CYCLE_COLLECTION_TRAVERSE(" +
|
|
CGDictionary.makeMemberName(m.identifier.name) +
|
|
")\n")
|
|
return retVal
|
|
|
|
def implUnlink(self):
|
|
retVal = ""
|
|
for m in self.descriptor.interface.members:
|
|
if m.isAttr():
|
|
name = CGDictionary.makeMemberName(m.identifier.name)
|
|
# Unroll the type so we pick up sequences of interfaces too.
|
|
if idlTypeNeedsCycleCollection(m.type):
|
|
retVal += " NS_IMPL_CYCLE_COLLECTION_UNLINK(" + name + ")\n"
|
|
elif m.type.isAny():
|
|
retVal += " tmp->" + name + ".setUndefined();\n"
|
|
elif m.type.isObject() or m.type.isSpiderMonkeyInterface():
|
|
retVal += " tmp->" + name + " = nullptr;\n"
|
|
return retVal
|
|
|
|
def implTrace(self):
|
|
retVal = ""
|
|
for m in self.descriptor.interface.members:
|
|
if m.isAttr():
|
|
name = CGDictionary.makeMemberName(m.identifier.name)
|
|
if m.type.isAny() or m.type.isObject() or m.type.isSpiderMonkeyInterface():
|
|
retVal += " NS_IMPL_CYCLE_COLLECTION_TRACE_JS_MEMBER_CALLBACK(" + name + ")\n"
|
|
elif typeNeedsRooting(m.type):
|
|
raise TypeError("Need to implement tracing for event "
|
|
"member of type %s" % m.type)
|
|
return retVal
|
|
|
|
def define(self):
|
|
dropJS = ""
|
|
for m in self.descriptor.interface.members:
|
|
if m.isAttr():
|
|
member = CGDictionary.makeMemberName(m.identifier.name)
|
|
if m.type.isAny():
|
|
dropJS += member + " = JS::UndefinedValue();\n"
|
|
elif m.type.isObject() or m.type.isSpiderMonkeyInterface():
|
|
dropJS += member + " = nullptr;\n"
|
|
if dropJS != "":
|
|
dropJS += "mozilla::DropJSObjects(this);\n"
|
|
# Just override CGClass and do our own thing
|
|
nativeType = self.descriptor.nativeType.split('::')[-1]
|
|
ctorParams = ("aOwner, nullptr, nullptr" if self.parentType == "Event"
|
|
else "aOwner")
|
|
|
|
classImpl = fill(
|
|
"""
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_CLASS(${nativeType})
|
|
|
|
NS_IMPL_ADDREF_INHERITED(${nativeType}, ${parentType})
|
|
NS_IMPL_RELEASE_INHERITED(${nativeType}, ${parentType})
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(${nativeType}, ${parentType})
|
|
$*{traverse}
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(${nativeType}, ${parentType})
|
|
$*{trace}
|
|
NS_IMPL_CYCLE_COLLECTION_TRACE_END
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(${nativeType}, ${parentType})
|
|
$*{unlink}
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
|
|
|
|
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(${nativeType})
|
|
NS_INTERFACE_MAP_END_INHERITING(${parentType})
|
|
|
|
${nativeType}::${nativeType}(mozilla::dom::EventTarget* aOwner)
|
|
: ${parentType}(${ctorParams})
|
|
{
|
|
}
|
|
|
|
${nativeType}::~${nativeType}()
|
|
{
|
|
$*{dropJS}
|
|
}
|
|
|
|
""",
|
|
ifaceName=self.descriptor.name,
|
|
nativeType=nativeType,
|
|
ctorParams=ctorParams,
|
|
parentType=self.parentType,
|
|
traverse=self.implTraverse(),
|
|
unlink=self.implUnlink(),
|
|
trace=self.implTrace(),
|
|
dropJS=dropJS)
|
|
return classImpl + CGBindingImplClass.define(self)
|
|
|
|
def getNativeTypeForIDLType(self, type):
|
|
if type.isPrimitive() and type.tag() in builtinNames:
|
|
nativeType = CGGeneric(builtinNames[type.tag()])
|
|
if type.nullable():
|
|
nativeType = CGTemplatedType("Nullable", nativeType)
|
|
elif type.isEnum():
|
|
nativeType = CGGeneric(type.unroll().inner.identifier.name)
|
|
if type.nullable():
|
|
nativeType = CGTemplatedType("Nullable", nativeType)
|
|
elif type.isDOMString() or type.isUSVString():
|
|
nativeType = CGGeneric("nsString")
|
|
elif type.isByteString():
|
|
nativeType = CGGeneric("nsCString")
|
|
elif type.isPromise():
|
|
nativeType = CGGeneric("RefPtr<Promise>")
|
|
elif type.isGeckoInterface():
|
|
iface = type.unroll().inner
|
|
nativeType = self.descriptor.getDescriptor(
|
|
iface.identifier.name).nativeType
|
|
# Now trim off unnecessary namespaces
|
|
nativeType = nativeType.split("::")
|
|
if nativeType[0] == "mozilla":
|
|
nativeType.pop(0)
|
|
if nativeType[0] == "dom":
|
|
nativeType.pop(0)
|
|
nativeType = CGWrapper(CGGeneric("::".join(nativeType)), pre="RefPtr<", post=">")
|
|
elif type.isAny():
|
|
nativeType = CGGeneric("JS::Heap<JS::Value>")
|
|
elif type.isObject() or type.isSpiderMonkeyInterface():
|
|
nativeType = CGGeneric("JS::Heap<JSObject*>")
|
|
elif type.isUnion():
|
|
nativeType = CGGeneric(CGUnionStruct.unionTypeDecl(type, True))
|
|
elif type.isSequence():
|
|
if type.nullable():
|
|
innerType = type.inner.inner
|
|
else:
|
|
innerType = type.inner
|
|
if (not innerType.isPrimitive() and not innerType.isEnum() and
|
|
not innerType.isDOMString() and not innerType.isByteString() and
|
|
not innerType.isPromise() and not innerType.isGeckoInterface()):
|
|
raise TypeError("Don't know how to properly manage GC/CC for "
|
|
"event member of type %s" %
|
|
type)
|
|
nativeType = CGTemplatedType(
|
|
"nsTArray",
|
|
self.getNativeTypeForIDLType(innerType))
|
|
if type.nullable():
|
|
nativeType = CGTemplatedType("Nullable", nativeType)
|
|
else:
|
|
raise TypeError("Don't know how to declare event member of type %s" %
|
|
type)
|
|
return nativeType
|
|
|
|
|
|
class CGEventRoot(CGThing):
|
|
def __init__(self, config, interfaceName):
|
|
descriptor = config.getDescriptor(interfaceName)
|
|
|
|
self.root = CGWrapper(CGEventClass(descriptor),
|
|
pre="\n", post="\n")
|
|
|
|
self.root = CGNamespace.build(["mozilla", "dom"], self.root)
|
|
|
|
self.root = CGList([CGClassForwardDeclare("JSContext", isStruct=True),
|
|
self.root])
|
|
|
|
parent = descriptor.interface.parent.identifier.name
|
|
|
|
# Throw in our #includes
|
|
self.root = CGHeaders(
|
|
[descriptor],
|
|
[],
|
|
[],
|
|
[],
|
|
[
|
|
config.getDescriptor(parent).headerFile,
|
|
"mozilla/Attributes.h",
|
|
"mozilla/ErrorResult.h",
|
|
"mozilla/dom/%sBinding.h" % interfaceName,
|
|
'mozilla/dom/BindingUtils.h',
|
|
],
|
|
[
|
|
"%s.h" % interfaceName,
|
|
"js/GCAPI.h",
|
|
'mozilla/dom/Nullable.h',
|
|
],
|
|
"", self.root, config)
|
|
|
|
# And now some include guards
|
|
self.root = CGIncludeGuard(interfaceName, self.root)
|
|
|
|
self.root = CGWrapper(
|
|
self.root,
|
|
pre=(AUTOGENERATED_WITH_SOURCE_WARNING_COMMENT %
|
|
os.path.basename(descriptor.interface.filename())))
|
|
|
|
self.root = CGWrapper(self.root, pre=dedent("""
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim:set ts=2 sw=2 sts=2 et cindent: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
"""))
|
|
|
|
def declare(self):
|
|
return self.root.declare()
|
|
|
|
def define(self):
|
|
return self.root.define()
|