# 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 operator
import os
import re
import string
import math
import itertools
from WebIDL import BuiltinTypes, IDLBuiltinType, IDLNullValue, IDLSequenceType, IDLType, IDLAttribute, IDLUndefinedValue
from Configuration import NoSuchDescriptorError, getTypesFromDescriptor, getTypesFromDictionary, getTypesFromCallback, Descriptor
AUTOGENERATED_WARNING_COMMENT = \
"/* THIS FILE IS AUTOGENERATED - DO NOT EDIT */\n\n"
ADDPROPERTY_HOOK_NAME = '_addProperty'
FINALIZE_HOOK_NAME = '_finalize'
CONSTRUCT_HOOK_NAME = '_constructor'
LEGACYCALLER_HOOK_NAME = '_legacycaller'
HASINSTANCE_HOOK_NAME = '_hasInstance'
NEWRESOLVE_HOOK_NAME = '_newResolve'
ENUMERATE_HOOK_NAME= '_enumerate'
ENUM_ENTRY_VARIABLE_NAME = 'strings'
INSTANCE_RESERVED_SLOTS = 3
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)))
def wantsAddProperty(desc):
return desc.concrete and \
desc.wrapperCache and \
not desc.interface.getExtendedAttribute("Global")
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 """const char *%s(unsigned int aIndex)
{
static const char table[] = %s;
static const uint16_t indices[] = { %s };
static_assert(%d <= UINT16_MAX, "string table overflow!");
return &table[indices[aIndex]];
}
""" % (self.accessorName, table, ", ".join("%d" % index for index in indices), 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 self.descriptor.workers:
return ""
return """// 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 self.descriptor.workers:
return ""
if self.descriptor.concrete and self.descriptor.proxy:
resolveOwnProperty = "ResolveOwnProperty"
enumerateOwnProperties = "EnumerateOwnProperties"
elif self.descriptor.needsXrayResolveHooks():
resolveOwnProperty = "ResolveOwnPropertyViaNewresolve"
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"
parent = self.descriptor.interface.parent
parentHooks = (toBindingNamespace(parent.identifier.name) + "::sNativePropertyHooks"
if parent else 'nullptr')
return CGWrapper(CGIndenter(CGList([CGGeneric(resolveOwnProperty),
CGGeneric(enumerateOwnProperties),
CGWrapper(CGList([CGGeneric(regular),
CGGeneric(chrome)],
", "),
pre="{ ", post=" }"),
CGGeneric(prototypeID),
CGGeneric(constructorID),
CGGeneric(parentHooks)],
",\n")),
pre="const NativePropertyHooks sNativePropertyHooks[] = { {\n",
post=("\n"
"} };\n")).define()
def NativePropertyHooks(descriptor):
return "&sWorkerNativePropertyHooks" if descriptor.workers else "sNativePropertyHooks"
def DOMClass(descriptor):
def make_name(d):
return "%s%s" % (d.interface.identifier.name, '_workers' if d.workers else '')
protoList = ['prototypes::id::' + make_name(descriptor.getDescriptor(proto)) for proto in descriptor.prototypeChain]
# 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)))
prototypeChainString = ', '.join(protoList)
participant = "GetCCParticipant<%s>::Get()" % descriptor.nativeType
getParentObject = "GetParentObject<%s>::Get" % descriptor.nativeType
return """{
{ %s },
IsBaseOf<nsISupports, %s >::value,
%s,
%s,
GetProtoObject,
%s
}""" % (prototypeChainString, descriptor.nativeType,
NativePropertyHooks(descriptor),
getParentObject,
participant)
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'
slotCount = INSTANCE_RESERVED_SLOTS + self.descriptor.interface.totalMembersInSlots
classFlags = "JSCLASS_IS_DOMJSCLASS | "
if self.descriptor.interface.getExtendedAttribute("Global"):
classFlags += "JSCLASS_DOM_GLOBAL | JSCLASS_GLOBAL_FLAGS_WITH_SLOTS(DOM_GLOBAL_SLOTS) | JSCLASS_IMPLEMENTS_BARRIERS"
traceHook = "mozilla::dom::TraceGlobal"
else:
classFlags += "JSCLASS_HAS_RESERVED_SLOTS(%d)" % slotCount
if self.descriptor.interface.getExtendedAttribute("NeedNewResolve"):
newResolveHook = "(JSResolveOp)" + NEWRESOLVE_HOOK_NAME
classFlags += " | JSCLASS_NEW_RESOLVE"
enumerateHook = ENUMERATE_HOOK_NAME
elif self.descriptor.interface.getExtendedAttribute("Global"):
newResolveHook = "(JSResolveOp) mozilla::dom::ResolveGlobal"
classFlags += " | JSCLASS_NEW_RESOLVE"
enumerateHook = "mozilla::dom::EnumerateGlobal"
else:
newResolveHook = "JS_ResolveStub"
enumerateHook = "JS_EnumerateStub"
return """
static const DOMJSClass Class = {
{ "%s",
%s,
%s, /* addProperty */
JS_DeletePropertyStub, /* delProperty */
JS_PropertyStub, /* getProperty */
JS_StrictPropertyStub, /* setProperty */
%s, /* enumerate */
%s, /* resolve */
JS_ConvertStub,
%s, /* finalize */
%s, /* call */
nullptr, /* hasInstance */
nullptr, /* construct */
%s, /* trace */
JS_NULL_CLASS_SPEC,
JS_NULL_CLASS_EXT,
JS_NULL_OBJECT_OPS
},
%s
};
""" % (self.descriptor.interface.identifier.name,
classFlags,
ADDPROPERTY_HOOK_NAME if wantsAddProperty(self.descriptor) else 'JS_PropertyStub',
enumerateHook, newResolveHook, FINALIZE_HOOK_NAME, callHook, traceHook,
CGIndenter(CGGeneric(DOMClass(self.descriptor))).define())
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")
callHook = LEGACYCALLER_HOOK_NAME if self.descriptor.operations["LegacyCaller"] else 'nullptr'
return """
static const DOMJSClass Class = {
PROXY_CLASS_DEF("%s",
0, /* extra slots */
%s,
%s, /* call */
nullptr /* construct */),
%s
};
""" % (self.descriptor.interface.identifier.name,
" | ".join(flags),
callHook,
CGIndenter(CGGeneric(DOMClass(self.descriptor))).define())
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 UseHolderForUnforgeable(descriptor):
return (descriptor.concrete and
descriptor.proxy and
any(m for m in descriptor.interface.members if m.isAttr() and m.isUnforgeable()))
def CallOnUnforgeableHolder(descriptor, code, isXrayCheck=None,
useSharedRoot=False):
"""
Generate the code to execute the code in "code" on an unforgeable holder if
needed. code should be a string containing the code to execute. If it
contains a ${holder} string parameter it will be replaced with the
unforgeable holder object.
If isXrayCheck is not None it should be a string that contains a statement
returning whether proxy is an Xray. If isXrayCheck is None the generated
code won't try to unwrap Xrays.
If useSharedRoot is true, we will use an existing
JS::Rooted<JSObject*> sharedRoot for storing our unforgeable holder instead
of declaring a new Rooted.
"""
code = string.Template(code).substitute({ "holder": "unforgeableHolder" })
if not isXrayCheck is None:
pre = """// Scope for 'global', 'ac' and 'unforgeableHolder'
{
JS::Rooted<JSObject*> global(cx);
Maybe<JSAutoCompartment> ac;
if (""" + isXrayCheck + """) {
global = js::GetGlobalForObjectCrossCompartment(js::UncheckedUnwrap(proxy));
ac.construct(cx, global);
} else {
global = js::GetGlobalForObjectCrossCompartment(proxy);
}"""
else:
pre = """// Scope for 'global' and 'unforgeableHolder'
{
JSObject* global = js::GetGlobalForObjectCrossCompartment(proxy);"""
if useSharedRoot:
holderDecl = "JS::Rooted<JSObject*>& unforgeableHolder(sharedRoot)"
else:
holderDecl = "JS::Rooted<JSObject*> unforgeableHolder(cx)"
return (pre + """
%s;
unforgeableHolder = GetUnforgeableHolder(global, prototypes::id::%s);
""" + CGIndenter(CGGeneric(code)).define() + """
}
""") % (holderDecl, descriptor.name)
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 UseHolderForUnforgeable(self.descriptor):
slotCount += " + 1 /* slot for the JSObject holding the unforgeable properties */"
return """static const DOMIfaceAndProtoJSClass PrototypeClass = {
{
"%sPrototype",
JSCLASS_IS_DOMIFACEANDPROTOJSCLASS | JSCLASS_HAS_RESERVED_SLOTS(%s),
JS_PropertyStub, /* addProperty */
JS_DeletePropertyStub, /* delProperty */
JS_PropertyStub, /* getProperty */
JS_StrictPropertyStub, /* setProperty */
JS_EnumerateStub,
JS_ResolveStub,
JS_ConvertStub,
nullptr, /* finalize */
nullptr, /* call */
nullptr, /* hasInstance */
nullptr, /* construct */
nullptr, /* trace */
JSCLASS_NO_INTERNAL_MEMBERS
},
eInterfacePrototype,
%s,
"[object %sPrototype]",
%s,
%s
};
""" % (self.descriptor.interface.identifier.name, slotCount,
NativePropertyHooks(self.descriptor),
self.descriptor.interface.identifier.name,
prototypeID, depth)
def NeedsGeneratedHasInstance(descriptor):
return descriptor.hasXPConnectImpls or descriptor.interface.isConsequential()
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))
return """
static const DOMIfaceAndProtoJSClass InterfaceObjectClass = {
{
"Function",
JSCLASS_IS_DOMIFACEANDPROTOJSCLASS | JSCLASS_HAS_RESERVED_SLOTS(%s),
JS_PropertyStub, /* addProperty */
JS_DeletePropertyStub, /* delProperty */
JS_PropertyStub, /* getProperty */
JS_StrictPropertyStub, /* setProperty */
JS_EnumerateStub,
JS_ResolveStub,
JS_ConvertStub,
nullptr, /* finalize */
%s, /* call */
%s, /* hasInstance */
%s, /* construct */
nullptr, /* trace */
JSCLASS_NO_INTERNAL_MEMBERS
},
eInterface,
%s,
"function %s() {\\n [native code]\\n}",
%s,
%s
};
""" % (slotCount, ctorname,
hasinstance, ctorname, NativePropertyHooks(self.descriptor),
self.descriptor.interface.identifier.name,
prototypeID, depth)
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, generator):
return self.joiner.join(filter(lambda s: len(s) > 0, (child for child in generator)))
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
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()
# 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)
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):
CGThing.__init__(self)
self.child = child
self.indent = " " * indentLevel
self.declareOnly = declareOnly
def declare(self):
decl = self.child.declare()
if decl is not "":
return re.sub(lineStartDetector, self.indent, decl)
else:
return ""
def define(self):
defn = self.child.define()
if defn is not "" and not self.declareOnly:
return re.sub(lineStartDetector, self.indent, defn)
else:
return defn
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(CGWrapper):
def __init__(self, child, condition):
pre = CGWrapper(CGGeneric(condition), pre="if (", post=") {\n",
reindent=True)
CGWrapper.__init__(self, CGIndenter(child), pre=pre.define(),
post="\n}")
class CGIfElseWrapper(CGList):
def __init__(self, condition, ifTrue, ifFalse):
kids = [ CGIfWrapper(ifTrue, condition),
CGWrapper(CGIndenter(ifFalse), pre=" else {\n", post="\n}") ]
CGList.__init__(self, kids)
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)
]
def getAllTypes(descriptors, dictionaries, callbacks):
"""
Generate all the types we're dealing with. For each type, a tuple
containing type, descriptor, dictionary is yielded. The
descriptor and dictionary can be None if the type does not come
from a descriptor or dictionary; they will never both be non-None.
"""
for d in descriptors:
if d.interface.isExternal():
continue
for t in getTypesFromDescriptor(d):
yield (t, d, None)
for dictionary in dictionaries:
for t in getTypesFromDictionary(dictionary):
yield (t, None, dictionary)
for callback in callbacks:
for t in getTypesFromCallback(callback):
yield (t, None, None)
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
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():
# UnionConversions.h includes UnionTypes.h
bindingHeaders.add("mozilla/dom/UnionConversions.h")
if dictionary:
# Our dictionary definition is in the header and
# needs the union type.
declareIncludes.add("mozilla/dom/UnionTypes.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")
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 nsRefPtr 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():
# Callbacks are both a type and an object
headerSet.add(self.getDeclarationFilename(t.unroll()))
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")
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 desc.interface.isExternal():
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"))
# getExtendedAttribute() returns a list, extract the entry.
funcList = desc.interface.getExtendedAttribute("Func")
if funcList is not None:
addHeaderForFunc(funcList[0])
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 BindingUtils.h so we can wrap "this" objects
declareIncludes.add("mozilla/dom/BindingUtils.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 BindingUtils.h so we can wrap "this" objects
declareIncludes.add("mozilla/dom/BindingUtils.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 SortedTuples(l):
"""
Sort a list of tuples based on the first item in the tuple
"""
return sorted(l, key=operator.itemgetter(0))
def SortedDictValues(d):
"""
Returns a list of values from the dict sorted by key.
"""
# Create a list of tuples containing key and value, sorted on key.
d = SortedTuples(d.items())
# We're only interested in the values.
return (i[1] for i in d)
def UnionTypes(descriptors, dictionaries, callbacks, config):
"""
Returns a tuple containing a set of header filenames to include in
UnionTypes.h, a set of header filenames to include in UnionTypes.cpp, a set
of tuples containing a type declaration and a boolean if the type is a
struct for member types of the unions and a CGList containing CGUnionStructs
for every union.
"""
# Now find all the things we'll need as arguments and return values because
# we need to wrap or unwrap them.
headers = set()
implheaders = set(["UnionTypes.h"])
declarations = set()
unionStructs = dict()
owningUnionStructs = dict()
def addInfoForType((t, descriptor, dictionary)):
"""
Add info for the given type. descriptor and dictionary, if passed, are
used to figure out what to do with interface types.
"""
assert not descriptor or not dictionary
t = t.unroll()
if not t.isUnion():
return
name = str(t)
if not name in unionStructs:
providers = getRelevantProviders(descriptor, config)
# FIXME: Unions are broken in workers. See bug 809899.
unionStructs[name] = CGUnionStruct(t, providers[0])
owningUnionStructs[name] = CGUnionStruct(t, providers[0],
ownsMembers=True)
for f in t.flatMemberTypes:
f = f.unroll()
if f.nullable():
headers.add("mozilla/dom/Nullable.h")
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():
# Callback interfaces always use strong refs, so
# we need to include the right header to be able
# to Release() in our inlined code.
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))
map(addInfoForType, getAllTypes(descriptors, dictionaries, callbacks))
return (headers, implheaders, declarations,
CGList(itertools.chain(SortedDictValues(unionStructs),
SortedDictValues(owningUnionStructs)), "\n"))
def UnionConversions(descriptors, dictionaries, callbacks, config):
"""
Returns a CGThing to declare all union argument conversion helper structs.
"""
# Now find all the things we'll need as arguments because we
# need to unwrap them.
headers = set()
unionConversions = dict()
def addInfoForType((t, descriptor, dictionary)):
"""
Add info for the given type. descriptor and dictionary, if passed, are
used to figure out what to do with interface types.
"""
assert not descriptor or not dictionary
t = t.unroll()
if not t.isUnion():
return
name = str(t)
if not name in unionConversions:
providers = getRelevantProviders(descriptor, config)
unionConversions[name] = CGUnionConversionStruct(t, providers[0])
for f in t.flatMemberTypes:
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))
# Check for whether we have a possibly-XPConnect-implemented
# interface. If we do, the right descriptor will come from
# providers[0], because that would be the non-worker
# descriptor provider, if we have one at all.
if (f.isGeckoInterface() and
providers[0].getDescriptor(f.inner.identifier.name).hasXPConnectImpls):
headers.add("nsDOMQS.h")
elif f.isDictionary():
headers.add(CGHeaders.getDeclarationFilename(f.inner))
elif f.isPrimitive():
headers.add("mozilla/dom/PrimitiveConversions.h")
map(addInfoForType, getAllTypes(descriptors, dictionaries, callbacks))
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 _define(self, fromDeclare=False):
return self.definition_prologue(fromDeclare) + "\n" + 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{" % (self._template(), self._decorators(),
self.name, self._argstring(fromDeclare))
def definition_epilogue(self):
return "\n}\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 = UnwrapDOMObject<%s>(obj);
""" % (self.descriptor.nativeType, self.descriptor.nativeType)
def definition_body(self):
return self.definition_body_prologue() + self.generate_code()
def generate_code(self):
# Override me
assert(False)
class CGGetJSClassMethod(CGAbstractMethod):
def __init__(self, descriptor):
CGAbstractMethod.__init__(self, descriptor, 'GetJSClass', 'const JSClass*',
[])
def definition_body(self):
return " return Class.ToJSClass();"
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::MutableHandle<JS::Value>', 'vp')]
CGAbstractClassHook.__init__(self, descriptor, ADDPROPERTY_HOOK_NAME,
'bool', args)
def generate_code(self):
assert self.descriptor.wrapperCache
return (" // We don't want to preserve if we don't have a wrapper.\n"
" if (self->GetWrapperPreserveColor()) {\n"
" PreserveWrapper(self);\n"
" }\n"
" return true;")
def DeferredFinalizeSmartPtr(descriptor):
if descriptor.nativeOwnership == 'owned':
smartPtr = 'nsAutoPtr'
else:
smartPtr = 'nsRefPtr'
return smartPtr
def finalizeHook(descriptor, hookName, freeOp):
finalize = "JSBindingFinalized<%s>::Finalized(self);\n" % descriptor.nativeType
if descriptor.wrapperCache:
finalize += "ClearWrapper(self, self);\n"
if descriptor.interface.getExtendedAttribute('OverrideBuiltins'):
finalize += "self->mExpandoAndGeneration.expando = JS::UndefinedValue();\n"
if descriptor.interface.getExtendedAttribute("Global"):
finalize += "mozilla::dom::FinalizeGlobal(CastToJSFreeOp(%s), obj);\n" % freeOp
finalize += ("AddForDeferredFinalization<%s, %s >(self);" %
(descriptor.nativeType, DeferredFinalizeSmartPtr(descriptor)))
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 CGIndenter(finalizeHook(self.descriptor, self.name, self.args[0].name)).define()
class CGClassConstructor(CGAbstractStaticMethod):
"""
JS-visible constructor for our objects
"""
def __init__(self, descriptor, ctor, name=CONSTRUCT_HOOK_NAME):
args = [Argument('JSContext*', 'cx'), Argument('unsigned', 'argc'), Argument('JS::Value*', 'vp')]
CGAbstractStaticMethod.__init__(self, descriptor, name, 'bool', args)
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):
preamble = """
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
JS::Rooted<JSObject*> obj(cx, &args.callee());
"""
# [ChromeOnly] interfaces may only be constructed by chrome.
if isChromeOnly(self._ctor):
preamble += (
"if (!nsContentUtils::ThreadsafeIsCallerChrome()) {\n"
" return ThrowingConstructor(cx, argc, vp);\n"
"}\n\n")
# 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 += (
"bool mayInvoke = args.isConstructing();\n"
"#ifdef RELEASE_BUILD\n"
"mayInvoke = mayInvoke || nsContentUtils::ThreadsafeIsCallerChrome();\n"
"#endif // RELEASE_BUILD\n"
"if (!mayInvoke) {\n"
" // XXXbz wish I could get the name from the callee instead of\n"
" // Adding more relocations\n"
' return ThrowConstructorWithoutNew(cx, "%s");\n'
"}" % ctorName)
name = self._ctor.identifier.name
nativeName = MakeNativeName(self.descriptor.binaryNames.get(name, name))
callGenerator = CGMethodCall(nativeName, True, self.descriptor,
self._ctor, isConstructor=True,
constructorName=ctorName)
return CGList([CGIndenter(CGGeneric(preamble)), callGenerator],
"\n").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 CGIndenter(CGGeneric(genConstructorBody(self.descriptor))).define()
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 string.Template(""" GlobalObject global(aCx, aObj);
if (global.Failed()) {
return nullptr;
}
ErrorResult rv;
nsRefPtr<mozilla::dom::${descriptorName}> result = ConstructNavigatorObjectHelper(aCx, global, rv);
rv.WouldReportJSException();
if (rv.Failed()) {
ThrowMethodFailedWithDetails(aCx, rv, "${descriptorName}", "navigatorConstructor");
return nullptr;
}
JS::Rooted<JS::Value> v(aCx);
if (!WrapNewBindingObject(aCx, aObj, result, &v)) {
MOZ_ASSERT(JS_IsExceptionPending(aCx));
return nullptr;
}
return &v.toObject();""").substitute(
{
'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,
"static const JSNativeHolder " + CONSTRUCT_HOOK_NAME + "_holder = {\n" +
" " + constructHook + ",\n" +
" " + NativePropertyHooks(descriptor) + "\n" +
"};\n")
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"
nativePropertyHooks = """const NativePropertyHooks sNamedConstructorNativePropertyHooks = {
nullptr,
nullptr,
{ nullptr, nullptr },
prototypes::id::%s,
%s,
nullptr
};
""" % (self.descriptor.name, constructorID)
namedConstructors = CGList([], ",\n")
for n in self.descriptor.interface.namedConstructors:
namedConstructors.append(CGGeneric("{ \"%s\", { %s, &sNamedConstructorNativePropertyHooks }, %i }" % (n.identifier.name, NamedConstructorName(n), methodLength(n))))
namedConstructors.append(CGGeneric("{ nullptr, { nullptr, nullptr }, 0 }"))
namedConstructors = CGWrapper(CGIndenter(namedConstructors),
pre="static const NamedConstructor namedConstructors[] = {\n",
post="\n};\n")
return nativePropertyHooks + namedConstructors.define()
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')]
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 = """
if (!vp.isObject()) {
*bp = false;
return true;
}
JS::Rooted<JSObject*> instance(cx, &vp.toObject());
"""
if self.descriptor.interface.hasInterfacePrototypeObject():
return header + """
static_assert(IsBaseOf<nsISupports, %s>::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));
nsCOMPtr<nsIDOM%s> qiResult = do_QueryInterface(native);
*bp = !!qiResult;
return true;
""" % (self.descriptor.nativeType,
self.descriptor.interface.identifier.name)
hasInstanceCode = """
const DOMClass* domClass = GetDOMClass(js::UncheckedUnwrap(instance));
*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))->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 += """
if (domClass->mInterfaceChain[PrototypeTraits<prototypes::id::%s>::Depth] == prototypes::id::%s) {
%s;
return true;
}
""" % (iface.identifier.name, iface.identifier.name, setBp)
hasInstanceCode += " return true;"
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):
assert pref is None or isinstance(pref, str)
assert func is None or isinstance(func, str)
assert available is None or isinstance(available, str)
self.pref = pref
def toFuncPtr(val):
if val is None:
return "nullptr"
return "&" + val
self.func = toFuncPtr(func)
self.available = toFuncPtr(available)
def __eq__(self, other):
return (self.pref == other.pref and self.func == other.func and
self.available == other.available)
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):
# No Xrays in workers.
return not self.descriptor.workers
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) is 1)
assert(attr[0] is not None)
return attr[0]
@staticmethod
def getControllingCondition(interfaceMember):
return MemberCondition(PropertyDefiner.getStringAttr(interfaceMember,
"Pref"),
PropertyDefiner.getStringAttr(interfaceMember,
"Func"),
getAvailableInTestFunc(interfaceMember))
def generatePrefableArray(self, array, name, specTemplate, 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
specTemplate is a template for each entry of the spec array
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 for substitution into specTemplate.
"""
# 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) is not 0)
lastCondition = getCondition(array[0]) # So we won't put a specTerminator
# at the very front of the list.
specs = []
prefableSpecs = []
prefableTemplate = ' { true, %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,
name + "_specs", len(specs)))
switchToCondition(self, lastCondition)
for member in array:
curCondition = getCondition(member)
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(specTemplate % getDataTuple(member))
specs.append(specTerminator)
prefableSpecs.append(" { false, nullptr }");
specType = "const " + specType
arrays = (("static %s %s_specs[] = {\n" +
',\n'.join(specs) + "\n" +
"};\n\n" +
"// Can't be const because the pref-enabled boolean needs to be writable\n"
"static Prefable<%s> %s[] = {\n" +
',\n'.join(prefableSpecs) + "\n" +
"};\n\n") % (specType, name, specType, name))
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)
class MethodDefiner(PropertyDefiner):
"""
A class for defining methods on a prototype object.
"""
def __init__(self, descriptor, name, static):
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
not m.isIdentifierLess()]
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
method = { "name": m.identifier.name,
"methodInfo": not m.isStatic(),
"length": methodLength(m),
"flags": "JSPROP_ENUMERATE",
"condition": PropertyDefiner.getControllingCondition(m),
"allowCrossOriginThis": m.getExtendedAttribute("CrossOriginCallable"),
"returnsPromise": m.returnsPromise(),
}
if isChromeOnly(m):
self.chrome.append(method)
else:
self.regular.append(method)
# FIXME Check for an existing iterator on the interface first.
if any(m.isGetter() and m.isIndexed() for m in methods):
self.regular.append({"name": "@@iterator",
"methodInfo": False,
"selfHostedName": "ArrayValues",
"length": 0,
"flags": "JSPROP_ENUMERATE",
"condition": MemberCondition(None, None) })
if not static:
stringifier = descriptor.operations['Stringifier']
if stringifier:
toStringDesc = { "name": "toString",
"nativeName": stringifier.identifier.name,
"length": 0,
"flags": "JSPROP_ENUMERATE",
"condition": PropertyDefiner.getControllingCondition(stringifier) }
if isChromeOnly(stringifier):
self.chrome.append(toStringDesc)
else:
self.regular.append(toStringDesc)
jsonifier = descriptor.operations['Jsonifier']
if jsonifier:
toJSONDesc = { "name": "toJSON",
"nativeName": jsonifier.identifier.name,
"length": 0,
"flags": "JSPROP_ENUMERATE",
"condition": PropertyDefiner.getControllingCondition(jsonifier) }
if isChromeOnly(jsonifier):
self.chrome.append(toJSONDesc)
else:
self.regular.append(toJSONDesc)
elif (descriptor.interface.isJSImplemented() and
descriptor.interface.hasInterfaceObject()):
self.chrome.append({"name": '_create',
"nativeName": ("%s::_Create" %
descriptor.name),
"methodInfo": False,
"length": 2,
"flags": "0",
"condition": MemberCondition(None, None) })
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):
return m["condition"]
def specData(m):
if "selfHostedName" in m:
selfHostedName = '"%s"' % m["selfHostedName"]
assert not m.get("methodInfo", True)
accessor = "nullptr"
jitinfo = "nullptr"
else:
selfHostedName = "nullptr";
accessor = m.get("nativeName", m["name"])
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):
raise TypeError("%s returns a Promise but needs "
"special generic ops?" %
accessor)
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"], m["flags"], selfHostedName)
return self.generatePrefableArray(
array, name,
' JS_FNSPEC("%s", %s, %s, %s, %s, %s)',
' JS_FS_END',
'JSFunctionSpec',
condition, specData, doIdArrays)
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
m.isUnforgeable() == unforgeable]
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 ""
return ("JSPROP_SHARED | JSPROP_ENUMERATE | JSPROP_NATIVE_ACCESSORS" +
unforgeable)
def getter(attr):
if self.static:
accessor = 'get_' + 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" % attr.identifier.name
return "{ { JS_CAST_NATIVE_TO(%s, JSPropertyOp), %s } }" % \
(accessor, jitinfo)
def setter(attr):
if (attr.readonly and
attr.getExtendedAttribute("PutForwards") is None and
attr.getExtendedAttribute("Replaceable") is None):
return "JSOP_NULLWRAPPER"
if self.static:
accessor = 'set_' + attr.identifier.name
jitinfo = "nullptr"
else:
if attr.hasLenientThis():
accessor = "genericLenientSetter"
elif attr.getExtendedAttribute("CrossOriginWritable"):
accessor = "genericCrossOriginSetter"
elif self.descriptor.needsSpecialGenericOps():
accessor = "genericSetter"
else:
accessor = "GenericBindingSetter"
jitinfo = "&%s_setterinfo" % attr.identifier.name
return "{ { JS_CAST_NATIVE_TO(%s, JSStrictPropertyOp), %s } }" % \
(accessor, jitinfo)
def specData(attr):
return (attr.identifier.name, flags(attr), getter(attr),
setter(attr))
return self.generatePrefableArray(
array, name,
' { "%s", %s, %s, %s}',
' JS_PS_END',
'JSPropertySpec',
PropertyDefiner.getControllingCondition, specData, doIdArrays)
class ConstDefiner(PropertyDefiner):
"""
A class for definining constants on the interface object
"""
def __init__(self, descriptor, name):
PropertyDefiner.__init__(self, descriptor, name)
self.name = name
constants = [m for m in descriptor.interface.members if m.isConst()]
self.chrome = [m for m in constants if isChromeOnly(m)]
self.regular = [m for m in constants if not isChromeOnly(m)]
def generateArray(self, array, name, doIdArrays):
if len(array) == 0:
return ""
def specData(const):
return (const.identifier.name,
convertConstIDLValueToJSVal(const.value))
return self.generatePrefableArray(
array, name,
' { "%s", %s }',
' { 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.unforgeableAttrs = AttrDefiner(descriptor, "UnforgeableAttributes",
static=False, unforgeable=True)
self.consts = ConstDefiner(descriptor, "Constants")
@staticmethod
def arrayNames():
return [ "staticMethods", "staticAttrs", "methods", "attrs",
"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))
return CGWrapper(CGIndenter(CGList(nativeProps, ",\n")),
pre="static const NativeProperties %s = {\n" % name,
post="\n};")
nativeProperties = []
if properties.hasNonChromeOnly():
nativeProperties.append(
generateNativeProperties("sNativeProperties", False))
if properties.hasChromeOnly():
nativeProperties.append(
generateNativeProperties("sChromeOnlyNativeProperties", True))
CGList.__init__(self, nativeProperties, "\n\n")
def declare(self):
return ""
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):
if len(self.descriptor.prototypeChain) == 1:
parentProtoType = "Rooted"
if self.descriptor.interface.getExtendedAttribute("ArrayClass"):
getParentProto = "aCx, JS_GetArrayPrototype(aCx, aGlobal)"
else:
getParentProto = "aCx, JS_GetObjectPrototype(aCx, aGlobal)"
else:
parentProtoName = self.descriptor.prototypeChain[-2]
parentDesc = self.descriptor.getDescriptor(parentProtoName)
if parentDesc.workers:
parentProtoName += '_workers'
getParentProto = ("%s::GetProtoObject(aCx, aGlobal)" %
toBindingNamespace(parentProtoName))
parentProtoType = "Handle"
parentWithInterfaceObject = self.descriptor.interface.parent
while (parentWithInterfaceObject and
not parentWithInterfaceObject.hasInterfaceObject()):
parentWithInterfaceObject = parentWithInterfaceObject.parent
if parentWithInterfaceObject:
parentIfaceName = parentWithInterfaceObject.identifier.name
parentDesc = self.descriptor.getDescriptor(parentIfaceName)
if parentDesc.workers:
parentIfaceName += "_workers"
getConstructorProto = ("%s::GetConstructorObject(aCx, aGlobal)" %
toBindingNamespace(parentIfaceName))
constructorProtoType = "Handle"
else:
getConstructorProto = "aCx, JS_GetFunctionPrototype(aCx, aGlobal)"
constructorProtoType = "Rooted"
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
idsToInit = []
# There is no need to init any IDs in workers, because worker bindings
# don't have Xrays.
if not self.descriptor.workers:
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;")
setFlag = CGGeneric("sIdsInited = true;")
initIdConditionals = [CGIfWrapper(CGGeneric("return;"), call)
for call in initIdCalls]
initIds = CGList([idsInitedFlag,
CGIfWrapper(CGList(initIdConditionals + [setFlag],
"\n"),
"!sIdsInited && NS_IsMainThread()")],
"\n")
else:
initIds = None
prefCacheData = []
for var in self.properties.arrayNames():
props = getattr(self.properties, var)
prefCacheData.extend(props.prefCacheData)
if len(prefCacheData) is not 0:
prefCacheData = [
CGGeneric('Preferences::AddBoolVarCache(%s, "%s");' % (ptr, pref)) for
(pref, ptr) in prefCacheData]
prefCache = CGWrapper(CGIndenter(CGList(prefCacheData, "\n")),
pre=("static bool sPrefCachesInited = false;\n"
"if (!sPrefCachesInited) {\n"
" sPrefCachesInited = true;\n"),
post="\n}")
else:
prefCache = None
if UseHolderForUnforgeable(self.descriptor):
createUnforgeableHolder = CGGeneric("""JS::Rooted<JSObject*> unforgeableHolder(aCx,
JS_NewObjectWithGivenProto(aCx, nullptr, JS::NullPtr(), JS::NullPtr()));
if (!unforgeableHolder) {
return;
}""")
defineUnforgeables = InitUnforgeablePropertiesOnObject(self.descriptor,
"unforgeableHolder",
self.properties)
createUnforgeableHolder = CGList([createUnforgeableHolder,
defineUnforgeables],
"\n")
else:
createUnforgeableHolder = None
getParentProto = ("JS::%s<JSObject*> parentProto(%s);\n" +
"if (!parentProto) {\n" +
" return;\n" +
"}") % (parentProtoType, getParentProto)
getConstructorProto = ("JS::%s<JSObject*> constructorProto(%s);\n"
"if (!constructorProto) {\n"
" return;\n"
"}" % (constructorProtoType, getConstructorProto))
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
else:
protoClass = "nullptr"
protoCache = "nullptr"
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"
if self.descriptor.concrete:
domClass = "&Class.mClass"
else:
domClass = "nullptr"
if self.properties.hasNonChromeOnly():
properties = "&sNativeProperties"
else:
properties = "nullptr"
if self.properties.hasChromeOnly():
accessCheck = "nsContentUtils::ThreadsafeIsCallerChrome()"
chromeProperties = accessCheck + " ? &sChromeOnlyNativeProperties : nullptr"
else:
chromeProperties = "nullptr"
call = ("dom::CreateInterfaceObjects(aCx, aGlobal, parentProto,\n"
" %s, %s,\n"
" constructorProto, %s, %s, %d, %s,\n"
" %s,\n"
" %s,\n"
" %s,\n"
" %s,\n"
" %s, aDefineOnGlobal);" % (
protoClass, protoCache,
interfaceClass, constructHookHolder, constructArgs,
namedConstructors,
interfaceCache,
domClass,
properties,
chromeProperties,
'"' + self.descriptor.interface.identifier.name + '"' if needInterfaceObject else "nullptr"))
if UseHolderForUnforgeable(self.descriptor):
assert needInterfacePrototypeObject
setUnforgeableHolder = CGGeneric(
"JSObject* proto = aProtoAndIfaceCache.EntrySlotOrCreate(prototypes::id::%s);\n"
"if (proto) {\n"
" js::SetReservedSlot(proto, DOM_INTERFACE_PROTO_SLOTS_BASE,\n"
" JS::ObjectValue(*unforgeableHolder));\n"
"}" % self.descriptor.name)
else:
setUnforgeableHolder = None
functionBody = CGList(
[CGGeneric(getParentProto), CGGeneric(getConstructorProto), initIds,
prefCache, createUnforgeableHolder, CGGeneric(call), setUnforgeableHolder],
"\n\n")
return CGIndenter(functionBody).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 ("""
/* Make sure our global is sane. Hopefully we can remove this sometime */
if (!(js::GetObjectClass(aGlobal)->flags & JSCLASS_DOM_GLOBAL)) {
return JS::NullPtr();
}
/* Check to see whether the interface objects are already installed */
ProtoAndIfaceCache& protoAndIfaceCache = *GetProtoAndIfaceCache(aGlobal);
if (!protoAndIfaceCache.EntrySlotIfExists(%s)) {
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(%s).address());""" % (self.id, self.id))
class CGGetProtoObjectMethod(CGGetPerInterfaceObject):
"""
A method for getting the interface prototype object.
"""
def __init__(self, descriptor):
CGGetPerInterfaceObject.__init__(self, descriptor, "GetProtoObject",
"prototypes::")
def definition_body(self):
return """
/* Get the interface prototype object for this class. This will create the
object as needed. */
bool aDefineOnGlobal = true;""" + CGGetPerInterfaceObject.definition_body(self)
class CGGetConstructorObjectMethod(CGGetPerInterfaceObject):
"""
A method for getting the interface constructor object.
"""
def __init__(self, descriptor):
CGGetPerInterfaceObject.__init__(
self, descriptor, "GetConstructorObject",
"constructors::",
extraArgs=[Argument("bool", "aDefineOnGlobal", "true")])
def definition_body(self):
return """
/* Get the interface object for this class. This will create the object as
needed. */""" + CGGetPerInterfaceObject.definition_body(self)
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 = """ JSObject* interfaceObject = GetConstructorObject(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 GetConstructorObject(aCx, aGlobal, aDefineOnGlobal);"
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):
conditions = []
iface = self.descriptor.interface
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)
# We should really have some conditions
assert len(conditions)
body = CGWrapper(CGList((CGGeneric(cond) for cond in conditions),
" &&\n"),
pre="return ", post=";", reindent=True)
return CGIndenter(body).define()
def CreateBindingJSObject(descriptor, properties, parent):
# 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.
objDecl = " JS::Rooted<JSObject*> obj(aCx);\n"
if descriptor.proxy:
create = """ JS::Rooted<JS::Value> proxyPrivateVal(aCx, JS::PrivateValue(aObject));
js::ProxyOptions options;
options.setClass(&Class.mBase);
obj = NewProxyObject(aCx, DOMProxyHandler::getInstance(),
proxyPrivateVal, proto, %s, options);
if (!obj) {
return nullptr;
}
"""
if descriptor.interface.getExtendedAttribute('OverrideBuiltins'):
create += """ js::SetProxyExtra(obj, JSPROXYSLOT_EXPANDO,
JS::PrivateValue(&aObject->mExpandoAndGeneration));
"""
else:
create = """ obj = JS_NewObject(aCx, Class.ToJSClass(), proto, %s);
if (!obj) {
return nullptr;
}
js::SetReservedSlot(obj, DOM_OBJECT_SLOT, PRIVATE_TO_JSVAL(aObject));
"""
if "Window" in descriptor.interface.identifier.name:
create = """ MOZ_ASSERT(false,
"Our current reserved slot situation is unsafe for globals. Fix "
"bug 760095!");
""" + create
create = objDecl + create
if descriptor.nativeOwnership == 'refcounted':
create += """ NS_ADDREF(aObject);
"""
else:
create += """ // Make sure the native objects inherit from NonRefcountedDOMObject so that we
// log their ctor and dtor.
MustInheritFromNonRefcountedDOMObject(aObject);
*aTookOwnership = true;
"""
return create % parent
def InitUnforgeablePropertiesOnObject(descriptor, obj, properties, failureReturnValue=""):
"""
properties is a PropertyArrays instance
"""
failureReturn = "return"
if len(failureReturnValue) > 0:
failureReturn += " " + failureReturnValue
failureReturn += ";"
defineUnforgeables = ("if (!DefineUnforgeableAttributes(aCx, " + obj + ", %s)) {\n"
" " + failureReturn + "\n"
"}")
unforgeableAttrs = properties.unforgeableAttrs
unforgeables = []
if unforgeableAttrs.hasNonChromeOnly():
unforgeables.append(CGGeneric(defineUnforgeables %
unforgeableAttrs.variableName(False)))
if unforgeableAttrs.hasChromeOnly():
unforgeables.append(
CGIfWrapper(CGGeneric(defineUnforgeables %
unforgeableAttrs.variableName(True)),
"nsContentUtils::ThreadsafeIsCallerChrome()"))
return CGList(unforgeables, "\n")
def InitUnforgeableProperties(descriptor, properties):
"""
properties is a PropertyArrays instance
"""
unforgeableAttrs = properties.unforgeableAttrs
if not unforgeableAttrs.hasNonChromeOnly() and not unforgeableAttrs.hasChromeOnly():
return ""
if descriptor.proxy:
unforgeableProperties = CGGeneric(
"// Unforgeable properties on proxy-based bindings are stored in an object held\n"
"// by the interface prototype object.\n")
else:
unforgeableProperties = CGWrapper(
InitUnforgeablePropertiesOnObject(descriptor, "obj", properties, "nullptr"),
pre=(
"// Important: do unforgeable property setup after we have handed\n"
"// over ownership of the C++ object to obj as needed, so that if\n"
"// we fail and it ends up GCed it won't have problems in the\n"
"// finalizer trying to drop its ownership of the C++ object.\n"))
return CGIndenter(CGWrapper(unforgeableProperties, pre="\n", post="\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" %
(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 = " aCache->ClearWrapper();\n"
else:
clearWrapper = ""
return CGIndenter(CGGeneric(
("if (!UpdateMemberSlots(aCx, obj, aObject)) {\n"
"%s"
" return nullptr;\n"
"}" % clearWrapper))).define()
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('JS::Handle<JSObject*>', 'aScope'),
Argument(descriptor.nativeType + '*', 'aObject'),
Argument('nsWrapperCache*', 'aCache')]
CGAbstractMethod.__init__(self, descriptor, 'Wrap', 'JSObject*', args)
self.properties = properties
def definition_body(self):
assertISupportsInheritance = (
' MOZ_ASSERT(ToSupportsIsOnPrimaryInheritanceChain(aObject, aCache),\n'
' "nsISupports must be on our primary inheritance chain");\n')
return """%s
%s
JS::Rooted<JSObject*> parent(aCx,
GetRealParentObject(aObject,
WrapNativeParent(aCx, aScope, aObject->GetParentObject())));
if (!parent) {
return nullptr;
}
// That might have ended up wrapping us already, due to the wonders
// of XBL. Check for that, and bail out as needed. Scope so we don't
// collide with the "obj" we declare in CreateBindingJSObject.
{
JSObject* obj = aCache->GetWrapper();
if (obj) {
return obj;
}
}
JSAutoCompartment ac(aCx, parent);
JS::Rooted<JSObject*> global(aCx, JS_GetGlobalForObject(aCx, parent));
JS::Handle<JSObject*> proto = GetProtoObject(aCx, global);
if (!proto) {
return nullptr;
}
%s
%s
aCache->SetWrapper(obj);
%s
return obj;""" % (AssertInheritanceChain(self.descriptor),
assertISupportsInheritance,
CreateBindingJSObject(self.descriptor, self.properties,
"parent"),
InitUnforgeableProperties(self.descriptor, self.properties),
InitMemberSlots(self.descriptor, True))
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('JS::Handle<JSObject*>', 'aScope'),
Argument('T*', 'aObject')]
CGAbstractMethod.__init__(self, descriptor, 'Wrap', 'JSObject*', args, inline=True, templateArgs=["class T"])
def definition_body(self):
return " return Wrap(aCx, aScope, aObject, aObject);"
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('JS::Handle<JSObject*>', 'aScope'),
Argument(descriptor.nativeType + '*', 'aObject')]
if descriptor.nativeOwnership == 'owned':
args.append(Argument('bool*', 'aTookOwnership'))
CGAbstractMethod.__init__(self, descriptor, 'Wrap', 'JSObject*', args)
self.properties = properties
def definition_body(self):
return """%s
JS::Rooted<JSObject*> global(aCx, JS_GetGlobalForObject(aCx, aScope));
JS::Handle<JSObject*> proto = GetProtoObject(aCx, global);
if (!proto) {
return nullptr;
}
%s
%s
%s
return obj;""" % (AssertInheritanceChain(self.descriptor),
CreateBindingJSObject(self.descriptor, self.properties,
"global"),
InitUnforgeableProperties(self.descriptor, self.properties),
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')]
CGAbstractMethod.__init__(self, descriptor, 'Wrap', 'JSObject*', args)
self.descriptor = descriptor
self.properties = properties
def definition_body(self):
return """%s
MOZ_ASSERT(ToSupportsIsOnPrimaryInheritanceChain(aObject, aCache),
"nsISupports must be on our primary inheritance chain");
JS::Rooted<JSObject*> obj(aCx);
obj = CreateGlobal<%s, GetProtoObject>(aCx,
aObject,
aCache,
Class.ToJSClass(),
aOptions,
aPrincipal);
%s
// XXXkhuey can't do this yet until workers can lazy resolve.
// JS_FireOnNewGlobalObject(aCx, obj);
return obj;""" % (AssertInheritanceChain(self.descriptor),
self.descriptor.nativeType,
InitUnforgeableProperties(self.descriptor, self.properties))
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):
slotMembers = (m for m in self.descriptor.interface.members if
m.isAttr() and m.getExtendedAttribute("StoreInSlot"))
storeSlots = (
CGGeneric(
'static_assert(%s < js::shadow::Object::MAX_FIXED_SLOTS,\n'
' "Not enough fixed slots to fit \'%s.%s\'");\n'
"if (!get_%s(aCx, aWrapper, aObject, args)) {\n"
" return false;\n"
"}\n"
"// Getter handled setting our reserved slots" %
(memberReservedSlot(m),
self.descriptor.interface.identifier.name,
m.identifier.name, m.identifier.name))
for m in slotMembers)
body = CGList(storeSlots, "\n\n")
body.prepend(CGGeneric("JS::Rooted<JS::Value> temp(aCx);\n"
"JSJitGetterCallArgs args(&temp);"))
body.append(CGGeneric("return true;"))
return CGIndenter(body).define()
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 = ("ClearCached%sValue" % MakeNativeName(member.identifier.name))
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);"
noopRetval = " true"
saveMember = (
"JS::Rooted<JS::Value> oldValue(aCx, js::GetReservedSlot(obj, %s));\n" %
slotIndex)
regetMember = ("\n"
"JS::Rooted<JS::Value> temp(aCx);\n"
"JSJitGetterCallArgs args(&temp);\n"
"JSAutoCompartment ac(aCx, obj);\n"
"if (!get_%s(aCx, obj, aObject, args)) {\n"
" js::SetReservedSlot(obj, %s, oldValue);\n"
" nsJSUtils::ReportPendingException(aCx);\n"
" return false;\n"
"}\n"
"return true;" % (self.member.identifier.name, slotIndex))
else:
declObj = "JSObject* obj;"
noopRetval = ""
saveMember = ""
regetMember = ""
return CGIndenter(CGGeneric(
"%s\n"
"obj = aObject->GetWrapper();\n"
"if (!obj) {\n"
" return%s;\n"
"}\n"
"%s"
"js::SetReservedSlot(obj, %s, JS::UndefinedValue());"
"%s"
% (declObj, noopRetval, saveMember, slotIndex, regetMember)
)).define()
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("jschar", "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([], "\n"))
case.append(CGGeneric("if (%s) {\n"
" return true;\n"
"}"% cond))
cases[firstLetter] = case
caseList = []
for firstLetter in sorted(cases.keys()):
caseList.append(CGCase("'%s'" % firstLetter, cases[firstLetter]))
switch = CGSwitch("propFirstChar", caseList)
return CGIndenter(CGList([switch, CGGeneric("return false;")], "\n\n")).define()
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):
if not exceptionCode:
exceptionCode = codeOnFailure
self.substitution = { "type" : descriptor.nativeType,
"protoID" : "prototypes::id::" + descriptor.name,
"target" : target,
"codeOnFailure" : CGIndenter(CGGeneric(codeOnFailure)).define(),
"exceptionCode" : CGIndenter(CGGeneric(exceptionCode), 4).define() }
if allowCrossOriginObj:
self.substitution["uncheckedObjDecl"] = (
"\n JS::Rooted<JSObject*> uncheckedObj(cx, js::UncheckedUnwrap(%s));" % source)
self.substitution["source"] = "uncheckedObj"
xpconnectUnwrap = (
"nsresult rv;\n"
"{ // Scope for the JSAutoCompartment, because we only\n"
" // want to be in that compartment for the UnwrapArg call.\n"
" JSAutoCompartment ac(cx, ${source});\n"
" rv = UnwrapArg<${type}>(cx, val, &objPtr, &objRef.ptr, &val);\n"
"}\n")
else:
self.substitution["uncheckedObjDecl"] = ""
self.substitution["source"] = source
xpconnectUnwrap = "nsresult rv = UnwrapArg<${type}>(cx, val, &objPtr, &objRef.ptr, &val);\n"
if descriptor.hasXPConnectImpls:
# We don't use xpc_qsUnwrapThis because it will always throw on
# unwrap failure, whereas we want to control whether we throw or
# not.
self.substitution["codeOnFailure"] = CGIndenter(CGGeneric(string.Template(
"${type} *objPtr;\n"
"SelfRef objRef;\n"
"JS::Rooted<JS::Value> val(cx, JS::ObjectValue(*${source}));\n" +
xpconnectUnwrap +
"if (NS_FAILED(rv)) {\n"
"${codeOnFailure}\n"
"}\n"
"// We should be castable!\n"
"MOZ_ASSERT(!objRef.ptr);\n"
"// We should have an object, too!\n"
"MOZ_ASSERT(objPtr);\n"
"${target} = objPtr;").substitute(self.substitution)), 4).define()
elif (isCallbackReturnValue == "JSImpl" and
descriptor.interface.isJSImplemented()):
self.substitution["codeOnFailure"] = CGIndenter(CGGeneric(string.Template(
"// Be careful to not wrap random DOM objects here, even if\n"
"// they're wrapped in opaque security wrappers for some reason.\n"
"// XXXbz Wish we could check for a JS-implemented object\n"
"// that already has a content reflection...\n"
"if (!IsDOMObject(js::UncheckedUnwrap(${source}))) {\n"
" nsCOMPtr<nsPIDOMWindow> ourWindow;\n"
" if (!GetWindowForJSImplementedObject(cx, Callback(), getter_AddRefs(ourWindow))) {\n"
"${exceptionCode}\n"
" }\n"
" JS::Rooted<JSObject*> jsImplSourceObj(cx, ${source});\n"
" ${target} = new ${type}(jsImplSourceObj, ourWindow);\n"
"} else {\n"
"${codeOnFailure}\n"
"}").substitute(self.substitution)), 4).define()
else:
self.substitution["codeOnFailure"] = CGIndenter(
CGGeneric(self.substitution["codeOnFailure"])).define()
def __str__(self):
codeOnFailure = self.substitution["codeOnFailure"] % {'securityError': 'rv == NS_ERROR_XPC_SECURITY_MANAGER_VETO'}
return string.Template(
"""{${uncheckedObjDecl}
nsresult rv = UnwrapObject<${protoID}, ${type}>(${source}, ${target});
if (NS_FAILED(rv)) {
${codeOnFailure}
}
}""").substitute(self.substitution, codeOnFailure=codeOnFailure)
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 = """{ // Scope for tempRoot
JS::Rooted<JSObject*> tempRoot(cx, &${val}.toObject());
${declName} = new %s(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
${mutableVal} is a mutable 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.
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"):
"""
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;"
# We often want exceptionCode to be indented, since it often appears in an
# if body.
exceptionCodeIndented = CGIndenter(CGGeneric(exceptionCode))
# 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 CGWrapper(
CGGeneric(
failureCode or
('ThrowErrorMessage(cx, MSG_NOT_OBJECT, "%s");\n'
'%s' % (firstCap(sourceDescription), exceptionCode))),
post="\n")
def onFailureBadType(failureCode, typeName):
return CGWrapper(
CGGeneric(
failureCode or
('ThrowErrorMessage(cx, MSG_DOES_NOT_IMPLEMENT_INTERFACE, "%s", "%s");\n'
'%s' % (firstCap(sourceDescription), typeName,
exceptionCode))),
post="\n")
def onFailureNotCallable(failureCode):
return CGWrapper(
CGGeneric(
failureCode or
('ThrowErrorMessage(cx, MSG_NOT_CALLABLE, "%s");\n'
'%s' % (firstCap(sourceDescription), exceptionCode))),
post="\n")
# 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 CGWrapper(
CGIndenter(CGGeneric(template)),
pre="if (${haveValue}) {\n",
post=("\n"
"} else {\n"
"%s;\n"
"}" %
CGIndenter(CGGeneric(setDefault)).define())).define()
# A helper function for handling null default values. Much like
# handleDefault, but checks that the default value, if it exists, is null.
def handleDefaultNull(template, codeToSetNull):
if (defaultValue is not None and
not isinstance(defaultValue, IDLNullValue)):
raise TypeError("Can't handle non-null default value here")
return handleDefault(template, codeToSetNull)
# 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 "%s;" % codeToSetNull
if not isDefinitelyObject:
# Handle the non-object cases by wrapping up the whole
# thing in an if cascade.
templateBody = (
"if (${val}.isObject()) {\n" +
CGIndenter(CGGeneric(templateBody)).define() + "\n")
if type.nullable():
templateBody += (
"} else if (${val}.isNullOrUndefined()) {\n"
"%s;\n" % CGIndenter(CGGeneric(codeToSetNull)).define())
templateBody += (
"} else {\n" +
CGIndenter(onFailureNotAnObject(failureCode)).define() +
"}")
if type.nullable():
templateBody = handleDefaultNull(templateBody, codeToSetNull)
else:
assert(defaultValue is None)
return templateBody
# A helper function for converting things that look like a JSObject*.
def handleJSObjectType(type, isMember, failureCode):
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 == "Sequence" or isMember == "Variadic" or
isMember == "Dictionary" or isMember == "OwningUnion")
# We'll get traced by the sequence or dictionary or union tracer
declType = CGGeneric("JSObject*")
declArgs = None
templateBody = "${declName} = &${val}.toObject();"
setToNullCode = "${declName} = nullptr;"
template = wrapObjectTemplate(templateBody, type, setToNullCode,
failureCode)
return JSToNativeConversionInfo(template, declType=declType,
dealWithOptional=isOptional,
declArgs=declArgs)
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 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)
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}"
# NOTE: Keep this in sync with variadic conversions as needed
templateBody = ("""JS::ForOfIterator iter(cx);
if (!iter.init(${val}, JS::ForOfIterator::AllowNonIterable)) {
%s
}
if (!iter.valueIsIterable()) {
%s
}
%s &arr = %s;
JS::Rooted<JS::Value> temp(cx);
while (true) {
bool done;
if (!iter.next(&temp, &done)) {
%s
}
if (done) {
break;
}
%s* slotPtr = arr.AppendElement();
if (!slotPtr) {
JS_ReportOutOfMemory(cx);
%s
}
%s& slot = *slotPtr;
""" % (exceptionCodeIndented.define(),
CGIndenter(CGGeneric(notSequence)).define(),
sequenceType,
arrayRef,
CGIndenter(exceptionCodeIndented).define(),
elementInfo.declType.define(),
CGIndenter(exceptionCodeIndented).define(),
elementInfo.declType.define()))
templateBody += CGIndenter(CGGeneric(
string.Template(elementInfo.template).substitute(
{
"val": "temp",
"mutableVal": "&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",
}
))).define()
templateBody += "\n}"
templateBody = wrapObjectTemplate(templateBody, type,
"${declName}.SetNull()", notSequence)
# 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.isUnion():
nullable = type.nullable();
if nullable:
type = type.inner
unionArgumentObj = "${declName}" if isMember else "${holderName}"
if nullable:
# If we're a member, we're a Nullable, which hasn't been told it has
# a value. Otherwise we're an already-constructed Maybe.
unionArgumentObj += ".SetValue()" if isMember else ".ref()"
memberTypes = type.flatMemberTypes
names = []
interfaceMemberTypes = filter(lambda t: t.isNonCallbackInterface(), memberTypes)
if len(interfaceMemberTypes) > 0:
interfaceObject = []
for memberType in interfaceMemberTypes:
if type.isGeckoInterface():
name = memberType.inner.identifier.name
else:
name = memberType.name
interfaceObject.append(CGGeneric("(failed = !%s.TrySetTo%s(cx, ${val}, ${mutableVal}, tryNext)) || !tryNext" % (unionArgumentObj, name)))
names.append(name)
interfaceObject = CGWrapper(CGList(interfaceObject, " ||\n"), pre="done = ", post=";\n", reindent=True)
else:
interfaceObject = None
arrayObjectMemberTypes = filter(lambda t: t.isArray() or t.isSequence(), memberTypes)
if len(arrayObjectMemberTypes) > 0:
raise TypeError("Bug 767924: We don't support sequences in unions yet")
else:
arrayObject = None
dateObjectMemberTypes = filter(lambda t: t.isDate(), memberTypes)
if len(dateObjectMemberTypes) > 0:
assert len(dateObjectMemberTypes) == 1
memberType = dateObjectMemberTypes[0]
name = memberType.name
dateObject = CGGeneric("%s.SetTo%s(cx, ${val}, ${mutableVal});\n"
"done = true;" % (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 = memberType.name
callbackObject = CGGeneric("done = (failed = !%s.TrySetTo%s(cx, ${val}, ${mutableVal}, tryNext)) || !tryNext;" % (unionArgumentObj, name))
names.append(name)
else:
callbackObject = None
dictionaryMemberTypes = filter(lambda t: t.isDictionary(), memberTypes)
if len(dictionaryMemberTypes) > 0:
assert len(dictionaryMemberTypes) == 1
name = dictionaryMemberTypes[0].inner.identifier.name
setDictionary = CGGeneric("done = (failed = !%s.TrySetTo%s(cx, ${val}, ${mutableVal}, tryNext)) || !tryNext;" % (unionArgumentObj, name))
names.append(name)
else:
setDictionary = 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("%s.SetToObject(cx, &${val}.toObject());\n"
"done = true;" % unionArgumentObj)
names.append(objectMemberTypes[0].name)
else:
object = None
hasObjectTypes = interfaceObject or arrayObject or dateObject or callbackObject or object
if hasObjectTypes:
# "object" is not distinguishable from other types
assert not object or not (interfaceObject or arrayObject or dateObject or callbackObject)
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 = CGList([arrayObject, dateObject, callbackObject],
" else ")
else:
templateBody = None
if interfaceObject:
assert not object
if templateBody:
templateBody = CGIfWrapper(templateBody, "!done")
templateBody = CGList([interfaceObject, templateBody], "\n")
else:
templateBody = CGList([templateBody, object], "\n")
if dateObject:
templateBody.prepend(CGGeneric("JS::Rooted<JSObject*> argObj(cx, &${val}.toObject());"))
templateBody = CGIfWrapper(templateBody, "${val}.isObject()")
else:
templateBody = CGGeneric()
if setDictionary:
assert not object
templateBody = CGList([templateBody,
CGIfWrapper(setDictionary, "!done")], "\n")
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):
if memberType.isEnum():
name = memberType.inner.identifier.name
else:
name = memberType.name
return CGGeneric("done = (failed = !%s.TrySetTo%s(cx, ${val}, ${mutableVal}, tryNext)) || !tryNext;\n"
"break;" % (unionArgumentObj, name))
other = CGList([], "\n")
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="\n} while (0);")
if hasObjectTypes or setDictionary:
other = CGWrapper(CGIndenter(other), "{\n", post="\n}")
if object:
join = " else "
else:
other = CGWrapper(other, pre="if (!done) ")
join = "\n"
templateBody = CGList([templateBody, other], join)
else:
assert templateBody.define() == ""
templateBody = other
else:
other = None
templateBody = CGWrapper(templateBody, pre="bool done = false, failed = false, tryNext;\n")
throw = CGGeneric("if (failed) {\n"
"%s\n"
"}\n"
"if (!done) {\n"
' ThrowErrorMessage(cx, MSG_NOT_IN_UNION, "%s", "%s");\n'
"%s\n"
"}" % (exceptionCodeIndented.define(),
firstCap(sourceDescription),
", ".join(names),
exceptionCodeIndented.define()))
templateBody = CGWrapper(CGIndenter(CGList([templateBody, throw], "\n")), pre="{\n", post="\n}")
typeName = CGUnionStruct.unionTypeDecl(type, isMember)
argumentTypeName = typeName + "Argument"
if nullable:
typeName = "Nullable<" + typeName + " >"
def handleNull(templateBody, setToNullVar, extraConditionForNull=""):
nullTest = "%s${val}.isNullOrUndefined()" % extraConditionForNull
return CGIfElseWrapper(nullTest,
CGGeneric("%s.SetNull();" % 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 isMember:
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
# isMember we do it all by hand because we do not want our holder
# constructed if we're null. But if we're isMember 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 isMember:
holderArgs = "${declName}.Value().SetValue()"
declType = CGTemplatedType("Optional", declType)
constructDecl = CGGeneric("${declName}.Construct();")
declLoc = "${declName}.Value()"
else:
holderArgs = "${declName}.SetValue()"
if holderType is not None:
constructHolder = CGGeneric("${holderName}.construct(%s);" % 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 defaultValue and not isinstance(defaultValue, IDLNullValue):
tag = defaultValue.type.tag()
if tag in numericSuffixes or tag is IDLType.Tags.bool:
defaultStr = getHandleDefault(defaultValue)
value = declLoc + (".Value()" if nullable else "")
default = CGGeneric("%s.SetAs%s() = %s;" % (value,
defaultValue.type,
defaultStr))
else:
default = CGGeneric(
handleDefaultStringValue(
defaultValue, "%s.SetStringData" % unionArgumentObj) +
";")
templateBody = CGIfElseWrapper("!(${haveValue})", default, templateBody)
templateBody = CGList([constructHolder, templateBody], "\n")
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 isMember and typeNeedsRooting(defaultValue.type):
ctorArgs = "cx"
else:
ctorArgs = ""
initDictionaryWithNull = CGIfWrapper(
CGGeneric("return false;"),
('!%s.SetAs%s(%s).Init(cx, JS::NullHandleValue, "Member of %s")'
% (declLoc, getUnionMemberName(defaultValue.type),
ctorArgs, type)))
templateBody = CGIfElseWrapper("!(${haveValue})",
initDictionaryWithNull,
templateBody)
templateBody = CGList([constructDecl, templateBody], "\n")
return JSToNativeConversionInfo(templateBody.define(),
declType=declType,
holderType=holderType,
holderArgs=holderArgs,
dealWithOptional=isOptional and (not nullable or isMember))
if type.isGeckoInterface():
assert not isEnforceRange and not isClamp
descriptor = descriptorProvider.getDescriptor(
type.unroll().inner.identifier.name)
if descriptor.nativeType == 'JSObject':
# XXXbz Workers code does this sometimes
assert descriptor.workers
return handleJSObjectType(type, isMember, failureCode)
if descriptor.interface.isCallback():
name = descriptor.interface.identifier.name
if type.nullable() or isCallbackReturnValue:
declType = CGGeneric("nsRefPtr<%s>" % name);
else:
declType = CGGeneric("OwningNonNull<%s>" % name)
conversion = CGIndenter(CGCallbackTempRoot(name)).define()
template = wrapObjectTemplate(conversion, type,
"${declName} = nullptr",
failureCode)
return JSToNativeConversionInfo(template, declType=declType,
dealWithOptional=isOptional)
# This is an interface that we implement as a concrete class
# or an XPCOM interface.
# Allow null pointers for nullable types and old-binding classes, and
# use an nsRefPtr or raw pointer for callback return values to make
# them easier to return.
argIsPointer = (type.nullable() or type.unroll().inner.isExternal() or
isCallbackReturnValue)
# Sequences and non-worker callbacks have to hold a strong ref to the
# thing being passed down. Union return values must hold a strong ref
# because they may be returning an addrefed pointer.
# 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.
forceOwningType = ((descriptor.interface.isCallback() and
not descriptor.workers) or
isMember or
isCallbackReturnValue)
if forceOwningType and descriptor.nativeOwnership == 'owned':
raise TypeError("Interface %s has 'owned' nativeOwnership, so we "
"don't know how to keep it alive in %s" %
(descriptor.interface.identifier.name,
sourceDescription))
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 = "nsRefPtr<" + typeName + ">"
else:
declType = typePtr
else:
if forceOwningType:
declType = "OwningNonNull<" + typeName + ">"
else:
declType = "NonNull<" + typeName + ">"
templateBody = ""
if 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)))
elif descriptor.workers:
return handleJSObjectType(type, isMember, failureCode)
else:
# Either external, or new-binding non-castable. We always have a
# holder for these, because we don't actually know whether we have
# to addref when unwrapping or not. So we just pass an
# getter_AddRefs(nsRefPtr) 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 += "nsRefPtr<" + typeName + "> ${holderName};\n"
else:
holderType = "nsRefPtr<" + typeName + ">"
templateBody += (
"JS::Rooted<JS::Value> tmpVal(cx, ${val});\n" +
typePtr + " tmp;\n"
"if (NS_FAILED(UnwrapArg<" + typeName + ">(cx, ${val}, &tmp, static_cast<" + typeName + "**>(getter_AddRefs(${holderName})), &tmpVal))) {\n")
templateBody += CGIndenter(onFailureBadType(failureCode,
descriptor.interface.identifier.name)).define()
templateBody += ("}\n"
"MOZ_ASSERT(tmp);\n")
if not isDefinitelyObject and not forceOwningType:
# Our tmpVal will go out of scope, so we can't rely on it
# for rooting
templateBody += (
"if (tmpVal != ${val} && !${holderName}) {\n"
" // We have to have a strong ref, because we got this off\n"
" // some random object that might get GCed\n"
" ${holderName} = tmp;\n"
"}\n")
# And store our tmp, before it goes out of scope.
templateBody += "${declName} = tmp;"
# 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", 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.name
arrayType = CGGeneric(name)
declType = arrayType
if type.nullable():
declType = CGTemplatedType("Nullable", declType)
objRef = "${declName}.SetValue()"
else:
objRef = "${declName}"
template = (
"if (!%s.Init(&${val}.toObject())) {\n"
"%s" # No newline here because onFailureBadType() handles that
"}\n" %
(objRef,
CGIndenter(onFailureBadType(failureCode, type.name)).define()))
template = wrapObjectTemplate(template, type, "${declName}.SetNull()",
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():
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):
conversionCode = (
"if (!ConvertJSValueToString(cx, ${val}, ${mutableVal}, %s, %s, %s)) {\n"
"%s\n"
"}" % (nullBehavior, undefinedBehavior, varName,
exceptionCodeIndented.define()))
if defaultValue is None:
return conversionCode
if isinstance(defaultValue, IDLNullValue):
assert(type.nullable())
defaultCode = "%s.SetNull()" % varName
else:
defaultCode = handleDefaultStringValue(defaultValue,
"%s.SetData" % varName)
return handleDefault(conversionCode, defaultCode)
if isMember:
# We have to make a copy, except in the variadic case, because our
# jsval may well not live as long as our string needs to.
declType = CGGeneric("nsString")
if isMember == "Variadic":
# The string is kept alive by the argument, so we can just
# depend on it.
assignString = "${declName}.Rebind(str.Data(), str.Length())"
else:
assignString = "${declName} = str"
return JSToNativeConversionInfo(
"{\n"
" binding_detail::FakeDependentString str;\n"
"%s\n"
" %s;\n"
"}\n" % (
CGIndenter(CGGeneric(getConversionCode("str"))).define(),
assignString),
declType=declType, dealWithOptional=isOptional)
if isOptional:
declType = "Optional<nsAString>"
holderType = CGGeneric("binding_detail::FakeDependentString")
conversionCode = ("%s\n"
"${declName} = &${holderName};" %
getConversionCode("${holderName}"))
else:
declType = "binding_detail::FakeDependentString"
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 = (
"if (!ConvertJSValueToByteString(cx, ${val}, ${mutableVal},"
" %s, ${declName})) {\n"
"%s\n"
"}" % (nullable, exceptionCodeIndented.define()))
# 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;"
handleInvalidEnumValueCode = (
" if (index < 0) {\n"
" return true;\n"
" }\n")
template = (
"{\n"
" bool ok;\n"
' int index = FindEnumStringIndex<%(invalidEnumValueFatal)s>(cx, ${val}, %(values)s, "%(enumtype)s", "%(sourceDescription)s", &ok);\n'
" if (!ok) {\n"
"%(exceptionCode)s\n"
" }\n"
"%(handleInvalidEnumValueCode)s"
" %(enumLoc)s = static_cast<%(enumtype)s>(index);\n"
"}" % { "enumtype" : enumName,
"values" : enumName + "Values::" + ENUM_ENTRY_VARIABLE_NAME,
"invalidEnumValueFatal" : toStringBool(invalidEnumValueFatal),
"handleInvalidEnumValueCode" : handleInvalidEnumValueCode,
"exceptionCode" : CGIndenter(exceptionCodeIndented).define(),
"enumLoc" : enumLoc,
"sourceDescription" : firstCap(sourceDescription)
})
setNull = "${declName}.SetNull();"
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" %
(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()
name = type.unroll().identifier.name
if type.nullable():
declType = CGGeneric("nsRefPtr<%s>" % name);
else:
declType = CGGeneric("OwningNonNull<%s>" % name)
conversion = CGIndenter(CGCallbackTempRoot(name)).define()
if allowTreatNonCallableAsNull and type.treatNonCallableAsNull():
haveCallable = "JS_ObjectIsCallable(cx, &${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"
"}")
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;")).define()
else:
template = conversion
else:
template = wrapObjectTemplate(
"if (JS_ObjectIsCallable(cx, &${val}.toObject())) {\n" +
conversion +
"} else {\n"
"%s"
"}" % CGIndenter(onFailureNotCallable(failureCode)).define(),
type,
"${declName} = nullptr",
failureCode)
return JSToNativeConversionInfo(template, declType=declType,
dealWithOptional=isOptional)
if type.isAny():
assert not isEnforceRange and not isClamp
declArgs = None
if (isMember == "Variadic" or isMember == "Sequence" or
isMember == "Dictionary"):
# 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};"
# 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()"
else:
assert isinstance(defaultValue, IDLUndefinedValue)
defaultHandling = "${declName} = JS::UndefinedValue()"
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)
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}"
if failureCode is not None:
if isDefinitelyObject:
dictionaryTest = "IsObjectValueConvertibleToDictionary"
else:
dictionaryTest = "IsConvertibleToDictionary"
# Check that the value we have can in fact be converted to
# a dictionary, and return failureCode if not.
template = CGIfWrapper(
CGGeneric(failureCode),
"!%s(cx, ${val})" % dictionaryTest).define() + "\n\n"
else:
template = ""
dictLoc = "${declName}"
if type.nullable():
dictLoc += ".SetValue()"
template += ('if (!%s.Init(cx, %s, "%s")) {\n'
"%s\n"
"}" % (dictLoc, val, firstCap(sourceDescription),
exceptionCodeIndented.define()))
if type.nullable():
declType = CGTemplatedType("Nullable", declType)
template = CGIfElseWrapper("${val}.isNullOrUndefined()",
CGGeneric("${declName}.SetNull();"),
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 = (
"JS::Rooted<JSObject*> possibleDateObject(cx, &${val}.toObject());\n"
"if (!JS_ObjectIsDate(cx, possibleDateObject) ||\n"
" !%s.SetTimeStamp(cx, possibleDateObject)) {\n"
"%s\n"
"}" %
(dateVal, CGIndenter(CGGeneric(notDate)).define()))
conversion = wrapObjectTemplate(conversion, type,
"${declName}.SetNull()", 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 = (
"if (%s) {\n"
" ${declName}.SetNull();\n"
"} else if (!ValueToPrimitive<%s, %s>(cx, ${val}, &%s)) {\n"
"%s\n"
"}" % (nullCondition, typeName, conversionBehavior,
writeLoc, exceptionCodeIndented.define()))
else:
assert(defaultValue is None or
not isinstance(defaultValue, IDLNullValue))
writeLoc = "${declName}"
readLoc = writeLoc
template = (
"if (!ValueToPrimitive<%s, %s>(cx, ${val}, &%s)) {\n"
"%s\n"
"}" % (typeName, conversionBehavior, writeLoc,
exceptionCodeIndented.define()))
declType = CGGeneric(typeName)
if type.isFloat() and not type.isUnrestricted():
if lenientFloatCode is not None:
nonFiniteCode = CGIndenter(CGGeneric(lenientFloatCode)).define()
else:
nonFiniteCode = (' ThrowErrorMessage(cx, MSG_NOT_FINITE, "%s");\n'
"%s" % (firstCap(sourceDescription),
exceptionCodeIndented.define()))
template += (" else if (!mozilla::IsFinite(%s)) {\n"
" // Note: mozilla::IsFinite will do the right thing\n"
" // when passed a non-finite float too.\n"
"%s\n"
"}" % (readLoc, 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;" % (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([], "\n")
# 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(";")]))
originalHolderName = replacements["holderName"]
if holderType is not None:
if dealWithOptional:
replacements["holderName"] = "%s.ref()" % originalHolderName
holderType = CGTemplatedType("Maybe", holderType)
holderCtorArgs = None
elif info.holderArgs is not None:
holderCtorArgs = CGWrapper(getArgsCGThing(info.holderArgs),
pre="(", post=")")
else:
holderCtorArgs = None
result.append(
CGList([holderType, CGGeneric(" "),
CGGeneric(originalHolderName),
holderCtorArgs, CGGeneric(";")]))
conversion = CGGeneric(
string.Template(templateBody).substitute(replacements)
)
if checkForValue:
if dealWithOptional:
declConstruct = CGIndenter(
CGGeneric("%s.Construct(%s);" %
(originalDeclName,
getArgsCGThing(info.declArgs).define() if
info.declArgs else "")))
if holderType is not None:
holderConstruct = CGIndenter(
CGGeneric("%s.construct(%s);" %
(originalHolderName,
getArgsCGThing(info.holderArgs).define() if
info.holderArgs else "")))
else:
holderConstruct = None
else:
declConstruct = None
holderConstruct = None
conversion = CGList(
[CGGeneric(
string.Template("if (${haveValue}) {").substitute(
replacements
)),
declConstruct,
holderConstruct,
CGIndenter(conversion),
CGGeneric("}")],
"\n")
result.append(conversion)
# Add an empty CGGeneric to get an extra newline after the argument
# conversion.
result.append(CGGeneric(""))
return result
def convertConstIDLValueToJSVal(value):
if isinstance(value, IDLNullValue):
return "JS::NullValue()"
if isinstance(value, IDLUndefinedValue):
return "JS::UndefinedValue()"
tag = value.type.tag()
if tag in [IDLType.Tags.int8, IDLType.Tags.uint8, IDLType.Tags.int16,
IDLType.Tags.uint16, IDLType.Tags.int32]:
return "INT_TO_JSVAL(%s)" % (value.value)
if tag == IDLType.Tags.uint32:
return "UINT_TO_JSVAL(%sU)" % (value.value)
if tag in [IDLType.Tags.int64, IDLType.Tags.uint64]:
return "DOUBLE_TO_JSVAL(%s)" % numericValue(tag, value.value)
if tag == IDLType.Tags.bool:
return "JSVAL_TRUE" if value.value else "JSVAL_FALSE"
if tag in [IDLType.Tags.float, IDLType.Tags.double]:
return "DOUBLE_TO_JSVAL(%s)" % (value.value)
raise TypeError("Const value of unhandled type: %s" % value.type)
class CGArgumentConverter(CGThing):
"""
A class that takes an IDL argument object and its index in the
argument list and generates code to unwrap the argument to the
right native type.
argDescription is a description of the argument for error-reporting
purposes. Callers should assume that it might get placed in the middle of a
sentence. If it ends up at the beginning of a sentence, its first character
will be automatically uppercased.
"""
def __init__(self, argument, index, descriptorProvider,
argDescription,
invalidEnumValueFatal=True, lenientFloatCode=None):
CGThing.__init__(self)
self.argument = argument
self.argDescription = argDescription
assert(not argument.defaultValue or argument.optional)
replacer = {
"index" : index,
"argc" : "args.length()"
}
self.replacementVariables = {
"declName" : "arg%d" % index,
"holderName" : ("arg%d" % index) + "_holder",
"obj" : "obj"
}
self.replacementVariables["val"] = string.Template(
"args[${index}]"
).substitute(replacer)
self.replacementVariables["mutableVal"] = self.replacementVariables["val"]
haveValueCheck = string.Template(
"args.hasDefined(${index})").substitute(replacer)
self.replacementVariables["haveValue"] = haveValueCheck
self.descriptorProvider = descriptorProvider
if self.argument.optional and not self.argument.defaultValue:
self.argcAndIndex = replacer
else:
self.argcAndIndex = None
self.invalidEnumValueFatal = invalidEnumValueFatal
self.lenientFloatCode = lenientFloatCode
def define(self):
typeConversion = getJSToNativeConversionInfo(
self.argument.type,
self.descriptorProvider,
isOptional=(self.argcAndIndex is not None and
not self.argument.variadic),
invalidEnumValueFatal=self.invalidEnumValueFatal,
defaultValue=self.argument.defaultValue,
treatNullAs=self.argument.treatNullAs,
isEnforceRange=self.argument.enforceRange,
isClamp=self.argument.clamp,
lenientFloatCode=self.lenientFloatCode,
isMember="Variadic" if self.argument.variadic else False,
allowTreatNonCallableAsNull=self.argument.allowTreatNonCallableAsNull(),
sourceDescription=self.argDescription)
if not self.argument.variadic:
return instantiateJSToNativeConversion(
typeConversion,
self.replacementVariables,
self.argcAndIndex is not None).define()
# Variadic arguments get turned into a sequence.
if typeConversion.dealWithOptional:
raise TypeError("Shouldn't have optional things in variadics")
if typeConversion.holderType is not None:
raise TypeError("Shouldn't need holders for variadics")
replacer = dict(self.argcAndIndex, **self.replacementVariables)
replacer["seqType"] = CGTemplatedType("binding_detail::AutoSequence",
typeConversion.declType).define()
if typeNeedsRooting(self.argument.type):
rooterDecl = ("SequenceRooter<%s> ${holderName}(cx, &${declName});\n" %
typeConversion.declType.define())
else:
rooterDecl = ""
replacer["elemType"] = typeConversion.declType.define()
# NOTE: Keep this in sync with sequence conversions as needed
variadicConversion = string.Template("${seqType} ${declName};\n" +
rooterDecl +
"""if (${argc} > ${index}) {
if (!${declName}.SetCapacity(${argc} - ${index})) {
JS_ReportOutOfMemory(cx);
return false;
}
for (uint32_t variadicArg = ${index}; variadicArg < ${argc}; ++variadicArg) {
${elemType}& slot = *${declName}.AppendElement();
""").substitute(replacer)
val = string.Template("args[variadicArg]").substitute(replacer)
variadicConversion += CGIndenter(CGGeneric(
string.Template(typeConversion.template).substitute(
{
"val" : val,
"mutableVal" : val,
"declName" : "slot",
# We only need holderName here to handle isExternal()
# interfaces, which use an internal holder for the
# conversion even when forceOwningType ends up true.
"holderName": "tempHolder",
# Use the same ${obj} as for the variadic arg itself
"obj": replacer["obj"]
}
)), 4).define()
variadicConversion += ("\n"
" }\n"
"}")
return variadicConversion
def getMaybeWrapValueFuncForType(type):
# Callbacks might actually be DOM objects; nothing prevents a page from
# doing that.
if type.isCallback() or type.isCallbackInterface() or type.isObject():
if type.nullable():
return "MaybeWrapObjectOrNullValue"
return "MaybeWrapObjectValue"
# Spidermonkey interfaces are never DOM objects. Neither are sequences or
# dictionaries, since those are always plain JS objects.
if type.isSpiderMonkeyInterface() or type.isDictionary() or type.isSequence():
if type.nullable():
return "MaybeWrapNonDOMObjectOrNullValue"
return "MaybeWrapNonDOMObjectValue"
if type.isAny():
return "MaybeWrapValue"
# For other types, just go ahead an fall back on MaybeWrapValue for now:
# it's always safe to do, and shouldn't be particularly slow for any of
# them
return "MaybeWrapValue"
sequenceWrapLevel = 0
def getWrapTemplateForType(type, descriptorProvider, result, successCode,
returnsNewObject, exceptionCode, typedArraysAreStructs):
"""
Reflect a C++ value stored in "result", of IDL type "type" into JS. The
"successCode" is the code to run once we have successfully done the
conversion and must guarantee that execution of the conversion template
stops once the successCode has executed (e.g. by doing a 'return', or by
doing a 'break' if the entire conversion template is inside a block that
the 'break' will exit).
If typedArraysAreStructs is true, then if the type is a typed array,
"result" is one of the dom::TypedArray subclasses, not a JSObject*.
The resulting string should be used with string.Template. It
needs the following keys when substituting:
jsvalHandle: something that can be passed to methods taking a
JS::MutableHandle<JS::Value>. This can be a
JS::MutableHandle<JS::Value> or a JS::Rooted<JS::Value>*.
jsvalRef: something that can have .address() called on it to get a
JS::Value* and .set() called on it to set it to a JS::Value.
This can be a JS::MutableHandle<JS::Value> or a
JS::Rooted<JS::Value>.
obj: a JS::Handle<JSObject*>.
Returns (templateString, infallibility of conversion template)
"""
if successCode is None:
successCode = "return true;"
# We often want exceptionCode to be indented, since it often appears in an
# if body.
exceptionCodeIndented = CGIndenter(CGGeneric(exceptionCode))
def setUndefined():
return _setValue("", setter="setUndefined")
def setNull():
return _setValue("", setter="setNull")
def setInt32(value):
return _setValue(value, setter="setInt32")
def setString(value):
return _setValue(value, setter="setString")
def setObject(value, wrapAsType=None):
return _setValue(value, wrapAsType=wrapAsType, setter="setObject")
def setObjectOrNull(value, wrapAsType=None):
return _setValue(value, wrapAsType=wrapAsType, setter="setObjectOrNull")
def setUint32(value):
return _setValue(value, setter="setNumber")
def setDouble(value):
return _setValue("JS_NumberValue(%s)" % value)
def setBoolean(value):
return _setValue(value, setter="setBoolean")
def _setValue(value, wrapAsType=None, setter="set"):
"""
Returns the code to set the jsval to value.
If wrapAsType is not None, then will wrap the resulting value using the
function that getMaybeWrapValueFuncForType(wrapAsType) returns.
Otherwise, no wrapping will be done.
"""
if wrapAsType is None:
tail = successCode
else:
tail = (("if (!%s(cx, ${jsvalHandle})) {\n"
"%s\n" % (getMaybeWrapValueFuncForType(wrapAsType),
exceptionCodeIndented.define())) +
"}\n" +
successCode)
return ("${jsvalRef}.%s(%s);\n" +
tail) % (setter, value)
def wrapAndSetPtr(wrapCall, failureCode=None):
"""
Returns the code to set the jsval by calling "wrapCall". "failureCode"
is the code to run if calling "wrapCall" fails
"""
if failureCode is None:
failureCode = exceptionCode
str = ("if (!%s) {\n" +
CGIndenter(CGGeneric(failureCode)).define() + "\n" +
"}\n" +
successCode) % (wrapCall)
return str
if type is None or type.isVoid():
return (setUndefined(), True)
if type.isArray():
raise TypeError("Can't handle array return values yet")
if type.isSequence():
if type.nullable():
# Nullable sequences are Nullable< nsTArray<T> >
(recTemplate, recInfall) = getWrapTemplateForType(type.inner, descriptorProvider,
"%s.Value()" % result, successCode,
returnsNewObject, exceptionCode,
typedArraysAreStructs)
return ("""
if (%s.IsNull()) {
%s
}
%s""" % (result, CGIndenter(CGGeneric(setNull())).define(), recTemplate), recInfall)
# Now do non-nullable sequences. Our success code is just to break to
# where we set the element in the array. Note that we bump the
# sequenceWrapLevel around this call so that nested sequence conversions
# will use different iteration variables.
global sequenceWrapLevel
index = "sequenceIdx%d" % sequenceWrapLevel
sequenceWrapLevel += 1
innerTemplate = wrapForType(
type.inner, descriptorProvider,
{
'result' : "%s[%s]" % (result, index),
'successCode': "break;",
'jsvalRef': "tmp",
'jsvalHandle': "&tmp",
'returnsNewObject': returnsNewObject,
'exceptionCode': exceptionCode,
'obj': "returnArray"
}
)
sequenceWrapLevel -= 1
innerTemplate = CGIndenter(CGGeneric(innerTemplate), 6).define()
return (("""
uint32_t length = %s.Length();
JS::Rooted<JSObject*> returnArray(cx, JS_NewArrayObject(cx, length));
if (!returnArray) {
%s
}
// Scope for 'tmp'
{
JS::Rooted<JS::Value> tmp(cx);
for (uint32_t %s = 0; %s < length; ++%s) {
// Control block to let us common up the JS_DefineElement calls when there
// are different ways to succeed at wrapping the object.
do {
%s
} while (0);
if (!JS_DefineElement(cx, returnArray, %s, tmp,
nullptr, nullptr, JSPROP_ENUMERATE)) {
%s
}
}
}\n""" % (result, exceptionCodeIndented.define(),
index, index, index,
innerTemplate, index,
CGIndenter(exceptionCodeIndented, 4).define())) +
setObject("*returnArray"), False)
if type.isGeckoInterface() and not type.isCallbackInterface():
descriptor = descriptorProvider.getDescriptor(type.unroll().inner.identifier.name)
if type.nullable():
wrappingCode = ("if (!%s) {\n" % (result) +
CGIndenter(CGGeneric(setNull())).define() + "\n" +
"}\n")
else:
wrappingCode = ""
if not descriptor.interface.isExternal() and not descriptor.skipGen:
if descriptor.wrapperCache:
assert descriptor.nativeOwnership != 'owned'
wrapMethod = "WrapNewBindingObject"
else:
if not returnsNewObject:
raise MethodNotNewObjectError(descriptor.interface.identifier.name)
if descriptor.nativeOwnership == 'owned':
wrapMethod = "WrapNewBindingNonWrapperCachedOwnedObject"
else:
wrapMethod = "WrapNewBindingNonWrapperCachedObject"
wrap = "%s(cx, ${obj}, %s, ${jsvalHandle})" % (wrapMethod, result)
if not descriptor.hasXPConnectImpls:
# Can only fail to wrap as a new-binding object
# if they already threw an exception.
failed = ("MOZ_ASSERT(JS_IsExceptionPending(cx));\n" +
"%s" % exceptionCode)
else:
if descriptor.notflattened:
raise TypeError("%s has XPConnect impls but not flattened; "
"fallback won't work correctly" %
descriptor.interface.identifier.name)
# Try old-style wrapping for bindings which might be XPConnect impls.
failed = wrapAndSetPtr("HandleNewBindingWrappingFailure(cx, ${obj}, %s, ${jsvalHandle})" % result)
else:
if descriptor.notflattened:
getIID = "&NS_GET_IID(%s), " % descriptor.nativeType
else:
getIID = ""
wrap = "WrapObject(cx, ${obj}, %s, %s${jsvalHandle})" % (result, getIID)
failed = None
wrappingCode += wrapAndSetPtr(wrap, failed)
return (wrappingCode, False)
if type.isDOMString():
if type.nullable():
return (wrapAndSetPtr("xpc::StringToJsval(cx, %s, ${jsvalHandle})" % result), False)
else:
return (wrapAndSetPtr("xpc::NonVoidStringToJsval(cx, %s, ${jsvalHandle})" % result), False)
if type.isByteString():
if type.nullable():
return (wrapAndSetPtr("ByteStringToJsval(cx, %s, ${jsvalHandle})" % result), False)
else:
return (wrapAndSetPtr("NonVoidByteStringToJsval(cx, %s, ${jsvalHandle})" % result), False)
if type.isEnum():
if type.nullable():
resultLoc = "%s.Value()" % result
else:
resultLoc = result
conversion = ("""{
// Scope for resultStr
MOZ_ASSERT(uint32_t(%(result)s) < ArrayLength(%(strings)s));
JSString* resultStr = JS_NewStringCopyN(cx, %(strings)s[uint32_t(%(result)s)].value, %(strings)s[uint32_t(%(result)s)].length);
if (!resultStr) {
%(exceptionCode)s
}
""" % { "result" : resultLoc,
"strings" : type.unroll().inner.identifier.name + "Values::" + ENUM_ENTRY_VARIABLE_NAME,
"exceptionCode" : CGIndenter(exceptionCodeIndented).define() } +
CGIndenter(CGGeneric(setString("resultStr"))).define() +
"\n}")
if type.nullable():
conversion = CGIfElseWrapper(
"%s.IsNull()" % result,
CGGeneric(setNull()),
CGGeneric(conversion)).define()
return conversion, False
if type.isCallback() or type.isCallbackInterface():
wrapCode = setObject(
"*GetCallbackFromCallbackObject(%(result)s)",
wrapAsType=type)
if type.nullable():
wrapCode = (
"if (%(result)s) {\n" +
CGIndenter(CGGeneric(wrapCode)).define() + "\n"
"} else {\n" +
CGIndenter(CGGeneric(setNull())).define() + "\n"
"}")
wrapCode = wrapCode % { "result": result }
return wrapCode, False
if type.isAny():
# See comments in WrapNewBindingObject explaining why we need
# to wrap here.
# NB: _setValue(..., type-that-is-any) calls JS_WrapValue(), so is fallible
return (_setValue(result, wrapAsType=type), False)
if (type.isObject() or (type.isSpiderMonkeyInterface() and
not typedArraysAreStructs)):
# See comments in WrapNewBindingObject explaining why we need
# to wrap here.
if type.nullable():
toValue = "%s"
setter = setObjectOrNull
else:
toValue = "*%s"
setter = setObject
# NB: setObject{,OrNull}(..., some-object-type) calls JS_WrapValue(), so is fallible
return (setter(toValue % result, wrapAsType=type), False)
if not (type.isUnion() or type.isPrimitive() or type.isDictionary() or
type.isDate() or
(type.isSpiderMonkeyInterface() and typedArraysAreStructs)):
raise TypeError("Need to learn to wrap %s" % type)
if type.nullable():
(recTemplate, recInfal) = getWrapTemplateForType(type.inner, descriptorProvider,
"%s.Value()" % result, successCode,
returnsNewObject, exceptionCode,
typedArraysAreStructs)
return ("if (%s.IsNull()) {\n" % result +
CGIndenter(CGGeneric(setNull())).define() + "\n" +
"}\n" + recTemplate, recInfal)
if type.isSpiderMonkeyInterface():
assert typedArraysAreStructs
# See comments in WrapNewBindingObject explaining why we need
# to wrap here.
# NB: setObject(..., some-object-type) calls JS_WrapValue(), so is fallible
return (setObject("*%s.Obj()" % result,
wrapAsType=type), False)
if type.isUnion():
return (wrapAndSetPtr("%s.ToJSVal(cx, ${obj}, ${jsvalHandle})" % result),
False)
if type.isDictionary():
return (wrapAndSetPtr("%s.ToObject(cx, ${jsvalHandle})" % result),
False)
if type.isDate():
return (wrapAndSetPtr("%s.ToDateObject(cx, ${jsvalHandle})" % result),
False)
tag = type.tag()
if tag in [IDLType.Tags.int8, IDLType.Tags.uint8, IDLType.Tags.int16,
IDLType.Tags.uint16, IDLType.Tags.int32]:
return (setInt32("int32_t(%s)" % result), True)
elif tag in [IDLType.Tags.int64, IDLType.Tags.uint64,
IDLType.Tags.unrestricted_float, IDLType.Tags.float,
IDLType.Tags.unrestricted_double, IDLType.Tags.double]:
# XXXbz will cast to double do the "even significand" thing that webidl
# calls for for 64-bit ints? Do we care?
return (setDouble("double(%s)" % result), True)
elif tag == IDLType.Tags.uint32:
return (setUint32(result), True)
elif tag == IDLType.Tags.bool:
return (setBoolean(result), True)
else:
raise TypeError("Need to learn to wrap primitive: %s" % type)
def wrapForType(type, descriptorProvider, templateValues):
"""
Reflect a C++ value of IDL type "type" into JS. TemplateValues is a dict
that should contain:
* 'jsvalRef': something that can have .address() called on it to get a
JS::Value* and .set() called on it to set it to a JS::Value.
This can be a JS::MutableHandle<JS::Value> or a
JS::Rooted<JS::Value>.
* 'jsvalHandle': something that can be passed to methods taking a
JS::MutableHandle<JS::Value>. This can be a
JS::MutableHandle<JS::Value> or a JS::Rooted<JS::Value>*.
* 'obj' (optional): the name of the variable that contains the JSObject to
use as a scope when wrapping, if not supplied 'obj'
will be used as the name
* 'result' (optional): the name of the variable in which the C++ value is
stored, if not supplied 'result' will be used as
the name
* 'successCode' (optional): the code to run once we have successfully
done the conversion, if not supplied 'return
true;' will be used as the code. The
successCode must ensure that once it runs no
more of the conversion template will be
executed (e.g. by doing a 'return' or 'break'
as appropriate).
* 'returnsNewObject' (optional): If true, we're wrapping for the return
value of a [NewObject] method. Assumed
false if not set.
* 'exceptionCode' (optional): Code to run when a JS exception is thrown.
The default is "return false;". The code
passed here must return.
"""
wrap = getWrapTemplateForType(type, descriptorProvider,
templateValues.get('result', 'result'),
templateValues.get('successCode', None),
templateValues.get('returnsNewObject', False),
templateValues.get('exceptionCode',
"return false;"),
templateValues.get('typedArraysAreStructs',
False))[0]
defaultValues = {'obj': 'obj'}
return string.Template(wrap).substitute(defaultValues, **templateValues)
def infallibleForMember(member, type, descriptorProvider):
"""
Determine the fallibility of changing a C++ value of IDL type "type" into
JS for the given attribute. Apart from returnsNewObject, all the defaults
are used, since the fallbility does not change based on the boolean values,
and the template will be discarded.
CURRENT ASSUMPTIONS:
We assume that successCode for wrapping up return values cannot contain
failure conditions.
"""
return getWrapTemplateForType(type, descriptorProvider, 'result', None,\
memberReturnsNewObject(member), "return false;",
False)[1]
def leafTypeNeedsCx(type, retVal):
return (type.isAny() or type.isObject() or
(retVal and type.isSpiderMonkeyInterface()))
def leafTypeNeedsScopeObject(type, retVal):
return retVal and type.isSpiderMonkeyInterface()
def leafTypeNeedsRooting(type):
return leafTypeNeedsCx(type, False) or type.isSpiderMonkeyInterface()
def typeNeedsRooting(type):
return typeMatchesLambda(type,
lambda t: leafTypeNeedsRooting(t))
def typeNeedsCx(type, retVal=False):
return typeMatchesLambda(type,
lambda t: leafTypeNeedsCx(t, retVal))
def typeNeedsScopeObject(type, retVal=False):
return typeMatchesLambda(type,
lambda t: leafTypeNeedsScopeObject(t, retVal))
def typeMatchesLambda(type, func):
if type is None:
return False
if type.nullable():
return typeMatchesLambda(type.inner, func)
if type.isSequence() or type.isArray():
return typeMatchesLambda(type.inner, func)
if type.isUnion():
return any(typeMatchesLambda(t, func) for t in
type.unroll().flatMemberTypes)
if type.isDictionary():
return dictionaryMatchesLambda(type.inner, func)
return func(type)
def dictionaryMatchesLambda(dictionary, func):
return (any(typeMatchesLambda(m.type, func) for m in dictionary.members) or
(dictionary.parent and dictionaryMatchesLambda(dictionary.parent, func)))
# Whenever this is modified, please update CGNativeMember.getRetvalInfo as
# needed to keep the types compatible.
def getRetvalDeclarationForType(returnType, descriptorProvider,
resultAlreadyAddRefed,
isMember=False):
"""
Returns a tuple containing four things:
1) A CGThing for the type of the return value, or None if there is no need
for a return value.
2) A boolean indicating whether the return value is passed as an out
parameter.
3) A CGThing for a tracer for the return value, or None if no tracing is
needed.
4) An argument string to pass to the retval declaration
constructor or None if there are no arguments.
"""
if returnType is None or returnType.isVoid():
# Nothing to declare
return None, False, None, None
if returnType.isPrimitive() and returnType.tag() in builtinNames:
result = CGGeneric(builtinNames[returnType.tag()])
if returnType.nullable():
result = CGTemplatedType("Nullable", result)
return result, False, None, None
if returnType.isDOMString():
if isMember:
return CGGeneric("nsString"), True, None, None
return CGGeneric("DOMString"), True, None, None
if returnType.isByteString():
return CGGeneric("nsCString"), True, None, None
if returnType.isEnum():
result = CGGeneric(returnType.unroll().inner.identifier.name)
if returnType.nullable():
result = CGTemplatedType("Nullable", result)
return result, False, None, None
if returnType.isGeckoInterface():
result = CGGeneric(descriptorProvider.getDescriptor(
returnType.unroll().inner.identifier.name).nativeType)
if descriptorProvider.getDescriptor(
returnType.unroll().inner.identifier.name).nativeOwnership == 'owned':
result = CGTemplatedType("nsAutoPtr", result)
elif resultAlreadyAddRefed:
result = CGTemplatedType("nsRefPtr", result)
else:
result = CGWrapper(result, post="*")
return result, False, None, None
if returnType.isCallback():
name = returnType.unroll().identifier.name
return CGGeneric("nsRefPtr<%s>" % name), False, None, None
if returnType.isAny():
return CGGeneric("JS::Value"), False, None, None
if returnType.isObject() or returnType.isSpiderMonkeyInterface():
return CGGeneric("JSObject*"), False, None, None
if returnType.isSequence():
nullable = returnType.nullable()
if nullable:
returnType = returnType.inner
# If our result is already addrefed, use the right type in the
# sequence argument here.
(result, _, _, _) = getRetvalDeclarationForType(returnType.inner,
descriptorProvider,
resultAlreadyAddRefed,
isMember="Sequence")
# While we have our inner type, set up our rooter, if needed
if not isMember and typeNeedsRooting(returnType):
rooter = CGGeneric("SequenceRooter<%s > resultRooter(cx, &result);" %
result.define())
else:
rooter = None
result = CGTemplatedType("nsTArray", result)
if nullable:
result = CGTemplatedType("Nullable", result)
return result, True, rooter, None
if returnType.isDictionary():
nullable = returnType.nullable()
dictName = CGDictionary.makeDictionaryName(returnType.unroll().inner)
result = CGGeneric(dictName)
if not isMember and typeNeedsRooting(returnType):
if nullable:
result = CGTemplatedType("NullableRootedDictionary", result)
else:
result = CGTemplatedType("RootedDictionary", result)
resultArgs = "cx"
else:
if nullable:
result = CGTemplatedType("Nullable", result)
resultArgs = None
return result, True, None, resultArgs
if returnType.isUnion():
result = CGGeneric(CGUnionStruct.unionTypeName(returnType.unroll(), True))
if not isMember and typeNeedsRooting(returnType):
if returnType.nullable():
result = CGTemplatedType("NullableRootedUnion", result)
else:
result = CGTemplatedType("RootedUnion", result)
resultArgs = "cx"
else:
if returnType.nullable():
result = CGTemplatedType("Nullable", result)
resultArgs = None
return result, True, None, resultArgs
if returnType.isDate():
result = CGGeneric("Date")
if returnType.nullable():
result = CGTemplatedType("Nullable", result)
return result, False, None, None
raise TypeError("Don't know how to declare return value for %s" %
returnType)
def isResultAlreadyAddRefed(extendedAttributes):
return not 'resultNotAddRefed' in extendedAttributes
def needCx(returnType, arguments, extendedAttributes, considerTypes):
return (considerTypes and
(typeNeedsCx(returnType, True) or
any(typeNeedsCx(a.type) for a in arguments)) or
'implicitJSContext' in extendedAttributes)
def needScopeObject(returnType, arguments, extendedAttributes,
isWrapperCached, considerTypes, isMember):
"""
isMember should be true if we're dealing with an attribute
annotated as [StoreInSlot].
"""
return (considerTypes and not isWrapperCached and
((not isMember and typeNeedsScopeObject(returnType, True)) or
any(typeNeedsScopeObject(a.type) for a in arguments)))
class CGCallGenerator(CGThing):
"""
A class to generate an actual call to a C++ object. Assumes that the C++
object is stored in a variable whose name is given by the |object| argument.
errorReport should be a CGThing for an error report or None if no
error reporting is needed.
"""
def __init__(self, errorReport, arguments, argsPre, returnType,
extendedAttributes, descriptorProvider, nativeMethodName,
static, object="self", argsPost=[]):
CGThing.__init__(self)
assert errorReport is None or isinstance(errorReport, CGThing)
isFallible = errorReport is not None
resultAlreadyAddRefed = isResultAlreadyAddRefed(extendedAttributes)
(result, resultOutParam,
resultRooter, resultArgs) = getRetvalDeclarationForType(
returnType, descriptorProvider, resultAlreadyAddRefed)
args = CGList([CGGeneric(arg) for arg in argsPre], ", ")
for (a, name) in arguments:
arg = CGGeneric(name)
# Now constify the things that need it
def needsConst(a):
if a.type.isDictionary():
return True
if a.type.isSequence():
return True
# isObject() types are always a JS::Rooted, whether
# nullable or not, and it turns out a const JS::Rooted
# is not very helpful at all (in particular, it won't
# even convert to a JS::Handle).
# XXX bz Well, why not???
if a.type.nullable() and not a.type.isObject():
return True
if a.type.isString():
return True
if a.optional and not a.defaultValue:
# If a.defaultValue, then it's not going to use an Optional,
# so doesn't need to be const just due to being optional.
# This also covers variadic arguments.
return True
if a.type.isUnion():
return True
if a.type.isSpiderMonkeyInterface():
return True
return False
if needsConst(a):
arg = CGWrapper(arg, pre="Constify(", post=")")
# And convert NonNull<T> to T&
if (((a.type.isGeckoInterface() or a.type.isCallback()) and
not a.type.nullable()) or
a.type.isDOMString()):
arg = CGWrapper(arg, pre="NonNullHelper(", post=")")
args.append(arg)
# Return values that go in outparams go here
if resultOutParam:
args.append(CGGeneric("result"))
if isFallible:
args.append(CGGeneric("rv"))
args.extend(CGGeneric(arg) for arg in argsPost)
# Build up our actual call
self.cgRoot = CGList([], "\n")
call = CGGeneric(nativeMethodName)
if not static:
call = CGWrapper(call, pre="%s->" % object)
call = CGList([call, CGWrapper(args, pre="(", post=");")])
if result is not None:
if resultRooter is not None:
self.cgRoot.prepend(resultRooter)
if resultArgs is not None:
resultArgs = "(%s)" % resultArgs
else:
resultArgs = ""
result = CGWrapper(result, post=(" result%s;" % resultArgs))
self.cgRoot.prepend(result)
if not resultOutParam:
call = CGWrapper(call, pre="result = ")
call = CGWrapper(call)
self.cgRoot.append(call)
if isFallible:
self.cgRoot.prepend(CGGeneric("ErrorResult rv;"))
self.cgRoot.append(CGGeneric("rv.WouldReportJSException();"))
self.cgRoot.append(CGGeneric("if (rv.Failed()) {"))
self.cgRoot.append(CGIndenter(errorReport))
self.cgRoot.append(CGGeneric("}"))
def define(self):
return self.cgRoot.define()
def getUnionMemberName(type):
if type.isGeckoInterface():
return type.inner.identifier.name
if type.isEnum():
return type.inner.identifier.name
if type.isArray() or type.isSequence():
return str(type)
return type.name
class MethodNotNewObjectError(Exception):
def __init__(self, typename):
self.typename = typename
# A counter for making sure that when we're wrapping up things in
# nested sequences we don't use the same variable name to iterate over
# different sequences.
sequenceWrapLevel = 0
def wrapTypeIntoCurrentCompartment(type, value, isMember=True):
"""
Take the thing named by "value" and if it contains "any",
"object", or spidermonkey-interface types inside return a CGThing
that will wrap them into the current compartment.
"""
if type.isAny():
assert not type.nullable()
if isMember:
value = "JS::MutableHandle<JS::Value>::fromMarkedLocation(&%s)" % value
else:
value = "&" + value
return CGGeneric("if (!JS_WrapValue(cx, %s)) {\n"
" return false;\n"
"}" % value)
if type.isObject():
if isMember:
value = "JS::MutableHandle<JSObject*>::fromMarkedLocation(&%s)" % value
else:
value = "&" + value
return CGGeneric("if (!JS_WrapObject(cx, %s)) {\n"
" return false;\n"
"}" % value)
if type.isSpiderMonkeyInterface():
origValue = value
if type.nullable():
value = "%s.Value()" % value
wrapCode = CGGeneric("if (!%s.WrapIntoNewCompartment(cx)) {\n"
" return false;\n"
"}" % value)
if type.nullable():
wrapCode = CGIfWrapper(wrapCode, "!%s.IsNull()" % origValue)
return wrapCode
if type.isSequence():
origValue = value
origType = type
if type.nullable():
type = type.inner
value = "%s.Value()" % value
global sequenceWrapLevel
index = "indexName%d" % sequenceWrapLevel
sequenceWrapLevel += 1
wrapElement = wrapTypeIntoCurrentCompartment(type.inner,
"%s[%s]" % (value, index))
sequenceWrapLevel -= 1
if not wrapElement:
return None
wrapCode = CGWrapper(CGIndenter(wrapElement),
pre=("for (uint32_t %s = 0; %s < %s.Length(); ++%s) {\n" %
(index, index, value, index)),
post="\n}")
if origType.nullable():
wrapCode = CGIfWrapper(wrapCode, "!%s.IsNull()" % origValue)
return wrapCode
if type.isDictionary():
assert not type.nullable()
myDict = type.inner
memberWraps = []
while myDict:
for member in myDict.members:
memberWrap = wrapArgIntoCurrentCompartment(
member,
"%s.%s" % (value, CGDictionary.makeMemberName(member.identifier.name)))
if memberWrap:
memberWraps.append(memberWrap)
myDict = myDict.parent
return CGList(memberWraps, "\n") if len(memberWraps) != 0 else None
if type.isUnion():
memberWraps = []
if type.nullable():
type = type.inner
value = "%s.Value()" % value
for member in type.flatMemberTypes:
memberName = getUnionMemberName(member)
memberWrap = wrapTypeIntoCurrentCompartment(
member, "%s.GetAs%s()" % (value, memberName))
if memberWrap:
memberWrap = CGIfWrapper(
memberWrap, "%s.Is%s()" % (value, memberName))
memberWraps.append(memberWrap)
return CGList(memberWraps, "else ") if len(memberWraps) != 0 else None
if (type.isString() or type.isPrimitive() or type.isEnum() or
type.isGeckoInterface() or type.isCallback() or type.isDate()):
# All of these don't need wrapping
return None
raise TypeError("Unknown type; we don't know how to wrap it in constructor "
"arguments: %s" % type)
def wrapArgIntoCurrentCompartment(arg, value, isMember=True):
"""
As wrapTypeIntoCurrentCompartment but handles things being optional
"""
origValue = value
isOptional = arg.optional and not arg.defaultValue
if isOptional:
value = value + ".Value()"
wrap = wrapTypeIntoCurrentCompartment(arg.type, value, isMember)
if wrap and isOptional:
wrap = CGIfWrapper(wrap, "%s.WasPassed()" % origValue)
return wrap
class CGPerSignatureCall(CGThing):
"""
This class handles the guts of generating code for a particular
call signature. A call signature consists of four things:
1) A return type, which can be None to indicate that there is no
actual return value (e.g. this is an attribute setter) or an
IDLType if there's an IDL type involved (including |void|).
2) An argument list, which is allowed to be empty.
3) A name of a native method to call.
4) Whether or not this method is static.
We also need to know whether this is a method or a getter/setter
to do error reporting correctly.
The idlNode parameter can be either a method or an attr. We can query
|idlNode.identifier| in both cases, so we can be agnostic between the two.
"""
# XXXbz For now each entry in the argument list is either an
# IDLArgument or a FakeArgument, but longer-term we may want to
# have ways of flagging things like JSContext* or optional_argc in
# there.
def __init__(self, returnType, arguments, nativeMethodName, static,
descriptor, idlNode, argConversionStartsAt=0, getter=False,
setter=False, isConstructor=False):
assert idlNode.isMethod() == (not getter and not setter)
assert idlNode.isAttr() == (getter or setter)
# Constructors are always static
assert not isConstructor or static
CGThing.__init__(self)
self.returnType = returnType
self.descriptor = descriptor
self.idlNode = idlNode
self.extendedAttributes = descriptor.getExtendedAttributes(idlNode,
getter=getter,
setter=setter)
self.arguments = arguments
self.argCount = len(arguments)
cgThings = []
lenientFloatCode = None
if idlNode.getExtendedAttribute('LenientFloat') is not None:
if setter:
lenientFloatCode = "return true;"
elif idlNode.isMethod():
lenientFloatCode = ("args.rval().setUndefined();\n"
"return true;")
argsPre = []
if static:
nativeMethodName = "%s::%s" % (descriptor.nativeType,
nativeMethodName)
# If we're a constructor, "obj" may not be a function, so calling
# XrayAwareCalleeGlobal() on it is not safe. Of course in the
# constructor case either "obj" is an Xray or we're already in the
# content compartment, not the Xray compartment, so just
# constructing the GlobalObject from "obj" is fine.
if isConstructor:
objForGlobalObject = "obj"
else:
objForGlobalObject = "xpc::XrayAwareCalleeGlobal(obj)"
cgThings.append(CGGeneric("""GlobalObject global(cx, %s);
if (global.Failed()) {
return false;
}
""" % objForGlobalObject))
argsPre.append("global")
# For JS-implemented interfaces we do not want to base the
# needsCx decision on the types involved, just on our extended
# attributes.
needsCx = needCx(returnType, arguments, self.extendedAttributes,
not descriptor.interface.isJSImplemented())
if needsCx and not (static and descriptor.workers):
argsPre.append("cx")
needsUnwrap = False
argsPost = []
if isConstructor:
needsUnwrap = True
needsUnwrappedVar = False
unwrappedVar = "obj"
elif descriptor.interface.isJSImplemented():
needsUnwrap = True
needsUnwrappedVar = True
argsPost.append("js::GetObjectCompartment(unwrappedObj.empty() ? obj : unwrappedObj.ref())")
elif needScopeObject(returnType, arguments, self.extendedAttributes,
descriptor.wrapperCache, True,
idlNode.getExtendedAttribute("StoreInSlot")):
needsUnwrap = True
needsUnwrappedVar = True
argsPre.append("unwrappedObj.empty() ? obj : unwrappedObj.ref()")
if needsUnwrap and needsUnwrappedVar:
# We cannot assign into obj because it's a Handle, not a
# MutableHandle, so we need a separate Rooted.
cgThings.append(CGGeneric("Maybe<JS::Rooted<JSObject*> > unwrappedObj;"))
unwrappedVar = "unwrappedObj.ref()"
if idlNode.isMethod() and idlNode.isLegacycaller():
# If we can have legacycaller with identifier, we can't
# just use the idlNode to determine whether we're
# generating code for the legacycaller or not.
assert idlNode.isIdentifierLess()
# Pass in our thisVal
argsPre.append("args.thisv()")
ourName = "%s.%s" % (descriptor.interface.identifier.name,
idlNode.identifier.name)
if idlNode.isMethod():
argDescription = "argument %(index)d of " + ourName
elif setter:
argDescription = "value being assigned to %s" % ourName
else:
assert self.argCount == 0
if needsUnwrap:
# It's very important that we construct our unwrappedObj, if we need
# to do it, before we might start setting up Rooted things for our
# arguments, so that we don't violate the stack discipline Rooted
# depends on.
cgThings.append(CGGeneric(
"bool objIsXray = xpc::WrapperFactory::IsXrayWrapper(obj);"))
if needsUnwrappedVar:
cgThings.append(CGIfWrapper(
CGGeneric("unwrappedObj.construct(cx, obj);"),
"objIsXray"))
cgThings.extend([CGArgumentConverter(arguments[i], i, self.descriptor,
argDescription % { "index": i + 1 },
invalidEnumValueFatal=not setter,
lenientFloatCode=lenientFloatCode) for
i in range(argConversionStartsAt, self.argCount)])
if needsUnwrap:
# Something depends on having the unwrapped object, so unwrap it now.
xraySteps = []
# XXXkhuey we should be able to MOZ_ASSERT that ${obj} is
# not null.
xraySteps.append(
CGGeneric(string.Template("""${obj} = js::CheckedUnwrap(${obj});
if (!${obj}) {
return false;
}""").substitute({ 'obj' : unwrappedVar })))
if isConstructor:
# If we're called via an xray, we need to enter the underlying
# object's compartment and then wrap up all of our arguments into
# that compartment as needed. This is all happening after we've
# already done the conversions from JS values to WebIDL (C++)
# values, so we only need to worry about cases where there are 'any'
# or 'object' types, or other things that we represent as actual
# JSAPI types, present. Effectively, we're emulating a
# CrossCompartmentWrapper, but working with the C++ types, not the
# original list of JS::Values.
cgThings.append(CGGeneric("Maybe<JSAutoCompartment> ac;"))
xraySteps.append(CGGeneric("ac.construct(cx, obj);"))
xraySteps.extend(
wrapArgIntoCurrentCompartment(arg, argname, isMember=False)
for (arg, argname) in self.getArguments())
cgThings.append(
CGIfWrapper(CGList(xraySteps, "\n"),
"objIsXray"))
cgThings.append(CGCallGenerator(
self.getErrorReport() if self.isFallible() else None,