# 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):
return "(DOM_INSTANCE_RESERVED_SLOTS + %d)" % member.slotIndex
def toStringBool(arg):
return str(not not arg).lower()
def toBindingNamespace(arg):
return re.sub("((_workers)?$)", "Binding\\1", arg)
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.isMozMap():
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 ""
if self.descriptor.concrete and self.descriptor.proxy:
resolveOwnProperty = "ResolveOwnProperty"
enumerateOwnProperties = "EnumerateOwnProperties"
elif self.descriptor.needsXrayResolveHooks():
resolveOwnProperty = "ResolveOwnPropertyViaResolve"
enumerateOwnProperties = "EnumerateOwnPropertiesViaGetOwnPropertyNames"
else:
resolveOwnProperty = "nullptr"
enumerateOwnProperties = "nullptr"
if self.properties.hasNonChromeOnly():
regular = "&sNativeProperties"
else:
regular = "nullptr"
if self.properties.hasChromeOnly():
chrome = "&sChromeOnlyNativeProperties"
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')
return fill(
"""
const NativePropertyHooks sNativePropertyHooks[] = { {
${resolveOwnProperty},
${enumerateOwnProperties},
{ ${regular}, ${chrome} },
${prototypeID},
${constructorID},
${parentHooks}
} };
""",
resolveOwnProperty=resolveOwnProperty,
enumerateOwnProperties=enumerateOwnProperties,
regular=regular,
chrome=chrome,
prototypeID=prototypeID,
constructorID=constructorID,
parentHooks=parentHooks)
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},
GetParentObject<${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):
traceHook = 'nullptr'
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 | "
classExtensionAndObjectOps = fill(
"""
{
false, /* isWrappedNative */
nullptr, /* weakmapKeyDelegateOp */
${objectMoved} /* objectMovedOp */
},
JS_NULL_OBJECT_OPS
""",
objectMoved=objectMovedHook)
if self.descriptor.isGlobal():
classFlags += "JSCLASS_DOM_GLOBAL | JSCLASS_GLOBAL_FLAGS_WITH_SLOTS(DOM_GLOBAL_SLOTS)"
traceHook = "JS_GlobalObjectTraceHook"
reservedSlots = "JSCLASS_GLOBAL_APPLICATION_SLOTS"
if self.descriptor.interface.identifier.name == "Window":
classExtensionAndObjectOps = fill(
"""
{
false, /* isWrappedNative */
nullptr, /* weakmapKeyDelegateOp */
${objectMoved} /* objectMovedOp */
},
{
nullptr, /* lookupProperty */
nullptr, /* defineProperty */
nullptr, /* hasProperty */
nullptr, /* getProperty */
nullptr, /* setProperty */
nullptr, /* getOwnPropertyDescriptor */
nullptr, /* deleteProperty */
nullptr, /* watch */
nullptr, /* unwatch */
nullptr, /* getElements */
nullptr, /* enumerate */
nullptr, /* funToString */
}
""",
objectMoved=objectMovedHook)
else:
classFlags += "JSCLASS_HAS_RESERVED_SLOTS(%d)" % slotCount
reservedSlots = slotCount
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 DOMJSClass Class = {
{ "${name}",
${flags},
${addProperty}, /* addProperty */
nullptr, /* delProperty */
nullptr, /* getProperty */
nullptr, /* setProperty */
${enumerate}, /* enumerate */
${resolve}, /* resolve */
${mayResolve}, /* mayResolve */
${finalize}, /* finalize */
${call}, /* call */
nullptr, /* hasInstance */
nullptr, /* construct */
${trace}, /* trace */
JS_NULL_CLASS_SPEC,
$*{classExtensionAndObjectOps}
},
$*{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,
classExtensionAndObjectOps=classExtensionAndObjectOps,
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 DOMJSClass Class = {
PROXY_CLASS_WITH_EXT("${name}",
${flags},
PROXY_MAKE_EXT(false, /* isWrappedNative */
${objectMoved})),
$*{descriptor}
};
""",
name=self.descriptor.interface.identifier.name,
flags=" | ".join(flags),
objectMoved=objectMovedHook,
descriptor=DOMClass(self.descriptor))
def PrototypeIDAndDepth(descriptor):
prototypeID = "prototypes::id::"
if descriptor.interface.hasInterfacePrototypeObject():
prototypeID += descriptor.interface.identifier.name
if descriptor.workers:
prototypeID += "_workers"
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_GetArrayPrototype"
elif descriptor.interface.getExtendedAttribute("ExceptionClass"):
protoGetter = "GetErrorPrototype"
elif descriptor.interface.isIteratorInterface():
protoGetter = "GetIteratorPrototype"
else:
protoGetter = "JS_GetObjectPrototype"
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"
if self.descriptor.hasUnforgeableMembers:
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 PrototypeClass = {
{
"${name}Prototype",
JSCLASS_IS_DOMIFACEANDPROTOJSCLASS | JSCLASS_HAS_RESERVED_SLOTS(${slotCount}),
nullptr, /* addProperty */
nullptr, /* delProperty */
nullptr, /* getProperty */
nullptr, /* setProperty */
nullptr, /* enumerate */
nullptr, /* resolve */
nullptr, /* mayResolve */
nullptr, /* finalize */
nullptr, /* call */
nullptr, /* hasInstance */
nullptr, /* construct */
nullptr, /* trace */
JS_NULL_CLASS_SPEC,
JS_NULL_CLASS_EXT,
JS_NULL_OBJECT_OPS
},
${type},
${hooks},
"[object ${name}Prototype]",
${prototypeID},
${depth},
${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):
"""
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:
parentIfaceName = parentInterface.identifier.name
parentDesc = descriptor.getDescriptor(parentIfaceName)
prefix = toBindingNamespace(parentDesc.name)
protoGetter = prefix + "::GetConstructorObject"
protoHandleGetter = prefix + "::GetConstructorObjectHandle"
else:
protoGetter = "JS_GetFunctionPrototype"
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():
ctorname = CONSTRUCT_HOOK_NAME
else:
ctorname = "ThrowingConstructor"
if NeedsGeneratedHasInstance(self.descriptor):
hasinstance = HASINSTANCE_HOOK_NAME
elif self.descriptor.interface.hasInterfacePrototypeObject():
hasinstance = "InterfaceHasInstance"
else:
hasinstance = "nullptr"
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)
return fill(
"""
static const DOMIfaceAndProtoJSClass InterfaceObjectClass = {
{
"Function",
JSCLASS_IS_DOMIFACEANDPROTOJSCLASS | JSCLASS_HAS_RESERVED_SLOTS(${slotCount}),
nullptr, /* addProperty */
nullptr, /* delProperty */
nullptr, /* getProperty */
nullptr, /* setProperty */
nullptr, /* enumerate */
nullptr, /* resolve */
nullptr, /* mayResolve */
nullptr, /* finalize */
${ctorname}, /* call */
${hasInstance}, /* hasInstance */
${ctorname}, /* construct */
nullptr, /* trace */
JS_NULL_CLASS_SPEC,
JS_NULL_CLASS_EXT,
{
nullptr, /* lookupProperty */
nullptr, /* defineProperty */
nullptr, /* hasProperty */
nullptr, /* getProperty */
nullptr, /* setProperty */
nullptr, /* getOwnPropertyDescriptor */
nullptr, /* deleteProperty */
nullptr, /* watch */
nullptr, /* unwatch */
nullptr, /* getElements */
nullptr, /* enumerate */
InterfaceObjectToString, /* funToString */
}
},
eInterface,
${hooks},
"function ${name}() {\\n [native code]\\n}",
${prototypeID},
${depth},
${protoGetter}
};
""",
slotCount=slotCount,
ctorname=ctorname,
hasInstance=hasinstance,
hooks=NativePropertyHooks(self.descriptor),
name=self.descriptor.interface.identifier.name,
prototypeID=prototypeID,
depth=depth,
protoGetter=protoGetter)
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):
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)
def getRelevantProviders(descriptor, config):
if descriptor is not None:
return [descriptor]
# Do both the non-worker and worker versions
return [
config.getDescriptorProvider(False),
config.getDescriptorProvider(True)
]
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)
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())
# Now find all the things we'll need as arguments because we
# need to wrap or unwrap them.
bindingHeaders = set()
declareIncludes = set(declareIncludes)
def addHeadersForType((t, descriptor, dictionary)):
"""
Add the relevant headers for this type. We use descriptor and
dictionary, if passed, to decide what to do with interface types.
"""
assert not descriptor or not dictionary
# 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():
if len(config.filenamesPerUnion[unrolled.name]) > 1:
headerSet.add("mozilla/dom/UnionTypes.h")
else:
headerSet.add(self.getDeclarationFilename(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.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:
providers = getRelevantProviders(descriptor, config)
for p in providers:
try:
typeDesc = p.getDescriptor(unrolled.inner.identifier.name)
except NoSuchDescriptorError:
continue
# 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.isMozMap():
if dictionary or jsImplementedDescriptors:
declareIncludes.add("mozilla/dom/MozMap.h")
else:
bindingHeaders.add("mozilla/dom/MozMap.h")
# Also add headers for the type the MozMap is
# parametrized over, if needed.
addHeadersForType((t.inner, descriptor, 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")
# Now for non-callback descriptors make sure we include any
# headers needed by Func declarations.
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
def addHeaderForFunc(func):
if func is None:
return
# Include the right class header, which we can only do
# if this is a class member function.
if 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")
for m in desc.interface.members:
addHeaderForFunc(PropertyDefiner.getStringAttr(m, "Func"))
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])
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, since
# they'll be needed for convenience functions
addHeadersForType((desc.interface.maplikeOrSetlikeOrIterable.keyType,
desc, None))
if desc.interface.maplikeOrSetlikeOrIterable.valueType:
addHeadersForType((desc.interface.maplikeOrSetlikeOrIterable.valueType,
desc, None))
for d in dictionaries:
if d.parent:
declareIncludes.add(self.getDeclarationFilename(d.parent))
bindingHeaders.add(self.getDeclarationFilename(d))
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')
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 tuples each containing two elements (type and descriptor)
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 tuples, each containing two
elements: a union type and a descriptor. 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, descriptor) in unionTypes:
name = str(t)
if name not in unionStructs:
providers = getRelevantProviders(descriptor, config)
unionStructs[name] = t
def addHeadersForType(f):
if f.nullable():
headers.add("mozilla/dom/Nullable.h")
isSequence = f.isSequence()
f = f.unroll()
if f.isInterface():
if f.isSpiderMonkeyInterface():
headers.add("jsfriendapi.h")
headers.add("mozilla/dom/TypedArray.h")
else:
for p in providers:
try:
typeDesc = p.getDescriptor(f.inner.identifier.name)
except NoSuchDescriptorError:
continue
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.isMozMap():
headers.add("mozilla/dom/MozMap.h")
# And add headers for the type we're parametrized over
addHeadersForType(f.inner)
if len(config.filenamesPerUnion[t.name]) > 1:
implheaders.add("mozilla/dom/UnionTypes.h")
else:
implheaders.add(CGHeaders.getDeclarationFilename(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, descriptor) in unionTypes:
name = str(t)
if name not in unionConversions:
providers = getRelevantProviders(descriptor, config)
unionConversions[name] = CGUnionConversionStruct(t, providers[0])
def addHeadersForType(f, providers):
f = f.unroll()
if f.isInterface():
if f.isSpiderMonkeyInterface():
headers.add("jsfriendapi.h")
headers.add("mozilla/dom/TypedArray.h")
elif f.inner.isExternal():
providers = getRelevantProviders(descriptor, config)
for p in providers:
try:
typeDesc = p.getDescriptor(f.inner.identifier.name)
except NoSuchDescriptorError:
continue
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.isMozMap():
headers.add("mozilla/dom/MozMap.h")
# And the internal type of the MozMap
addHeadersForType(f.inner, providers)
if len(config.filenamesPerUnion[t.name]) == 1:
headers.add(CGHeaders.getDeclarationFilename(t))
for f in t.flatMemberTypes:
addHeadersForType(f, providers)
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 Class.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
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}");
}
JS::Rooted<JSObject*> desiredProto(cx);
if (!GetDesiredProto(cx, args, &desiredProto)) {
return false;
}
""",
chromeOnlyCheck=chromeOnlyCheck,
ctorName=ctorName)
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 CGConstructNavigatorObjectHelper(CGAbstractStaticMethod):
"""
Construct a new JS-implemented WebIDL DOM object, for use on navigator.
"""
def __init__(self, descriptor):
name = "ConstructNavigatorObjectHelper"
args = [Argument('JSContext*', 'cx'),
Argument('GlobalObject&', 'global'),
Argument('ErrorResult&', 'aRv')]
rtype = 'already_AddRefed<%s>' % descriptor.name
CGAbstractStaticMethod.__init__(self, descriptor, name, rtype, args)
def definition_body(self):
return genConstructorBody(self.descriptor)
class CGConstructNavigatorObject(CGAbstractMethod):
"""
Wrap a JS-implemented WebIDL object into a JS value, for use on navigator.
"""
def __init__(self, descriptor):
name = 'ConstructNavigatorObject'
args = [Argument('JSContext*', 'aCx'), Argument('JS::Handle<JSObject*>', 'aObj')]
CGAbstractMethod.__init__(self, descriptor, name, 'JSObject*', 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 fill(
"""
GlobalObject global(aCx, aObj);
if (global.Failed()) {
return nullptr;
}
ErrorResult rv;
JS::Rooted<JS::Value> v(aCx);
{ // Scope to make sure |result| goes out of scope while |v| is rooted
RefPtr<mozilla::dom::${descriptorName}> result = ConstructNavigatorObjectHelper(aCx, global, rv);
if (rv.MaybeSetPendingException(aCx)) {
return nullptr;
}
if (!GetOrCreateDOMReflector(aCx, result, &v)) {
//XXX Assertion disabled for now, see bug 991271.
MOZ_ASSERT(true || JS_IsExceptionPending(aCx));
return nullptr;
}
}
return &v.toObject();
""",
descriptorName=self.descriptor.name)
class CGClassConstructHookHolder(CGGeneric):
def __init__(self, descriptor):
if descriptor.interface.ctor():
constructHook = CONSTRUCT_HOOK_NAME
else:
constructHook = "ThrowingConstructor"
CGGeneric.__init__(self, fill(
"""
static const JSNativeHolder ${CONSTRUCT_HOOK_NAME}_holder = {
${constructHook},
${hooks}
};
""",
CONSTRUCT_HOOK_NAME=CONSTRUCT_HOOK_NAME,
constructHook=constructHook,
hooks=NativePropertyHooks(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 },
prototypes::id::${name},
${constructorID},
nullptr
};
static const NamedConstructor namedConstructors[] = {
$*{namedConstructors}
{ nullptr, { nullptr, nullptr }, 0 }
};
""",
name=self.descriptor.name,
constructorID=constructorID,
namedConstructors=namedConstructors)
class CGClassHasInstanceHook(CGAbstractStaticMethod):
def __init__(self, descriptor):
args = [Argument('JSContext*', 'cx'),
Argument('JS::Handle<JSObject*>', 'obj'),
Argument('JS::MutableHandle<JS::Value>', 'vp'),
Argument('bool*', 'bp')]
assert descriptor.interface.hasInterfaceObject()
CGAbstractStaticMethod.__init__(self, descriptor, HASINSTANCE_HOOK_NAME,
'bool', args)
def define(self):
if not NeedsGeneratedHasInstance(self.descriptor):
return ""
return CGAbstractStaticMethod.define(self)
def definition_body(self):
return self.generate_code()
def generate_code(self):
header = dedent("""
if (!vp.isObject()) {
*bp = false;
return true;
}
JS::Rooted<JSObject*> instance(cx, &vp.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, obj, instance, bp);
if (!ok || *bp) {
return ok;
}
// FIXME Limit this to chrome by checking xpc::AccessCheck::isChrome(obj).
nsISupports* native =
nsContentUtils::XPConnect()->GetNativeOfWrapper(cx,
js::UncheckedUnwrap(instance, /* stopAtWindowProxy = */ false));
nsCOMPtr<nsIDOM${name}> qiResult = do_QueryInterface(native);
*bp = !!qiResult;
return true;
""",
nativeType=self.descriptor.nativeType,
name=self.descriptor.interface.identifier.name))
hasInstanceCode = dedent("""
const DOMJSClass* domClass = GetDOMClass(js::UncheckedUnwrap(instance, /* stopAtWindowProxy = */ false));
*bp = false;
if (!domClass) {
// Not a DOM object, so certainly not an instance of this interface
return true;
}
""")
if self.descriptor.interface.identifier.name == "ChromeWindow":
setBp = "*bp = UnwrapDOMObject<nsGlobalWindow>(js::UncheckedUnwrap(instance, /* stopAtWindowProxy = */ false))->IsChromeWindow()"
else:
setBp = "*bp = 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}) {
${setBp};
return true;
}
""",
name=iface.identifier.name,
setBp=setBp)
hasInstanceCode += "return true;\n"
return header + hasInstanceCode
def isChromeOnly(m):
return m.getExtendedAttribute("ChromeOnly")
def getAvailableInTestFunc(obj):
availableIn = obj.getExtendedAttribute("AvailableIn")
if availableIn is None:
return None
assert isinstance(availableIn, list) and len(availableIn) == 1
if availableIn[0] == "PrivilegedApps":
return "IsInPrivilegedApp"
if availableIn[0] == "CertifiedApps":
return "IsInCertifiedApp"
raise TypeError("Unknown AvailableIn value '%s'" % availableIn[0])
class MemberCondition:
"""
An object representing the condition for a member to actually be
exposed. Any of pref, func, and available can be None. If not
None, they should be strings that have the pref name (for "pref")
or function name (for "func" and "available").
"""
def __init__(self, pref, func, available=None, checkAnyPermissions=None, checkAllPermissions=None):
assert pref is None or isinstance(pref, str)
assert func is None or isinstance(func, str)
assert available is None or isinstance(available, str)
assert checkAnyPermissions is None or isinstance(checkAnyPermissions, int)
assert checkAllPermissions is None or isinstance(checkAllPermissions, int)
self.pref = pref
def toFuncPtr(val):
if val is None:
return "nullptr"
return "&" + val
self.func = toFuncPtr(func)
self.available = toFuncPtr(available)
if checkAnyPermissions is None:
self.checkAnyPermissions = "nullptr"
else:
self.checkAnyPermissions = "anypermissions_%i" % checkAnyPermissions
if checkAllPermissions is None:
self.checkAllPermissions = "nullptr"
else:
self.checkAllPermissions = "allpermissions_%i" % checkAllPermissions
def __eq__(self, other):
return (self.pref == other.pref and self.func == other.func and
self.available == other.available and
self.checkAnyPermissions == other.checkAnyPermissions and
self.checkAllPermissions == other.checkAllPermissions)
def __ne__(self, other):
return not self.__eq__(other)
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):
return MemberCondition(PropertyDefiner.getStringAttr(interfaceMember,
"Pref"),
PropertyDefiner.getStringAttr(interfaceMember,
"Func"),
getAvailableInTestFunc(interfaceMember),
descriptor.checkAnyPermissionsIndicesForMembers.get(interfaceMember.identifier.name),
descriptor.checkAllPermissionsIndicesForMembers.get(interfaceMember.identifier.name))
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 = []
prefableSpecs = []
prefableTemplate = ' { true, %s, %s, %s, %s, &%s[%d] }'
prefCacheTemplate = '&%s[%d].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
prefableSpecs.append(prefableTemplate %
(condition.func,
condition.available,
condition.checkAnyPermissions,
condition.checkAllPermissions,
name + "_specs", 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 pref
switchToCondition(self, curCondition)
lastCondition = curCondition
# And the actual spec
specs.append(specFormatter(getDataTuple(member)))
specs.append(specTerminator)
prefableSpecs.append(" { false, nullptr }")
specType = "const " + specType
arrays = fill(
"""
static ${specType} ${name}_specs[] = {
${specs}
};
// Can't be const because the pref-enabled boolean needs to be writable
static Prefable<${specType}> ${name}[] = {
${prefableSpecs}
};
""",
specType=specType,
name=name,
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 isMaybeExposedIn(member, descriptor):
# All we can say for sure is that if this is a worker descriptor
# and member is not exposed in any worker, then it's not exposed.
return not descriptor.workers or member.isExposedInAnyWorker()
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.slotIndex 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() and
isMaybeExposedIn(m, descriptor)]
else:
methods = []
self.chrome = []
self.regular = []
for m in methods:
if m.identifier.name == 'queryInterface':
if self.descriptor.workers:
continue
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(None, 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 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() and
isMaybeExposedIn(descriptor.operations['IndexedGetter'], descriptor)):
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(None, None)
})
# Output an @@iterator for generated iterator interfaces. This should
# not be necessary, but
# https://bugzilla.mozilla.org/show_bug.cgi?id=1091945 means that
# %IteratorPrototype%[@@iterator] is a broken puppy.
if (not static and
not unforgeable and
descriptor.interface.isIteratorInterface()):
self.regular.append({
"name": "@@iterator",
"methodInfo": False,
"selfHostedName": "IteratorIdentity",
"length": 0,
"flags": "0",
"condition": MemberCondition(None, None)
})
# Generate the maplike/setlike iterator, if one wasn't already
# generated by a method. If we already have an @@iterator symbol, fail.
if descriptor.interface.maplikeOrSetlikeOrIterable:
if hasIterator(methods, self.regular):
raise TypeError("Cannot have maplike/setlike/iterable interface with "
"other members that generate @@iterator "
"on interface %s, such as indexed getters "
"or aliased functions." %
self.descriptor.interface.identifier.name)
for m in methods:
if (m.isMaplikeOrSetlikeOrIterableMethod() and
(((m.maplikeOrSetlikeOrIterable.isMaplike() or
(m.maplikeOrSetlikeOrIterable.isIterable() and
m.maplikeOrSetlikeOrIterable.hasValueType())) and
m.identifier.name == "entries") or
(((m.maplikeOrSetlikeOrIterable.isSetlike() or
(m.maplikeOrSetlikeOrIterable.isIterable() and
not m.maplikeOrSetlikeOrIterable.hasValueType()))) and
m.identifier.name == "values"))):
self.regular.append({
"name": "@@iterator",
"methodName": m.identifier.name,
"length": methodLength(m),
"flags": "0",
"condition": PropertyDefiner.getControllingCondition(m,
descriptor),
})
break
if not static:
stringifier = descriptor.operations['Stringifier']
if (stringifier and
unforgeable == MemberIsUnforgeable(stringifier, descriptor) and
isMaybeExposedIn(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) and
isMaybeExposedIn(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',
"nativeName": "UnforgeableValueOf",
"methodInfo": False,
"length": 0,
"flags": "JSPROP_ENUMERATE", # readonly/permanent added
# automatically.
"condition": MemberCondition(None, None)
})
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(None, None)
})
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(None, None)
})
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
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
isMaybeExposedIn(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):
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() and
isMaybeExposedIn(m, descriptor)]
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()
nativeProps = []
for array in properties.arrayNames():
propertyArray = getattr(properties, array)
if check(propertyArray):
if propertyArray.usedForXrays():
ids = "%(name)s_ids"
else:
ids = "nullptr"
props = "%(name)s, " + ids + ", %(name)s_specs"
props = (props % {'name': propertyArray.variableName(chrome)})
else:
props = "nullptr, nullptr, nullptr"
nativeProps.append(CGGeneric(props))
iteratorAliasIndex = -1
for index, item in enumerate(properties.methods.regular):
if item.get("hasIteratorAlias"):
iteratorAliasIndex = index
break
nativeProps.append(CGGeneric(str(iteratorAliasIndex)))
return CGWrapper(CGIndenter(CGList(nativeProps, ",\n")),
pre="static const NativeProperties %s = {\n" % name,
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):
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
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, aGlobal)"
(protoGetter, protoHandleGetter) = InterfaceObjectProtoGetter(self.descriptor)
if protoHandleGetter is None:
getConstructorProto = "aCx, " + protoGetter
constructorProtoType = "Rooted"
else:
getConstructorProto = protoHandleGetter
constructorProtoType = "Handle"
getConstructorProto += "(aCx, aGlobal)"
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 (needInterfaceObject and
self.descriptor.needsConstructHookHolder()):
constructHookHolder = "&" + CONSTRUCT_HOOK_NAME + "_holder"
else:
constructHookHolder = "nullptr"
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 = "&PrototypeClass.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 = "&InterfaceObjectClass.mBase"
interfaceCache = "&aProtoAndIfaceCache.EntrySlotOrCreate(constructors::id::%s)" % self.descriptor.name
else:
# We don't have slots to store the named constructors.
assert len(self.descriptor.interface.namedConstructors) == 0
interfaceClass = "nullptr"
interfaceCache = "nullptr"
isGlobal = self.descriptor.isGlobal() is not None
if not isGlobal and self.properties.hasNonChromeOnly():
properties = "&sNativeProperties"
else:
properties = "nullptr"
if not isGlobal and self.properties.hasChromeOnly():
chromeProperties = "nsContentUtils::ThreadsafeIsCallerChrome() ? &sChromeOnlyNativeProperties : 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}, ${constructHookHolder}, ${constructArgs}, ${namedConstructors},
interfaceCache,
${properties},
${chromeProperties},
${name}, aDefineOnGlobal);
""",
protoClass=protoClass,
parentProto=parentProto,
protoCache=protoCache,
interfaceClass=interfaceClass,
constructHookHolder=constructHookHolder,
constructArgs=constructArgs,
namedConstructors=namedConstructors,
interfaceCache=interfaceCache,
properties=properties,
chromeProperties=chromeProperties,
name='"' + self.descriptor.interface.identifier.name + '"' if needInterfaceObject else "nullptr")
# If we fail after here, we must clear interface and prototype caches
# using this code: intermediate failure must not expose the interface in
# partially-constructed state. Note that every case after here needs an
# interface prototype object.
failureCode = dedent(
"""
*protoCache = nullptr;
if (interfaceCache) {
*interfaceCache = nullptr;
}
return;
""")
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, aGlobal);
if (!proto) {
$*{failureCode}
}
""",
failureCode=failureCode)),
CGGeneric("JS::Rooted<JS::Value> aliasedVal(aCx);\n\n")
] + [defineAliasesFor(m) for m in sorted(aliasedMembers)])
else:
defineAliases = None
if self.descriptor.hasUnforgeableMembers:
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.
#
# Also, for a global we can't use the global's class; just use
# nullpr and when we do the copy off the holder we'll take a slower
# path. This also means that we don't need to worry about matching
# the prototype.
if self.descriptor.proxy or self.descriptor.isGlobal():
holderClass = "nullptr"
holderProto = "nullptr"
else:
holderClass = "Class.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.name == "Promise":
speciesSetup = CGGeneric(fill(
"""
JS::Rooted<JSObject*> promiseConstructor(aCx, *interfaceCache);
JS::Rooted<jsid> species(aCx,
SYMBOL_TO_JSID(JS::GetWellKnownSymbol(aCx, JS::SymbolCode::species)));
if (!JS_DefinePropertyById(aCx, promiseConstructor, species, JS::UndefinedHandleValue,
JSPROP_SHARED, Promise::PromiseSpecies, nullptr)) {
$*{failureCode}
}
""",
failureCode=failureCode))
else:
speciesSetup = None
if (self.descriptor.interface.isOnGlobalProtoChain() and
needInterfacePrototypeObject):
makeProtoPrototypeImmutable = CGGeneric(fill(
"""
if (*${protoCache}) {
bool succeeded;
JS::Handle<JSObject*> prot = GetProtoObjectHandle(aCx, aGlobal);
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, CGGeneric(getConstructorProto), initIds,
prefCache, CGGeneric(call), defineAliases, unforgeableHolderSetup,
speciesSetup, 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'),
Argument('JS::Handle<JSObject*>', 'aGlobal')] + 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 */
if (!(js::GetObjectClass(aGlobal)->flags & JSCLASS_DOM_GLOBAL)) {
return nullptr;
}
/* Check to see whether the interface objects are already installed */
ProtoAndIfaceCache& protoAndIfaceCache = *GetProtoAndIfaceCache(aGlobal);
if (!protoAndIfaceCache.EntrySlotIfExists(${id})) {
CreateInterfaceObjects(aCx, aGlobal, 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.
*/
return JS::Handle<JSObject*>::fromMarkedLocation(protoAndIfaceCache.EntrySlotMustExist(${id}).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'),
Argument('JS::Handle<JSObject*>', 'aGlobal')])
def definition_body(self):
return "return GetProtoObjectHandle(aCx, aGlobal);\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'),
Argument('JS::Handle<JSObject*>', 'aGlobal')])
def definition_body(self):
return "return GetConstructorObjectHandle(aCx, aGlobal);\n"
class CGGetNamedPropertiesObjectMethod(CGAbstractStaticMethod):
def __init__(self, descriptor):
args = [Argument('JSContext*', 'aCx'),
Argument('JS::Handle<JSObject*>', 'aGlobal')]
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, aGlobal));
if (!parentProto) {
return nullptr;
}
""",
parent=toBindingNamespace(parentProtoName))
parentProto = "parentProto"
return fill(
"""
/* Make sure our global is sane. Hopefully we can remove this sometime */
if (!(js::GetObjectClass(aGlobal)->flags & JSCLASS_DOM_GLOBAL)) {
return nullptr;
}
/* Check to see whether the named properties object has already been created */
ProtoAndIfaceCache& protoAndIfaceCache = *GetProtoAndIfaceCache(aGlobal);
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 declare(self):
if self.descriptor.workers:
return ''
return CGAbstractMethod.declare(self)
def define(self):
if self.descriptor.workers:
return ''
return CGAbstractMethod.define(self)
def definition_body(self):
if len(self.descriptor.interface.namedConstructors) > 0:
getConstructor = dedent("""
JSObject* interfaceObject = GetConstructorObjectHandle(aCx, aGlobal, aDefineOnGlobal);
if (!interfaceObject) {
return nullptr;
}
for (unsigned slot = DOM_INTERFACE_SLOTS_BASE; slot < JSCLASS_RESERVED_SLOTS(&InterfaceObjectClass.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, aGlobal, aDefineOnGlobal);\n"
return getConstructor
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")
conditions = []
iface = self.descriptor.interface
if not iface.isExposedInWindow():
exposedInWindowCheck = dedent(
"""
MOZ_ASSERT(!NS_IsMainThread(), "Why did we even get called?");
""")
body.append(CGGeneric(exposedInWindowCheck))
if iface.isExposedInSomeButNotAllWorkers():
workerGlobals = sorted(iface.getWorkerExposureSet())
workerCondition = CGList((CGGeneric('strcmp(name, "%s")' % workerGlobal)
for workerGlobal in workerGlobals), " && ")
exposedInWorkerCheck = fill(
"""
const char* name = js::GetObjectClass(aObj)->name;
if (${workerCondition}) {
return false;
}
""", workerCondition=workerCondition.define())
exposedInWorkerCheck = CGGeneric(exposedInWorkerCheck)
if iface.isExposedInWindow():
exposedInWorkerCheck = CGIfWrapper(exposedInWorkerCheck,
"!NS_IsMainThread()")
body.append(exposedInWorkerCheck)
pref = iface.getExtendedAttribute("Pref")
if pref:
assert isinstance(pref, list) and len(pref) == 1
conditions.append('Preferences::GetBool("%s")' % pref[0])
if iface.getExtendedAttribute("ChromeOnly"):
conditions.append("nsContentUtils::ThreadsafeIsCallerChrome()")
func = iface.getExtendedAttribute("Func")
if func:
assert isinstance(func, list) and len(func) == 1
conditions.append("%s(aCx, aObj)" % func[0])
availableIn = getAvailableInTestFunc(iface)
if availableIn:
conditions.append("%s(aCx, aObj)" % availableIn)
checkAnyPermissions = self.descriptor.checkAnyPermissionsIndex
if checkAnyPermissions is not None:
conditions.append("CheckAnyPermissions(aCx, aObj, anypermissions_%i)" % checkAnyPermissions)
checkAllPermissions = self.descriptor.checkAllPermissionsIndex
if checkAllPermissions is not None:
conditions.append("CheckAllPermissions(aCx, aObj, allpermissions_%i)" % checkAllPermissions)
# We should really have some conditions
assert len(body) or len(conditions)
conditionsWrapper = ""
if len(conditions):
conditionsWrapper = CGWrapper(CGList((CGGeneric(cond) for cond in conditions),
" &&\n"),
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, &Class.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, Class.ToJSClass(), proto, aObject, aReflector);
if (!aReflector) {
return false;
}
""")
return objDecl + create
def InitUnforgeablePropertiesOnHolder(descriptor, properties, failureCode):
"""
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, unforgeableHolder, %s)) {
$*{failureCode}
}
""",
failureCode=failureCode)
defineUnforgeableMethods = fill(
"""
if (!DefineUnforgeableMethods(aCx, unforgeableHolder, %s)) {
$*{failureCode}
}
""",
failureCode=failureCode)
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 toJSON and 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, unforgeableHolder, toPrimitive,
JS::UndefinedHandleValue,
JSPROP_READONLY | JSPROP_PERMANENT) ||
!JS_DefineProperty(aCx, unforgeableHolder, "toJSON",
JS::UndefinedHandleValue,
JSPROP_READONLY | JSPROP_ENUMERATE | JSPROP_PERMANENT)) {
$*{failureCode}
}
""",
failureCode=failureCode)))
return CGWrapper(CGList(unforgeables), pre="\n")
def CopyUnforgeablePropertiesToInstance(descriptor, wrapperCache):
"""
Copy the unforgeable properties from the unforgeable holder for
this interface to the instance object we have.
"""
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.
"""))
]
if wrapperCache:
cleanup = dedent(
"""
aCache->ReleaseWrapper(aObject);
aCache->ClearWrapper();
""")
else:
cleanup = ""
# 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) {
$*{cleanup}
return false;
}
""",
cleanup=cleanup)))
obj = "expando"
else:
obj = "aReflector"
# We can't do the fast copy for globals, because we can't allocate the
# unforgeable holder for those with the right JSClass. Luckily, there
# aren't too many globals being created.
if descriptor.isGlobal():
copyFunc = "JS_CopyPropertiesFrom"
else:
copyFunc = "JS_InitializePropertiesFromCompatibleNativeObject"
copyCode.append(CGGeneric(fill(
"""
JS::Rooted<JSObject*> unforgeableHolder(aCx,
&js::GetReservedSlot(canonicalProto, DOM_INTERFACE_PROTO_SLOTS_BASE).toObject());
if (!${copyFunc}(aCx, ${obj}, unforgeableHolder)) {
$*{cleanup}
return false;
}
""",
copyFunc=copyFunc,
obj=obj,
cleanup=cleanup)))
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, wrapperCache):
"""
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 ""
if wrapperCache:
clearWrapper = dedent(
"""
aCache->ReleaseWrapper(aObject);
aCache->ClearWrapper();
""")
else:
clearWrapper = ""
return fill(
"""
if (!UpdateMemberSlots(aCx, aReflector, aObject)) {
$*{clearWrapper}
return false;
}
""",
clearWrapper=clearWrapper)
def DeclareProto():
"""
Declare the canonicalProto and proto we have for our wrapping operation.
"""
return dedent(
"""
JS::Handle<JSObject*> canonicalProto = GetProtoObjectHandle(aCx, global);
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"
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*> parent(aCx, WrapNativeParent(aCx, aObject->GetParentObject()));
if (!parent) {
return false;
}
// 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, parent);
JS::Rooted<JSObject*> global(aCx, js::GetGlobalForObjectCrossCompartment(parent));
$*{declareProto}
$*{createObject}
aCache->SetWrapper(aReflector);
$*{unforgeable}
$*{slots}
creator.InitializationSucceeded();
MOZ_ASSERT(aCache->GetWrapperPreserveColor() &&
aCache->GetWrapperPreserveColor() == aReflector);
// If proto != canonicalProto, we have to preserve our wrapper;
// otherwise we won't be able to properly recreate it later, since
// we won't know what proto to use. Note that we don't check
// aGivenProto here, since it's entirely possible (and even
// somewhat common) to have a non-null aGivenProto which is the
// same as canonicalProto.
if (proto != canonicalProto) {
$*{preserveWrapper}
}
return true;
""",
assertInheritance=AssertInheritanceChain(self.descriptor),
declareProto=DeclareProto(),
createObject=CreateBindingJSObject(self.descriptor, self.properties),
unforgeable=CopyUnforgeablePropertiesToInstance(self.descriptor, True),
slots=InitMemberSlots(self.descriptor, True),
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):
return fill(
"""
$*{assertions}
JS::Rooted<JSObject*> global(aCx, JS::CurrentGlobalOrNull(aCx));
$*{declareProto}
$*{createObject}
$*{unforgeable}
$*{slots}
creator.InitializationSucceeded();
return true;
""",
assertions=AssertInheritanceChain(self.descriptor),
declareProto=DeclareProto(),
createObject=CreateBindingJSObject(self.descriptor, self.properties),
unforgeable=CopyUnforgeablePropertiesToInstance(self.descriptor, False),
slots=InitMemberSlots(self.descriptor, False))
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"
else:
properties = "nullptr"
if self.properties.hasChromeOnly():
chromeProperties = "nsContentUtils::ThreadsafeIsCallerChrome() ? &sChromeOnlyNativeProperties : nullptr"
else:
chromeProperties = "nullptr"
if self.descriptor.workers:
fireOnNewGlobal = """// XXXkhuey can't do this yet until workers can lazy resolve.
// JS_FireOnNewGlobalObject(aCx, aReflector);
"""
else:
fireOnNewGlobal = ""
if self.descriptor.hasUnforgeableMembers:
declareProto = "JS::Handle<JSObject*> canonicalProto =\n"
assertProto = (
"MOZ_ASSERT(canonicalProto &&\n"
" IsDOMIfaceAndProtoClass(js::GetObjectClass(canonicalProto)));\n")
else:
declareProto = ""
assertProto = ""
return fill(
"""
$*{assertions}
MOZ_ASSERT(ToSupportsIsOnPrimaryInheritanceChain(aObject, aCache),
"nsISupports must be on our primary inheritance chain");
$*{declareProto}
CreateGlobal<${nativeType}, GetProtoObjectHandle>(aCx,
aObject,
aCache,
Class.ToJSClass(),
aOptions,
aPrincipal,
aInitStandardClasses,
aReflector);
if (!aReflector) {
return false;
}
$*{assertProto}
// 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})) {
return false;
}
$*{unforgeable}
$*{slots}
$*{fireOnNewGlobal}
return true;
""",
assertions=AssertInheritanceChain(self.descriptor),
nativeType=self.descriptor.nativeType,
declareProto=declareProto,
assertProto=assertProto,
properties=properties,
chromeProperties=chromeProperties,
unforgeable=CopyUnforgeablePropertiesToInstance(self.descriptor, True),
slots=InitMemberSlots(self.descriptor, True),
fireOnNewGlobal=fireOnNewGlobal)
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
""",
slot=memberReservedSlot(m),
interface=self.descriptor.interface.identifier.name,
member=m.identifier.name)
body += "\nreturn true;\n"
return body
class CGClearCachedValueMethod(CGAbstractMethod):
def __init__(self, descriptor, member):
self.member = member
# If we're StoreInSlot, we'll need to call the getter
if member.getExtendedAttribute("StoreInSlot"):
args = [Argument('JSContext*', 'aCx')]
returnType = 'bool'
else:
args = []
returnType = 'void'
args.append(Argument(descriptor.nativeType + '*', 'aObject'))
name = MakeClearCachedValueNativeName(member)
CGAbstractMethod.__init__(self, descriptor, name, returnType, args)
def definition_body(self):
slotIndex = memberReservedSlot(self.member)
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 = ""
return fill(
"""
$*{declObj}
obj = aObject->GetWrapper();
if (!obj) {
return${noopRetval};
}
$*{saveMember}
js::SetReservedSlot(obj, ${slotIndex}, JS::UndefinedValue());
$*{regetMember}
""",
declObj=declObj,
noopRetval=noopRetval,
saveMember=saveMember,
slotIndex=slotIndex,
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 named by the "source" argument
based on the passed-in descriptor and storing it in a variable
called by the name in the "target" argument.
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, target, codeOnFailure,
exceptionCode=None, isCallbackReturnValue=False,
allowCrossOriginObj=False):
self.substitution = {
"type": descriptor.nativeType,
"protoID": "prototypes::id::" + descriptor.name,
"target": target,
"codeOnFailure": codeOnFailure,
}
if allowCrossOriginObj:
self.substitution["uncheckedObjDecl"] = (
"JS::Rooted<JSObject*> uncheckedObj(cx, js::UncheckedUnwrap(%s));\n" % source)
self.substitution["source"] = "uncheckedObj"
xpconnectUnwrap = dedent("""
nsresult rv;
{ // Scope for the JSAutoCompartment, because we only
// want to be in that compartment for the UnwrapArg call.
JS::Rooted<JSObject*> source(cx, ${source});
JSAutoCompartment ac(cx, ${source});
rv = UnwrapArg<${type}>(source, getter_AddRefs(objPtr));
}
""")
else:
self.substitution["uncheckedObjDecl"] = ""
self.substitution["source"] = source
xpconnectUnwrap = (
"JS::Rooted<JSObject*> source(cx, ${source});\n"
"nsresult rv = UnwrapArg<${type}>(source, 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}))) {
nsCOMPtr<nsIGlobalObject> contentGlobal;
if (!GetContentGlobalForJSImplementedObject(cx, Callback(), getter_AddRefs(contentGlobal))) {
$*{exceptionCode}
}
JS::Rooted<JSObject*> jsImplSourceObj(cx, ${source});
${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}
nsresult rv = UnwrapObject<${protoID}, ${type}>(${source}, ${target});
if (NS_FAILED(rv)) {
$*{codeOnFailure}
}
}
""",
**substitution)
class FailureFatalCastableObjectUnwrapper(CastableObjectUnwrapper):
"""
As CastableObjectUnwrapper, but defaulting to throwing if unwrapping fails
"""
def __init__(self, descriptor, source, target, exceptionCode,
isCallbackReturnValue, sourceDescription):
CastableObjectUnwrapper.__init__(
self, descriptor, source, 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)
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
${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.
${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 (char16_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()
return ("static const char16_t data[] = { %s };\n"
"%s(data, ArrayLength(data) - 1)" %
(", ".join(["'" + char + "'" for char in
defaultValue.value] + ["0"]),
method))
# 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", "MozMap"))
# 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.isArray():
raise TypeError("Can't handle array arguments yet")
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 nsAutoTarray to the right size
# will memmove its elements, but nsAutoTArrays 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),
"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.isMozMap():
assert not isEnforceRange and not isClamp
if failureCode is None:
notMozMap = ('ThrowErrorMessage(cx, MSG_NOT_OBJECT, "%s");\n'
"%s" % (firstCap(sourceDescription), exceptionCode))
else:
notMozMap = failureCode
nullable = type.nullable()
# Be very careful not to change "type": we need it later
if nullable:
valueType = type.inner.inner
else:
valueType = type.inner
valueInfo = getJSToNativeConversionInfo(
valueType, descriptorProvider, isMember="MozMap",
exceptionCode=exceptionCode, lenientFloatCode=lenientFloatCode,
isCallbackReturnValue=isCallbackReturnValue,
sourceDescription="value in %s" % sourceDescription,
nestingLevel=incrementNestingLevel())
if valueInfo.dealWithOptional:
raise TypeError("Shouldn't have optional things in MozMap")
if valueInfo.holderType is not None:
raise TypeError("Shouldn't need holders for MozMap")
typeName = CGTemplatedType("MozMap", valueInfo.declType)
mozMapType = typeName.define()
if nullable:
typeName = CGTemplatedType("Nullable", typeName)
mozMapRef = "${declName}.SetValue()"
else:
mozMapRef = "${declName}"
valueConversion = string.Template(valueInfo.template).substitute({
"val": "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}"
})
templateBody = fill(
"""
${mozMapType} &mozMap = ${mozMapRef};
JS::Rooted<JSObject*> mozMapObj(cx, &$${val}.toObject());
JS::Rooted<JS::IdVector> ids(cx, JS::IdVector(cx));
if (!JS_Enumerate(cx, mozMapObj, &ids)) {
$*{exceptionCode}
}
JS::Rooted<JS::Value> propNameValue(cx);
JS::Rooted<JS::Value> temp(cx);
JS::Rooted<jsid> curId(cx);
for (size_t i = 0; i < ids.length(); ++i) {
// Make sure we get the value before converting the name, since
// getting the value can trigger GC but our name is a dependent
// string.
curId = ids[i];
binding_detail::FakeString propName;
bool isSymbol;
if (!ConvertIdToString(cx, curId, propName, isSymbol) ||
(!isSymbol && !JS_GetPropertyById(cx, mozMapObj, curId, &temp))) {
$*{exceptionCode}
}
if (isSymbol) {
continue;
}
${valueType}* slotPtr = mozMap.AddEntry(propName);
if (!slotPtr) {
JS_ReportOutOfMemory(cx);
$*{exceptionCode}
}
${valueType}& slot = *slotPtr;
$*{valueConversion}
}
""",
exceptionCode=exceptionCode,
mozMapType=mozMapType,
mozMapRef=mozMapRef,
valueType=valueInfo.declType.define(),
valueConversion=valueConversion)
templateBody = wrapObjectTemplate(templateBody, type,
"${declName}.SetNull();\n",
notMozMap)
declType = typeName
declArgs = None
holderType = None
holderArgs = None
# MozMap 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("MozMapRooter", valueInfo.declType)
# If our MozMap 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" % mozMapRef
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
arrayObjectMemberTypes = filter(lambda t: t.isArray() or t.isSequence(), memberTypes)
if len(arrayObjectMemberTypes) > 0:
assert len(arrayObjectMemberTypes) == 1
name = getUnionMemberName(arrayObjectMemberTypes[0])
arrayObject = CGGeneric(
"done = (failed = !%s.TrySetTo%s(cx, ${val}, tryNext, ${passedToJSImpl})) || !tryNext;\n" %
(unionArgumentObj, name))
names.append(name)
else:
arrayObject = 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
mozMapMemberTypes = filter(lambda t: t.isMozMap(), memberTypes)
if len(mozMapMemberTypes) > 0:
assert len(mozMapMemberTypes) == 1
name = getUnionMemberName(mozMapMemberTypes[0])
mozMapObject = CGGeneric(
"done = (failed = !%s.TrySetTo%s(cx, ${val}, tryNext, ${passedToJSImpl})) || !tryNext;\n" %
(unionArgumentObj, name))
names.append(name)
else:
mozMapObject = 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 arrayObject or dateObject or callbackObject or object or mozMapObject
if hasObjectTypes:
# "object" is not distinguishable from other types
assert not object or not (interfaceObject or arrayObject or dateObject or callbackObject or mozMapObject)
if arrayObject or dateObject or callbackObject:
# An object can be both an array object and a callback or
# dictionary, but we shouldn't have both in the union's members
# because they are not distinguishable.
assert not (arrayObject and callbackObject)
templateBody = CGElseChain([arrayObject, 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 mozMapObject:
templateBody = CGList([templateBody,
CGIfWrapper(mozMapObject, "!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))
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.isGeckoInterface():
assert not isEnforceRange and not isClamp
descriptor = descriptorProvider.getDescriptor(
type.unroll().inner.identifier.name)
assert descriptor.nativeType != 'JSObject'
if descriptor.interface.isCallback():
name = descriptor.interface.identifier.name
if type.nullable() or isCallbackReturnValue:
declType = CGGeneric("RefPtr<%s>" % name)
else:
declType = CGGeneric("OwningNonNull<%s>" % name)
conversion = indent(CGCallbackTempRoot(name).define())
template = wrapObjectTemplate(conversion, type,
"${declName} = nullptr;\n",
failureCode)
return JSToNativeConversionInfo(template, declType=declType,
dealWithOptional=isOptional)
if descriptor.interface.identifier.name == "AbortablePromise":
raise TypeError("Need to figure out what argument conversion "
"should look like for AbortablePromise: %s" %
sourceDescription)
# 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.
#
# Finally, promises need to hold a strong ref because that's what
# Promise.resolve returns.
assert not descriptor.interface.isCallback()
isPromise = descriptor.interface.identifier.name == "Promise"
forceOwningType = isMember or isCallbackReturnValue or isPromise
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 isPromise:
# 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.
# This is in theory a case the spec covers but in practice it
# really doesn't define behavior here because it doesn't define
# what Realm we're in after the callback returns, which is when
# the argument conversion happens. We will use the current
# compartment, which is the compartment of the callable (which
# may itself be a cross-compartment wrapper itself), which makes
# as much sense as anything else. In practice, such an API would
# once again be providing a Promise to signal completion of an
# operation, which would then not be exposed to anyone other than
# our own implementation code.
# 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)
else:
getPromiseGlobal = ""
templateBody = fill(
"""
{ // Scope for our GlobalObject, ErrorResult, JSAutoCompartment,
// etc.
JS::Rooted<JSObject*> globalObj(cx, JS::CurrentGlobalOrNull(cx));
$*{getPromiseGlobal}
JSAutoCompartment ac(cx, globalObj);
GlobalObject promiseGlobal(cx, globalObj);
if (promiseGlobal.Failed()) {
$*{exceptionCode}
}
ErrorResult promiseRv;
JS::Handle<JSObject*> promiseCtor =
PromiseBinding::GetConstructorObjectHandle(cx, globalObj);
if (!promiseCtor) {
$*{exceptionCode}
}
JS::Rooted<JS::Value> resolveThisv(cx, JS::ObjectValue(*promiseCtor));
JS::Rooted<JS::Value> resolveResult(cx);
JS::Rooted<JS::Value> valueToResolve(cx, $${val});
if (!JS_WrapValue(cx, &valueToResolve)) {
$*{exceptionCode}
}
Promise::Resolve(promiseGlobal, resolveThisv, valueToResolve,
&resolveResult, promiseRv);
if (promiseRv.MaybeSetPendingException(cx)) {
$*{exceptionCode}
}
nsresult unwrapRv = UNWRAP_OBJECT(Promise, &resolveResult.toObject(), $${declName});
if (NS_FAILED(unwrapRv)) { // Quite odd
promiseRv.Throw(unwrapRv);
promiseRv.MaybeSetPendingException(cx);
$*{exceptionCode}
}
}
""",
getPromiseGlobal=getPromiseGlobal,
exceptionCode=exceptionCode)
elif not descriptor.skipGen and not descriptor.interface.isConsequential() and not descriptor.interface.isExternal():
if failureCode is not None:
templateBody += str(CastableObjectUnwrapper(
descriptor,
"&${val}.toObject()",
"${declName}",
failureCode))
else:
templateBody += str(FailureFatalCastableObjectUnwrapper(
descriptor,
"&${val}.toObject()",
"${declName}",
exceptionCode,
isCallbackReturnValue,
firstCap(sourceDescription)))
else:
# Worker descriptors can't end up here, because all of our
# "external" stuff is not exposed in workers.
assert not descriptor.workers
# 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"
if isPromise:
if type.nullable():
codeToSetNull = "${declName} = nullptr;\n"
templateBody = CGIfElseWrapper(
"${val}.isNullOrUndefined()",
CGGeneric(codeToSetNull),
CGGeneric(templateBody)).define()
if isinstance(defaultValue, IDLNullValue):
templateBody = handleDefault(templateBody, codeToSetNull)
else:
assert defaultValue is None
else:
# 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(cx, %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)
# ByteString arguments cannot have a default value.
assert defaultValue is None
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(
"""
{
bool ok;
int index = FindEnumStringIndex<${invalidEnumValueFatal}>(cx, $${val}, ${values}, "${enumtype}", "${sourceDescription}", &ok);
if (!ok) {
$*{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
if type.nullable():
declType = CGGeneric("RefPtr<%s>" % name)
else:
declType = CGGeneric("OwningNonNull<%s>" % name)
conversion = indent(CGCallbackTempRoot(name).define())
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,
dealWithOptional=isOptional)
if type.isAny():
assert not isEnforceRange and not isClamp
declArgs = None
if isMember in ("Variadic", "Sequence", "Dictionary", "MozMap"):
# 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 dictionaries
assert not type.nullable() or isCallbackReturnValue
# 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:
