diff options
Diffstat (limited to 'dom/bindings/Codegen.py')
| -rw-r--r-- | dom/bindings/Codegen.py | 17364 |
1 files changed, 17364 insertions, 0 deletions
diff --git a/dom/bindings/Codegen.py b/dom/bindings/Codegen.py new file mode 100644 index 000000000..3174c37dd --- /dev/null +++ b/dom/bindings/Codegen.py @@ -0,0 +1,17364 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this file, +# You can obtain one at http://mozilla.org/MPL/2.0/. + +# Common codegen classes. + +import os +import re +import string +import math +import textwrap +import functools + +from WebIDL import BuiltinTypes, IDLBuiltinType, IDLNullValue, IDLSequenceType, IDLType, IDLAttribute, IDLInterfaceMember, IDLUndefinedValue, IDLEmptySequenceValue, IDLDictionary +from Configuration import NoSuchDescriptorError, getTypesFromDescriptor, getTypesFromDictionary, getTypesFromCallback, getAllTypes, Descriptor, MemberIsUnforgeable, iteratorNativeType + +AUTOGENERATED_WARNING_COMMENT = \ + "/* THIS FILE IS AUTOGENERATED BY Codegen.py - DO NOT EDIT */\n\n" +AUTOGENERATED_WITH_SOURCE_WARNING_COMMENT = \ + "/* THIS FILE IS AUTOGENERATED FROM %s BY Codegen.py - DO NOT EDIT */\n\n" +ADDPROPERTY_HOOK_NAME = '_addProperty' +FINALIZE_HOOK_NAME = '_finalize' +OBJECT_MOVED_HOOK_NAME = '_objectMoved' +CONSTRUCT_HOOK_NAME = '_constructor' +LEGACYCALLER_HOOK_NAME = '_legacycaller' +HASINSTANCE_HOOK_NAME = '_hasInstance' +RESOLVE_HOOK_NAME = '_resolve' +MAY_RESOLVE_HOOK_NAME = '_mayResolve' +ENUMERATE_HOOK_NAME = '_enumerate' +ENUM_ENTRY_VARIABLE_NAME = 'strings' +INSTANCE_RESERVED_SLOTS = 1 + + +def memberReservedSlot(member, descriptor): + return ("(DOM_INSTANCE_RESERVED_SLOTS + %d)" % + member.slotIndices[descriptor.interface.identifier.name]) + + +def memberXrayExpandoReservedSlot(member, descriptor): + return ("(xpc::JSSLOT_EXPANDO_COUNT + %d)" % + member.slotIndices[descriptor.interface.identifier.name]) + + +def mayUseXrayExpandoSlots(descriptor, attr): + assert not attr.getExtendedAttribute("NewObject") + # For attributes whose type is a Gecko interface we always use + # slots on the reflector for caching. Also, for interfaces that + # don't want Xrays we obviously never use the Xray expando slot. + return descriptor.wantsXrays and not attr.type.isGeckoInterface() + + +def toStringBool(arg): + return str(not not arg).lower() + + +def toBindingNamespace(arg): + return arg + "Binding" + + +def isTypeCopyConstructible(type): + # Nullable and sequence stuff doesn't affect copy-constructibility + type = type.unroll() + return (type.isPrimitive() or type.isString() or type.isEnum() or + (type.isUnion() and + CGUnionStruct.isUnionCopyConstructible(type)) or + (type.isDictionary() and + CGDictionary.isDictionaryCopyConstructible(type.inner)) or + # Interface types are only copy-constructible if they're Gecko + # interfaces. SpiderMonkey interfaces are not copy-constructible + # because of rooting issues. + (type.isInterface() and type.isGeckoInterface())) + + +def idlTypeNeedsCycleCollection(type): + type = type.unroll() # Takes care of sequences and nullables + if ((type.isPrimitive() and type.tag() in builtinNames) or + type.isEnum() or + type.isString() or + type.isAny() or + type.isObject() or + type.isSpiderMonkeyInterface()): + return False + elif type.isCallback() or type.isGeckoInterface(): + return True + elif type.isUnion(): + return any(idlTypeNeedsCycleCollection(t) for t in type.flatMemberTypes) + elif type.isMozMap(): + if idlTypeNeedsCycleCollection(type.inner): + raise TypeError("Cycle collection for type %s is not supported" % type) + return False + elif type.isDictionary(): + if any(idlTypeNeedsCycleCollection(m.type) for m in type.inner.members): + raise TypeError("Cycle collection for type %s is not supported" % type) + return False + else: + raise TypeError("Don't know whether to cycle-collect type %s" % type) + + +def wantsAddProperty(desc): + return (desc.concrete and desc.wrapperCache and not desc.isGlobal()) + + +# We'll want to insert the indent at the beginnings of lines, but we +# don't want to indent empty lines. So only indent lines that have a +# non-newline character on them. +lineStartDetector = re.compile("^(?=[^\n#])", re.MULTILINE) + + +def indent(s, indentLevel=2): + """ + Indent C++ code. + + Weird secret feature: this doesn't indent lines that start with # (such as + #include lines or #ifdef/#endif). + """ + if s == "": + return s + return re.sub(lineStartDetector, indentLevel * " ", s) + + +# dedent() and fill() are often called on the same string multiple +# times. We want to memoize their return values so we don't keep +# recomputing them all the time. +def memoize(fn): + """ + Decorator to memoize a function of one argument. The cache just + grows without bound. + """ + cache = {} + + @functools.wraps(fn) + def wrapper(arg): + retval = cache.get(arg) + if retval is None: + retval = cache[arg] = fn(arg) + return retval + return wrapper + + +@memoize +def dedent(s): + """ + Remove all leading whitespace from s, and remove a blank line + at the beginning. + """ + if s.startswith('\n'): + s = s[1:] + return textwrap.dedent(s) + + +# This works by transforming the fill()-template to an equivalent +# string.Template. +fill_multiline_substitution_re = re.compile(r"( *)\$\*{(\w+)}(\n)?") + + +find_substitutions = re.compile(r"\${") + + +@memoize +def compile_fill_template(template): + """ + Helper function for fill(). Given the template string passed to fill(), + do the reusable part of template processing and return a pair (t, + argModList) that can be used every time fill() is called with that + template argument. + + argsModList is list of tuples that represent modifications to be + made to args. Each modification has, in order: i) the arg name, + ii) the modified name, iii) the indent depth. + """ + t = dedent(template) + assert t.endswith("\n") or "\n" not in t + argModList = [] + + def replace(match): + """ + Replaces a line like ' $*{xyz}\n' with '${xyz_n}', + where n is the indent depth, and add a corresponding entry to + argModList. + + Note that this needs to close over argModList, so it has to be + defined inside compile_fill_template(). + """ + indentation, name, nl = match.groups() + depth = len(indentation) + + # Check that $*{xyz} appears by itself on a line. + prev = match.string[:match.start()] + if (prev and not prev.endswith("\n")) or nl is None: + raise ValueError("Invalid fill() template: $*{%s} must appear by itself on a line" % name) + + # Now replace this whole line of template with the indented equivalent. + modified_name = name + "_" + str(depth) + argModList.append((name, modified_name, depth)) + return "${" + modified_name + "}" + + t = re.sub(fill_multiline_substitution_re, replace, t) + if not re.search(find_substitutions, t): + raise TypeError("Using fill() when dedent() would do.") + return (string.Template(t), argModList) + + +def fill(template, **args): + """ + Convenience function for filling in a multiline template. + + `fill(template, name1=v1, name2=v2)` is a lot like + `string.Template(template).substitute({"name1": v1, "name2": v2})`. + + However, it's shorter, and has a few nice features: + + * If `template` is indented, fill() automatically dedents it! + This makes code using fill() with Python's multiline strings + much nicer to look at. + + * If `template` starts with a blank line, fill() strips it off. + (Again, convenient with multiline strings.) + + * fill() recognizes a special kind of substitution + of the form `$*{name}`. + + Use this to paste in, and automatically indent, multiple lines. + (Mnemonic: The `*` is for "multiple lines"). + + A `$*` substitution must appear by itself on a line, with optional + preceding indentation (spaces only). The whole line is replaced by the + corresponding keyword argument, indented appropriately. If the + argument is an empty string, no output is generated, not even a blank + line. + """ + + t, argModList = compile_fill_template(template) + # Now apply argModList to args + for (name, modified_name, depth) in argModList: + if not (args[name] == "" or args[name].endswith("\n")): + raise ValueError("Argument %s with value %r is missing a newline" % (name, args[name])) + args[modified_name] = indent(args[name], depth) + + return t.substitute(args) + + +class CGThing(): + """ + Abstract base class for things that spit out code. + """ + def __init__(self): + pass # Nothing for now + + def declare(self): + """Produce code for a header file.""" + assert False # Override me! + + def define(self): + """Produce code for a cpp file.""" + assert False # Override me! + + def deps(self): + """Produce the deps for a pp file""" + assert False # Override me! + + +class CGStringTable(CGThing): + """ + Generate a string table for the given strings with a function accessor: + + const char *accessorName(unsigned int index) { + static const char table[] = "..."; + static const uint16_t indices = { ... }; + return &table[indices[index]]; + } + + This is more efficient than the more natural: + + const char *table[] = { + ... + }; + + The uint16_t indices are smaller than the pointer equivalents, and the + string table requires no runtime relocations. + """ + def __init__(self, accessorName, strings): + CGThing.__init__(self) + self.accessorName = accessorName + self.strings = strings + + def declare(self): + return "extern const char *%s(unsigned int aIndex);\n" % self.accessorName + + def define(self): + table = ' "\\0" '.join('"%s"' % s for s in self.strings) + indices = [] + currentIndex = 0 + for s in self.strings: + indices.append(currentIndex) + currentIndex += len(s) + 1 # for the null terminator + return fill( + """ + const char *${name}(unsigned int aIndex) + { + static const char table[] = ${table}; + static const uint16_t indices[] = { ${indices} }; + static_assert(${currentIndex} <= UINT16_MAX, "string table overflow!"); + return &table[indices[aIndex]]; + } + """, + name=self.accessorName, + table=table, + indices=", ".join("%d" % index for index in indices), + currentIndex=currentIndex) + + +class CGNativePropertyHooks(CGThing): + """ + Generate a NativePropertyHooks for a given descriptor + """ + def __init__(self, descriptor, properties): + CGThing.__init__(self) + self.descriptor = descriptor + self.properties = properties + + def declare(self): + if not self.descriptor.wantsXrays: + return "" + return dedent(""" + // We declare this as an array so that retrieving a pointer to this + // binding's property hooks only requires compile/link-time resolvable + // address arithmetic. Declaring it as a pointer instead would require + // doing a run-time load to fetch a pointer to this binding's property + // hooks. And then structures which embedded a pointer to this structure + // would require a run-time load for proper initialization, which would + // then induce static constructors. Lots of static constructors. + extern const NativePropertyHooks sNativePropertyHooks[]; + """) + + def define(self): + if not self.descriptor.wantsXrays: + return "" + deleteNamedProperty = "nullptr" + if self.descriptor.concrete and self.descriptor.proxy: + resolveOwnProperty = "ResolveOwnProperty" + enumerateOwnProperties = "EnumerateOwnProperties" + if self.descriptor.needsXrayNamedDeleterHook(): + deleteNamedProperty = "DeleteNamedProperty" + elif self.descriptor.needsXrayResolveHooks(): + resolveOwnProperty = "ResolveOwnPropertyViaResolve" + enumerateOwnProperties = "EnumerateOwnPropertiesViaGetOwnPropertyNames" + else: + resolveOwnProperty = "nullptr" + enumerateOwnProperties = "nullptr" + if self.properties.hasNonChromeOnly(): + regular = "sNativeProperties.Upcast()" + else: + regular = "nullptr" + if self.properties.hasChromeOnly(): + chrome = "sChromeOnlyNativeProperties.Upcast()" + else: + chrome = "nullptr" + constructorID = "constructors::id::" + if self.descriptor.interface.hasInterfaceObject(): + constructorID += self.descriptor.name + else: + constructorID += "_ID_Count" + prototypeID = "prototypes::id::" + if self.descriptor.interface.hasInterfacePrototypeObject(): + prototypeID += self.descriptor.name + else: + prototypeID += "_ID_Count" + parentProtoName = self.descriptor.parentPrototypeName + parentHooks = (toBindingNamespace(parentProtoName) + "::sNativePropertyHooks" + if parentProtoName else 'nullptr') + + if self.descriptor.wantsXrayExpandoClass: + expandoClass = "&sXrayExpandoObjectClass" + else: + expandoClass = "&DefaultXrayExpandoObjectClass" + + return fill( + """ + const NativePropertyHooks sNativePropertyHooks[] = { { + ${resolveOwnProperty}, + ${enumerateOwnProperties}, + ${deleteNamedProperty}, + { ${regular}, ${chrome} }, + ${prototypeID}, + ${constructorID}, + ${parentHooks}, + ${expandoClass} + } }; + """, + resolveOwnProperty=resolveOwnProperty, + enumerateOwnProperties=enumerateOwnProperties, + deleteNamedProperty=deleteNamedProperty, + regular=regular, + chrome=chrome, + prototypeID=prototypeID, + constructorID=constructorID, + parentHooks=parentHooks, + expandoClass=expandoClass) + + +def NativePropertyHooks(descriptor): + return "&sEmptyNativePropertyHooks" if not descriptor.wantsXrays else "sNativePropertyHooks" + + +def DOMClass(descriptor): + protoList = ['prototypes::id::' + proto for proto in descriptor.prototypeNameChain] + # Pad out the list to the right length with _ID_Count so we + # guarantee that all the lists are the same length. _ID_Count + # is never the ID of any prototype, so it's safe to use as + # padding. + protoList.extend(['prototypes::id::_ID_Count'] * (descriptor.config.maxProtoChainLength - len(protoList))) + + return fill( + """ + { ${protoChain} }, + IsBaseOf<nsISupports, ${nativeType} >::value, + ${hooks}, + FindAssociatedGlobalForNative<${nativeType}>::Get, + GetProtoObjectHandle, + GetCCParticipant<${nativeType}>::Get() + """, + protoChain=', '.join(protoList), + nativeType=descriptor.nativeType, + hooks=NativePropertyHooks(descriptor)) + + +class CGDOMJSClass(CGThing): + """ + Generate a DOMJSClass for a given descriptor + """ + def __init__(self, descriptor): + CGThing.__init__(self) + self.descriptor = descriptor + + def declare(self): + return "" + + def define(self): + callHook = LEGACYCALLER_HOOK_NAME if self.descriptor.operations["LegacyCaller"] else 'nullptr' + objectMovedHook = OBJECT_MOVED_HOOK_NAME if self.descriptor.wrapperCache else 'nullptr' + slotCount = INSTANCE_RESERVED_SLOTS + self.descriptor.interface.totalMembersInSlots + classFlags = "JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE | " + if self.descriptor.isGlobal(): + classFlags += "JSCLASS_DOM_GLOBAL | JSCLASS_GLOBAL_FLAGS_WITH_SLOTS(DOM_GLOBAL_SLOTS)" + traceHook = "JS_GlobalObjectTraceHook" + reservedSlots = "JSCLASS_GLOBAL_APPLICATION_SLOTS" + else: + classFlags += "JSCLASS_HAS_RESERVED_SLOTS(%d)" % slotCount + traceHook = 'nullptr' + reservedSlots = slotCount + if self.descriptor.interface.isProbablyShortLivingObject(): + classFlags += " | JSCLASS_SKIP_NURSERY_FINALIZE" + if self.descriptor.interface.getExtendedAttribute("NeedResolve"): + resolveHook = RESOLVE_HOOK_NAME + mayResolveHook = MAY_RESOLVE_HOOK_NAME + enumerateHook = ENUMERATE_HOOK_NAME + elif self.descriptor.isGlobal(): + resolveHook = "mozilla::dom::ResolveGlobal" + mayResolveHook = "mozilla::dom::MayResolveGlobal" + enumerateHook = "mozilla::dom::EnumerateGlobal" + else: + resolveHook = "nullptr" + mayResolveHook = "nullptr" + enumerateHook = "nullptr" + + return fill( + """ + static const js::ClassOps sClassOps = { + ${addProperty}, /* addProperty */ + nullptr, /* delProperty */ + nullptr, /* getProperty */ + nullptr, /* setProperty */ + ${enumerate}, /* enumerate */ + ${resolve}, /* resolve */ + ${mayResolve}, /* mayResolve */ + ${finalize}, /* finalize */ + ${call}, /* call */ + nullptr, /* hasInstance */ + nullptr, /* construct */ + ${trace}, /* trace */ + }; + + static const js::ClassExtension sClassExtension = { + nullptr, /* weakmapKeyDelegateOp */ + ${objectMoved} /* objectMovedOp */ + }; + + static const DOMJSClass sClass = { + { "${name}", + ${flags}, + &sClassOps, + JS_NULL_CLASS_SPEC, + &sClassExtension, + JS_NULL_OBJECT_OPS + }, + $*{descriptor} + }; + static_assert(${instanceReservedSlots} == DOM_INSTANCE_RESERVED_SLOTS, + "Must have the right minimal number of reserved slots."); + static_assert(${reservedSlots} >= ${slotCount}, + "Must have enough reserved slots."); + """, + name=self.descriptor.interface.identifier.name, + flags=classFlags, + addProperty=ADDPROPERTY_HOOK_NAME if wantsAddProperty(self.descriptor) else 'nullptr', + enumerate=enumerateHook, + resolve=resolveHook, + mayResolve=mayResolveHook, + finalize=FINALIZE_HOOK_NAME, + call=callHook, + trace=traceHook, + objectMoved=objectMovedHook, + descriptor=DOMClass(self.descriptor), + instanceReservedSlots=INSTANCE_RESERVED_SLOTS, + reservedSlots=reservedSlots, + slotCount=slotCount) + + +class CGDOMProxyJSClass(CGThing): + """ + Generate a DOMJSClass for a given proxy descriptor + """ + def __init__(self, descriptor): + CGThing.__init__(self) + self.descriptor = descriptor + + def declare(self): + return "" + + def define(self): + flags = ["JSCLASS_IS_DOMJSCLASS"] + # We don't use an IDL annotation for JSCLASS_EMULATES_UNDEFINED because + # we don't want people ever adding that to any interface other than + # HTMLAllCollection. So just hardcode it here. + if self.descriptor.interface.identifier.name == "HTMLAllCollection": + flags.append("JSCLASS_EMULATES_UNDEFINED") + objectMovedHook = OBJECT_MOVED_HOOK_NAME if self.descriptor.wrapperCache else 'nullptr' + return fill( + """ + static const js::ClassExtension sClassExtension = PROXY_MAKE_EXT( + ${objectMoved} + ); + + static const DOMJSClass sClass = { + PROXY_CLASS_WITH_EXT("${name}", + ${flags}, + &sClassExtension), + $*{descriptor} + }; + """, + name=self.descriptor.interface.identifier.name, + flags=" | ".join(flags), + objectMoved=objectMovedHook, + descriptor=DOMClass(self.descriptor)) + + +class CGXrayExpandoJSClass(CGThing): + """ + Generate a JSClass for an Xray expando object. This is only + needed if we have members in slots (for [Cached] or [StoreInSlot] + stuff). + """ + def __init__(self, descriptor): + assert descriptor.interface.totalMembersInSlots != 0 + assert descriptor.wantsXrays + assert descriptor.wantsXrayExpandoClass + CGThing.__init__(self) + self.descriptor = descriptor; + + def declare(self): + return "" + + def define(self): + return fill( + """ + // This may allocate too many slots, because we only really need + // slots for our non-interface-typed members that we cache. But + // allocating slots only for those would make the slot index + // computations much more complicated, so let's do this the simple + // way for now. + DEFINE_XRAY_EXPANDO_CLASS(static, sXrayExpandoObjectClass, ${memberSlots}); + """, + memberSlots=self.descriptor.interface.totalMembersInSlots) + + +def PrototypeIDAndDepth(descriptor): + prototypeID = "prototypes::id::" + if descriptor.interface.hasInterfacePrototypeObject(): + prototypeID += descriptor.interface.identifier.name + depth = "PrototypeTraits<%s>::Depth" % prototypeID + else: + prototypeID += "_ID_Count" + depth = "0" + return (prototypeID, depth) + + +def InterfacePrototypeObjectProtoGetter(descriptor): + """ + Returns a tuple with two elements: + + 1) The name of the function to call to get the prototype to use for the + interface prototype object as a JSObject*. + + 2) The name of the function to call to get the prototype to use for the + interface prototype object as a JS::Handle<JSObject*> or None if no + such function exists. + """ + parentProtoName = descriptor.parentPrototypeName + if descriptor.hasNamedPropertiesObject: + protoGetter = "GetNamedPropertiesObject" + protoHandleGetter = None + elif parentProtoName is None: + if descriptor.interface.getExtendedAttribute("ArrayClass"): + protoGetter = "JS::GetRealmArrayPrototype" + elif descriptor.interface.getExtendedAttribute("ExceptionClass"): + protoGetter = "JS::GetRealmErrorPrototype" + elif descriptor.interface.isIteratorInterface(): + protoGetter = "JS::GetRealmIteratorPrototype" + else: + protoGetter = "JS::GetRealmObjectPrototype" + protoHandleGetter = None + else: + prefix = toBindingNamespace(parentProtoName) + protoGetter = prefix + "::GetProtoObject" + protoHandleGetter = prefix + "::GetProtoObjectHandle" + + return (protoGetter, protoHandleGetter) + + +class CGPrototypeJSClass(CGThing): + def __init__(self, descriptor, properties): + CGThing.__init__(self) + self.descriptor = descriptor + self.properties = properties + + def declare(self): + # We're purely for internal consumption + return "" + + def define(self): + prototypeID, depth = PrototypeIDAndDepth(self.descriptor) + slotCount = "DOM_INTERFACE_PROTO_SLOTS_BASE" + # Globals handle unforgeables directly in Wrap() instead of + # via a holder. + if (self.descriptor.hasUnforgeableMembers and + not self.descriptor.isGlobal()): + slotCount += " + 1 /* slot for the JSObject holding the unforgeable properties */" + (protoGetter, _) = InterfacePrototypeObjectProtoGetter(self.descriptor) + type = "eGlobalInterfacePrototype" if self.descriptor.isGlobal() else "eInterfacePrototype" + return fill( + """ + static const DOMIfaceAndProtoJSClass sPrototypeClass = { + { + "${name}Prototype", + JSCLASS_IS_DOMIFACEANDPROTOJSCLASS | JSCLASS_HAS_RESERVED_SLOTS(${slotCount}), + JS_NULL_CLASS_OPS, + JS_NULL_CLASS_SPEC, + JS_NULL_CLASS_EXT, + JS_NULL_OBJECT_OPS + }, + ${type}, + false, + ${prototypeID}, + ${depth}, + ${hooks}, + "[object ${name}Prototype]", + ${protoGetter} + }; + """, + name=self.descriptor.interface.identifier.name, + slotCount=slotCount, + type=type, + hooks=NativePropertyHooks(self.descriptor), + prototypeID=prototypeID, + depth=depth, + protoGetter=protoGetter) + + +def NeedsGeneratedHasInstance(descriptor): + assert descriptor.interface.hasInterfaceObject() + return descriptor.hasXPConnectImpls or descriptor.interface.isConsequential() + + +def InterfaceObjectProtoGetter(descriptor, forXrays=False): + """ + Returns a tuple with two elements: + + 1) The name of the function to call to get the prototype to use for the + interface object as a JSObject*. + + 2) The name of the function to call to get the prototype to use for the + interface prototype as a JS::Handle<JSObject*> or None if no such + function exists. + """ + parentInterface = descriptor.interface.parent + if parentInterface: + assert not descriptor.interface.isNamespace() + parentIfaceName = parentInterface.identifier.name + parentDesc = descriptor.getDescriptor(parentIfaceName) + prefix = toBindingNamespace(parentDesc.name) + protoGetter = prefix + "::GetConstructorObject" + protoHandleGetter = prefix + "::GetConstructorObjectHandle" + elif descriptor.interface.isNamespace(): + if (forXrays or + not descriptor.interface.getExtendedAttribute("ProtoObjectHack")): + protoGetter = "JS::GetRealmObjectPrototype" + else: + protoGetter = "binding_detail::GetHackedNamespaceProtoObject" + protoHandleGetter = None + else: + protoGetter = "JS::GetRealmFunctionPrototype" + protoHandleGetter = None + return (protoGetter, protoHandleGetter) + + +class CGInterfaceObjectJSClass(CGThing): + def __init__(self, descriptor, properties): + CGThing.__init__(self) + self.descriptor = descriptor + self.properties = properties + + def declare(self): + # We're purely for internal consumption + return "" + + def define(self): + if self.descriptor.interface.ctor(): + assert not self.descriptor.interface.isNamespace() + ctorname = CONSTRUCT_HOOK_NAME + elif self.descriptor.interface.isNamespace(): + ctorname = "nullptr" + else: + ctorname = "ThrowingConstructor" + needsHasInstance = ( + not NeedsGeneratedHasInstance(self.descriptor) and + self.descriptor.interface.hasInterfacePrototypeObject()) + + prototypeID, depth = PrototypeIDAndDepth(self.descriptor) + slotCount = "DOM_INTERFACE_SLOTS_BASE" + if len(self.descriptor.interface.namedConstructors) > 0: + slotCount += (" + %i /* slots for the named constructors */" % + len(self.descriptor.interface.namedConstructors)) + (protoGetter, _) = InterfaceObjectProtoGetter(self.descriptor, + forXrays=True) + + if ctorname == "ThrowingConstructor": + ret = "" + classOpsPtr = "&sBoringInterfaceObjectClassClassOps" + elif ctorname == "nullptr": + ret = "" + classOpsPtr = "JS_NULL_CLASS_OPS" + else: + ret = fill( + """ + static const js::ClassOps sInterfaceObjectClassOps = { + nullptr, /* addProperty */ + nullptr, /* delProperty */ + nullptr, /* getProperty */ + nullptr, /* setProperty */ + nullptr, /* enumerate */ + nullptr, /* resolve */ + nullptr, /* mayResolve */ + nullptr, /* finalize */ + ${ctorname}, /* call */ + nullptr, /* hasInstance */ + ${ctorname}, /* construct */ + nullptr, /* trace */ + }; + + """, + ctorname=ctorname) + classOpsPtr = "&sInterfaceObjectClassOps" + + if self.descriptor.interface.isNamespace(): + classString = self.descriptor.interface.getExtendedAttribute("ClassString") + if classString is None: + classString = "Object" + else: + classString = classString[0] + toStringResult = "[object %s]" % classString + objectOps = "JS_NULL_OBJECT_OPS" + else: + classString = "Function" + toStringResult = ("function %s() {\\n [native code]\\n}" % + self.descriptor.interface.identifier.name) + # We need non-default ObjectOps so we can actually make + # use of our toStringResult. + objectOps = "&sInterfaceObjectClassObjectOps" + + ret = ret + fill( + """ + static const DOMIfaceAndProtoJSClass sInterfaceObjectClass = { + { + "${classString}", + JSCLASS_IS_DOMIFACEANDPROTOJSCLASS | JSCLASS_HAS_RESERVED_SLOTS(${slotCount}), + ${classOpsPtr}, + JS_NULL_CLASS_SPEC, + JS_NULL_CLASS_EXT, + ${objectOps} + }, + eInterface, + ${needsHasInstance}, + ${prototypeID}, + ${depth}, + ${hooks}, + "${toStringResult}", + ${protoGetter} + }; + """, + classString=classString, + slotCount=slotCount, + classOpsPtr=classOpsPtr, + hooks=NativePropertyHooks(self.descriptor), + objectOps=objectOps, + needsHasInstance=toStringBool(needsHasInstance), + prototypeID=prototypeID, + depth=depth, + toStringResult=toStringResult, + protoGetter=protoGetter) + return ret + +class CGList(CGThing): + """ + Generate code for a list of GCThings. Just concatenates them together, with + an optional joiner string. "\n" is a common joiner. + """ + def __init__(self, children, joiner=""): + CGThing.__init__(self) + # Make a copy of the kids into a list, because if someone passes in a + # generator we won't be able to both declare and define ourselves, or + # define ourselves more than once! + self.children = list(children) + self.joiner = joiner + + def append(self, child): + self.children.append(child) + + def prepend(self, child): + self.children.insert(0, child) + + def extend(self, kids): + self.children.extend(kids) + + def join(self, iterable): + return self.joiner.join(s for s in iterable if len(s) > 0) + + def declare(self): + return self.join(child.declare() for child in self.children if child is not None) + + def define(self): + return self.join(child.define() for child in self.children if child is not None) + + def deps(self): + deps = set() + for child in self.children: + if child is None: + continue + deps = deps.union(child.deps()) + return deps + + def __len__(self): + return len(self.children) + + +class CGGeneric(CGThing): + """ + A class that spits out a fixed string into the codegen. Can spit out a + separate string for the declaration too. + """ + def __init__(self, define="", declare=""): + self.declareText = declare + self.defineText = define + + def declare(self): + return self.declareText + + def define(self): + return self.defineText + + def deps(self): + return set() + + +class CGIndenter(CGThing): + """ + A class that takes another CGThing and generates code that indents that + CGThing by some number of spaces. The default indent is two spaces. + """ + def __init__(self, child, indentLevel=2, declareOnly=False): + assert isinstance(child, CGThing) + CGThing.__init__(self) + self.child = child + self.indentLevel = indentLevel + self.declareOnly = declareOnly + + def declare(self): + return indent(self.child.declare(), self.indentLevel) + + def define(self): + defn = self.child.define() + if self.declareOnly: + return defn + else: + return indent(defn, self.indentLevel) + + +class CGWrapper(CGThing): + """ + Generic CGThing that wraps other CGThings with pre and post text. + """ + def __init__(self, child, pre="", post="", declarePre=None, + declarePost=None, definePre=None, definePost=None, + declareOnly=False, defineOnly=False, reindent=False): + CGThing.__init__(self) + self.child = child + self.declarePre = declarePre or pre + self.declarePost = declarePost or post + self.definePre = definePre or pre + self.definePost = definePost or post + self.declareOnly = declareOnly + self.defineOnly = defineOnly + self.reindent = reindent + + def declare(self): + if self.defineOnly: + return '' + decl = self.child.declare() + if self.reindent: + decl = self.reindentString(decl, self.declarePre) + return self.declarePre + decl + self.declarePost + + def define(self): + if self.declareOnly: + return '' + defn = self.child.define() + if self.reindent: + defn = self.reindentString(defn, self.definePre) + return self.definePre + defn + self.definePost + + @staticmethod + def reindentString(stringToIndent, widthString): + # We don't use lineStartDetector because we don't want to + # insert whitespace at the beginning of our _first_ line. + # Use the length of the last line of width string, in case + # it is a multiline string. + lastLineWidth = len(widthString.splitlines()[-1]) + return stripTrailingWhitespace( + stringToIndent.replace("\n", "\n" + (" " * lastLineWidth))) + + def deps(self): + return self.child.deps() + + +class CGIfWrapper(CGList): + def __init__(self, child, condition): + CGList.__init__(self, [ + CGWrapper(CGGeneric(condition), pre="if (", post=") {\n", reindent=True), + CGIndenter(child), + CGGeneric("}\n") + ]) + + +class CGIfElseWrapper(CGList): + def __init__(self, condition, ifTrue, ifFalse): + CGList.__init__(self, [ + CGWrapper(CGGeneric(condition), pre="if (", post=") {\n", reindent=True), + CGIndenter(ifTrue), + CGGeneric("} else {\n"), + CGIndenter(ifFalse), + CGGeneric("}\n") + ]) + + +class CGElseChain(CGThing): + """ + Concatenate if statements in an if-else-if-else chain. + """ + def __init__(self, children): + self.children = [c for c in children if c is not None] + + def declare(self): + assert False + + def define(self): + if not self.children: + return "" + s = self.children[0].define() + assert s.endswith("\n") + for child in self.children[1:]: + code = child.define() + assert code.startswith("if") or code.startswith("{") + assert code.endswith("\n") + s = s.rstrip() + " else " + code + return s + + +class CGTemplatedType(CGWrapper): + def __init__(self, templateName, child, isConst=False, isReference=False): + const = "const " if isConst else "" + pre = "%s%s<" % (const, templateName) + ref = "&" if isReference else "" + post = ">%s" % ref + CGWrapper.__init__(self, child, pre=pre, post=post) + + +class CGNamespace(CGWrapper): + def __init__(self, namespace, child, declareOnly=False): + pre = "namespace %s {\n" % namespace + post = "} // namespace %s\n" % namespace + CGWrapper.__init__(self, child, pre=pre, post=post, + declareOnly=declareOnly) + + @staticmethod + def build(namespaces, child, declareOnly=False): + """ + Static helper method to build multiple wrapped namespaces. + """ + if not namespaces: + return CGWrapper(child, declareOnly=declareOnly) + inner = CGNamespace.build(namespaces[1:], child, declareOnly=declareOnly) + return CGNamespace(namespaces[0], inner, declareOnly=declareOnly) + + +class CGIncludeGuard(CGWrapper): + """ + Generates include guards for a header. + """ + def __init__(self, prefix, child): + """|prefix| is the filename without the extension.""" + define = 'mozilla_dom_%s_h' % prefix + CGWrapper.__init__(self, child, + declarePre='#ifndef %s\n#define %s\n\n' % (define, define), + declarePost='\n#endif // %s\n' % define) + + +class CGHeaders(CGWrapper): + """ + Generates the appropriate include statements. + """ + def __init__(self, descriptors, dictionaries, callbacks, + callbackDescriptors, + declareIncludes, defineIncludes, prefix, child, + config=None, jsImplementedDescriptors=[]): + """ + Builds a set of includes to cover |descriptors|. + + Also includes the files in |declareIncludes| in the header + file and the files in |defineIncludes| in the .cpp. + + |prefix| contains the basename of the file that we generate include + statements for. + """ + + # Determine the filenames for which we need headers. + interfaceDeps = [d.interface for d in descriptors] + ancestors = [] + for iface in interfaceDeps: + if iface.parent: + # We're going to need our parent's prototype, to use as the + # prototype of our prototype object. + ancestors.append(iface.parent) + # And if we have an interface object, we'll need the nearest + # ancestor with an interface object too, so we can use its + # interface object as the proto of our interface object. + if iface.hasInterfaceObject(): + parent = iface.parent + while parent and not parent.hasInterfaceObject(): + parent = parent.parent + if parent: + ancestors.append(parent) + interfaceDeps.extend(ancestors) + bindingIncludes = set(self.getDeclarationFilename(d) for d in interfaceDeps) + + # Grab all the implementation declaration files we need. + implementationIncludes = set(d.headerFile for d in descriptors if d.needsHeaderInclude()) + + # Grab the includes for checking hasInstance + interfacesImplementingSelf = set() + for d in descriptors: + interfacesImplementingSelf |= d.interface.interfacesImplementingSelf + implementationIncludes |= set(self.getDeclarationFilename(i) for i in + interfacesImplementingSelf) + + # Grab the includes for the things that involve XPCOM interfaces + hasInstanceIncludes = set("nsIDOM" + d.interface.identifier.name + ".h" for d + in descriptors if + d.interface.hasInterfaceObject() and + NeedsGeneratedHasInstance(d) and + d.interface.hasInterfacePrototypeObject()) + if len(hasInstanceIncludes) > 0: + hasInstanceIncludes.add("nsContentUtils.h") + + # Now find all the things we'll need as arguments because we + # need to wrap or unwrap them. + bindingHeaders = set() + declareIncludes = set(declareIncludes) + + def addHeadersForType((t, dictionary)): + """ + Add the relevant headers for this type. We use dictionary, if + passed, to decide what to do with interface types. + """ + # Dictionaries have members that need to be actually + # declared, not just forward-declared. + if dictionary: + headerSet = declareIncludes + else: + headerSet = bindingHeaders + if t.nullable(): + # Need to make sure that Nullable as a dictionary + # member works. + headerSet.add("mozilla/dom/Nullable.h") + unrolled = t.unroll() + if unrolled.isUnion(): + headerSet.add(self.getUnionDeclarationFilename(config, unrolled)) + bindingHeaders.add("mozilla/dom/UnionConversions.h") + elif unrolled.isDate(): + if dictionary or jsImplementedDescriptors: + declareIncludes.add("mozilla/dom/Date.h") + else: + bindingHeaders.add("mozilla/dom/Date.h") + elif unrolled.isInterface(): + if unrolled.isSpiderMonkeyInterface(): + bindingHeaders.add("jsfriendapi.h") + if jsImplementedDescriptors: + # Since we can't forward-declare typed array types + # (because they're typedefs), we have to go ahead and + # just include their header if we need to have functions + # taking references to them declared in that header. + headerSet = declareIncludes + headerSet.add("mozilla/dom/TypedArray.h") + else: + try: + typeDesc = config.getDescriptor(unrolled.inner.identifier.name) + except NoSuchDescriptorError: + return + # Dictionaries with interface members rely on the + # actual class definition of that interface member + # being visible in the binding header, because they + # store them in RefPtr and have inline + # constructors/destructors. + # + # XXXbz maybe dictionaries with interface members + # should just have out-of-line constructors and + # destructors? + headerSet.add(typeDesc.headerFile) + elif unrolled.isDictionary(): + headerSet.add(self.getDeclarationFilename(unrolled.inner)) + elif unrolled.isCallback(): + headerSet.add(self.getDeclarationFilename(unrolled.callback)) + elif unrolled.isFloat() and not unrolled.isUnrestricted(): + # Restricted floats are tested for finiteness + bindingHeaders.add("mozilla/FloatingPoint.h") + bindingHeaders.add("mozilla/dom/PrimitiveConversions.h") + elif unrolled.isEnum(): + filename = self.getDeclarationFilename(unrolled.inner) + declareIncludes.add(filename) + elif unrolled.isPrimitive(): + bindingHeaders.add("mozilla/dom/PrimitiveConversions.h") + elif unrolled.isMozMap(): + if dictionary or jsImplementedDescriptors: + declareIncludes.add("mozilla/dom/MozMap.h") + else: + bindingHeaders.add("mozilla/dom/MozMap.h") + # Also add headers for the type the MozMap is + # parametrized over, if needed. + addHeadersForType((t.inner, dictionary)) + + map(addHeadersForType, + getAllTypes(descriptors + callbackDescriptors, dictionaries, + callbacks)) + + # Now make sure we're not trying to include the header from inside itself + declareIncludes.discard(prefix + ".h") + + def addHeaderForFunc(func, desc): + if func is None: + return + # Include the right class header, which we can only do + # if this is a class member function. + if desc is not None and not desc.headerIsDefault: + # An explicit header file was provided, assume that we know + # what we're doing. + return + + if "::" in func: + # Strip out the function name and convert "::" to "/" + bindingHeaders.add("/".join(func.split("::")[:-1]) + ".h") + + # Now for non-callback descriptors make sure we include any + # headers needed by Func declarations and other things like that. + for desc in descriptors: + # If this is an iterator interface generated for a seperate + # iterable interface, skip generating type includes, as we have + # what we need in IterableIterator.h + if desc.interface.isExternal() or desc.interface.isIteratorInterface(): + continue + + for m in desc.interface.members: + addHeaderForFunc(PropertyDefiner.getStringAttr(m, "Func"), desc) + staticTypeOverride = PropertyDefiner.getStringAttr(m, "StaticClassOverride") + if staticTypeOverride: + bindingHeaders.add("/".join(staticTypeOverride.split("::")) + ".h") + # getExtendedAttribute() returns a list, extract the entry. + funcList = desc.interface.getExtendedAttribute("Func") + if funcList is not None: + addHeaderForFunc(funcList[0], desc) + + if desc.interface.maplikeOrSetlikeOrIterable: + # We need ToJSValue.h for maplike/setlike type conversions + bindingHeaders.add("mozilla/dom/ToJSValue.h") + # Add headers for the key and value types of the + # maplike/setlike/iterable, since they'll be needed for + # convenience functions + if desc.interface.maplikeOrSetlikeOrIterable.hasKeyType(): + addHeadersForType((desc.interface.maplikeOrSetlikeOrIterable.keyType, + None)) + if desc.interface.maplikeOrSetlikeOrIterable.hasValueType(): + addHeadersForType((desc.interface.maplikeOrSetlikeOrIterable.valueType, + None)) + + for d in dictionaries: + if d.parent: + declareIncludes.add(self.getDeclarationFilename(d.parent)) + bindingHeaders.add(self.getDeclarationFilename(d)) + for m in d.members: + addHeaderForFunc(PropertyDefiner.getStringAttr(m, "Func"), + None) + # No need to worry about Func on members of ancestors, because that + # will happen automatically in whatever files those ancestors live + # in. + + for c in callbacks: + bindingHeaders.add(self.getDeclarationFilename(c)) + + for c in callbackDescriptors: + bindingHeaders.add(self.getDeclarationFilename(c.interface)) + + if len(callbacks) != 0: + # We need CallbackFunction to serve as our parent class + declareIncludes.add("mozilla/dom/CallbackFunction.h") + # And we need ToJSValue.h so we can wrap "this" objects + declareIncludes.add("mozilla/dom/ToJSValue.h") + + if len(callbackDescriptors) != 0 or len(jsImplementedDescriptors) != 0: + # We need CallbackInterface to serve as our parent class + declareIncludes.add("mozilla/dom/CallbackInterface.h") + # And we need ToJSValue.h so we can wrap "this" objects + declareIncludes.add("mozilla/dom/ToJSValue.h") + + # Also need to include the headers for ancestors of + # JS-implemented interfaces. + for jsImplemented in jsImplementedDescriptors: + jsParent = jsImplemented.interface.parent + if jsParent: + parentDesc = jsImplemented.getDescriptor(jsParent.identifier.name) + declareIncludes.add(parentDesc.jsImplParentHeader) + + # Let the machinery do its thing. + def _includeString(includes): + return ''.join(['#include "%s"\n' % i for i in includes]) + '\n' + CGWrapper.__init__(self, child, + declarePre=_includeString(sorted(declareIncludes)), + definePre=_includeString(sorted(set(defineIncludes) | + bindingIncludes | + bindingHeaders | + hasInstanceIncludes | + implementationIncludes))) + + @staticmethod + def getDeclarationFilename(decl): + # Use our local version of the header, not the exported one, so that + # test bindings, which don't export, will work correctly. + basename = os.path.basename(decl.filename()) + return basename.replace('.webidl', 'Binding.h') + + @staticmethod + def getUnionDeclarationFilename(config, unionType): + assert unionType.isUnion() + assert unionType.unroll() == unionType + # If a union is "defined" in multiple files, it goes in UnionTypes.h. + if len(config.filenamesPerUnion[unionType.name]) > 1: + return "mozilla/dom/UnionTypes.h" + # If a union is defined by a built-in typedef, it also goes in + # UnionTypes.h. + assert len(config.filenamesPerUnion[unionType.name]) == 1 + if "<unknown>" in config.filenamesPerUnion[unionType.name]: + return "mozilla/dom/UnionTypes.h" + return CGHeaders.getDeclarationFilename(unionType) + + +def SortedDictValues(d): + """ + Returns a list of values from the dict sorted by key. + """ + return [v for k, v in sorted(d.items())] + + +def UnionsForFile(config, webIDLFile): + """ + Returns a list of union types for all union types that are only used in + webIDLFile. If webIDLFile is None this will return the list of tuples for + union types that are used in more than one WebIDL file. + """ + return config.unionsPerFilename.get(webIDLFile, []) + + +def UnionTypes(unionTypes, config): + """ + The unionTypes argument should be a list of union types. This is typically + the list generated by UnionsForFile. + + Returns a tuple containing a set of header filenames to include in + the header for the types in unionTypes, a set of header filenames to + include in the implementation file for the types in unionTypes, a set + of tuples containing a type declaration and a boolean if the type is a + struct for member types of the union, a list of traverse methods, + unlink methods and a list of union types. These last three lists only + contain unique union types. + """ + + headers = set() + implheaders = set() + declarations = set() + unionStructs = dict() + traverseMethods = dict() + unlinkMethods = dict() + + for t in unionTypes: + name = str(t) + if name not in unionStructs: + unionStructs[name] = t + + def addHeadersForType(f): + if f.nullable(): + headers.add("mozilla/dom/Nullable.h") + isSequence = f.isSequence() + f = f.unroll() + if f.isInterface(): + if f.isSpiderMonkeyInterface(): + headers.add("jsfriendapi.h") + headers.add("mozilla/dom/TypedArray.h") + else: + try: + typeDesc = config.getDescriptor(f.inner.identifier.name) + except NoSuchDescriptorError: + return + if typeDesc.interface.isCallback() or isSequence: + # Callback interfaces always use strong refs, so + # we need to include the right header to be able + # to Release() in our inlined code. + # + # Similarly, sequences always contain strong + # refs, so we'll need the header to handler + # those. + headers.add(typeDesc.headerFile) + else: + declarations.add((typeDesc.nativeType, False)) + implheaders.add(typeDesc.headerFile) + elif f.isDictionary(): + # For a dictionary, we need to see its declaration in + # UnionTypes.h so we have its sizeof and know how big to + # make our union. + headers.add(CGHeaders.getDeclarationFilename(f.inner)) + # And if it needs rooting, we need RootedDictionary too + if typeNeedsRooting(f): + headers.add("mozilla/dom/RootedDictionary.h") + elif f.isEnum(): + # Need to see the actual definition of the enum, + # unfortunately. + headers.add(CGHeaders.getDeclarationFilename(f.inner)) + elif f.isCallback(): + # Callbacks always use strong refs, so we need to include + # the right header to be able to Release() in our inlined + # code. + headers.add(CGHeaders.getDeclarationFilename(f.callback)) + elif f.isMozMap(): + headers.add("mozilla/dom/MozMap.h") + # And add headers for the type we're parametrized over + addHeadersForType(f.inner) + + implheaders.add(CGHeaders.getUnionDeclarationFilename(config, t)) + for f in t.flatMemberTypes: + assert not f.nullable() + addHeadersForType(f) + + if idlTypeNeedsCycleCollection(t): + declarations.add(("mozilla::dom::%s" % CGUnionStruct.unionTypeName(t, True), False)) + traverseMethods[name] = CGCycleCollectionTraverseForOwningUnionMethod(t) + unlinkMethods[name] = CGCycleCollectionUnlinkForOwningUnionMethod(t) + + # The order of items in CGList is important. + # Since the union structs friend the unlinkMethods, the forward-declaration + # for these methods should come before the class declaration. Otherwise + # some compilers treat the friend declaration as a forward-declaration in + # the class scope. + return (headers, implheaders, declarations, + SortedDictValues(traverseMethods), SortedDictValues(unlinkMethods), + SortedDictValues(unionStructs)) + + +def UnionConversions(unionTypes, config): + """ + The unionTypes argument should be a list of tuples, each containing two + elements: a union type and a descriptor. This is typically the list + generated by UnionsForFile. + + Returns a tuple containing a list of headers and a CGThing to declare all + union argument conversion helper structs. + """ + headers = set() + unionConversions = dict() + + for t in unionTypes: + name = str(t) + if name not in unionConversions: + unionConversions[name] = CGUnionConversionStruct(t, config) + + def addHeadersForType(f): + f = f.unroll() + if f.isInterface(): + if f.isSpiderMonkeyInterface(): + headers.add("jsfriendapi.h") + headers.add("mozilla/dom/TypedArray.h") + elif f.inner.isExternal(): + try: + typeDesc = config.getDescriptor(f.inner.identifier.name) + except NoSuchDescriptorError: + return + headers.add(typeDesc.headerFile) + else: + headers.add(CGHeaders.getDeclarationFilename(f.inner)) + elif f.isDictionary(): + headers.add(CGHeaders.getDeclarationFilename(f.inner)) + elif f.isPrimitive(): + headers.add("mozilla/dom/PrimitiveConversions.h") + elif f.isMozMap(): + headers.add("mozilla/dom/MozMap.h") + # And the internal type of the MozMap + addHeadersForType(f.inner) + + # We plan to include UnionTypes.h no matter what, so it's + # OK if we throw it into the set here. + headers.add(CGHeaders.getUnionDeclarationFilename(config, t)) + + for f in t.flatMemberTypes: + addHeadersForType(f) + + return (headers, + CGWrapper(CGList(SortedDictValues(unionConversions), "\n"), + post="\n\n")) + + +class Argument(): + """ + A class for outputting the type and name of an argument + """ + def __init__(self, argType, name, default=None): + self.argType = argType + self.name = name + self.default = default + + def declare(self): + string = self.argType + ' ' + self.name + if self.default is not None: + string += " = " + self.default + return string + + def define(self): + return self.argType + ' ' + self.name + + +class CGAbstractMethod(CGThing): + """ + An abstract class for generating code for a method. Subclasses + should override definition_body to create the actual code. + + descriptor is the descriptor for the interface the method is associated with + + name is the name of the method as a string + + returnType is the IDLType of the return value + + args is a list of Argument objects + + inline should be True to generate an inline method, whose body is + part of the declaration. + + alwaysInline should be True to generate an inline method annotated with + MOZ_ALWAYS_INLINE. + + static should be True to generate a static method, which only has + a definition. + + If templateArgs is not None it should be a list of strings containing + template arguments, and the function will be templatized using those + arguments. + """ + def __init__(self, descriptor, name, returnType, args, inline=False, alwaysInline=False, static=False, templateArgs=None): + CGThing.__init__(self) + self.descriptor = descriptor + self.name = name + self.returnType = returnType + self.args = args + self.inline = inline + self.alwaysInline = alwaysInline + self.static = static + self.templateArgs = templateArgs + + def _argstring(self, declare): + return ', '.join([a.declare() if declare else a.define() for a in self.args]) + + def _template(self): + if self.templateArgs is None: + return '' + return 'template <%s>\n' % ', '.join(self.templateArgs) + + def _decorators(self): + decorators = [] + if self.alwaysInline: + decorators.append('MOZ_ALWAYS_INLINE') + elif self.inline: + decorators.append('inline') + if self.static: + decorators.append('static') + decorators.append(self.returnType) + maybeNewline = " " if self.inline else "\n" + return ' '.join(decorators) + maybeNewline + + def declare(self): + if self.inline: + return self._define(True) + return "%s%s%s(%s);\n" % (self._template(), self._decorators(), self.name, self._argstring(True)) + + def indent_body(self, body): + """ + Indent the code returned by self.definition_body(). Most classes + simply indent everything two spaces. This is here for + CGRegisterProtos, which needs custom indentation. + """ + return indent(body) + + def _define(self, fromDeclare=False): + return (self.definition_prologue(fromDeclare) + + self.indent_body(self.definition_body()) + + self.definition_epilogue()) + + def define(self): + return "" if self.inline else self._define() + + def definition_prologue(self, fromDeclare): + return "%s%s%s(%s)\n{\n" % (self._template(), self._decorators(), + self.name, self._argstring(fromDeclare)) + + def definition_epilogue(self): + return "}\n" + + def definition_body(self): + assert False # Override me! + + +class CGAbstractStaticMethod(CGAbstractMethod): + """ + Abstract base class for codegen of implementation-only (no + declaration) static methods. + """ + def __init__(self, descriptor, name, returnType, args): + CGAbstractMethod.__init__(self, descriptor, name, returnType, args, + inline=False, static=True) + + def declare(self): + # We only have implementation + return "" + + +class CGAbstractClassHook(CGAbstractStaticMethod): + """ + Meant for implementing JSClass hooks, like Finalize or Trace. Does very raw + 'this' unwrapping as it assumes that the unwrapped type is always known. + """ + def __init__(self, descriptor, name, returnType, args): + CGAbstractStaticMethod.__init__(self, descriptor, name, returnType, + args) + + def definition_body_prologue(self): + return ("%s* self = UnwrapPossiblyNotInitializedDOMObject<%s>(obj);\n" % + (self.descriptor.nativeType, self.descriptor.nativeType)) + + def definition_body(self): + return self.definition_body_prologue() + self.generate_code() + + def generate_code(self): + assert False # Override me! + + +class CGGetJSClassMethod(CGAbstractMethod): + def __init__(self, descriptor): + CGAbstractMethod.__init__(self, descriptor, 'GetJSClass', 'const JSClass*', + []) + + def definition_body(self): + return "return sClass.ToJSClass();\n" + + +class CGAddPropertyHook(CGAbstractClassHook): + """ + A hook for addProperty, used to preserve our wrapper from GC. + """ + def __init__(self, descriptor): + args = [Argument('JSContext*', 'cx'), + Argument('JS::Handle<JSObject*>', 'obj'), + Argument('JS::Handle<jsid>', 'id'), + Argument('JS::Handle<JS::Value>', 'val')] + CGAbstractClassHook.__init__(self, descriptor, ADDPROPERTY_HOOK_NAME, + 'bool', args) + + def generate_code(self): + assert self.descriptor.wrapperCache + return dedent(""" + // We don't want to preserve if we don't have a wrapper, and we + // obviously can't preserve if we're not initialized. + if (self && self->GetWrapperPreserveColor()) { + PreserveWrapper(self); + } + return true; + """) + + +def finalizeHook(descriptor, hookName, freeOp): + finalize = "" + if descriptor.wrapperCache: + finalize += "ClearWrapper(self, self);\n" + if descriptor.interface.getExtendedAttribute('OverrideBuiltins'): + finalize += "self->mExpandoAndGeneration.expando = JS::UndefinedValue();\n" + if descriptor.isGlobal(): + finalize += "mozilla::dom::FinalizeGlobal(CastToJSFreeOp(%s), obj);\n" % freeOp + finalize += ("AddForDeferredFinalization<%s>(self);\n" % + descriptor.nativeType) + return CGIfWrapper(CGGeneric(finalize), "self") + + +class CGClassFinalizeHook(CGAbstractClassHook): + """ + A hook for finalize, used to release our native object. + """ + def __init__(self, descriptor): + args = [Argument('js::FreeOp*', 'fop'), Argument('JSObject*', 'obj')] + CGAbstractClassHook.__init__(self, descriptor, FINALIZE_HOOK_NAME, + 'void', args) + + def generate_code(self): + return finalizeHook(self.descriptor, self.name, self.args[0].name).define() + + +class CGClassObjectMovedHook(CGAbstractClassHook): + """ + A hook for objectMovedOp, used to update the wrapper cache when an object it + is holding moves. + """ + def __init__(self, descriptor): + args = [Argument('JSObject*', 'obj'), Argument('const JSObject*', 'old')] + CGAbstractClassHook.__init__(self, descriptor, OBJECT_MOVED_HOOK_NAME, + 'void', args) + + def generate_code(self): + assert self.descriptor.wrapperCache + return CGIfWrapper(CGGeneric("UpdateWrapper(self, self, obj, old);\n"), + "self").define() + + +def JSNativeArguments(): + return [Argument('JSContext*', 'cx'), + Argument('unsigned', 'argc'), + Argument('JS::Value*', 'vp')] + + +class CGClassConstructor(CGAbstractStaticMethod): + """ + JS-visible constructor for our objects + """ + def __init__(self, descriptor, ctor, name=CONSTRUCT_HOOK_NAME): + CGAbstractStaticMethod.__init__(self, descriptor, name, 'bool', + JSNativeArguments()) + self._ctor = ctor + + def define(self): + if not self._ctor: + return "" + return CGAbstractStaticMethod.define(self) + + def definition_body(self): + return self.generate_code() + + def generate_code(self): + # [ChromeOnly] interfaces may only be constructed by chrome. + chromeOnlyCheck = "" + if isChromeOnly(self._ctor): + chromeOnlyCheck = dedent(""" + if (!nsContentUtils::ThreadsafeIsCallerChrome()) { + return ThrowingConstructor(cx, argc, vp); + } + + """) + + # Additionally, we want to throw if a caller does a bareword invocation + # of a constructor without |new|. We don't enforce this for chrome in + # realease builds to avoid the addon compat fallout of making that + # change. See bug 916644. + # + # Figure out the name of our constructor for error reporting purposes. + # For unnamed webidl constructors, identifier.name is "constructor" but + # the name JS sees is the interface name; for named constructors + # identifier.name is the actual name. + name = self._ctor.identifier.name + if name != "constructor": + ctorName = name + else: + ctorName = self.descriptor.interface.identifier.name + + preamble = fill( + """ + JS::CallArgs args = JS::CallArgsFromVp(argc, vp); + JS::Rooted<JSObject*> obj(cx, &args.callee()); + $*{chromeOnlyCheck} + if (!args.isConstructing()) { + // XXXbz wish I could get the name from the callee instead of + // Adding more relocations + return ThrowConstructorWithoutNew(cx, "${ctorName}"); + } + JS::Rooted<JSObject*> desiredProto(cx); + if (!GetDesiredProto(cx, args, &desiredProto)) { + return false; + } + """, + chromeOnlyCheck=chromeOnlyCheck, + ctorName=ctorName) + + name = self._ctor.identifier.name + nativeName = MakeNativeName(self.descriptor.binaryNameFor(name)) + callGenerator = CGMethodCall(nativeName, True, self.descriptor, + self._ctor, isConstructor=True, + constructorName=ctorName) + return preamble + "\n" + callGenerator.define() + + +# Encapsulate the constructor in a helper method to share genConstructorBody with CGJSImplMethod. +class CGConstructNavigatorObject(CGAbstractMethod): + """ + Construct a new JS-implemented WebIDL DOM object, for use on navigator. + """ + def __init__(self, descriptor): + args = [Argument('JSContext*', 'cx'), + Argument('JS::Handle<JSObject*>', 'obj'), + Argument('ErrorResult&', 'aRv')] + rtype = 'already_AddRefed<%s>' % descriptor.name + CGAbstractMethod.__init__(self, descriptor, "ConstructNavigatorObject", + rtype, args) + + def definition_body(self): + if not self.descriptor.interface.isJSImplemented(): + raise TypeError("Only JS-implemented classes are currently supported " + "on navigator. See bug 856820.") + + return dedent( + """ + GlobalObject global(cx, obj); + if (global.Failed()) { + aRv.Throw(NS_ERROR_FAILURE); + return nullptr; + } + """) + genConstructorBody(self.descriptor) + + +def NamedConstructorName(m): + return '_' + m.identifier.name + + +class CGNamedConstructors(CGThing): + def __init__(self, descriptor): + self.descriptor = descriptor + CGThing.__init__(self) + + def declare(self): + return "" + + def define(self): + if len(self.descriptor.interface.namedConstructors) == 0: + return "" + + constructorID = "constructors::id::" + if self.descriptor.interface.hasInterfaceObject(): + constructorID += self.descriptor.name + else: + constructorID += "_ID_Count" + + namedConstructors = "" + for n in self.descriptor.interface.namedConstructors: + namedConstructors += ( + "{ \"%s\", { %s, &sNamedConstructorNativePropertyHooks }, %i },\n" % + (n.identifier.name, NamedConstructorName(n), methodLength(n))) + + return fill( + """ + const NativePropertyHooks sNamedConstructorNativePropertyHooks = { + nullptr, + nullptr, + nullptr, + { nullptr, nullptr }, + prototypes::id::${name}, + ${constructorID}, + nullptr + }; + + static const NamedConstructor namedConstructors[] = { + $*{namedConstructors} + { nullptr, { nullptr, nullptr }, 0 } + }; + """, + name=self.descriptor.name, + constructorID=constructorID, + namedConstructors=namedConstructors) + + +class CGHasInstanceHook(CGAbstractStaticMethod): + def __init__(self, descriptor): + args = [Argument('JSContext*', 'cx'), + Argument('unsigned', 'argc'), + Argument('JS::Value*', 'vp')] + assert descriptor.interface.hasInterfaceObject() + assert NeedsGeneratedHasInstance(descriptor) + CGAbstractStaticMethod.__init__(self, descriptor, HASINSTANCE_HOOK_NAME, + 'bool', args) + + def define(self): + return CGAbstractStaticMethod.define(self) + + def definition_body(self): + return self.generate_code() + + def generate_code(self): + header = dedent(""" + JS::CallArgs args = JS::CallArgsFromVp(argc, vp); + if (!args.get(0).isObject()) { + args.rval().setBoolean(false); + return true; + } + + JS::Rooted<JSObject*> instance(cx, &args[0].toObject()); + """) + if self.descriptor.interface.hasInterfacePrototypeObject(): + return ( + header + + fill( + """ + + static_assert(IsBaseOf<nsISupports, ${nativeType}>::value, + "HasInstance only works for nsISupports-based classes."); + + bool ok = InterfaceHasInstance(cx, argc, vp); + if (!ok || args.rval().toBoolean()) { + return ok; + } + + // FIXME Limit this to chrome by checking xpc::AccessCheck::isChrome(obj). + nsCOMPtr<nsISupports> native = + xpc::UnwrapReflectorToISupports(js::UncheckedUnwrap(instance, /* stopAtWindowProxy = */ false)); + nsCOMPtr<nsIDOM${name}> qiResult = do_QueryInterface(native); + args.rval().setBoolean(!!qiResult); + return true; + """, + nativeType=self.descriptor.nativeType, + name=self.descriptor.interface.identifier.name)) + + hasInstanceCode = dedent(""" + + const DOMJSClass* domClass = GetDOMClass(js::UncheckedUnwrap(instance, /* stopAtWindowProxy = */ false)); + if (!domClass) { + // Not a DOM object, so certainly not an instance of this interface + args.rval().setBoolean(false); + return true; + } + """) + if self.descriptor.interface.identifier.name == "ChromeWindow": + setRval = "args.rval().setBoolean(UnwrapDOMObject<nsGlobalWindow>(js::UncheckedUnwrap(instance, /* stopAtWindowProxy = */ false))->IsChromeWindow())" + else: + setRval = "args.rval().setBoolean(true)" + # Sort interaces implementing self by name so we get stable output. + for iface in sorted(self.descriptor.interface.interfacesImplementingSelf, + key=lambda iface: iface.identifier.name): + hasInstanceCode += fill( + """ + + if (domClass->mInterfaceChain[PrototypeTraits<prototypes::id::${name}>::Depth] == prototypes::id::${name}) { + ${setRval}; + return true; + } + """, + name=iface.identifier.name, + setRval=setRval) + hasInstanceCode += ("args.rval().setBoolean(false);\n" + "return true;\n") + return header + hasInstanceCode + + +def isChromeOnly(m): + return m.getExtendedAttribute("ChromeOnly") + + +class MemberCondition: + """ + An object representing the condition for a member to actually be + exposed. Any of the arguments can be None. If not + None, they should have the following types: + + pref: The name of the preference. + func: The name of the function. + secureContext: A bool indicating whether a secure context is required. + nonExposedGlobals: A set of names of globals. Can be empty, in which case + it's treated the same way as None. + """ + def __init__(self, pref=None, func=None, secureContext=False, + nonExposedGlobals=None): + assert pref is None or isinstance(pref, str) + assert func is None or isinstance(func, str) + assert isinstance(secureContext, bool) + assert nonExposedGlobals is None or isinstance(nonExposedGlobals, set) + self.pref = pref + self.secureContext = secureContext + + def toFuncPtr(val): + if val is None: + return "nullptr" + return "&" + val + self.func = toFuncPtr(func) + + if nonExposedGlobals: + # Nonempty set + self.nonExposedGlobals = " | ".join( + map(lambda g: "GlobalNames::%s" % g, + sorted(nonExposedGlobals))) + else: + self.nonExposedGlobals = "0" + + def __eq__(self, other): + return (self.pref == other.pref and self.func == other.func and + self.secureContext == other.secureContext and + self.nonExposedGlobals == other.nonExposedGlobals) + + def __ne__(self, other): + return not self.__eq__(other) + + def hasDisablers(self): + return (self.pref is not None or + self.secureContext or + self.func != "nullptr" or + self.nonExposedGlobals != "0") + + +class PropertyDefiner: + """ + A common superclass for defining things on prototype objects. + + Subclasses should implement generateArray to generate the actual arrays of + things we're defining. They should also set self.chrome to the list of + things only exposed to chrome and self.regular to the list of things exposed + to both chrome and web pages. + """ + def __init__(self, descriptor, name): + self.descriptor = descriptor + self.name = name + # self.prefCacheData will store an array of (prefname, bool*) + # pairs for our bool var caches. generateArray will fill it + # in as needed. + self.prefCacheData = [] + + def hasChromeOnly(self): + return len(self.chrome) > 0 + + def hasNonChromeOnly(self): + return len(self.regular) > 0 + + def variableName(self, chrome): + if chrome: + if self.hasChromeOnly(): + return "sChrome" + self.name + else: + if self.hasNonChromeOnly(): + return "s" + self.name + return "nullptr" + + def usedForXrays(self): + return self.descriptor.wantsXrays + + def __str__(self): + # We only need to generate id arrays for things that will end + # up used via ResolveProperty or EnumerateProperties. + str = self.generateArray(self.regular, self.variableName(False), + self.usedForXrays()) + if self.hasChromeOnly(): + str += self.generateArray(self.chrome, self.variableName(True), + self.usedForXrays()) + return str + + @staticmethod + def getStringAttr(member, name): + attr = member.getExtendedAttribute(name) + if attr is None: + return None + # It's a list of strings + assert len(attr) == 1 + assert attr[0] is not None + return attr[0] + + @staticmethod + def getControllingCondition(interfaceMember, descriptor): + interface = descriptor.interface + nonExposureSet = interface.exposureSet - interfaceMember.exposureSet + + return MemberCondition( + PropertyDefiner.getStringAttr(interfaceMember, + "Pref"), + PropertyDefiner.getStringAttr(interfaceMember, + "Func"), + interfaceMember.getExtendedAttribute("SecureContext") is not None, + nonExposureSet) + + def generatePrefableArray(self, array, name, specFormatter, specTerminator, + specType, getCondition, getDataTuple, doIdArrays): + """ + This method generates our various arrays. + + array is an array of interface members as passed to generateArray + + name is the name as passed to generateArray + + specFormatter is a function that takes a single argument, a tuple, + and returns a string, a spec array entry + + specTerminator is a terminator for the spec array (inserted every time + our controlling pref changes and at the end of the array) + + specType is the actual typename of our spec + + getCondition is a callback function that takes an array entry and + returns the corresponding MemberCondition. + + getDataTuple is a callback function that takes an array entry and + returns a tuple suitable to be passed to specFormatter. + """ + + # We want to generate a single list of specs, but with specTerminator + # inserted at every point where the pref name controlling the member + # changes. That will make sure the order of the properties as exposed + # on the interface and interface prototype objects does not change when + # pref control is added to members while still allowing us to define all + # the members in the smallest number of JSAPI calls. + assert len(array) != 0 + # So we won't put a specTerminator at the very front of the list: + lastCondition = getCondition(array[0], self.descriptor) + + specs = [] + disablers = [] + prefableSpecs = [] + + disablersTemplate = dedent( + """ + static PrefableDisablers %s_disablers%d = { + true, %s, %s, %s + }; + """) + prefableWithDisablersTemplate = ' { &%s_disablers%d, &%s_specs[%d] }' + prefableWithoutDisablersTemplate = ' { nullptr, &%s_specs[%d] }' + prefCacheTemplate = '&%s[%d].disablers->enabled' + + def switchToCondition(props, condition): + # Remember the info about where our pref-controlled + # booleans live. + if condition.pref is not None: + props.prefCacheData.append( + (condition.pref, + prefCacheTemplate % (name, len(prefableSpecs)))) + # Set up pointers to the new sets of specs inside prefableSpecs + if condition.hasDisablers(): + prefableSpecs.append(prefableWithDisablersTemplate % + (name, len(specs), name, len(specs))) + disablers.append(disablersTemplate % + (name, len(specs), + toStringBool(condition.secureContext), + condition.nonExposedGlobals, + condition.func)) + else: + prefableSpecs.append(prefableWithoutDisablersTemplate % + (name, len(specs))) + + switchToCondition(self, lastCondition) + + for member in array: + curCondition = getCondition(member, self.descriptor) + if lastCondition != curCondition: + # Terminate previous list + specs.append(specTerminator) + # And switch to our new condition + switchToCondition(self, curCondition) + lastCondition = curCondition + # And the actual spec + specs.append(specFormatter(getDataTuple(member))) + specs.append(specTerminator) + prefableSpecs.append(" { nullptr, nullptr }") + + specType = "const " + specType + arrays = fill( + """ + static ${specType} ${name}_specs[] = { + ${specs} + }; + + ${disablers} + // Can't be const because the pref-enabled boolean needs to be writable + static Prefable<${specType}> ${name}[] = { + ${prefableSpecs} + }; + + """, + specType=specType, + name=name, + disablers='\n'.join(disablers), + specs=',\n'.join(specs), + prefableSpecs=',\n'.join(prefableSpecs)) + if doIdArrays: + arrays += "static jsid %s_ids[%i];\n\n" % (name, len(specs)) + return arrays + + +# The length of a method is the minimum of the lengths of the +# argument lists of all its overloads. +def overloadLength(arguments): + i = len(arguments) + while i > 0 and arguments[i - 1].optional: + i -= 1 + return i + + +def methodLength(method): + signatures = method.signatures() + return min(overloadLength(arguments) for retType, arguments in signatures) + + +def clearableCachedAttrs(descriptor): + return (m for m in descriptor.interface.members if + m.isAttr() and + # Constants should never need clearing! + m.dependsOn != "Nothing" and + m.slotIndices is not None) + + +def MakeClearCachedValueNativeName(member): + return "ClearCached%sValue" % MakeNativeName(member.identifier.name) + + +def MakeJSImplClearCachedValueNativeName(member): + return "_" + MakeClearCachedValueNativeName(member) + + +def IDLToCIdentifier(name): + return name.replace("-", "_") + + +class MethodDefiner(PropertyDefiner): + """ + A class for defining methods on a prototype object. + """ + def __init__(self, descriptor, name, static, unforgeable=False): + assert not (static and unforgeable) + PropertyDefiner.__init__(self, descriptor, name) + + # FIXME https://bugzilla.mozilla.org/show_bug.cgi?id=772822 + # We should be able to check for special operations without an + # identifier. For now we check if the name starts with __ + + # Ignore non-static methods for interfaces without a proto object + if descriptor.interface.hasInterfacePrototypeObject() or static: + methods = [m for m in descriptor.interface.members if + m.isMethod() and m.isStatic() == static and + MemberIsUnforgeable(m, descriptor) == unforgeable and + not m.isIdentifierLess()] + else: + methods = [] + self.chrome = [] + self.regular = [] + for m in methods: + if m.identifier.name == 'queryInterface': + if m.isStatic(): + raise TypeError("Legacy queryInterface member shouldn't be static") + signatures = m.signatures() + + def argTypeIsIID(arg): + return arg.type.inner.isExternal() and arg.type.inner.identifier.name == 'IID' + if len(signatures) > 1 or len(signatures[0][1]) > 1 or not argTypeIsIID(signatures[0][1][0]): + raise TypeError("There should be only one queryInterface method with 1 argument of type IID") + + # Make sure to not stick QueryInterface on abstract interfaces that + # have hasXPConnectImpls (like EventTarget). So only put it on + # interfaces that are concrete and all of whose ancestors are abstract. + def allAncestorsAbstract(iface): + if not iface.parent: + return True + desc = self.descriptor.getDescriptor(iface.parent.identifier.name) + if desc.concrete: + return False + return allAncestorsAbstract(iface.parent) + if (not self.descriptor.interface.hasInterfacePrototypeObject() or + not self.descriptor.concrete or + not allAncestorsAbstract(self.descriptor.interface)): + raise TypeError("QueryInterface is only supported on " + "interfaces that are concrete and all " + "of whose ancestors are abstract: " + + self.descriptor.name) + condition = "WantsQueryInterface<%s>::Enabled" % descriptor.nativeType + self.regular.append({ + "name": 'QueryInterface', + "methodInfo": False, + "length": 1, + "flags": "0", + "condition": MemberCondition(func=condition) + }) + continue + + # Iterable methods should be enumerable, maplike/setlike methods + # should not. + isMaplikeOrSetlikeMethod = (m.isMaplikeOrSetlikeOrIterableMethod() and + (m.maplikeOrSetlikeOrIterable.isMaplike() or + m.maplikeOrSetlikeOrIterable.isSetlike())) + method = { + "name": m.identifier.name, + "methodInfo": not m.isStatic(), + "length": methodLength(m), + # Methods generated for a maplike/setlike declaration are not + # enumerable. + "flags": "JSPROP_ENUMERATE" if not isMaplikeOrSetlikeMethod else "0", + "condition": PropertyDefiner.getControllingCondition(m, descriptor), + "allowCrossOriginThis": m.getExtendedAttribute("CrossOriginCallable"), + "returnsPromise": m.returnsPromise(), + "hasIteratorAlias": "@@iterator" in m.aliases + } + + if m.isStatic(): + method["nativeName"] = CppKeywords.checkMethodName(IDLToCIdentifier(m.identifier.name)) + + if isChromeOnly(m): + self.chrome.append(method) + else: + self.regular.append(method) + + # TODO: Once iterable is implemented, use tiebreak rules instead of + # failing. Also, may be more tiebreak rules to implement once spec bug + # is resolved. + # https://www.w3.org/Bugs/Public/show_bug.cgi?id=28592 + def hasIterator(methods, regular): + return (any("@@iterator" in m.aliases for m in methods) or + any("@@iterator" == r["name"] for r in regular)) + + # Check whether we need to output an @@iterator due to having an indexed + # getter. We only do this while outputting non-static and + # non-unforgeable methods, since the @@iterator function will be + # neither. + if (not static and + not unforgeable and + descriptor.supportsIndexedProperties()): + if hasIterator(methods, self.regular): + raise TypeError("Cannot have indexed getter/attr on " + "interface %s with other members " + "that generate @@iterator, such as " + "maplike/setlike or aliased functions." % + self.descriptor.interface.identifier.name) + self.regular.append({ + "name": "@@iterator", + "methodInfo": False, + "selfHostedName": "ArrayValues", + "length": 0, + "flags": "JSPROP_ENUMERATE", + "condition": MemberCondition() + }) + + if (static and + not unforgeable and + descriptor.interface.hasInterfaceObject() and + NeedsGeneratedHasInstance(descriptor)): + self.regular.append({ + "name": "@@hasInstance", + "methodInfo": False, + "nativeName": HASINSTANCE_HOOK_NAME, + "length": 1, + # Flags match those of Function[Symbol.hasInstance] + "flags": "JSPROP_READONLY | JSPROP_PERMANENT", + "condition": MemberCondition() + }) + + # Generate the keys/values/entries aliases for value iterables. + maplikeOrSetlikeOrIterable = descriptor.interface.maplikeOrSetlikeOrIterable + if (not static and + not unforgeable and + maplikeOrSetlikeOrIterable and + maplikeOrSetlikeOrIterable.isIterable() and + maplikeOrSetlikeOrIterable.isValueIterator()): + # Add our keys/values/entries/forEach + self.regular.append({ + "name": "keys", + "methodInfo": False, + "selfHostedName": "ArrayKeys", + "length": 0, + "flags": "JSPROP_ENUMERATE", + "condition": PropertyDefiner.getControllingCondition(m, + descriptor) + }) + self.regular.append({ + "name": "values", + "methodInfo": False, + "selfHostedName": "ArrayValues", + "length": 0, + "flags": "JSPROP_ENUMERATE", + "condition": PropertyDefiner.getControllingCondition(m, + descriptor) + }) + self.regular.append({ + "name": "entries", + "methodInfo": False, + "selfHostedName": "ArrayEntries", + "length": 0, + "flags": "JSPROP_ENUMERATE", + "condition": PropertyDefiner.getControllingCondition(m, + descriptor) + }) + self.regular.append({ + "name": "forEach", + "methodInfo": False, + "selfHostedName": "ArrayForEach", + "length": 1, + "flags": "JSPROP_ENUMERATE", + "condition": PropertyDefiner.getControllingCondition(m, + descriptor) + }) + + if not static: + stringifier = descriptor.operations['Stringifier'] + if (stringifier and + unforgeable == MemberIsUnforgeable(stringifier, descriptor)): + toStringDesc = { + "name": "toString", + "nativeName": stringifier.identifier.name, + "length": 0, + "flags": "JSPROP_ENUMERATE", + "condition": PropertyDefiner.getControllingCondition(stringifier, descriptor) + } + if isChromeOnly(stringifier): + self.chrome.append(toStringDesc) + else: + self.regular.append(toStringDesc) + jsonifier = descriptor.operations['Jsonifier'] + if (jsonifier and + unforgeable == MemberIsUnforgeable(jsonifier, descriptor)): + toJSONDesc = { + "name": "toJSON", + "nativeName": jsonifier.identifier.name, + "length": 0, + "flags": "JSPROP_ENUMERATE", + "condition": PropertyDefiner.getControllingCondition(jsonifier, descriptor) + } + if isChromeOnly(jsonifier): + self.chrome.append(toJSONDesc) + else: + self.regular.append(toJSONDesc) + if (unforgeable and + descriptor.interface.getExtendedAttribute("Unforgeable")): + # Synthesize our valueOf method + self.regular.append({ + "name": 'valueOf', + "nativeName": "UnforgeableValueOf", + "methodInfo": False, + "length": 0, + "flags": "JSPROP_ENUMERATE", # readonly/permanent added + # automatically. + "condition": MemberCondition() + }) + + if descriptor.interface.isJSImplemented(): + if static: + if descriptor.interface.hasInterfaceObject(): + self.chrome.append({ + "name": '_create', + "nativeName": ("%s::_Create" % descriptor.name), + "methodInfo": False, + "length": 2, + "flags": "0", + "condition": MemberCondition() + }) + else: + for m in clearableCachedAttrs(descriptor): + attrName = MakeNativeName(m.identifier.name) + self.chrome.append({ + "name": "_clearCached%sValue" % attrName, + "nativeName": MakeJSImplClearCachedValueNativeName(m), + "methodInfo": False, + "length": "0", + "flags": "0", + "condition": MemberCondition() + }) + + self.unforgeable = unforgeable + + if static: + if not descriptor.interface.hasInterfaceObject(): + # static methods go on the interface object + assert not self.hasChromeOnly() and not self.hasNonChromeOnly() + else: + if not descriptor.interface.hasInterfacePrototypeObject(): + # non-static methods go on the interface prototype object + assert not self.hasChromeOnly() and not self.hasNonChromeOnly() + + def generateArray(self, array, name, doIdArrays): + if len(array) == 0: + return "" + + def condition(m, d): + return m["condition"] + + def flags(m): + unforgeable = " | JSPROP_PERMANENT | JSPROP_READONLY" if self.unforgeable else "" + return m["flags"] + unforgeable + + def specData(m): + if "selfHostedName" in m: + selfHostedName = '"%s"' % m["selfHostedName"] + assert not m.get("methodInfo", True) + accessor = "nullptr" + jitinfo = "nullptr" + else: + selfHostedName = "nullptr" + # When defining symbols, function name may not match symbol name + methodName = m.get("methodName", m["name"]) + accessor = m.get("nativeName", IDLToCIdentifier(methodName)) + if m.get("methodInfo", True): + # Cast this in case the methodInfo is a + # JSTypedMethodJitInfo. + jitinfo = ("reinterpret_cast<const JSJitInfo*>(&%s_methodinfo)" % accessor) + if m.get("allowCrossOriginThis", False): + if m.get("returnsPromise", False): + raise TypeError("%s returns a Promise but should " + "be allowed cross-origin?" % + accessor) + accessor = "genericCrossOriginMethod" + elif self.descriptor.needsSpecialGenericOps(): + if m.get("returnsPromise", False): + accessor = "genericPromiseReturningMethod" + else: + accessor = "genericMethod" + elif m.get("returnsPromise", False): + accessor = "GenericPromiseReturningBindingMethod" + else: + accessor = "GenericBindingMethod" + else: + if m.get("returnsPromise", False): + jitinfo = "&%s_methodinfo" % accessor + accessor = "StaticMethodPromiseWrapper" + else: + jitinfo = "nullptr" + + return (m["name"], accessor, jitinfo, m["length"], flags(m), selfHostedName) + + def formatSpec(fields): + if fields[0].startswith("@@"): + fields = (fields[0][2:],) + fields[1:] + return ' JS_SYM_FNSPEC(%s, %s, %s, %s, %s, %s)' % fields + return ' JS_FNSPEC("%s", %s, %s, %s, %s, %s)' % fields + + return self.generatePrefableArray( + array, name, + formatSpec, + ' JS_FS_END', + 'JSFunctionSpec', + condition, specData, doIdArrays) + + +def IsCrossOriginWritable(attr, descriptor): + """ + Return whether the IDLAttribute in question is cross-origin writable on the + interface represented by descriptor. This is needed to handle the fact that + some, but not all, interfaces implementing URLUtils want a cross-origin + writable .href. + """ + crossOriginWritable = attr.getExtendedAttribute("CrossOriginWritable") + if not crossOriginWritable: + return False + if crossOriginWritable is True: + return True + assert (isinstance(crossOriginWritable, list) and + len(crossOriginWritable) == 1) + return crossOriginWritable[0] == descriptor.interface.identifier.name + +def isNonExposedNavigatorObjectGetter(attr, descriptor): + return (attr.navigatorObjectGetter and + not descriptor.getDescriptor(attr.type.inner.identifier.name).register) + +class AttrDefiner(PropertyDefiner): + def __init__(self, descriptor, name, static, unforgeable=False): + assert not (static and unforgeable) + PropertyDefiner.__init__(self, descriptor, name) + self.name = name + # Ignore non-static attributes for interfaces without a proto object + if descriptor.interface.hasInterfacePrototypeObject() or static: + attributes = [m for m in descriptor.interface.members if + m.isAttr() and m.isStatic() == static and + MemberIsUnforgeable(m, descriptor) == unforgeable and + not isNonExposedNavigatorObjectGetter(m, descriptor)] + else: + attributes = [] + self.chrome = [m for m in attributes if isChromeOnly(m)] + self.regular = [m for m in attributes if not isChromeOnly(m)] + self.static = static + self.unforgeable = unforgeable + + if static: + if not descriptor.interface.hasInterfaceObject(): + # static attributes go on the interface object + assert not self.hasChromeOnly() and not self.hasNonChromeOnly() + else: + if not descriptor.interface.hasInterfacePrototypeObject(): + # non-static attributes go on the interface prototype object + assert not self.hasChromeOnly() and not self.hasNonChromeOnly() + + def generateArray(self, array, name, doIdArrays): + if len(array) == 0: + return "" + + def flags(attr): + unforgeable = " | JSPROP_PERMANENT" if self.unforgeable else "" + # Attributes generated as part of a maplike/setlike declaration are + # not enumerable. + enumerable = " | JSPROP_ENUMERATE" if not attr.isMaplikeOrSetlikeAttr() else "" + return ("JSPROP_SHARED" + enumerable + unforgeable) + + def getter(attr): + if self.static: + accessor = 'get_' + IDLToCIdentifier(attr.identifier.name) + jitinfo = "nullptr" + else: + if attr.hasLenientThis(): + accessor = "genericLenientGetter" + elif attr.getExtendedAttribute("CrossOriginReadable"): + accessor = "genericCrossOriginGetter" + elif self.descriptor.needsSpecialGenericOps(): + accessor = "genericGetter" + else: + accessor = "GenericBindingGetter" + jitinfo = ("&%s_getterinfo" % + IDLToCIdentifier(attr.identifier.name)) + return "{ { %s, %s } }" % \ + (accessor, jitinfo) + + def setter(attr): + if (attr.readonly and + attr.getExtendedAttribute("PutForwards") is None and + attr.getExtendedAttribute("Replaceable") is None and + attr.getExtendedAttribute("LenientSetter") is None): + return "JSNATIVE_WRAPPER(nullptr)" + if self.static: + accessor = 'set_' + IDLToCIdentifier(attr.identifier.name) + jitinfo = "nullptr" + else: + if attr.hasLenientThis(): + accessor = "genericLenientSetter" + elif IsCrossOriginWritable(attr, self.descriptor): + accessor = "genericCrossOriginSetter" + elif self.descriptor.needsSpecialGenericOps(): + accessor = "genericSetter" + else: + accessor = "GenericBindingSetter" + jitinfo = "&%s_setterinfo" % IDLToCIdentifier(attr.identifier.name) + return "{ { %s, %s } }" % \ + (accessor, jitinfo) + + def specData(attr): + return (attr.identifier.name, flags(attr), getter(attr), + setter(attr)) + + return self.generatePrefableArray( + array, name, + lambda fields: ' { "%s", %s, { { %s, %s } } }' % fields, + ' JS_PS_END', + 'JSPropertySpec', + PropertyDefiner.getControllingCondition, specData, doIdArrays) + + +class ConstDefiner(PropertyDefiner): + """ + A class for definining constants on the interface object + """ + def __init__(self, descriptor, name): + PropertyDefiner.__init__(self, descriptor, name) + self.name = name + constants = [m for m in descriptor.interface.members if m.isConst()] + self.chrome = [m for m in constants if isChromeOnly(m)] + self.regular = [m for m in constants if not isChromeOnly(m)] + + def generateArray(self, array, name, doIdArrays): + if len(array) == 0: + return "" + + def specData(const): + return (const.identifier.name, + convertConstIDLValueToJSVal(const.value)) + + return self.generatePrefableArray( + array, name, + lambda fields: ' { "%s", %s }' % fields, + ' { 0, JS::UndefinedValue() }', + 'ConstantSpec', + PropertyDefiner.getControllingCondition, specData, doIdArrays) + + +class PropertyArrays(): + def __init__(self, descriptor): + self.staticMethods = MethodDefiner(descriptor, "StaticMethods", + static=True) + self.staticAttrs = AttrDefiner(descriptor, "StaticAttributes", + static=True) + self.methods = MethodDefiner(descriptor, "Methods", static=False) + self.attrs = AttrDefiner(descriptor, "Attributes", static=False) + self.unforgeableMethods = MethodDefiner(descriptor, "UnforgeableMethods", + static=False, unforgeable=True) + self.unforgeableAttrs = AttrDefiner(descriptor, "UnforgeableAttributes", + static=False, unforgeable=True) + self.consts = ConstDefiner(descriptor, "Constants") + + @staticmethod + def arrayNames(): + return ["staticMethods", "staticAttrs", "methods", "attrs", + "unforgeableMethods", "unforgeableAttrs", "consts"] + + def hasChromeOnly(self): + return any(getattr(self, a).hasChromeOnly() for a in self.arrayNames()) + + def hasNonChromeOnly(self): + return any(getattr(self, a).hasNonChromeOnly() for a in self.arrayNames()) + + def __str__(self): + define = "" + for array in self.arrayNames(): + define += str(getattr(self, array)) + return define + + +class CGNativeProperties(CGList): + def __init__(self, descriptor, properties): + def generateNativeProperties(name, chrome): + def check(p): + return p.hasChromeOnly() if chrome else p.hasNonChromeOnly() + + nativePropsInts = [] + nativePropsTrios = [] + + iteratorAliasIndex = -1 + for index, item in enumerate(properties.methods.regular): + if item.get("hasIteratorAlias"): + iteratorAliasIndex = index + break + nativePropsInts.append(CGGeneric(str(iteratorAliasIndex))) + + offset = 0 + for array in properties.arrayNames(): + propertyArray = getattr(properties, array) + if check(propertyArray): + varName = propertyArray.variableName(chrome) + bitfields = "true, %d /* %s */" % (offset, varName) + offset += 1 + nativePropsInts.append(CGGeneric(bitfields)) + + if propertyArray.usedForXrays(): + ids = "%(name)s_ids" + else: + ids = "nullptr" + trio = "{ %(name)s, " + ids + ", %(name)s_specs }" + trio = trio % {'name': varName} + nativePropsTrios.append(CGGeneric(trio)) + else: + bitfields = "false, 0" + nativePropsInts.append(CGGeneric(bitfields)) + + nativePropsTrios = \ + [CGWrapper(CGIndenter(CGList(nativePropsTrios, ",\n")), + pre='{\n', post='\n}')] + nativeProps = nativePropsInts + nativePropsTrios + pre = ("static const NativePropertiesN<%d> %s = {\n" % + (offset, name)) + return CGWrapper(CGIndenter(CGList(nativeProps, ",\n")), + pre=pre, post="\n};\n") + + nativeProperties = [] + if properties.hasNonChromeOnly(): + nativeProperties.append( + generateNativeProperties("sNativeProperties", False)) + if properties.hasChromeOnly(): + nativeProperties.append( + generateNativeProperties("sChromeOnlyNativeProperties", True)) + + CGList.__init__(self, nativeProperties, "\n") + + def declare(self): + return "" + + def define(self): + return CGList.define(self) + + +class CGJsonifyAttributesMethod(CGAbstractMethod): + """ + Generate the JsonifyAttributes method for an interface descriptor + """ + def __init__(self, descriptor): + args = [Argument('JSContext*', 'aCx'), + Argument('JS::Handle<JSObject*>', 'obj'), + Argument('%s*' % descriptor.nativeType, 'self'), + Argument('JS::Rooted<JSObject*>&', 'aResult')] + CGAbstractMethod.__init__(self, descriptor, 'JsonifyAttributes', 'bool', args) + + def definition_body(self): + ret = '' + interface = self.descriptor.interface + for m in interface.members: + if m.isAttr() and not m.isStatic() and m.type.isSerializable(): + ret += fill( + """ + { // scope for "temp" + JS::Rooted<JS::Value> temp(aCx); + if (!get_${name}(aCx, obj, self, JSJitGetterCallArgs(&temp))) { + return false; + } + if (!JS_DefineProperty(aCx, aResult, "${name}", temp, JSPROP_ENUMERATE)) { + return false; + } + } + """, + name=IDLToCIdentifier(m.identifier.name)) + ret += 'return true;\n' + return ret + + +class CGCreateInterfaceObjectsMethod(CGAbstractMethod): + """ + Generate the CreateInterfaceObjects method for an interface descriptor. + + properties should be a PropertyArrays instance. + """ + def __init__(self, descriptor, properties, haveUnscopables): + args = [Argument('JSContext*', 'aCx'), + Argument('JS::Handle<JSObject*>', 'aGlobal'), + Argument('ProtoAndIfaceCache&', 'aProtoAndIfaceCache'), + Argument('bool', 'aDefineOnGlobal')] + CGAbstractMethod.__init__(self, descriptor, 'CreateInterfaceObjects', 'void', args) + self.properties = properties + self.haveUnscopables = haveUnscopables + + def definition_body(self): + (protoGetter, protoHandleGetter) = InterfacePrototypeObjectProtoGetter(self.descriptor) + if protoHandleGetter is None: + parentProtoType = "Rooted" + getParentProto = "aCx, " + protoGetter + else: + parentProtoType = "Handle" + getParentProto = protoHandleGetter + getParentProto = getParentProto + "(aCx)" + + (protoGetter, protoHandleGetter) = InterfaceObjectProtoGetter(self.descriptor) + if protoHandleGetter is None: + getConstructorProto = "aCx, " + protoGetter + constructorProtoType = "Rooted" + else: + getConstructorProto = protoHandleGetter + constructorProtoType = "Handle" + getConstructorProto += "(aCx)" + + needInterfaceObject = self.descriptor.interface.hasInterfaceObject() + needInterfacePrototypeObject = self.descriptor.interface.hasInterfacePrototypeObject() + + # if we don't need to create anything, why are we generating this? + assert needInterfaceObject or needInterfacePrototypeObject + + getParentProto = fill( + """ + JS::${type}<JSObject*> parentProto(${getParentProto}); + if (!parentProto) { + return; + } + """, + type=parentProtoType, + getParentProto=getParentProto) + + getConstructorProto = fill( + """ + JS::${type}<JSObject*> constructorProto(${getConstructorProto}); + if (!constructorProto) { + return; + } + """, + type=constructorProtoType, + getConstructorProto=getConstructorProto) + + idsToInit = [] + # There is no need to init any IDs in bindings that don't want Xrays. + if self.descriptor.wantsXrays: + for var in self.properties.arrayNames(): + props = getattr(self.properties, var) + # We only have non-chrome ids to init if we have no chrome ids. + if props.hasChromeOnly(): + idsToInit.append(props.variableName(True)) + if props.hasNonChromeOnly(): + idsToInit.append(props.variableName(False)) + if len(idsToInit) > 0: + initIdCalls = ["!InitIds(aCx, %s, %s_ids)" % (varname, varname) + for varname in idsToInit] + idsInitedFlag = CGGeneric("static bool sIdsInited = false;\n") + setFlag = CGGeneric("sIdsInited = true;\n") + initIdConditionals = [CGIfWrapper(CGGeneric("return;\n"), call) + for call in initIdCalls] + initIds = CGList([idsInitedFlag, + CGIfWrapper(CGList(initIdConditionals + [setFlag]), + "!sIdsInited && NS_IsMainThread()")]) + else: + initIds = None + + prefCacheData = [] + for var in self.properties.arrayNames(): + props = getattr(self.properties, var) + prefCacheData.extend(props.prefCacheData) + if len(prefCacheData) != 0: + prefCacheData = [ + CGGeneric('Preferences::AddBoolVarCache(%s, "%s");\n' % (ptr, pref)) + for pref, ptr in prefCacheData] + prefCache = CGWrapper(CGIndenter(CGList(prefCacheData)), + pre=("static bool sPrefCachesInited = false;\n" + "if (!sPrefCachesInited && NS_IsMainThread()) {\n" + " sPrefCachesInited = true;\n"), + post="}\n") + else: + prefCache = None + + if self.descriptor.interface.ctor(): + constructArgs = methodLength(self.descriptor.interface.ctor()) + else: + constructArgs = 0 + if len(self.descriptor.interface.namedConstructors) > 0: + namedConstructors = "namedConstructors" + else: + namedConstructors = "nullptr" + + if needInterfacePrototypeObject: + protoClass = "&sPrototypeClass.mBase" + protoCache = "&aProtoAndIfaceCache.EntrySlotOrCreate(prototypes::id::%s)" % self.descriptor.name + parentProto = "parentProto" + getParentProto = CGGeneric(getParentProto) + else: + protoClass = "nullptr" + protoCache = "nullptr" + parentProto = "nullptr" + getParentProto = None + + if needInterfaceObject: + interfaceClass = "&sInterfaceObjectClass.mBase" + interfaceCache = "&aProtoAndIfaceCache.EntrySlotOrCreate(constructors::id::%s)" % self.descriptor.name + getConstructorProto = CGGeneric(getConstructorProto) + constructorProto = "constructorProto" + else: + # We don't have slots to store the named constructors. + assert len(self.descriptor.interface.namedConstructors) == 0 + interfaceClass = "nullptr" + interfaceCache = "nullptr" + getConstructorProto = None + constructorProto = "nullptr" + + isGlobal = self.descriptor.isGlobal() is not None + if self.properties.hasNonChromeOnly(): + properties = "sNativeProperties.Upcast()" + else: + properties = "nullptr" + if self.properties.hasChromeOnly(): + chromeProperties = "nsContentUtils::ThreadsafeIsCallerChrome() ? sChromeOnlyNativeProperties.Upcast() : nullptr" + else: + chromeProperties = "nullptr" + + call = fill( + """ + JS::Heap<JSObject*>* protoCache = ${protoCache}; + JS::Heap<JSObject*>* interfaceCache = ${interfaceCache}; + dom::CreateInterfaceObjects(aCx, aGlobal, ${parentProto}, + ${protoClass}, protoCache, + ${constructorProto}, ${interfaceClass}, ${constructArgs}, ${namedConstructors}, + interfaceCache, + ${properties}, + ${chromeProperties}, + ${name}, aDefineOnGlobal, + ${unscopableNames}, + ${isGlobal}); + """, + protoClass=protoClass, + parentProto=parentProto, + protoCache=protoCache, + constructorProto=constructorProto, + interfaceClass=interfaceClass, + constructArgs=constructArgs, + namedConstructors=namedConstructors, + interfaceCache=interfaceCache, + properties=properties, + chromeProperties=chromeProperties, + name='"' + self.descriptor.interface.identifier.name + '"' if needInterfaceObject else "nullptr", + unscopableNames="unscopableNames" if self.haveUnscopables else "nullptr", + isGlobal=toStringBool(isGlobal)) + + # If we fail after here, we must clear interface and prototype caches + # using this code: intermediate failure must not expose the interface in + # partially-constructed state. Note that every case after here needs an + # interface prototype object. + failureCode = dedent( + """ + *protoCache = nullptr; + if (interfaceCache) { + *interfaceCache = nullptr; + } + return; + """) + + aliasedMembers = [m for m in self.descriptor.interface.members if m.isMethod() and m.aliases] + if aliasedMembers: + assert needInterfacePrototypeObject + + def defineAlias(alias): + if alias == "@@iterator": + symbolJSID = "SYMBOL_TO_JSID(JS::GetWellKnownSymbol(aCx, JS::SymbolCode::iterator))" + getSymbolJSID = CGGeneric(fill("JS::Rooted<jsid> iteratorId(aCx, ${symbolJSID});", + symbolJSID=symbolJSID)) + defineFn = "JS_DefinePropertyById" + prop = "iteratorId" + elif alias.startswith("@@"): + raise TypeError("Can't handle any well-known Symbol other than @@iterator") + else: + getSymbolJSID = None + defineFn = "JS_DefineProperty" + prop = '"%s"' % alias + return CGList([ + getSymbolJSID, + # XXX If we ever create non-enumerable properties that can + # be aliased, we should consider making the aliases + # match the enumerability of the property being aliased. + CGGeneric(fill( + """ + if (!${defineFn}(aCx, proto, ${prop}, aliasedVal, JSPROP_ENUMERATE)) { + $*{failureCode} + } + """, + defineFn=defineFn, + prop=prop, + failureCode=failureCode)) + ], "\n") + + def defineAliasesFor(m): + return CGList([ + CGGeneric(fill( + """ + if (!JS_GetProperty(aCx, proto, \"${prop}\", &aliasedVal)) { + $*{failureCode} + } + """, + failureCode=failureCode, + prop=m.identifier.name)) + ] + [defineAlias(alias) for alias in sorted(m.aliases)]) + + defineAliases = CGList([ + CGGeneric(fill(""" + // Set up aliases on the interface prototype object we just created. + JS::Handle<JSObject*> proto = GetProtoObjectHandle(aCx); + if (!proto) { + $*{failureCode} + } + + """, + failureCode=failureCode)), + CGGeneric("JS::Rooted<JS::Value> aliasedVal(aCx);\n\n") + ] + [defineAliasesFor(m) for m in sorted(aliasedMembers)]) + else: + defineAliases = None + + # Globals handle unforgeables directly in Wrap() instead of + # via a holder. + if self.descriptor.hasUnforgeableMembers and not self.descriptor.isGlobal(): + assert needInterfacePrototypeObject + + # We want to use the same JSClass and prototype as the object we'll + # end up defining the unforgeable properties on in the end, so that + # we can use JS_InitializePropertiesFromCompatibleNativeObject to do + # a fast copy. In the case of proxies that's null, because the + # expando object is a vanilla object, but in the case of other DOM + # objects it's whatever our class is. + if self.descriptor.proxy: + holderClass = "nullptr" + holderProto = "nullptr" + else: + holderClass = "sClass.ToJSClass()" + holderProto = "*protoCache" + createUnforgeableHolder = CGGeneric(fill( + """ + JS::Rooted<JSObject*> unforgeableHolder(aCx); + { + JS::Rooted<JSObject*> holderProto(aCx, ${holderProto}); + unforgeableHolder = JS_NewObjectWithoutMetadata(aCx, ${holderClass}, holderProto); + if (!unforgeableHolder) { + $*{failureCode} + } + } + """, + holderProto=holderProto, + holderClass=holderClass, + failureCode=failureCode)) + defineUnforgeables = InitUnforgeablePropertiesOnHolder(self.descriptor, + self.properties, + failureCode) + createUnforgeableHolder = CGList( + [createUnforgeableHolder, defineUnforgeables]) + + installUnforgeableHolder = CGGeneric(dedent( + """ + if (*protoCache) { + js::SetReservedSlot(*protoCache, DOM_INTERFACE_PROTO_SLOTS_BASE, + JS::ObjectValue(*unforgeableHolder)); + } + """)) + + unforgeableHolderSetup = CGList( + [createUnforgeableHolder, installUnforgeableHolder], "\n") + else: + unforgeableHolderSetup = None + + if self.descriptor.name == "Promise": + speciesSetup = CGGeneric(fill( + """ + #ifndef SPIDERMONKEY_PROMISE + JS::Rooted<JSObject*> promiseConstructor(aCx, *interfaceCache); + JS::Rooted<jsid> species(aCx, + SYMBOL_TO_JSID(JS::GetWellKnownSymbol(aCx, JS::SymbolCode::species))); + if (!JS_DefinePropertyById(aCx, promiseConstructor, species, JS::UndefinedHandleValue, + JSPROP_SHARED, Promise::PromiseSpecies, nullptr)) { + $*{failureCode} + } + #endif // SPIDERMONKEY_PROMISE + """, + failureCode=failureCode)) + else: + speciesSetup = None + + if (self.descriptor.interface.isOnGlobalProtoChain() and + needInterfacePrototypeObject): + makeProtoPrototypeImmutable = CGGeneric(fill( + """ + if (*${protoCache}) { + bool succeeded; + JS::Handle<JSObject*> prot = GetProtoObjectHandle(aCx); + if (!JS_SetImmutablePrototype(aCx, prot, &succeeded)) { + $*{failureCode} + } + + MOZ_ASSERT(succeeded, + "making a fresh prototype object's [[Prototype]] " + "immutable can internally fail, but it should " + "never be unsuccessful"); + } + """, + protoCache=protoCache, + failureCode=failureCode)) + else: + makeProtoPrototypeImmutable = None + + return CGList( + [getParentProto, getConstructorProto, initIds, + prefCache, CGGeneric(call), defineAliases, unforgeableHolderSetup, + speciesSetup, makeProtoPrototypeImmutable], + "\n").define() + + +class CGGetPerInterfaceObject(CGAbstractMethod): + """ + A method for getting a per-interface object (a prototype object or interface + constructor object). + """ + def __init__(self, descriptor, name, idPrefix="", extraArgs=[]): + args = [Argument('JSContext*', 'aCx')] + extraArgs + CGAbstractMethod.__init__(self, descriptor, name, + 'JS::Handle<JSObject*>', args) + self.id = idPrefix + "id::" + self.descriptor.name + + def definition_body(self): + return fill( + """ + /* Make sure our global is sane. Hopefully we can remove this sometime */ + JSObject* global = JS::CurrentGlobalOrNull(aCx); + if (!(js::GetObjectClass(global)->flags & JSCLASS_DOM_GLOBAL)) { + return nullptr; + } + + /* Check to see whether the interface objects are already installed */ + ProtoAndIfaceCache& protoAndIfaceCache = *GetProtoAndIfaceCache(global); + if (!protoAndIfaceCache.EntrySlotIfExists(${id})) { + JS::Rooted<JSObject*> rootedGlobal(aCx, global); + CreateInterfaceObjects(aCx, rootedGlobal, protoAndIfaceCache, aDefineOnGlobal); + } + + /* + * The object might _still_ be null, but that's OK. + * + * Calling fromMarkedLocation() is safe because protoAndIfaceCache is + * traced by TraceProtoAndIfaceCache() and its contents are never + * changed after they have been set. + * + * Calling address() avoids the read read barrier that does gray + * unmarking, but it's not possible for the object to be gray here. + */ + + const JS::Heap<JSObject*>& entrySlot = protoAndIfaceCache.EntrySlotMustExist(${id}); + MOZ_ASSERT_IF(entrySlot, !JS::ObjectIsMarkedGray(entrySlot)); + return JS::Handle<JSObject*>::fromMarkedLocation(entrySlot.address()); + """, + id=self.id) + + +class CGGetProtoObjectHandleMethod(CGGetPerInterfaceObject): + """ + A method for getting the interface prototype object. + """ + def __init__(self, descriptor): + CGGetPerInterfaceObject.__init__(self, descriptor, "GetProtoObjectHandle", + "prototypes::") + + def definition_body(self): + return dedent(""" + /* Get the interface prototype object for this class. This will create the + object as needed. */ + bool aDefineOnGlobal = true; + + """) + CGGetPerInterfaceObject.definition_body(self) + + +class CGGetProtoObjectMethod(CGAbstractMethod): + """ + A method for getting the interface prototype object. + """ + def __init__(self, descriptor): + CGAbstractMethod.__init__( + self, descriptor, "GetProtoObject", "JSObject*", + [Argument('JSContext*', 'aCx')]) + + def definition_body(self): + return "return GetProtoObjectHandle(aCx);\n" + + +class CGGetConstructorObjectHandleMethod(CGGetPerInterfaceObject): + """ + A method for getting the interface constructor object. + """ + def __init__(self, descriptor): + CGGetPerInterfaceObject.__init__( + self, descriptor, "GetConstructorObjectHandle", + "constructors::", + extraArgs=[Argument("bool", "aDefineOnGlobal", "true")]) + + def definition_body(self): + return dedent(""" + /* Get the interface object for this class. This will create the object as + needed. */ + + """) + CGGetPerInterfaceObject.definition_body(self) + + +class CGGetConstructorObjectMethod(CGAbstractMethod): + """ + A method for getting the interface constructor object. + """ + def __init__(self, descriptor): + CGAbstractMethod.__init__( + self, descriptor, "GetConstructorObject", "JSObject*", + [Argument('JSContext*', 'aCx')]) + + def definition_body(self): + return "return GetConstructorObjectHandle(aCx);\n" + + +class CGGetNamedPropertiesObjectMethod(CGAbstractStaticMethod): + def __init__(self, descriptor): + args = [Argument('JSContext*', 'aCx')] + CGAbstractStaticMethod.__init__(self, descriptor, + 'GetNamedPropertiesObject', + 'JSObject*', args) + + def definition_body(self): + parentProtoName = self.descriptor.parentPrototypeName + if parentProtoName is None: + getParentProto = "" + parentProto = "nullptr" + else: + getParentProto = fill( + """ + JS::Rooted<JSObject*> parentProto(aCx, ${parent}::GetProtoObjectHandle(aCx)); + if (!parentProto) { + return nullptr; + } + """, + parent=toBindingNamespace(parentProtoName)) + parentProto = "parentProto" + return fill( + """ + /* Make sure our global is sane. Hopefully we can remove this sometime */ + JSObject* global = JS::CurrentGlobalOrNull(aCx); + if (!(js::GetObjectClass(global)->flags & JSCLASS_DOM_GLOBAL)) { + return nullptr; + } + + /* Check to see whether the named properties object has already been created */ + ProtoAndIfaceCache& protoAndIfaceCache = *GetProtoAndIfaceCache(global); + + JS::Heap<JSObject*>& namedPropertiesObject = protoAndIfaceCache.EntrySlotOrCreate(namedpropertiesobjects::id::${ifaceName}); + if (!namedPropertiesObject) { + $*{getParentProto} + namedPropertiesObject = ${nativeType}::CreateNamedPropertiesObject(aCx, ${parentProto}); + DebugOnly<const DOMIfaceAndProtoJSClass*> clasp = + DOMIfaceAndProtoJSClass::FromJSClass(js::GetObjectClass(namedPropertiesObject)); + MOZ_ASSERT(clasp->mType == eNamedPropertiesObject, + "Expected ${nativeType}::CreateNamedPropertiesObject to return a named properties object"); + MOZ_ASSERT(clasp->mNativeHooks, + "The named properties object for ${nativeType} should have NativePropertyHooks."); + MOZ_ASSERT(clasp->mNativeHooks->mResolveOwnProperty, + "Don't know how to resolve the properties of the named properties object for ${nativeType}."); + MOZ_ASSERT(clasp->mNativeHooks->mEnumerateOwnProperties, + "Don't know how to enumerate the properties of the named properties object for ${nativeType}."); + } + return namedPropertiesObject.get(); + """, + getParentProto=getParentProto, + ifaceName=self.descriptor.name, + parentProto=parentProto, + nativeType=self.descriptor.nativeType) + + +class CGDefineDOMInterfaceMethod(CGAbstractMethod): + """ + A method for resolve hooks to try to lazily define the interface object for + a given interface. + """ + def __init__(self, descriptor): + args = [Argument('JSContext*', 'aCx'), + Argument('JS::Handle<JSObject*>', 'aGlobal'), + Argument('JS::Handle<jsid>', 'id'), + Argument('bool', 'aDefineOnGlobal')] + CGAbstractMethod.__init__(self, descriptor, 'DefineDOMInterface', 'JSObject*', args) + + def definition_body(self): + if len(self.descriptor.interface.namedConstructors) > 0: + getConstructor = dedent(""" + JSObject* interfaceObject = GetConstructorObjectHandle(aCx, aDefineOnGlobal); + if (!interfaceObject) { + return nullptr; + } + for (unsigned slot = DOM_INTERFACE_SLOTS_BASE; slot < JSCLASS_RESERVED_SLOTS(&sInterfaceObjectClass.mBase); ++slot) { + JSObject* constructor = &js::GetReservedSlot(interfaceObject, slot).toObject(); + if (JS_GetFunctionId(JS_GetObjectFunction(constructor)) == JSID_TO_STRING(id)) { + return constructor; + } + } + return interfaceObject; + """) + else: + getConstructor = "return GetConstructorObjectHandle(aCx, aDefineOnGlobal);\n" + return getConstructor + + +def getConditionList(idlobj, cxName, objName): + """ + Get the list of conditions for idlobj (to be used in "is this enabled" + checks). This will be returned as a CGList with " &&\n" as the separator, + for readability. + + objName is the name of the object that we're working with, because some of + our test functions want that. + """ + conditions = [] + pref = idlobj.getExtendedAttribute("Pref") + if pref: + assert isinstance(pref, list) and len(pref) == 1 + conditions.append('Preferences::GetBool("%s")' % pref[0]) + if idlobj.getExtendedAttribute("ChromeOnly"): + conditions.append("nsContentUtils::ThreadsafeIsCallerChrome()") + func = idlobj.getExtendedAttribute("Func") + if func: + assert isinstance(func, list) and len(func) == 1 + conditions.append("%s(%s, %s)" % (func[0], cxName, objName)) + if idlobj.getExtendedAttribute("SecureContext"): + conditions.append("mozilla::dom::IsSecureContextOrObjectIsFromSecureContext(%s, %s)" % (cxName, objName)) + + return CGList((CGGeneric(cond) for cond in conditions), " &&\n") + + +class CGConstructorEnabled(CGAbstractMethod): + """ + A method for testing whether we should be exposing this interface + object or navigator property. This can perform various tests + depending on what conditions are specified on the interface. + """ + def __init__(self, descriptor): + CGAbstractMethod.__init__(self, descriptor, + 'ConstructorEnabled', 'bool', + [Argument("JSContext*", "aCx"), + Argument("JS::Handle<JSObject*>", "aObj")]) + + def definition_body(self): + body = CGList([], "\n") + + iface = self.descriptor.interface + + if not iface.isExposedOnMainThread(): + exposedInWindowCheck = dedent( + """ + MOZ_ASSERT(!NS_IsMainThread(), "Why did we even get called?"); + """) + body.append(CGGeneric(exposedInWindowCheck)) + + if iface.isExposedInSomeButNotAllWorkers(): + workerGlobals = sorted(iface.getWorkerExposureSet()) + workerCondition = CGList((CGGeneric('strcmp(name, "%s")' % workerGlobal) + for workerGlobal in workerGlobals), " && ") + exposedInWorkerCheck = fill( + """ + const char* name = js::GetObjectClass(aObj)->name; + if (${workerCondition}) { + return false; + } + """, workerCondition=workerCondition.define()) + exposedInWorkerCheck = CGGeneric(exposedInWorkerCheck) + if iface.isExposedOnMainThread(): + exposedInWorkerCheck = CGIfWrapper(exposedInWorkerCheck, + "!NS_IsMainThread()") + body.append(exposedInWorkerCheck) + + conditions = getConditionList(iface, "aCx", "aObj") + + # We should really have some conditions + assert len(body) or len(conditions) + + conditionsWrapper = "" + if len(conditions): + conditionsWrapper = CGWrapper(conditions, + pre="return ", + post=";\n", + reindent=True) + else: + conditionsWrapper = CGGeneric("return true;\n") + + body.append(conditionsWrapper) + return body.define() + + +def CreateBindingJSObject(descriptor, properties): + objDecl = "BindingJSObjectCreator<%s> creator(aCx);\n" % descriptor.nativeType + + # We don't always need to root obj, but there are a variety + # of cases where we do, so for simplicity, just always root it. + if descriptor.proxy: + create = dedent( + """ + creator.CreateProxyObject(aCx, &sClass.mBase, DOMProxyHandler::getInstance(), + proto, aObject, aReflector); + if (!aReflector) { + return false; + } + + """) + if descriptor.interface.getExtendedAttribute('OverrideBuiltins'): + create += dedent(""" + js::SetProxyExtra(aReflector, JSPROXYSLOT_EXPANDO, + JS::PrivateValue(&aObject->mExpandoAndGeneration)); + + """) + else: + create = dedent( + """ + creator.CreateObject(aCx, sClass.ToJSClass(), proto, aObject, aReflector); + if (!aReflector) { + return false; + } + """) + return objDecl + create + + +def InitUnforgeablePropertiesOnHolder(descriptor, properties, failureCode, + holderName="unforgeableHolder"): + """ + Define the unforgeable properties on the unforgeable holder for + the interface represented by descriptor. + + properties is a PropertyArrays instance. + + """ + assert (properties.unforgeableAttrs.hasNonChromeOnly() or + properties.unforgeableAttrs.hasChromeOnly() or + properties.unforgeableMethods.hasNonChromeOnly() or + properties.unforgeableMethods.hasChromeOnly()) + + unforgeables = [] + + defineUnforgeableAttrs = fill( + """ + if (!DefineUnforgeableAttributes(aCx, ${holderName}, %s)) { + $*{failureCode} + } + """, + failureCode=failureCode, + holderName=holderName) + defineUnforgeableMethods = fill( + """ + if (!DefineUnforgeableMethods(aCx, ${holderName}, %s)) { + $*{failureCode} + } + """, + failureCode=failureCode, + holderName=holderName) + + unforgeableMembers = [ + (defineUnforgeableAttrs, properties.unforgeableAttrs), + (defineUnforgeableMethods, properties.unforgeableMethods) + ] + for (template, array) in unforgeableMembers: + if array.hasNonChromeOnly(): + unforgeables.append(CGGeneric(template % array.variableName(False))) + if array.hasChromeOnly(): + unforgeables.append( + CGIfWrapper(CGGeneric(template % array.variableName(True)), + "nsContentUtils::ThreadsafeIsCallerChrome()")) + + if descriptor.interface.getExtendedAttribute("Unforgeable"): + # We do our undefined toJSON and toPrimitive here, not as a regular + # property because we don't have a concept of value props anywhere in + # IDL. + unforgeables.append(CGGeneric(fill( + """ + JS::RootedId toPrimitive(aCx, + SYMBOL_TO_JSID(JS::GetWellKnownSymbol(aCx, JS::SymbolCode::toPrimitive))); + if (!JS_DefinePropertyById(aCx, ${holderName}, toPrimitive, + JS::UndefinedHandleValue, + JSPROP_READONLY | JSPROP_PERMANENT) || + !JS_DefineProperty(aCx, ${holderName}, "toJSON", + JS::UndefinedHandleValue, + JSPROP_READONLY | JSPROP_ENUMERATE | JSPROP_PERMANENT)) { + $*{failureCode} + } + """, + failureCode=failureCode, + holderName=holderName))) + + return CGWrapper(CGList(unforgeables), pre="\n") + + +def CopyUnforgeablePropertiesToInstance(descriptor, failureCode): + """ + Copy the unforgeable properties from the unforgeable holder for + this interface to the instance object we have. + """ + assert not descriptor.isGlobal(); + + if not descriptor.hasUnforgeableMembers: + return "" + + copyCode = [ + CGGeneric(dedent( + """ + // Important: do unforgeable property setup after we have handed + // over ownership of the C++ object to obj as needed, so that if + // we fail and it ends up GCed it won't have problems in the + // finalizer trying to drop its ownership of the C++ object. + """)) + ] + + # For proxies, we want to define on the expando object, not directly on the + # reflector, so we can make sure we don't get confused by named getters. + if descriptor.proxy: + copyCode.append(CGGeneric(fill( + """ + JS::Rooted<JSObject*> expando(aCx, + DOMProxyHandler::EnsureExpandoObject(aCx, aReflector)); + if (!expando) { + $*{failureCode} + } + """, + failureCode=failureCode))) + obj = "expando" + else: + obj = "aReflector" + + copyCode.append(CGGeneric(fill( + """ + JS::Rooted<JSObject*> unforgeableHolder(aCx, + &js::GetReservedSlot(canonicalProto, DOM_INTERFACE_PROTO_SLOTS_BASE).toObject()); + if (!JS_InitializePropertiesFromCompatibleNativeObject(aCx, ${obj}, unforgeableHolder)) { + $*{failureCode} + } + """, + obj=obj, + failureCode=failureCode))) + + return CGWrapper(CGList(copyCode), pre="\n").define() + + +def AssertInheritanceChain(descriptor): + asserts = "" + iface = descriptor.interface + while iface: + desc = descriptor.getDescriptor(iface.identifier.name) + asserts += ( + "MOZ_ASSERT(static_cast<%s*>(aObject) == \n" + " reinterpret_cast<%s*>(aObject),\n" + " \"Multiple inheritance for %s is broken.\");\n" % + (desc.nativeType, desc.nativeType, desc.nativeType)) + iface = iface.parent + asserts += "MOZ_ASSERT(ToSupportsIsCorrect(aObject));\n" + return asserts + + +def InitMemberSlots(descriptor, failureCode): + """ + Initialize member slots on our JS object if we're supposed to have some. + + Note that this is called after the SetWrapper() call in the + wrapperCache case, since that can affect how our getters behave + and we plan to invoke them here. So if we fail, we need to + ClearWrapper. + """ + if not descriptor.interface.hasMembersInSlots(): + return "" + return fill( + """ + if (!UpdateMemberSlots(aCx, aReflector, aObject)) { + $*{failureCode} + } + """, + failureCode=failureCode) + + +def SetImmutablePrototype(descriptor, failureCode): + if not descriptor.hasNonOrdinaryGetPrototypeOf(): + return "" + + return fill( + """ + bool succeeded; + if (!JS_SetImmutablePrototype(aCx, aReflector, &succeeded)) { + ${failureCode} + } + MOZ_ASSERT(succeeded, + "Making a fresh reflector instance have an immutable " + "prototype can internally fail, but it should never be " + "unsuccessful"); + """, + failureCode=failureCode) + + +def DeclareProto(): + """ + Declare the canonicalProto and proto we have for our wrapping operation. + """ + return dedent( + """ + JS::Handle<JSObject*> canonicalProto = GetProtoObjectHandle(aCx); + if (!canonicalProto) { + return false; + } + JS::Rooted<JSObject*> proto(aCx); + if (aGivenProto) { + proto = aGivenProto; + // Unfortunately, while aGivenProto was in the compartment of aCx + // coming in, we changed compartments to that of "parent" so may need + // to wrap the proto here. + if (js::GetContextCompartment(aCx) != js::GetObjectCompartment(proto)) { + if (!JS_WrapObject(aCx, &proto)) { + return false; + } + } + } else { + proto = canonicalProto; + } + """) + + +class CGWrapWithCacheMethod(CGAbstractMethod): + """ + Create a wrapper JSObject for a given native that implements nsWrapperCache. + + properties should be a PropertyArrays instance. + """ + def __init__(self, descriptor, properties): + assert descriptor.interface.hasInterfacePrototypeObject() + args = [Argument('JSContext*', 'aCx'), + Argument(descriptor.nativeType + '*', 'aObject'), + Argument('nsWrapperCache*', 'aCache'), + Argument('JS::Handle<JSObject*>', 'aGivenProto'), + Argument('JS::MutableHandle<JSObject*>', 'aReflector')] + CGAbstractMethod.__init__(self, descriptor, 'Wrap', 'bool', args) + self.properties = properties + + def definition_body(self): + if self.descriptor.proxy: + preserveWrapper = dedent( + """ + // For DOM proxies, the only reliable way to preserve the wrapper + // is to force creation of the expando object. + JS::Rooted<JSObject*> unused(aCx, + DOMProxyHandler::EnsureExpandoObject(aCx, aReflector)); + """) + else: + preserveWrapper = "PreserveWrapper(aObject);\n" + + failureCode = dedent( + """ + aCache->ReleaseWrapper(aObject); + aCache->ClearWrapper(); + return false; + """) + + return fill( + """ + $*{assertInheritance} + MOZ_ASSERT(!aCache->GetWrapper(), + "You should probably not be using Wrap() directly; use " + "GetOrCreateDOMReflector instead"); + + MOZ_ASSERT(ToSupportsIsOnPrimaryInheritanceChain(aObject, aCache), + "nsISupports must be on our primary inheritance chain"); + + JS::Rooted<JSObject*> global(aCx, FindAssociatedGlobal(aCx, aObject->GetParentObject())); + if (!global) { + return false; + } + MOZ_ASSERT(JS_IsGlobalObject(global)); + MOZ_ASSERT(!JS::ObjectIsMarkedGray(global)); + + // That might have ended up wrapping us already, due to the wonders + // of XBL. Check for that, and bail out as needed. + aReflector.set(aCache->GetWrapper()); + if (aReflector) { + #ifdef DEBUG + binding_detail::AssertReflectorHasGivenProto(aCx, aReflector, aGivenProto); + #endif // DEBUG + return true; + } + + JSAutoCompartment ac(aCx, global); + $*{declareProto} + + $*{createObject} + + aCache->SetWrapper(aReflector); + $*{unforgeable} + $*{slots} + $*{setImmutablePrototype} + creator.InitializationSucceeded(); + + MOZ_ASSERT(aCache->GetWrapperPreserveColor() && + aCache->GetWrapperPreserveColor() == aReflector); + // If proto != canonicalProto, we have to preserve our wrapper; + // otherwise we won't be able to properly recreate it later, since + // we won't know what proto to use. Note that we don't check + // aGivenProto here, since it's entirely possible (and even + // somewhat common) to have a non-null aGivenProto which is the + // same as canonicalProto. + if (proto != canonicalProto) { + $*{preserveWrapper} + } + + return true; + """, + assertInheritance=AssertInheritanceChain(self.descriptor), + declareProto=DeclareProto(), + createObject=CreateBindingJSObject(self.descriptor, self.properties), + unforgeable=CopyUnforgeablePropertiesToInstance(self.descriptor, + failureCode), + slots=InitMemberSlots(self.descriptor, failureCode), + setImmutablePrototype=SetImmutablePrototype(self.descriptor, + failureCode), + preserveWrapper=preserveWrapper) + + +class CGWrapMethod(CGAbstractMethod): + def __init__(self, descriptor): + # XXX can we wrap if we don't have an interface prototype object? + assert descriptor.interface.hasInterfacePrototypeObject() + args = [Argument('JSContext*', 'aCx'), + Argument('T*', 'aObject'), + Argument('JS::Handle<JSObject*>', 'aGivenProto')] + CGAbstractMethod.__init__(self, descriptor, 'Wrap', 'JSObject*', args, + inline=True, templateArgs=["class T"]) + + def definition_body(self): + return dedent(""" + JS::Rooted<JSObject*> reflector(aCx); + return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr; + """) + + +class CGWrapNonWrapperCacheMethod(CGAbstractMethod): + """ + Create a wrapper JSObject for a given native that does not implement + nsWrapperCache. + + properties should be a PropertyArrays instance. + """ + def __init__(self, descriptor, properties): + # XXX can we wrap if we don't have an interface prototype object? + assert descriptor.interface.hasInterfacePrototypeObject() + args = [Argument('JSContext*', 'aCx'), + Argument(descriptor.nativeType + '*', 'aObject'), + Argument('JS::Handle<JSObject*>', 'aGivenProto'), + Argument('JS::MutableHandle<JSObject*>', 'aReflector')] + CGAbstractMethod.__init__(self, descriptor, 'Wrap', 'bool', args) + self.properties = properties + + def definition_body(self): + failureCode = "return false;\n" + + return fill( + """ + $*{assertions} + + JS::Rooted<JSObject*> global(aCx, JS::CurrentGlobalOrNull(aCx)); + $*{declareProto} + + $*{createObject} + + $*{unforgeable} + + $*{slots} + + $*{setImmutablePrototype} + creator.InitializationSucceeded(); + return true; + """, + assertions=AssertInheritanceChain(self.descriptor), + declareProto=DeclareProto(), + createObject=CreateBindingJSObject(self.descriptor, self.properties), + unforgeable=CopyUnforgeablePropertiesToInstance(self.descriptor, + failureCode), + slots=InitMemberSlots(self.descriptor, failureCode), + setImmutablePrototype=SetImmutablePrototype(self.descriptor, + failureCode)) + + +class CGWrapGlobalMethod(CGAbstractMethod): + """ + Create a wrapper JSObject for a global. The global must implement + nsWrapperCache. + + properties should be a PropertyArrays instance. + """ + def __init__(self, descriptor, properties): + assert descriptor.interface.hasInterfacePrototypeObject() + args = [Argument('JSContext*', 'aCx'), + Argument(descriptor.nativeType + '*', 'aObject'), + Argument('nsWrapperCache*', 'aCache'), + Argument('JS::CompartmentOptions&', 'aOptions'), + Argument('JSPrincipals*', 'aPrincipal'), + Argument('bool', 'aInitStandardClasses'), + Argument('JS::MutableHandle<JSObject*>', 'aReflector')] + CGAbstractMethod.__init__(self, descriptor, 'Wrap', 'bool', args) + self.descriptor = descriptor + self.properties = properties + + def definition_body(self): + if self.properties.hasNonChromeOnly(): + properties = "sNativeProperties.Upcast()" + else: + properties = "nullptr" + if self.properties.hasChromeOnly(): + chromeProperties = "nsContentUtils::ThreadsafeIsCallerChrome() ? sChromeOnlyNativeProperties.Upcast() : nullptr" + else: + chromeProperties = "nullptr" + + failureCode = dedent( + """ + aCache->ReleaseWrapper(aObject); + aCache->ClearWrapper(); + return false; + """); + + if self.descriptor.hasUnforgeableMembers: + unforgeable = InitUnforgeablePropertiesOnHolder( + self.descriptor, self.properties, failureCode, + "aReflector").define(); + else: + unforgeable = "" + + return fill( + """ + $*{assertions} + MOZ_ASSERT(ToSupportsIsOnPrimaryInheritanceChain(aObject, aCache), + "nsISupports must be on our primary inheritance chain"); + + if (!CreateGlobal<${nativeType}, GetProtoObjectHandle>(aCx, + aObject, + aCache, + sClass.ToJSClass(), + aOptions, + aPrincipal, + aInitStandardClasses, + aReflector)) { + $*{failureCode} + } + + // aReflector is a new global, so has a new compartment. Enter it + // before doing anything with it. + JSAutoCompartment ac(aCx, aReflector); + + if (!DefineProperties(aCx, aReflector, ${properties}, ${chromeProperties})) { + $*{failureCode} + } + $*{unforgeable} + + $*{slots} + + return true; + """, + assertions=AssertInheritanceChain(self.descriptor), + nativeType=self.descriptor.nativeType, + properties=properties, + chromeProperties=chromeProperties, + failureCode=failureCode, + unforgeable=unforgeable, + slots=InitMemberSlots(self.descriptor, failureCode)) + + +class CGUpdateMemberSlotsMethod(CGAbstractStaticMethod): + def __init__(self, descriptor): + args = [Argument('JSContext*', 'aCx'), + Argument('JS::Handle<JSObject*>', 'aWrapper'), + Argument(descriptor.nativeType + '*', 'aObject')] + CGAbstractStaticMethod.__init__(self, descriptor, 'UpdateMemberSlots', 'bool', args) + + def definition_body(self): + body = ("JS::Rooted<JS::Value> temp(aCx);\n" + "JSJitGetterCallArgs args(&temp);\n") + for m in self.descriptor.interface.members: + if m.isAttr() and m.getExtendedAttribute("StoreInSlot"): + # Skip doing this for the "window" and "self" attributes on the + # Window interface, because those can't be gotten safely until + # we have hooked it up correctly to the outer window. The + # window code handles doing the get itself. + if (self.descriptor.interface.identifier.name == "Window" and + (m.identifier.name == "window" or m.identifier.name == "self")): + continue + body += fill( + """ + + if (!get_${member}(aCx, aWrapper, aObject, args)) { + return false; + } + // Getter handled setting our reserved slots + """, + member=m.identifier.name) + + body += "\nreturn true;\n" + return body + + +class CGClearCachedValueMethod(CGAbstractMethod): + def __init__(self, descriptor, member): + self.member = member + # If we're StoreInSlot, we'll need to call the getter + if member.getExtendedAttribute("StoreInSlot"): + args = [Argument('JSContext*', 'aCx')] + returnType = 'bool' + else: + args = [] + returnType = 'void' + args.append(Argument(descriptor.nativeType + '*', 'aObject')) + name = MakeClearCachedValueNativeName(member) + CGAbstractMethod.__init__(self, descriptor, name, returnType, args) + + def definition_body(self): + slotIndex = memberReservedSlot(self.member, self.descriptor) + if self.member.getExtendedAttribute("StoreInSlot"): + # We have to root things and save the old value in case + # regetting fails, so we can restore it. + declObj = "JS::Rooted<JSObject*> obj(aCx);\n" + noopRetval = " true" + saveMember = ( + "JS::Rooted<JS::Value> oldValue(aCx, js::GetReservedSlot(obj, %s));\n" % + slotIndex) + regetMember = fill( + """ + JS::Rooted<JS::Value> temp(aCx); + JSJitGetterCallArgs args(&temp); + JSAutoCompartment ac(aCx, obj); + if (!get_${name}(aCx, obj, aObject, args)) { + js::SetReservedSlot(obj, ${slotIndex}, oldValue); + return false; + } + return true; + """, + name=self.member.identifier.name, + slotIndex=slotIndex) + else: + declObj = "JSObject* obj;\n" + noopRetval = "" + saveMember = "" + regetMember = "" + + if self.descriptor.wantsXrays: + clearXrayExpandoSlots = fill( + """ + xpc::ClearXrayExpandoSlots(obj, ${xraySlotIndex}); + """, + xraySlotIndex=memberXrayExpandoReservedSlot(self.member, + self.descriptor)) + else : + clearXrayExpandoSlots = "" + + return fill( + """ + $*{declObj} + obj = aObject->GetWrapper(); + if (!obj) { + return${noopRetval}; + } + $*{saveMember} + js::SetReservedSlot(obj, ${slotIndex}, JS::UndefinedValue()); + $*{clearXrayExpandoSlots} + $*{regetMember} + """, + declObj=declObj, + noopRetval=noopRetval, + saveMember=saveMember, + slotIndex=slotIndex, + clearXrayExpandoSlots=clearXrayExpandoSlots, + regetMember=regetMember) + + +class CGIsPermittedMethod(CGAbstractMethod): + """ + crossOriginGetters/Setters/Methods are sets of names of the relevant members. + """ + def __init__(self, descriptor, crossOriginGetters, crossOriginSetters, + crossOriginMethods): + self.crossOriginGetters = crossOriginGetters + self.crossOriginSetters = crossOriginSetters + self.crossOriginMethods = crossOriginMethods + args = [Argument("JSFlatString*", "prop"), + Argument("char16_t", "propFirstChar"), + Argument("bool", "set")] + CGAbstractMethod.__init__(self, descriptor, "IsPermitted", "bool", args, + inline=True) + + def definition_body(self): + allNames = self.crossOriginGetters | self.crossOriginSetters | self.crossOriginMethods + readwrite = self.crossOriginGetters & self.crossOriginSetters + readonly = (self.crossOriginGetters - self.crossOriginSetters) | self.crossOriginMethods + writeonly = self.crossOriginSetters - self.crossOriginGetters + cases = {} + for name in sorted(allNames): + cond = 'JS_FlatStringEqualsAscii(prop, "%s")' % name + if name in readonly: + cond = "!set && %s" % cond + elif name in writeonly: + cond = "set && %s" % cond + else: + assert name in readwrite + firstLetter = name[0] + case = cases.get(firstLetter, CGList([])) + case.append(CGGeneric("if (%s) {\n" + " return true;\n" + "}\n" % cond)) + cases[firstLetter] = case + caseList = [] + for firstLetter in sorted(cases.keys()): + caseList.append(CGCase("'%s'" % firstLetter, cases[firstLetter])) + switch = CGSwitch("propFirstChar", caseList) + return switch.define() + "\nreturn false;\n" + + +class CGCycleCollectionTraverseForOwningUnionMethod(CGAbstractMethod): + """ + ImplCycleCollectionUnlink for owning union type. + """ + def __init__(self, type): + self.type = type + args = [Argument("nsCycleCollectionTraversalCallback&", "aCallback"), + Argument("%s&" % CGUnionStruct.unionTypeName(type, True), "aUnion"), + Argument("const char*", "aName"), + Argument("uint32_t", "aFlags", "0")] + CGAbstractMethod.__init__(self, None, "ImplCycleCollectionTraverse", "void", args) + + def deps(self): + return self.type.getDeps() + + def definition_body(self): + memberNames = [getUnionMemberName(t) + for t in self.type.flatMemberTypes + if idlTypeNeedsCycleCollection(t)] + assert memberNames + + conditionTemplate = 'aUnion.Is%s()' + functionCallTemplate = 'ImplCycleCollectionTraverse(aCallback, aUnion.GetAs%s(), "m%s", aFlags);\n' + + ifStaments = (CGIfWrapper(CGGeneric(functionCallTemplate % (m, m)), + conditionTemplate % m) + for m in memberNames) + + return CGElseChain(ifStaments).define() + + +class CGCycleCollectionUnlinkForOwningUnionMethod(CGAbstractMethod): + """ + ImplCycleCollectionUnlink for owning union type. + """ + def __init__(self, type): + self.type = type + args = [Argument("%s&" % CGUnionStruct.unionTypeName(type, True), "aUnion")] + CGAbstractMethod.__init__(self, None, "ImplCycleCollectionUnlink", "void", args) + + def deps(self): + return self.type.getDeps() + + def definition_body(self): + return "aUnion.Uninit();\n" + + +builtinNames = { + IDLType.Tags.bool: 'bool', + IDLType.Tags.int8: 'int8_t', + IDLType.Tags.int16: 'int16_t', + IDLType.Tags.int32: 'int32_t', + IDLType.Tags.int64: 'int64_t', + IDLType.Tags.uint8: 'uint8_t', + IDLType.Tags.uint16: 'uint16_t', + IDLType.Tags.uint32: 'uint32_t', + IDLType.Tags.uint64: 'uint64_t', + IDLType.Tags.unrestricted_float: 'float', + IDLType.Tags.float: 'float', + IDLType.Tags.unrestricted_double: 'double', + IDLType.Tags.double: 'double' +} + +numericSuffixes = { + IDLType.Tags.int8: '', + IDLType.Tags.uint8: '', + IDLType.Tags.int16: '', + IDLType.Tags.uint16: '', + IDLType.Tags.int32: '', + IDLType.Tags.uint32: 'U', + IDLType.Tags.int64: 'LL', + IDLType.Tags.uint64: 'ULL', + IDLType.Tags.unrestricted_float: 'F', + IDLType.Tags.float: 'F', + IDLType.Tags.unrestricted_double: '', + IDLType.Tags.double: '' +} + + +def numericValue(t, v): + if (t == IDLType.Tags.unrestricted_double or + t == IDLType.Tags.unrestricted_float): + typeName = builtinNames[t] + if v == float("inf"): + return "mozilla::PositiveInfinity<%s>()" % typeName + if v == float("-inf"): + return "mozilla::NegativeInfinity<%s>()" % typeName + if math.isnan(v): + return "mozilla::UnspecifiedNaN<%s>()" % typeName + return "%s%s" % (v, numericSuffixes[t]) + + +class CastableObjectUnwrapper(): + """ + A class for unwrapping an object stored in a JS Value (or + MutableHandle<Value> or Handle<Value>) named by the "source" and + "mutableSource" arguments based on the passed-in descriptor and storing it + in a variable called by the name in the "target" argument. The "source" + argument should be able to produce a Value or Handle<Value>; the + "mutableSource" argument should be able to produce a MutableHandle<Value> + + codeOnFailure is the code to run if unwrapping fails. + + If isCallbackReturnValue is "JSImpl" and our descriptor is also + JS-implemented, fall back to just creating the right object if what we + have isn't one already. + + If allowCrossOriginObj is True, then we'll first do an + UncheckedUnwrap and then operate on the result. + """ + def __init__(self, descriptor, source, mutableSource, target, codeOnFailure, + exceptionCode=None, isCallbackReturnValue=False, + allowCrossOriginObj=False): + self.substitution = { + "type": descriptor.nativeType, + "protoID": "prototypes::id::" + descriptor.name, + "target": target, + "codeOnFailure": codeOnFailure, + } + # Supporting both the "cross origin object" case and the "has + # XPConnect impls" case at the same time is a pain, so let's + # not do that. That allows us to assume that our source is + # always a Handle or MutableHandle. + if allowCrossOriginObj and descriptor.hasXPConnectImpls: + raise TypeError("Interface %s both allows a cross-origin 'this' " + "and has XPConnect impls. We don't support that" % + descriptor.name) + if allowCrossOriginObj: + self.substitution["uncheckedObjDecl"] = fill( + """ + JS::Rooted<JSObject*> maybeUncheckedObj(cx, &${source}.toObject()); + """, + source=source) + self.substitution["uncheckedObjGet"] = fill( + """ + if (xpc::WrapperFactory::IsXrayWrapper(maybeUncheckedObj)) { + maybeUncheckedObj = js::UncheckedUnwrap(maybeUncheckedObj); + } else { + maybeUncheckedObj = js::CheckedUnwrap(maybeUncheckedObj); + if (!maybeUncheckedObj) { + $*{codeOnFailure} + } + } + """, + codeOnFailure=(codeOnFailure % { 'securityError': 'true'})) + self.substitution["source"] = "maybeUncheckedObj" + self.substitution["mutableSource"] = "&maybeUncheckedObj" + # No need to set up xpconnectUnwrap, since it won't be + # used in the allowCrossOriginObj case. + else: + self.substitution["uncheckedObjDecl"] = "" + self.substitution["uncheckedObjGet"] = "" + self.substitution["source"] = source + self.substitution["mutableSource"] = mutableSource + xpconnectUnwrap = ( + "nsresult rv = UnwrapXPConnect<${type}>(cx, ${mutableSource}, getter_AddRefs(objPtr));\n") + + if descriptor.hasXPConnectImpls: + self.substitution["codeOnFailure"] = string.Template( + "RefPtr<${type}> objPtr;\n" + + xpconnectUnwrap + + "if (NS_FAILED(rv)) {\n" + "${indentedCodeOnFailure}" + "}\n" + "// We should have an object\n" + "MOZ_ASSERT(objPtr);\n" + "${target} = objPtr;\n" + ).substitute(self.substitution, + indentedCodeOnFailure=indent(codeOnFailure)) + elif (isCallbackReturnValue == "JSImpl" and + descriptor.interface.isJSImplemented()): + exceptionCode = exceptionCode or codeOnFailure + self.substitution["codeOnFailure"] = fill( + """ + // Be careful to not wrap random DOM objects here, even if + // they're wrapped in opaque security wrappers for some reason. + // XXXbz Wish we could check for a JS-implemented object + // that already has a content reflection... + if (!IsDOMObject(js::UncheckedUnwrap(&${source}.toObject()))) { + nsCOMPtr<nsIGlobalObject> contentGlobal; + if (!GetContentGlobalForJSImplementedObject(cx, Callback(), getter_AddRefs(contentGlobal))) { + $*{exceptionCode} + } + JS::Rooted<JSObject*> jsImplSourceObj(cx, &${source}.toObject()); + ${target} = new ${type}(jsImplSourceObj, contentGlobal); + } else { + $*{codeOnFailure} + } + """, + exceptionCode=exceptionCode, + **self.substitution) + else: + self.substitution["codeOnFailure"] = codeOnFailure + + def __str__(self): + substitution = self.substitution.copy() + substitution["codeOnFailure"] %= { + 'securityError': 'rv == NS_ERROR_XPC_SECURITY_MANAGER_VETO' + } + return fill( + """ + $*{uncheckedObjDecl} + { + $*{uncheckedObjGet} + nsresult rv = UnwrapObject<${protoID}, ${type}>(${mutableSource}, ${target}); + if (NS_FAILED(rv)) { + $*{codeOnFailure} + } + } + """, + **substitution) + + +class FailureFatalCastableObjectUnwrapper(CastableObjectUnwrapper): + """ + As CastableObjectUnwrapper, but defaulting to throwing if unwrapping fails + """ + def __init__(self, descriptor, source, mutableSource, target, exceptionCode, + isCallbackReturnValue, sourceDescription): + CastableObjectUnwrapper.__init__( + self, descriptor, source, mutableSource, target, + 'ThrowErrorMessage(cx, MSG_DOES_NOT_IMPLEMENT_INTERFACE, "%s", "%s");\n' + '%s' % (sourceDescription, descriptor.interface.identifier.name, + exceptionCode), + exceptionCode, + isCallbackReturnValue) + + +class CGCallbackTempRoot(CGGeneric): + def __init__(self, name): + define = dedent(""" + { // Scope for tempRoot + JS::Rooted<JSObject*> tempRoot(cx, &${val}.toObject()); + ${declName} = new %s(cx, tempRoot, mozilla::dom::GetIncumbentGlobal()); + } + """) % name + CGGeneric.__init__(self, define=define) + + +def getCallbackConversionInfo(type, idlObject, isMember, isCallbackReturnValue, + isOptional): + """ + Returns a tuple containing the declType, declArgs, and basic + conversion for the given callback type, with the given callback + idl object in the given context (isMember/isCallbackReturnValue/isOptional). + """ + name = idlObject.identifier.name + + # We can't use fast callbacks if isOptional because then we get an + # Optional<RootedCallback> thing, which is not transparent to consumers. + useFastCallback = (not isMember and not isCallbackReturnValue and + not isOptional) + if useFastCallback: + name = "binding_detail::Fast%s" % name + + if type.nullable() or isCallbackReturnValue: + declType = CGGeneric("RefPtr<%s>" % name) + else: + declType = CGGeneric("OwningNonNull<%s>" % name) + + if useFastCallback: + declType = CGTemplatedType("RootedCallback", declType) + declArgs = "cx" + else: + declArgs = None + + conversion = indent(CGCallbackTempRoot(name).define()) + return (declType, declArgs, conversion) + + +class JSToNativeConversionInfo(): + """ + An object representing information about a JS-to-native conversion. + """ + def __init__(self, template, declType=None, holderType=None, + dealWithOptional=False, declArgs=None, + holderArgs=None): + """ + template: A string representing the conversion code. This will have + template substitution performed on it as follows: + + ${val} is a handle to the JS::Value in question + ${maybeMutableVal} May be a mutable handle to the JS::Value in + question. This is only OK to use if ${val} is + known to not be undefined. + ${holderName} replaced by the holder's name, if any + ${declName} replaced by the declaration's name + ${haveValue} replaced by an expression that evaluates to a boolean + for whether we have a JS::Value. Only used when + defaultValue is not None or when True is passed for + checkForValue to instantiateJSToNativeConversion. + ${passedToJSImpl} replaced by an expression that evaluates to a boolean + for whether this value is being passed to a JS- + implemented interface. + + declType: A CGThing representing the native C++ type we're converting + to. This is allowed to be None if the conversion code is + supposed to be used as-is. + + holderType: A CGThing representing the type of a "holder" which will + hold a possible reference to the C++ thing whose type we + returned in declType, or None if no such holder is needed. + + dealWithOptional: A boolean indicating whether the caller has to do + optional-argument handling. This should only be set + to true if the JS-to-native conversion is being done + for an optional argument or dictionary member with no + default value and if the returned template expects + both declType and holderType to be wrapped in + Optional<>, with ${declName} and ${holderName} + adjusted to point to the Value() of the Optional, and + Construct() calls to be made on the Optional<>s as + needed. + + declArgs: If not None, the arguments to pass to the ${declName} + constructor. These will have template substitution performed + on them so you can use things like ${val}. This is a + single string, not a list of strings. + + holderArgs: If not None, the arguments to pass to the ${holderName} + constructor. These will have template substitution + performed on them so you can use things like ${val}. + This is a single string, not a list of strings. + + ${declName} must be in scope before the code from 'template' is entered. + + If holderType is not None then ${holderName} must be in scope before + the code from 'template' is entered. + """ + assert isinstance(template, str) + assert declType is None or isinstance(declType, CGThing) + assert holderType is None or isinstance(holderType, CGThing) + self.template = template + self.declType = declType + self.holderType = holderType + self.dealWithOptional = dealWithOptional + self.declArgs = declArgs + self.holderArgs = holderArgs + + +def getHandleDefault(defaultValue): + tag = defaultValue.type.tag() + if tag in numericSuffixes: + # Some numeric literals require a suffix to compile without warnings + return numericValue(tag, defaultValue.value) + assert tag == IDLType.Tags.bool + return toStringBool(defaultValue.value) + + +def handleDefaultStringValue(defaultValue, method): + """ + Returns a string which ends up calling 'method' with a (char_t*, length) + pair that sets this string default value. This string is suitable for + passing as the second argument of handleDefault; in particular it does not + end with a ';' + """ + assert defaultValue.type.isDOMString() or defaultValue.type.isByteString() + return ("static const %(char_t)s data[] = { %(data)s };\n" + "%(method)s(data, ArrayLength(data) - 1)") % { + 'char_t': "char" if defaultValue.type.isByteString() else "char16_t", + 'method': method, + 'data': ", ".join(["'" + char + "'" for char in + defaultValue.value] + ["0"]) + } + + +# If this function is modified, modify CGNativeMember.getArg and +# CGNativeMember.getRetvalInfo accordingly. The latter cares about the decltype +# and holdertype we end up using, because it needs to be able to return the code +# that will convert those to the actual return value of the callback function. +def getJSToNativeConversionInfo(type, descriptorProvider, failureCode=None, + isDefinitelyObject=False, + isMember=False, + isOptional=False, + invalidEnumValueFatal=True, + defaultValue=None, + treatNullAs="Default", + isEnforceRange=False, + isClamp=False, + isNullOrUndefined=False, + exceptionCode=None, + lenientFloatCode=None, + allowTreatNonCallableAsNull=False, + isCallbackReturnValue=False, + sourceDescription="value", + nestingLevel=""): + """ + Get a template for converting a JS value to a native object based on the + given type and descriptor. If failureCode is given, then we're actually + testing whether we can convert the argument to the desired type. That + means that failures to convert due to the JS value being the wrong type of + value need to use failureCode instead of throwing exceptions. Failures to + convert that are due to JS exceptions (from toString or valueOf methods) or + out of memory conditions need to throw exceptions no matter what + failureCode is. However what actually happens when throwing an exception + can be controlled by exceptionCode. The only requirement on that is that + exceptionCode must end up doing a return, and every return from this + function must happen via exceptionCode if exceptionCode is not None. + + If isDefinitelyObject is True, that means we know the value + isObject() and we have no need to recheck that. + + if isMember is not False, we're being converted from a property of some JS + object, not from an actual method argument, so we can't rely on our jsval + being rooted or outliving us in any way. Callers can pass "Dictionary", + "Variadic", "Sequence", or "OwningUnion" to indicate that the conversion is + for something that is a dictionary member, a variadic argument, a sequence, + or an owning union respectively. + + If isOptional is true, then we are doing conversion of an optional + argument with no default value. + + invalidEnumValueFatal controls whether an invalid enum value conversion + attempt will throw (if true) or simply return without doing anything (if + false). + + If defaultValue is not None, it's the IDL default value for this conversion + + If isEnforceRange is true, we're converting an integer and throwing if the + value is out of range. + + If isClamp is true, we're converting an integer and clamping if the + value is out of range. + + If lenientFloatCode is not None, it should be used in cases when + we're a non-finite float that's not unrestricted. + + If allowTreatNonCallableAsNull is true, then [TreatNonCallableAsNull] and + [TreatNonObjectAsNull] extended attributes on nullable callback functions + will be honored. + + If isCallbackReturnValue is "JSImpl" or "Callback", then the declType may be + adjusted to make it easier to return from a callback. Since that type is + never directly observable by any consumers of the callback code, this is OK. + Furthermore, if isCallbackReturnValue is "JSImpl", that affects the behavior + of the FailureFatalCastableObjectUnwrapper conversion; this is used for + implementing auto-wrapping of JS-implemented return values from a + JS-implemented interface. + + sourceDescription is a description of what this JS value represents, to be + used in error reporting. Callers should assume that it might get placed in + the middle of a sentence. If it ends up at the beginning of a sentence, its + first character will be automatically uppercased. + + The return value from this function is a JSToNativeConversionInfo. + """ + # If we have a defaultValue then we're not actually optional for + # purposes of what we need to be declared as. + assert defaultValue is None or not isOptional + + # Also, we should not have a defaultValue if we know we're an object + assert not isDefinitelyObject or defaultValue is None + + # And we can't both be an object and be null or undefined + assert not isDefinitelyObject or not isNullOrUndefined + + # If exceptionCode is not set, we'll just rethrow the exception we got. + # Note that we can't just set failureCode to exceptionCode, because setting + # failureCode will prevent pending exceptions from being set in cases when + # they really should be! + if exceptionCode is None: + exceptionCode = "return false;\n" + + # Unfortunately, .capitalize() on a string will lowercase things inside the + # string, which we do not want. + def firstCap(string): + return string[0].upper() + string[1:] + + # Helper functions for dealing with failures due to the JS value being the + # wrong type of value + def onFailureNotAnObject(failureCode): + return CGGeneric( + failureCode or + ('ThrowErrorMessage(cx, MSG_NOT_OBJECT, "%s");\n' + '%s' % (firstCap(sourceDescription), exceptionCode))) + + def onFailureBadType(failureCode, typeName): + return CGGeneric( + failureCode or + ('ThrowErrorMessage(cx, MSG_DOES_NOT_IMPLEMENT_INTERFACE, "%s", "%s");\n' + '%s' % (firstCap(sourceDescription), typeName, exceptionCode))) + + def onFailureNotCallable(failureCode): + return CGGeneric( + failureCode or + ('ThrowErrorMessage(cx, MSG_NOT_CALLABLE, "%s");\n' + '%s' % (firstCap(sourceDescription), exceptionCode))) + + # A helper function for handling default values. Takes a template + # body and the C++ code to set the default value and wraps the + # given template body in handling for the default value. + def handleDefault(template, setDefault): + if defaultValue is None: + return template + return ( + "if (${haveValue}) {\n" + + indent(template) + + "} else {\n" + + indent(setDefault) + + "}\n") + + # A helper function for wrapping up the template body for + # possibly-nullable objecty stuff + def wrapObjectTemplate(templateBody, type, codeToSetNull, failureCode=None): + if isNullOrUndefined and type.nullable(): + # Just ignore templateBody and set ourselves to null. + # Note that we don't have to worry about default values + # here either, since we already examined this value. + return codeToSetNull + + if not isDefinitelyObject: + # Handle the non-object cases by wrapping up the whole + # thing in an if cascade. + if type.nullable(): + elifLine = "} else if (${val}.isNullOrUndefined()) {\n" + elifBody = codeToSetNull + else: + elifLine = "" + elifBody = "" + + # Note that $${val} below expands to ${val}. This string is + # used as a template later, and val will be filled in then. + templateBody = fill( + """ + if ($${val}.isObject()) { + $*{templateBody} + $*{elifLine} + $*{elifBody} + } else { + $*{failureBody} + } + """, + templateBody=templateBody, + elifLine=elifLine, + elifBody=elifBody, + failureBody=onFailureNotAnObject(failureCode).define()) + + if isinstance(defaultValue, IDLNullValue): + assert type.nullable() # Parser should enforce this + templateBody = handleDefault(templateBody, codeToSetNull) + elif isinstance(defaultValue, IDLEmptySequenceValue): + # Our caller will handle it + pass + else: + assert defaultValue is None + + return templateBody + + # A helper function for converting things that look like a JSObject*. + def handleJSObjectType(type, isMember, failureCode, exceptionCode, sourceDescription): + if not isMember: + if isOptional: + # We have a specialization of Optional that will use a + # Rooted for the storage here. + declType = CGGeneric("JS::Handle<JSObject*>") + else: + declType = CGGeneric("JS::Rooted<JSObject*>") + declArgs = "cx" + else: + assert (isMember in + ("Sequence", "Variadic", "Dictionary", "OwningUnion", "MozMap")) + # We'll get traced by the sequence or dictionary or union tracer + declType = CGGeneric("JSObject*") + declArgs = None + templateBody = "${declName} = &${val}.toObject();\n" + + # For JS-implemented APIs, we refuse to allow passing objects that the + # API consumer does not subsume. The extra parens around + # ($${passedToJSImpl}) suppress unreachable code warnings when + # $${passedToJSImpl} is the literal `false`. + if not isinstance(descriptorProvider, Descriptor) or descriptorProvider.interface.isJSImplemented(): + templateBody = fill( + """ + if (($${passedToJSImpl}) && !CallerSubsumes($${val})) { + ThrowErrorMessage(cx, MSG_PERMISSION_DENIED_TO_PASS_ARG, "${sourceDescription}"); + $*{exceptionCode} + } + """, + sourceDescription=sourceDescription, + exceptionCode=exceptionCode) + templateBody + + setToNullCode = "${declName} = nullptr;\n" + template = wrapObjectTemplate(templateBody, type, setToNullCode, + failureCode) + return JSToNativeConversionInfo(template, declType=declType, + dealWithOptional=isOptional, + declArgs=declArgs) + + def incrementNestingLevel(): + if nestingLevel is "": + return 1 + return nestingLevel + 1 + + assert not (isEnforceRange and isClamp) # These are mutually exclusive + + if type.isSequence(): + assert not isEnforceRange and not isClamp + + if failureCode is None: + notSequence = ('ThrowErrorMessage(cx, MSG_NOT_SEQUENCE, "%s");\n' + "%s" % (firstCap(sourceDescription), exceptionCode)) + else: + notSequence = failureCode + + nullable = type.nullable() + # Be very careful not to change "type": we need it later + if nullable: + elementType = type.inner.inner + else: + elementType = type.inner + + # We want to use auto arrays if we can, but we have to be careful with + # reallocation behavior for arrays. In particular, if we use auto + # arrays for sequences and have a sequence of elements which are + # themselves sequences or have sequences as members, we have a problem. + # In that case, resizing the outermost AutoTArray to the right size + # will memmove its elements, but AutoTArrays are not memmovable and + # hence will end up with pointers to bogus memory, which is bad. To + # deal with this, we typically map WebIDL sequences to our Sequence + # type, which is in fact memmovable. The one exception is when we're + # passing in a sequence directly as an argument without any sort of + # optional or nullable complexity going on. In that situation, we can + # use an AutoSequence instead. We have to keep using Sequence in the + # nullable and optional cases because we don't want to leak the + # AutoSequence type to consumers, which would be unavoidable with + # Nullable<AutoSequence> or Optional<AutoSequence>. + if isMember or isOptional or nullable or isCallbackReturnValue: + sequenceClass = "Sequence" + else: + sequenceClass = "binding_detail::AutoSequence" + + # XXXbz we can't include the index in the sourceDescription, because + # we don't really have a way to pass one in dynamically at runtime... + elementInfo = getJSToNativeConversionInfo( + elementType, descriptorProvider, isMember="Sequence", + exceptionCode=exceptionCode, lenientFloatCode=lenientFloatCode, + isCallbackReturnValue=isCallbackReturnValue, + sourceDescription="element of %s" % sourceDescription, + nestingLevel=incrementNestingLevel()) + if elementInfo.dealWithOptional: + raise TypeError("Shouldn't have optional things in sequences") + if elementInfo.holderType is not None: + raise TypeError("Shouldn't need holders for sequences") + + typeName = CGTemplatedType(sequenceClass, elementInfo.declType) + sequenceType = typeName.define() + if nullable: + typeName = CGTemplatedType("Nullable", typeName) + arrayRef = "${declName}.SetValue()" + else: + arrayRef = "${declName}" + + elementConversion = string.Template(elementInfo.template).substitute({ + "val": "temp" + str(nestingLevel), + "maybeMutableVal": "&temp" + str(nestingLevel), + "declName": "slot" + str(nestingLevel), + # We only need holderName here to handle isExternal() + # interfaces, which use an internal holder for the + # conversion even when forceOwningType ends up true. + "holderName": "tempHolder" + str(nestingLevel), + "passedToJSImpl": "${passedToJSImpl}" + }) + + # NOTE: Keep this in sync with variadic conversions as needed + templateBody = fill( + """ + JS::ForOfIterator iter${nestingLevel}(cx); + if (!iter${nestingLevel}.init($${val}, JS::ForOfIterator::AllowNonIterable)) { + $*{exceptionCode} + } + if (!iter${nestingLevel}.valueIsIterable()) { + $*{notSequence} + } + ${sequenceType} &arr${nestingLevel} = ${arrayRef}; + JS::Rooted<JS::Value> temp${nestingLevel}(cx); + while (true) { + bool done${nestingLevel}; + if (!iter${nestingLevel}.next(&temp${nestingLevel}, &done${nestingLevel})) { + $*{exceptionCode} + } + if (done${nestingLevel}) { + break; + } + ${elementType}* slotPtr${nestingLevel} = arr${nestingLevel}.AppendElement(mozilla::fallible); + if (!slotPtr${nestingLevel}) { + JS_ReportOutOfMemory(cx); + $*{exceptionCode} + } + ${elementType}& slot${nestingLevel} = *slotPtr${nestingLevel}; + $*{elementConversion} + } + """, + exceptionCode=exceptionCode, + notSequence=notSequence, + sequenceType=sequenceType, + arrayRef=arrayRef, + elementType=elementInfo.declType.define(), + elementConversion=elementConversion, + nestingLevel=str(nestingLevel)) + + templateBody = wrapObjectTemplate(templateBody, type, + "${declName}.SetNull();\n", notSequence) + if isinstance(defaultValue, IDLEmptySequenceValue): + if type.nullable(): + codeToSetEmpty = "${declName}.SetValue();\n" + else: + codeToSetEmpty = "/* Array is already empty; nothing to do */\n" + templateBody = handleDefault(templateBody, codeToSetEmpty) + + # Sequence arguments that might contain traceable things need + # to get traced + if not isMember and typeNeedsRooting(elementType): + holderType = CGTemplatedType("SequenceRooter", elementInfo.declType) + # If our sequence is nullable, this will set the Nullable to be + # not-null, but that's ok because we make an explicit SetNull() call + # on it as needed if our JS value is actually null. + holderArgs = "cx, &%s" % arrayRef + else: + holderType = None + holderArgs = None + + return JSToNativeConversionInfo(templateBody, declType=typeName, + holderType=holderType, + dealWithOptional=isOptional, + holderArgs=holderArgs) + + if type.isMozMap(): + assert not isEnforceRange and not isClamp + if failureCode is None: + notMozMap = ('ThrowErrorMessage(cx, MSG_NOT_OBJECT, "%s");\n' + "%s" % (firstCap(sourceDescription), exceptionCode)) + else: + notMozMap = failureCode + + nullable = type.nullable() + # Be very careful not to change "type": we need it later + if nullable: + valueType = type.inner.inner + else: + valueType = type.inner + + valueInfo = getJSToNativeConversionInfo( + valueType, descriptorProvider, isMember="MozMap", + exceptionCode=exceptionCode, lenientFloatCode=lenientFloatCode, + isCallbackReturnValue=isCallbackReturnValue, + sourceDescription="value in %s" % sourceDescription, + nestingLevel=incrementNestingLevel()) + if valueInfo.dealWithOptional: + raise TypeError("Shouldn't have optional things in MozMap") + if valueInfo.holderType is not None: + raise TypeError("Shouldn't need holders for MozMap") + + typeName = CGTemplatedType("MozMap", valueInfo.declType) + mozMapType = typeName.define() + if nullable: + typeName = CGTemplatedType("Nullable", typeName) + mozMapRef = "${declName}.SetValue()" + else: + mozMapRef = "${declName}" + + valueConversion = string.Template(valueInfo.template).substitute({ + "val": "temp", + "maybeMutableVal": "&temp", + "declName": "slot", + # We only need holderName here to handle isExternal() + # interfaces, which use an internal holder for the + # conversion even when forceOwningType ends up true. + "holderName": "tempHolder", + "passedToJSImpl": "${passedToJSImpl}" + }) + + templateBody = fill( + """ + ${mozMapType} &mozMap = ${mozMapRef}; + + JS::Rooted<JSObject*> mozMapObj(cx, &$${val}.toObject()); + JS::Rooted<JS::IdVector> ids(cx, JS::IdVector(cx)); + if (!JS_Enumerate(cx, mozMapObj, &ids)) { + $*{exceptionCode} + } + JS::Rooted<JS::Value> propNameValue(cx); + JS::Rooted<JS::Value> temp(cx); + JS::Rooted<jsid> curId(cx); + for (size_t i = 0; i < ids.length(); ++i) { + // Make sure we get the value before converting the name, since + // getting the value can trigger GC but our name is a dependent + // string. + curId = ids[i]; + binding_detail::FakeString propName; + bool isSymbol; + if (!ConvertIdToString(cx, curId, propName, isSymbol) || + (!isSymbol && !JS_GetPropertyById(cx, mozMapObj, curId, &temp))) { + $*{exceptionCode} + } + if (isSymbol) { + continue; + } + + ${valueType}* slotPtr = mozMap.AddEntry(propName); + if (!slotPtr) { + JS_ReportOutOfMemory(cx); + $*{exceptionCode} + } + ${valueType}& slot = *slotPtr; + $*{valueConversion} + } + """, + exceptionCode=exceptionCode, + mozMapType=mozMapType, + mozMapRef=mozMapRef, + valueType=valueInfo.declType.define(), + valueConversion=valueConversion) + + templateBody = wrapObjectTemplate(templateBody, type, + "${declName}.SetNull();\n", + notMozMap) + + declType = typeName + declArgs = None + holderType = None + holderArgs = None + # MozMap arguments that might contain traceable things need + # to get traced + if not isMember and isCallbackReturnValue: + # Go ahead and just convert directly into our actual return value + declType = CGWrapper(declType, post="&") + declArgs = "aRetVal" + elif not isMember and typeNeedsRooting(valueType): + holderType = CGTemplatedType("MozMapRooter", valueInfo.declType) + # If our MozMap is nullable, this will set the Nullable to be + # not-null, but that's ok because we make an explicit SetNull() call + # on it as needed if our JS value is actually null. + holderArgs = "cx, &%s" % mozMapRef + + return JSToNativeConversionInfo(templateBody, declType=declType, + declArgs=declArgs, + holderType=holderType, + dealWithOptional=isOptional, + holderArgs=holderArgs) + + if type.isUnion(): + nullable = type.nullable() + if nullable: + type = type.inner + + isOwningUnion = isMember or isCallbackReturnValue + unionArgumentObj = "${declName}" if isOwningUnion else "${holderName}" + if nullable: + # If we're owning, we're a Nullable, which hasn't been told it has + # a value. Otherwise we're an already-constructed Maybe. + unionArgumentObj += ".SetValue()" if isOwningUnion else ".ref()" + + memberTypes = type.flatMemberTypes + names = [] + + interfaceMemberTypes = filter(lambda t: t.isNonCallbackInterface(), memberTypes) + if len(interfaceMemberTypes) > 0: + interfaceObject = [] + for memberType in interfaceMemberTypes: + name = getUnionMemberName(memberType) + interfaceObject.append( + CGGeneric("(failed = !%s.TrySetTo%s(cx, ${val}, tryNext, ${passedToJSImpl})) || !tryNext" % + (unionArgumentObj, name))) + names.append(name) + interfaceObject = CGWrapper(CGList(interfaceObject, " ||\n"), + pre="done = ", post=";\n\n", reindent=True) + else: + interfaceObject = None + + sequenceObjectMemberTypes = filter(lambda t: t.isSequence(), memberTypes) + if len(sequenceObjectMemberTypes) > 0: + assert len(sequenceObjectMemberTypes) == 1 + name = getUnionMemberName(sequenceObjectMemberTypes[0]) + sequenceObject = CGGeneric( + "done = (failed = !%s.TrySetTo%s(cx, ${val}, tryNext, ${passedToJSImpl})) || !tryNext;\n" % + (unionArgumentObj, name)) + names.append(name) + else: + sequenceObject = None + + dateObjectMemberTypes = filter(lambda t: t.isDate(), memberTypes) + if len(dateObjectMemberTypes) > 0: + assert len(dateObjectMemberTypes) == 1 + memberType = dateObjectMemberTypes[0] + name = getUnionMemberName(memberType) + dateObject = CGGeneric("%s.SetTo%s(cx, ${val});\n" + "done = true;\n" % (unionArgumentObj, name)) + dateObject = CGIfWrapper(dateObject, "JS_ObjectIsDate(cx, argObj)") + names.append(name) + else: + dateObject = None + + callbackMemberTypes = filter(lambda t: t.isCallback() or t.isCallbackInterface(), memberTypes) + if len(callbackMemberTypes) > 0: + assert len(callbackMemberTypes) == 1 + memberType = callbackMemberTypes[0] + name = getUnionMemberName(memberType) + callbackObject = CGGeneric( + "done = (failed = !%s.TrySetTo%s(cx, ${val}, tryNext, ${passedToJSImpl})) || !tryNext;\n" % + (unionArgumentObj, name)) + names.append(name) + else: + callbackObject = None + + dictionaryMemberTypes = filter(lambda t: t.isDictionary(), memberTypes) + if len(dictionaryMemberTypes) > 0: + assert len(dictionaryMemberTypes) == 1 + name = getUnionMemberName(dictionaryMemberTypes[0]) + setDictionary = CGGeneric( + "done = (failed = !%s.TrySetTo%s(cx, ${val}, tryNext, ${passedToJSImpl})) || !tryNext;\n" % + (unionArgumentObj, name)) + names.append(name) + else: + setDictionary = None + + mozMapMemberTypes = filter(lambda t: t.isMozMap(), memberTypes) + if len(mozMapMemberTypes) > 0: + assert len(mozMapMemberTypes) == 1 + name = getUnionMemberName(mozMapMemberTypes[0]) + mozMapObject = CGGeneric( + "done = (failed = !%s.TrySetTo%s(cx, ${val}, tryNext, ${passedToJSImpl})) || !tryNext;\n" % + (unionArgumentObj, name)) + names.append(name) + else: + mozMapObject = None + + objectMemberTypes = filter(lambda t: t.isObject(), memberTypes) + if len(objectMemberTypes) > 0: + assert len(objectMemberTypes) == 1 + # Very important to NOT construct a temporary Rooted here, since the + # SetToObject call can call a Rooted constructor and we need to keep + # stack discipline for Rooted. + object = CGGeneric("if (!%s.SetToObject(cx, &${val}.toObject(), ${passedToJSImpl})) {\n" + "%s" + "}\n" + "done = true;\n" % (unionArgumentObj, indent(exceptionCode))) + names.append(objectMemberTypes[0].name) + else: + object = None + + hasObjectTypes = interfaceObject or sequenceObject or dateObject or callbackObject or object or mozMapObject + if hasObjectTypes: + # "object" is not distinguishable from other types + assert not object or not (interfaceObject or sequenceObject or dateObject or callbackObject or mozMapObject) + if sequenceObject or dateObject or callbackObject: + # An object can be both an sequence object and a callback or + # dictionary, but we shouldn't have both in the union's members + # because they are not distinguishable. + assert not (sequenceObject and callbackObject) + templateBody = CGElseChain([sequenceObject, dateObject, callbackObject]) + else: + templateBody = None + if interfaceObject: + assert not object + if templateBody: + templateBody = CGIfWrapper(templateBody, "!done") + templateBody = CGList([interfaceObject, templateBody]) + else: + templateBody = CGList([templateBody, object]) + + if dateObject: + templateBody.prepend(CGGeneric("JS::Rooted<JSObject*> argObj(cx, &${val}.toObject());\n")) + + if mozMapObject: + templateBody = CGList([templateBody, + CGIfWrapper(mozMapObject, "!done")]) + + templateBody = CGIfWrapper(templateBody, "${val}.isObject()") + else: + templateBody = CGGeneric() + + if setDictionary: + assert not object + templateBody = CGList([templateBody, + CGIfWrapper(setDictionary, "!done")]) + + stringTypes = [t for t in memberTypes if t.isString() or t.isEnum()] + numericTypes = [t for t in memberTypes if t.isNumeric()] + booleanTypes = [t for t in memberTypes if t.isBoolean()] + if stringTypes or numericTypes or booleanTypes: + assert len(stringTypes) <= 1 + assert len(numericTypes) <= 1 + assert len(booleanTypes) <= 1 + + # We will wrap all this stuff in a do { } while (0); so we + # can use "break" for flow control. + def getStringOrPrimitiveConversion(memberType): + name = getUnionMemberName(memberType) + return CGGeneric("done = (failed = !%s.TrySetTo%s(cx, ${val}, tryNext)) || !tryNext;\n" + "break;\n" % (unionArgumentObj, name)) + other = CGList([]) + stringConversion = map(getStringOrPrimitiveConversion, stringTypes) + numericConversion = map(getStringOrPrimitiveConversion, numericTypes) + booleanConversion = map(getStringOrPrimitiveConversion, booleanTypes) + if stringConversion: + if booleanConversion: + other.append(CGIfWrapper(booleanConversion[0], + "${val}.isBoolean()")) + if numericConversion: + other.append(CGIfWrapper(numericConversion[0], + "${val}.isNumber()")) + other.append(stringConversion[0]) + elif numericConversion: + if booleanConversion: + other.append(CGIfWrapper(booleanConversion[0], + "${val}.isBoolean()")) + other.append(numericConversion[0]) + else: + assert booleanConversion + other.append(booleanConversion[0]) + + other = CGWrapper(CGIndenter(other), pre="do {\n", post="} while (0);\n") + if hasObjectTypes or setDictionary: + other = CGWrapper(CGIndenter(other), "{\n", post="}\n") + if object: + templateBody = CGElseChain([templateBody, other]) + else: + other = CGWrapper(other, pre="if (!done) ") + templateBody = CGList([templateBody, other]) + else: + assert templateBody.define() == "" + templateBody = other + else: + other = None + + templateBody = CGWrapper(templateBody, pre="bool done = false, failed = false, tryNext;\n") + throw = CGGeneric(fill( + """ + if (failed) { + $*{exceptionCode} + } + if (!done) { + ThrowErrorMessage(cx, MSG_NOT_IN_UNION, "${desc}", "${names}"); + $*{exceptionCode} + } + """, + exceptionCode=exceptionCode, + desc=firstCap(sourceDescription), + names=", ".join(names))) + + templateBody = CGWrapper(CGIndenter(CGList([templateBody, throw])), pre="{\n", post="}\n") + + typeName = CGUnionStruct.unionTypeDecl(type, isOwningUnion) + argumentTypeName = typeName + "Argument" + if nullable: + typeName = "Nullable<" + typeName + " >" + + def handleNull(templateBody, setToNullVar, extraConditionForNull=""): + nullTest = "%s${val}.isNullOrUndefined()" % extraConditionForNull + return CGIfElseWrapper(nullTest, + CGGeneric("%s.SetNull();\n" % setToNullVar), + templateBody) + + if type.hasNullableType: + assert not nullable + # Make sure to handle a null default value here + if defaultValue and isinstance(defaultValue, IDLNullValue): + assert defaultValue.type == type + extraConditionForNull = "!(${haveValue}) || " + else: + extraConditionForNull = "" + templateBody = handleNull(templateBody, unionArgumentObj, + extraConditionForNull=extraConditionForNull) + + declType = CGGeneric(typeName) + if isOwningUnion: + holderType = None + else: + holderType = CGGeneric(argumentTypeName) + if nullable: + holderType = CGTemplatedType("Maybe", holderType) + + # If we're isOptional and not nullable the normal optional handling will + # handle lazy construction of our holder. If we're nullable and not + # owning we do it all by hand because we do not want our holder + # constructed if we're null. But if we're owning we don't have a + # holder anyway, so we can do the normal Optional codepath. + declLoc = "${declName}" + constructDecl = None + if nullable: + if isOptional and not isOwningUnion: + holderArgs = "${declName}.Value().SetValue()" + declType = CGTemplatedType("Optional", declType) + constructDecl = CGGeneric("${declName}.Construct();\n") + declLoc = "${declName}.Value()" + else: + holderArgs = "${declName}.SetValue()" + if holderType is not None: + constructHolder = CGGeneric("${holderName}.emplace(%s);\n" % holderArgs) + else: + constructHolder = None + # Don't need to pass those args when the holder is being constructed + holderArgs = None + else: + holderArgs = "${declName}" + constructHolder = None + + if not isMember and isCallbackReturnValue: + declType = CGWrapper(declType, post="&") + declArgs = "aRetVal" + else: + declArgs = None + + if defaultValue and not isinstance(defaultValue, IDLNullValue): + tag = defaultValue.type.tag() + + if tag in numericSuffixes or tag is IDLType.Tags.bool: + defaultStr = getHandleDefault(defaultValue) + # Make sure we actually construct the thing inside the nullable. + value = declLoc + (".SetValue()" if nullable else "") + name = getUnionMemberName(defaultValue.type) + default = CGGeneric("%s.RawSetAs%s() = %s;\n" % + (value, name, defaultStr)) + elif isinstance(defaultValue, IDLEmptySequenceValue): + name = getUnionMemberName(defaultValue.type) + # Make sure we actually construct the thing inside the nullable. + value = declLoc + (".SetValue()" if nullable else "") + # It's enough to set us to the right type; that will + # create an empty array, which is all we need here. + default = CGGeneric("%s.RawSetAs%s();\n" % + (value, name)) + elif defaultValue.type.isEnum(): + name = getUnionMemberName(defaultValue.type) + # Make sure we actually construct the thing inside the nullable. + value = declLoc + (".SetValue()" if nullable else "") + default = CGGeneric( + "%s.RawSetAs%s() = %s::%s;\n" % + (value, name, + defaultValue.type.inner.identifier.name, + getEnumValueName(defaultValue.value))) + else: + default = CGGeneric( + handleDefaultStringValue( + defaultValue, "%s.SetStringData" % unionArgumentObj) + + ";\n") + + templateBody = CGIfElseWrapper("!(${haveValue})", default, templateBody) + + templateBody = CGList([constructHolder, templateBody]) + + if nullable: + if defaultValue: + if isinstance(defaultValue, IDLNullValue): + extraConditionForNull = "!(${haveValue}) || " + else: + extraConditionForNull = "${haveValue} && " + else: + extraConditionForNull = "" + templateBody = handleNull(templateBody, declLoc, + extraConditionForNull=extraConditionForNull) + elif (not type.hasNullableType and defaultValue and + isinstance(defaultValue, IDLNullValue)): + assert type.hasDictionaryType() + assert defaultValue.type.isDictionary() + if not isOwningUnion and typeNeedsRooting(defaultValue.type): + ctorArgs = "cx" + else: + ctorArgs = "" + initDictionaryWithNull = CGIfWrapper( + CGGeneric("return false;\n"), + ('!%s.RawSetAs%s(%s).Init(cx, JS::NullHandleValue, "Member of %s")' + % (declLoc, getUnionMemberName(defaultValue.type), + ctorArgs, type))) + templateBody = CGIfElseWrapper("!(${haveValue})", + initDictionaryWithNull, + templateBody) + + templateBody = CGList([constructDecl, templateBody]) + + return JSToNativeConversionInfo(templateBody.define(), + declType=declType, + declArgs=declArgs, + holderType=holderType, + holderArgs=holderArgs, + dealWithOptional=isOptional and (not nullable or isOwningUnion)) + + if type.isGeckoInterface(): + assert not isEnforceRange and not isClamp + + descriptor = descriptorProvider.getDescriptor( + type.unroll().inner.identifier.name) + + assert descriptor.nativeType != 'JSObject' + + if descriptor.interface.isCallback(): + (declType, declArgs, + conversion) = getCallbackConversionInfo(type, descriptor.interface, + isMember, + isCallbackReturnValue, + isOptional) + template = wrapObjectTemplate(conversion, type, + "${declName} = nullptr;\n", + failureCode) + return JSToNativeConversionInfo(template, declType=declType, + declArgs=declArgs, + dealWithOptional=isOptional) + + # This is an interface that we implement as a concrete class + # or an XPCOM interface. + + # Allow null pointers for nullable types and old-binding classes, and + # use an RefPtr or raw pointer for callback return values to make + # them easier to return. + argIsPointer = (type.nullable() or type.unroll().inner.isExternal() or + isCallbackReturnValue) + + # Sequence and dictionary members, as well as owning unions (which can + # appear here as return values in JS-implemented interfaces) have to + # hold a strong ref to the thing being passed down. Those all set + # isMember. + # + # Also, callback return values always end up addrefing anyway, so there + # is no point trying to avoid it here and it makes other things simpler + # since we can assume the return value is a strong ref. + # + # Finally, promises need to hold a strong ref because that's what + # Promise.resolve returns. + assert not descriptor.interface.isCallback() + isPromise = descriptor.interface.identifier.name == "Promise" + forceOwningType = isMember or isCallbackReturnValue or isPromise + + typeName = descriptor.nativeType + typePtr = typeName + "*" + + # Compute a few things: + # - declType is the type we want to return as the first element of our + # tuple. + # - holderType is the type we want to return as the third element + # of our tuple. + + # Set up some sensible defaults for these things insofar as we can. + holderType = None + if argIsPointer: + if forceOwningType: + declType = "RefPtr<" + typeName + ">" + else: + declType = typePtr + else: + if forceOwningType: + declType = "OwningNonNull<" + typeName + ">" + else: + declType = "NonNull<" + typeName + ">" + + templateBody = "" + if forceOwningType: + templateBody += 'static_assert(IsRefcounted<%s>::value, "We can only store refcounted classes.");' % typeName + + if isPromise: + # Per spec, what we're supposed to do is take the original + # Promise.resolve and call it with the original Promise as this + # value to make a Promise out of whatever value we actually have + # here. The question is which global we should use. There are + # several cases to consider: + # + # 1) Normal call to API with a Promise argument. This is a case the + # spec covers, and we should be using the current Realm's + # Promise. That means the current compartment. + # 2) Call to API with a Promise argument over Xrays. In practice, + # this sort of thing seems to be used for giving an API + # implementation a way to wait for conclusion of an asyc + # operation, _not_ to expose the Promise to content code. So we + # probably want to allow callers to use such an API in a + # "natural" way, by passing chrome-side promises; indeed, that + # may be all that the caller has to represent their async + # operation. That means we really need to do the + # Promise.resolve() in the caller (chrome) compartment: if we do + # it in the content compartment, we will try to call .then() on + # the chrome promise while in the content compartment, which will + # throw and we'll just get a rejected Promise. Note that this is + # also the reason why a caller who has a chrome Promise + # representing an async operation can't itself convert it to a + # content-side Promise (at least not without some serious + # gyrations). + # 3) Promise return value from a callback or callback interface. + # This is in theory a case the spec covers but in practice it + # really doesn't define behavior here because it doesn't define + # what Realm we're in after the callback returns, which is when + # the argument conversion happens. We will use the current + # compartment, which is the compartment of the callable (which + # may itself be a cross-compartment wrapper itself), which makes + # as much sense as anything else. In practice, such an API would + # once again be providing a Promise to signal completion of an + # operation, which would then not be exposed to anyone other than + # our own implementation code. + # 4) Return value from a JS-implemented interface. In this case we + # have a problem. Our current compartment is the compartment of + # the JS implementation. But if the JS implementation returned + # a page-side Promise (which is a totally sane thing to do, and + # in fact the right thing to do given that this return value is + # going right to content script) then we don't want to + # Promise.resolve with our current compartment Promise, because + # that will wrap it up in a chrome-side Promise, which is + # decidedly _not_ what's desired here. So in that case we + # should really unwrap the return value and use the global of + # the result. CheckedUnwrap should be good enough for that; if + # it fails, then we're failing unwrap while in a + # system-privileged compartment, so presumably we have a dead + # object wrapper. Just error out. Do NOT fall back to using + # the current compartment instead: that will return a + # system-privileged rejected (because getting .then inside + # resolve() failed) Promise to the caller, which they won't be + # able to touch. That's not helpful. If we error out, on the + # other hand, they will get a content-side rejected promise. + # Same thing if the value returned is not even an object. + if isCallbackReturnValue == "JSImpl": + # Case 4 above. Note that globalObj defaults to the current + # compartment global. Note that we don't use $*{exceptionCode} + # here because that will try to aRv.Throw(NS_ERROR_UNEXPECTED) + # which we don't really want here. + assert exceptionCode == "aRv.Throw(NS_ERROR_UNEXPECTED);\nreturn nullptr;\n" + getPromiseGlobal = fill( + """ + if (!$${val}.isObject()) { + aRv.ThrowTypeError<MSG_NOT_OBJECT>(NS_LITERAL_STRING("${sourceDescription}")); + return nullptr; + } + JSObject* unwrappedVal = js::CheckedUnwrap(&$${val}.toObject()); + if (!unwrappedVal) { + // A slight lie, but not much of one, for a dead object wrapper. + aRv.ThrowTypeError<MSG_NOT_OBJECT>(NS_LITERAL_STRING("${sourceDescription}")); + return nullptr; + } + globalObj = js::GetGlobalForObjectCrossCompartment(unwrappedVal); + """, + sourceDescription=sourceDescription) + else: + getPromiseGlobal = "" + + templateBody = fill( + """ + { // Scope for our GlobalObject, FastErrorResult, JSAutoCompartment, + // etc. + + JS::Rooted<JSObject*> globalObj(cx, JS::CurrentGlobalOrNull(cx)); + $*{getPromiseGlobal} + JSAutoCompartment ac(cx, globalObj); + GlobalObject promiseGlobal(cx, globalObj); + if (promiseGlobal.Failed()) { + $*{exceptionCode} + } + + JS::Rooted<JS::Value> valueToResolve(cx, $${val}); + if (!JS_WrapValue(cx, &valueToResolve)) { + $*{exceptionCode} + } + binding_detail::FastErrorResult promiseRv; + #ifdef SPIDERMONKEY_PROMISE + nsCOMPtr<nsIGlobalObject> global = + do_QueryInterface(promiseGlobal.GetAsSupports()); + if (!global) { + promiseRv.Throw(NS_ERROR_UNEXPECTED); + promiseRv.MaybeSetPendingException(cx); + $*{exceptionCode} + } + $${declName} = Promise::Resolve(global, cx, valueToResolve, + promiseRv); + if (promiseRv.MaybeSetPendingException(cx)) { + $*{exceptionCode} + } + #else + JS::Handle<JSObject*> promiseCtor = + PromiseBinding::GetConstructorObjectHandle(cx); + if (!promiseCtor) { + $*{exceptionCode} + } + JS::Rooted<JS::Value> resolveThisv(cx, JS::ObjectValue(*promiseCtor)); + JS::Rooted<JS::Value> resolveResult(cx); + Promise::Resolve(promiseGlobal, resolveThisv, valueToResolve, + &resolveResult, promiseRv); + if (promiseRv.MaybeSetPendingException(cx)) { + $*{exceptionCode} + } + nsresult unwrapRv = UNWRAP_OBJECT(Promise, &resolveResult.toObject(), $${declName}); + if (NS_FAILED(unwrapRv)) { // Quite odd + promiseRv.Throw(unwrapRv); + promiseRv.MaybeSetPendingException(cx); + $*{exceptionCode} + } + #endif // SPIDERMONKEY_PROMISE + } + """, + getPromiseGlobal=getPromiseGlobal, + exceptionCode=exceptionCode) + elif not descriptor.interface.isConsequential() and not descriptor.interface.isExternal(): + if failureCode is not None: + templateBody += str(CastableObjectUnwrapper( + descriptor, + "${val}", + "${maybeMutableVal}", + "${declName}", + failureCode)) + else: + templateBody += str(FailureFatalCastableObjectUnwrapper( + descriptor, + "${val}", + "${maybeMutableVal}", + "${declName}", + exceptionCode, + isCallbackReturnValue, + firstCap(sourceDescription))) + else: + # Either external, or new-binding non-castable. We always have a + # holder for these, because we don't actually know whether we have + # to addref when unwrapping or not. So we just pass an + # getter_AddRefs(RefPtr) to XPConnect and if we'll need a release + # it'll put a non-null pointer in there. + if forceOwningType: + # Don't return a holderType in this case; our declName + # will just own stuff. + templateBody += "RefPtr<" + typeName + "> ${holderName};\n" + else: + holderType = "RefPtr<" + typeName + ">" + templateBody += ( + "JS::Rooted<JSObject*> source(cx, &${val}.toObject());\n" + + "if (NS_FAILED(UnwrapArg<" + typeName + ">(source, getter_AddRefs(${holderName})))) {\n") + templateBody += CGIndenter(onFailureBadType(failureCode, + descriptor.interface.identifier.name)).define() + templateBody += ("}\n" + "MOZ_ASSERT(${holderName});\n") + + # And store our value in ${declName} + templateBody += "${declName} = ${holderName};\n" + + if isPromise: + if type.nullable(): + codeToSetNull = "${declName} = nullptr;\n" + templateBody = CGIfElseWrapper( + "${val}.isNullOrUndefined()", + CGGeneric(codeToSetNull), + CGGeneric(templateBody)).define() + if isinstance(defaultValue, IDLNullValue): + templateBody = handleDefault(templateBody, codeToSetNull) + else: + assert defaultValue is None + else: + # Just pass failureCode, not onFailureBadType, here, so we'll report + # the thing as not an object as opposed to not implementing whatever + # our interface is. + templateBody = wrapObjectTemplate(templateBody, type, + "${declName} = nullptr;\n", + failureCode) + + declType = CGGeneric(declType) + if holderType is not None: + holderType = CGGeneric(holderType) + return JSToNativeConversionInfo(templateBody, + declType=declType, + holderType=holderType, + dealWithOptional=isOptional) + + if type.isSpiderMonkeyInterface(): + assert not isEnforceRange and not isClamp + name = type.unroll().name # unroll() because it may be nullable + arrayType = CGGeneric(name) + declType = arrayType + if type.nullable(): + declType = CGTemplatedType("Nullable", declType) + objRef = "${declName}.SetValue()" + else: + objRef = "${declName}" + + # Again, this is a bit strange since we are actually building a + # template string here. ${objRef} and $*{badType} below are filled in + # right now; $${val} expands to ${val}, to be filled in later. + template = fill( + """ + if (!${objRef}.Init(&$${val}.toObject())) { + $*{badType} + } + """, + objRef=objRef, + badType=onFailureBadType(failureCode, type.name).define()) + template = wrapObjectTemplate(template, type, "${declName}.SetNull();\n", + failureCode) + if not isMember: + # This is a bit annoying. In a union we don't want to have a + # holder, since unions don't support that. But if we're optional we + # want to have a holder, so that the callee doesn't see + # Optional<RootedTypedArray<ArrayType> >. So do a holder if we're + # optional and use a RootedTypedArray otherwise. + if isOptional: + holderType = CGTemplatedType("TypedArrayRooter", arrayType) + # If our typed array is nullable, this will set the Nullable to + # be not-null, but that's ok because we make an explicit + # SetNull() call on it as needed if our JS value is actually + # null. XXXbz Because "Maybe" takes const refs for constructor + # arguments, we can't pass a reference here; have to pass a + # pointer. + holderArgs = "cx, &%s" % objRef + declArgs = None + else: + holderType = None + holderArgs = None + declType = CGTemplatedType("RootedTypedArray", declType) + declArgs = "cx" + else: + holderType = None + holderArgs = None + declArgs = None + return JSToNativeConversionInfo(template, + declType=declType, + holderType=holderType, + dealWithOptional=isOptional, + declArgs=declArgs, + holderArgs=holderArgs) + + if type.isDOMString() or type.isUSVString(): + assert not isEnforceRange and not isClamp + + treatAs = { + "Default": "eStringify", + "EmptyString": "eEmpty", + "Null": "eNull", + } + if type.nullable(): + # For nullable strings null becomes a null string. + treatNullAs = "Null" + # For nullable strings undefined also becomes a null string. + undefinedBehavior = "eNull" + else: + undefinedBehavior = "eStringify" + nullBehavior = treatAs[treatNullAs] + + def getConversionCode(varName): + normalizeCode = "" + if type.isUSVString(): + normalizeCode = "NormalizeUSVString(cx, %s);\n" % varName + + conversionCode = fill(""" + if (!ConvertJSValueToString(cx, $${val}, ${nullBehavior}, ${undefinedBehavior}, ${varName})) { + $*{exceptionCode} + } + $*{normalizeCode} + """ + , + nullBehavior=nullBehavior, + undefinedBehavior=undefinedBehavior, + varName=varName, + exceptionCode=exceptionCode, + normalizeCode=normalizeCode) + + if defaultValue is None: + return conversionCode + + if isinstance(defaultValue, IDLNullValue): + assert(type.nullable()) + defaultCode = "%s.SetIsVoid(true)" % varName + else: + defaultCode = handleDefaultStringValue(defaultValue, + "%s.Rebind" % varName) + return handleDefault(conversionCode, defaultCode + ";\n") + + if isMember: + # Convert directly into the nsString member we have. + declType = CGGeneric("nsString") + return JSToNativeConversionInfo( + getConversionCode("${declName}"), + declType=declType, + dealWithOptional=isOptional) + + if isOptional: + declType = "Optional<nsAString>" + holderType = CGGeneric("binding_detail::FakeString") + conversionCode = ("%s" + "${declName} = &${holderName};\n" % + getConversionCode("${holderName}")) + else: + declType = "binding_detail::FakeString" + holderType = None + conversionCode = getConversionCode("${declName}") + + # No need to deal with optional here; we handled it already + return JSToNativeConversionInfo( + conversionCode, + declType=CGGeneric(declType), + holderType=holderType) + + if type.isByteString(): + assert not isEnforceRange and not isClamp + + nullable = toStringBool(type.nullable()) + + conversionCode = fill(""" + if (!ConvertJSValueToByteString(cx, $${val}, ${nullable}, $${declName})) { + $*{exceptionCode} + } + """, + nullable=nullable, + exceptionCode=exceptionCode) + + if defaultValue is not None: + if isinstance(defaultValue, IDLNullValue): + assert(type.nullable()) + defaultCode = "${declName}.SetIsVoid(true)" + else: + defaultCode = handleDefaultStringValue(defaultValue, + "${declName}.Rebind") + conversionCode = handleDefault(conversionCode, defaultCode + ";\n") + + return JSToNativeConversionInfo( + conversionCode, + declType=CGGeneric("nsCString"), + dealWithOptional=isOptional) + + if type.isEnum(): + assert not isEnforceRange and not isClamp + + enumName = type.unroll().inner.identifier.name + declType = CGGeneric(enumName) + if type.nullable(): + declType = CGTemplatedType("Nullable", declType) + declType = declType.define() + enumLoc = "${declName}.SetValue()" + else: + enumLoc = "${declName}" + declType = declType.define() + + if invalidEnumValueFatal: + handleInvalidEnumValueCode = "MOZ_ASSERT(index >= 0);\n" + else: + # invalidEnumValueFatal is false only for attributes. So we won't + # have a non-default exceptionCode here unless attribute "arg + # conversion" code starts passing in an exceptionCode. At which + # point we'll need to figure out what that even means. + assert exceptionCode == "return false;\n" + handleInvalidEnumValueCode = dedent(""" + if (index < 0) { + return true; + } + """) + + template = fill( + """ + { + int index; + if (!FindEnumStringIndex<${invalidEnumValueFatal}>(cx, $${val}, ${values}, "${enumtype}", "${sourceDescription}", &index)) { + $*{exceptionCode} + } + $*{handleInvalidEnumValueCode} + ${enumLoc} = static_cast<${enumtype}>(index); + } + """, + enumtype=enumName, + values=enumName + "Values::" + ENUM_ENTRY_VARIABLE_NAME, + invalidEnumValueFatal=toStringBool(invalidEnumValueFatal), + handleInvalidEnumValueCode=handleInvalidEnumValueCode, + exceptionCode=exceptionCode, + enumLoc=enumLoc, + sourceDescription=firstCap(sourceDescription)) + + setNull = "${declName}.SetNull();\n" + + if type.nullable(): + template = CGIfElseWrapper("${val}.isNullOrUndefined()", + CGGeneric(setNull), + CGGeneric(template)).define() + + if defaultValue is not None: + if isinstance(defaultValue, IDLNullValue): + assert type.nullable() + template = handleDefault(template, setNull) + else: + assert(defaultValue.type.tag() == IDLType.Tags.domstring) + template = handleDefault(template, + ("%s = %s::%s;\n" % + (enumLoc, enumName, + getEnumValueName(defaultValue.value)))) + return JSToNativeConversionInfo(template, declType=CGGeneric(declType), + dealWithOptional=isOptional) + + if type.isCallback(): + assert not isEnforceRange and not isClamp + assert not type.treatNonCallableAsNull() or type.nullable() + assert not type.treatNonObjectAsNull() or type.nullable() + assert not type.treatNonObjectAsNull() or not type.treatNonCallableAsNull() + + callback = type.unroll().callback + name = callback.identifier.name + (declType, declArgs, + conversion) = getCallbackConversionInfo(type, callback, isMember, + isCallbackReturnValue, + isOptional) + + if allowTreatNonCallableAsNull and type.treatNonCallableAsNull(): + haveCallable = "JS::IsCallable(&${val}.toObject())" + if not isDefinitelyObject: + haveCallable = "${val}.isObject() && " + haveCallable + if defaultValue is not None: + assert(isinstance(defaultValue, IDLNullValue)) + haveCallable = "${haveValue} && " + haveCallable + template = ( + ("if (%s) {\n" % haveCallable) + + conversion + + "} else {\n" + " ${declName} = nullptr;\n" + "}\n") + elif allowTreatNonCallableAsNull and type.treatNonObjectAsNull(): + if not isDefinitelyObject: + haveObject = "${val}.isObject()" + if defaultValue is not None: + assert(isinstance(defaultValue, IDLNullValue)) + haveObject = "${haveValue} && " + haveObject + template = CGIfElseWrapper(haveObject, + CGGeneric(conversion), + CGGeneric("${declName} = nullptr;\n")).define() + else: + template = conversion + else: + template = wrapObjectTemplate( + "if (JS::IsCallable(&${val}.toObject())) {\n" + + conversion + + "} else {\n" + + indent(onFailureNotCallable(failureCode).define()) + + "}\n", + type, + "${declName} = nullptr;\n", + failureCode) + return JSToNativeConversionInfo(template, declType=declType, + declArgs=declArgs, + dealWithOptional=isOptional) + + if type.isAny(): + assert not isEnforceRange and not isClamp + + declArgs = None + if isMember in ("Variadic", "Sequence", "Dictionary", "MozMap"): + # Rooting is handled by the sequence and dictionary tracers. + declType = "JS::Value" + else: + assert not isMember + declType = "JS::Rooted<JS::Value>" + declArgs = "cx" + + assert not isOptional + templateBody = "${declName} = ${val};\n" + + # For JS-implemented APIs, we refuse to allow passing objects that the + # API consumer does not subsume. The extra parens around + # ($${passedToJSImpl}) suppress unreachable code warnings when + # $${passedToJSImpl} is the literal `false`. + if not isinstance(descriptorProvider, Descriptor) or descriptorProvider.interface.isJSImplemented(): + templateBody = fill( + """ + if (($${passedToJSImpl}) && !CallerSubsumes($${val})) { + ThrowErrorMessage(cx, MSG_PERMISSION_DENIED_TO_PASS_ARG, "${sourceDescription}"); + $*{exceptionCode} + } + """, + sourceDescription=sourceDescription, + exceptionCode=exceptionCode) + templateBody + + # We may not have a default value if we're being converted for + # a setter, say. + if defaultValue: + if isinstance(defaultValue, IDLNullValue): + defaultHandling = "${declName} = JS::NullValue();\n" + else: + assert isinstance(defaultValue, IDLUndefinedValue) + defaultHandling = "${declName} = JS::UndefinedValue();\n" + templateBody = handleDefault(templateBody, defaultHandling) + return JSToNativeConversionInfo(templateBody, + declType=CGGeneric(declType), + declArgs=declArgs) + + if type.isObject(): + assert not isEnforceRange and not isClamp + return handleJSObjectType(type, isMember, failureCode, exceptionCode, sourceDescription) + + if type.isDictionary(): + # There are no nullable dictionaries + assert not type.nullable() or isCallbackReturnValue + # All optional dictionaries always have default values, so we + # should be able to assume not isOptional here. + assert not isOptional + # In the callback return value case we never have to worry + # about a default value; we always have a value. + assert not isCallbackReturnValue or defaultValue is None + + typeName = CGDictionary.makeDictionaryName(type.unroll().inner) + if not isMember and not isCallbackReturnValue: + # Since we're not a member and not nullable or optional, no one will + # see our real type, so we can do the fast version of the dictionary + # that doesn't pre-initialize members. + typeName = "binding_detail::Fast" + typeName + + declType = CGGeneric(typeName) + + # We do manual default value handling here, because we + # actually do want a jsval, and we only handle null anyway + # NOTE: if isNullOrUndefined or isDefinitelyObject are true, + # we know we have a value, so we don't have to worry about the + # default value. + if (not isNullOrUndefined and not isDefinitelyObject and + defaultValue is not None): + assert(isinstance(defaultValue, IDLNullValue)) + val = "(${haveValue}) ? ${val} : JS::NullHandleValue" + else: + val = "${val}" + + dictLoc = "${declName}" + if type.nullable(): + dictLoc += ".SetValue()" + + conversionCode = fill(""" + if (!${dictLoc}.Init(cx, ${val}, "${desc}", $${passedToJSImpl})) { + $*{exceptionCode} + } + """, + dictLoc=dictLoc, + val=val, + desc=firstCap(sourceDescription), + exceptionCode=exceptionCode) + + if failureCode is not None: + if isDefinitelyObject: + dictionaryTest = "IsObjectValueConvertibleToDictionary" + else: + dictionaryTest = "IsConvertibleToDictionary" + + template = fill(""" + { // scope for isConvertible + bool isConvertible; + if (!${testConvertible}(cx, ${val}, &isConvertible)) { + $*{exceptionCode} + } + if (!isConvertible) { + $*{failureCode} + } + + $*{conversionCode} + } + + """, + testConvertible=dictionaryTest, + val=val, + exceptionCode=exceptionCode, + failureCode=failureCode, + conversionCode=conversionCode) + else: + template = conversionCode + + if type.nullable(): + declType = CGTemplatedType("Nullable", declType) + template = CGIfElseWrapper("${val}.isNullOrUndefined()", + CGGeneric("${declName}.SetNull();\n"), + CGGeneric(template)).define() + + # Dictionary arguments that might contain traceable things need to get + # traced + if not isMember and isCallbackReturnValue: + # Go ahead and just convert directly into our actual return value + declType = CGWrapper(declType, post="&") + declArgs = "aRetVal" + elif not isMember and typeNeedsRooting(type): + declType = CGTemplatedType("RootedDictionary", declType) + declArgs = "cx" + else: + declArgs = None + + return JSToNativeConversionInfo(template, declType=declType, + declArgs=declArgs) + + if type.isVoid(): + assert not isOptional + # This one only happens for return values, and its easy: Just + # ignore the jsval. + return JSToNativeConversionInfo("") + + if type.isDate(): + assert not isEnforceRange and not isClamp + + declType = CGGeneric("Date") + if type.nullable(): + declType = CGTemplatedType("Nullable", declType) + dateVal = "${declName}.SetValue()" + else: + dateVal = "${declName}" + + if failureCode is None: + notDate = ('ThrowErrorMessage(cx, MSG_NOT_DATE, "%s");\n' + "%s" % (firstCap(sourceDescription), exceptionCode)) + else: + notDate = failureCode + + conversion = fill( + """ + JS::Rooted<JSObject*> possibleDateObject(cx, &$${val}.toObject()); + { // scope for isDate + bool isDate; + if (!JS_ObjectIsDate(cx, possibleDateObject, &isDate)) { + $*{exceptionCode} + } + if (!isDate) { + $*{notDate} + } + if (!${dateVal}.SetTimeStamp(cx, possibleDateObject)) { + $*{exceptionCode} + } + } + """, + exceptionCode=exceptionCode, + dateVal=dateVal, + notDate=notDate) + + conversion = wrapObjectTemplate(conversion, type, + "${declName}.SetNull();\n", notDate) + return JSToNativeConversionInfo(conversion, + declType=declType, + dealWithOptional=isOptional) + + if not type.isPrimitive(): + raise TypeError("Need conversion for argument type '%s'" % str(type)) + + typeName = builtinNames[type.tag()] + + conversionBehavior = "eDefault" + if isEnforceRange: + assert type.isInteger() + conversionBehavior = "eEnforceRange" + elif isClamp: + assert type.isInteger() + conversionBehavior = "eClamp" + + if type.nullable(): + declType = CGGeneric("Nullable<" + typeName + ">") + writeLoc = "${declName}.SetValue()" + readLoc = "${declName}.Value()" + nullCondition = "${val}.isNullOrUndefined()" + if defaultValue is not None and isinstance(defaultValue, IDLNullValue): + nullCondition = "!(${haveValue}) || " + nullCondition + template = fill(""" + if (${nullCondition}) { + $${declName}.SetNull(); + } else if (!ValueToPrimitive<${typeName}, ${conversionBehavior}>(cx, $${val}, &${writeLoc})) { + $*{exceptionCode} + } + """, + nullCondition=nullCondition, + typeName=typeName, + conversionBehavior=conversionBehavior, + writeLoc=writeLoc, + exceptionCode=exceptionCode) + else: + assert(defaultValue is None or + not isinstance(defaultValue, IDLNullValue)) + writeLoc = "${declName}" + readLoc = writeLoc + template = fill(""" + if (!ValueToPrimitive<${typeName}, ${conversionBehavior}>(cx, $${val}, &${writeLoc})) { + $*{exceptionCode} + } + """, + typeName=typeName, + conversionBehavior=conversionBehavior, + writeLoc=writeLoc, + exceptionCode=exceptionCode) + declType = CGGeneric(typeName) + + if type.isFloat() and not type.isUnrestricted(): + if lenientFloatCode is not None: + nonFiniteCode = lenientFloatCode + else: + nonFiniteCode = ('ThrowErrorMessage(cx, MSG_NOT_FINITE, "%s");\n' + "%s" % (firstCap(sourceDescription), exceptionCode)) + + # We're appending to an if-block brace, so strip trailing whitespace + # and add an extra space before the else. + template = template.rstrip() + template += fill(""" + else if (!mozilla::IsFinite(${readLoc})) { + $*{nonFiniteCode} + } + """, + readLoc=readLoc, + nonFiniteCode=nonFiniteCode) + + if (defaultValue is not None and + # We already handled IDLNullValue, so just deal with the other ones + not isinstance(defaultValue, IDLNullValue)): + tag = defaultValue.type.tag() + defaultStr = getHandleDefault(defaultValue) + template = CGIfElseWrapper( + "${haveValue}", + CGGeneric(template), + CGGeneric("%s = %s;\n" % (writeLoc, defaultStr))).define() + + return JSToNativeConversionInfo(template, declType=declType, + dealWithOptional=isOptional) + + +def instantiateJSToNativeConversion(info, replacements, checkForValue=False): + """ + Take a JSToNativeConversionInfo as returned by getJSToNativeConversionInfo + and a set of replacements as required by the strings in such an object, and + generate code to convert into stack C++ types. + + If checkForValue is True, then the conversion will get wrapped in + a check for ${haveValue}. + """ + templateBody, declType, holderType, dealWithOptional = ( + info.template, info.declType, info.holderType, info.dealWithOptional) + + if dealWithOptional and not checkForValue: + raise TypeError("Have to deal with optional things, but don't know how") + if checkForValue and declType is None: + raise TypeError("Need to predeclare optional things, so they will be " + "outside the check for big enough arg count!") + + # We can't precompute our holder constructor arguments, since + # those might depend on ${declName}, which we change below. Just + # compute arguments at the point when we need them as we go. + def getArgsCGThing(args): + return CGGeneric(string.Template(args).substitute(replacements)) + + result = CGList([]) + # Make a copy of "replacements" since we may be about to start modifying it + replacements = dict(replacements) + originalDeclName = replacements["declName"] + if declType is not None: + if dealWithOptional: + replacements["declName"] = "%s.Value()" % originalDeclName + declType = CGTemplatedType("Optional", declType) + declCtorArgs = None + elif info.declArgs is not None: + declCtorArgs = CGWrapper(getArgsCGThing(info.declArgs), + pre="(", post=")") + else: + declCtorArgs = None + result.append( + CGList([declType, CGGeneric(" "), + CGGeneric(originalDeclName), + declCtorArgs, CGGeneric(";\n")])) + + originalHolderName = replacements["holderName"] + if holderType is not None: + if dealWithOptional: + replacements["holderName"] = "%s.ref()" % originalHolderName + holderType = CGTemplatedType("Maybe", holderType) + holderCtorArgs = None + elif info.holderArgs is not None: + holderCtorArgs = CGWrapper(getArgsCGThing(info.holderArgs), + pre="(", post=")") + else: + holderCtorArgs = None + result.append( + CGList([holderType, CGGeneric(" "), + CGGeneric(originalHolderName), + holderCtorArgs, CGGeneric(";\n")])) + + if "maybeMutableVal" not in replacements: + replacements["maybeMutableVal"] = replacements["val"] + + conversion = CGGeneric( + string.Template(templateBody).substitute(replacements)) + + if checkForValue: + if dealWithOptional: + declConstruct = CGIndenter( + CGGeneric("%s.Construct(%s);\n" % + (originalDeclName, + getArgsCGThing(info.declArgs).define() if + info.declArgs else ""))) + if holderType is not None: + holderConstruct = CGIndenter( + CGGeneric("%s.emplace(%s);\n" % + (originalHolderName, + getArgsCGThing(info.holderArgs).define() if + info.holderArgs else ""))) + else: + holderConstruct = None + else: + declConstruct = None + holderConstruct = None + + conversion = CGList([ + CGGeneric( + string.Template("if (${haveValue}) {\n").substitute(replacements)), + declConstruct, + holderConstruct, + CGIndenter(conversion), + CGGeneric("}\n") + ]) + + result.append(conversion) + return result + + +def convertConstIDLValueToJSVal(value): + if isinstance(value, IDLNullValue): + return "JS::NullValue()" + if isinstance(value, IDLUndefinedValue): + return "JS::UndefinedValue()" + tag = value.type.tag() + if tag in [IDLType.Tags.int8, IDLType.Tags.uint8, IDLType.Tags.int16, + IDLType.Tags.uint16, IDLType.Tags.int32]: + return "JS::Int32Value(%s)" % (value.value) + if tag == IDLType.Tags.uint32: + return "JS::NumberValue(%sU)" % (value.value) + if tag in [IDLType.Tags.int64, IDLType.Tags.uint64]: + return "JS::CanonicalizedDoubleValue(%s)" % numericValue(tag, value.value) + if tag == IDLType.Tags.bool: + return "JS::BooleanValue(true)" if value.value else "JS::BooleanValue(false)" + if tag in [IDLType.Tags.float, IDLType.Tags.double]: + return "JS::CanonicalizedDoubleValue(%s)" % (value.value) + raise TypeError("Const value of unhandled type: %s" % value.type) + + +class CGArgumentConverter(CGThing): + """ + A class that takes an IDL argument object and its index in the + argument list and generates code to unwrap the argument to the + right native type. + + argDescription is a description of the argument for error-reporting + purposes. Callers should assume that it might get placed in the middle of a + sentence. If it ends up at the beginning of a sentence, its first character + will be automatically uppercased. + """ + def __init__(self, argument, index, descriptorProvider, + argDescription, member, + invalidEnumValueFatal=True, lenientFloatCode=None): + CGThing.__init__(self) + self.argument = argument + self.argDescription = argDescription + assert(not argument.defaultValue or argument.optional) + + replacer = { + "index": index, + "argc": "args.length()" + } + self.replacementVariables = { + "declName": "arg%d" % index, + "holderName": ("arg%d" % index) + "_holder", + "obj": "obj", + "passedToJSImpl": toStringBool(isJSImplementedDescriptor(descriptorProvider)) + } + # If we have a method generated by the maplike/setlike portion of an + # interface, arguments can possibly be undefined, but will need to be + # converted to the key/value type of the backing object. In this case, + # use .get() instead of direct access to the argument. This won't + # matter for iterable since generated functions for those interface + # don't take arguments. + if member.isMethod() and member.isMaplikeOrSetlikeOrIterableMethod(): + self.replacementVariables["val"] = string.Template( + "args.get(${index})").substitute(replacer) + self.replacementVariables["maybeMutableVal"] = string.Template( + "args[${index}]").substitute(replacer) + else: + self.replacementVariables["val"] = string.Template( + "args[${index}]").substitute(replacer) + haveValueCheck = string.Template( + "args.hasDefined(${index})").substitute(replacer) + self.replacementVariables["haveValue"] = haveValueCheck + self.descriptorProvider = descriptorProvider + if self.argument.canHaveMissingValue(): + self.argcAndIndex = replacer + else: + self.argcAndIndex = None + self.invalidEnumValueFatal = invalidEnumValueFatal + self.lenientFloatCode = lenientFloatCode + + def define(self): + typeConversion = getJSToNativeConversionInfo( + self.argument.type, + self.descriptorProvider, + isOptional=(self.argcAndIndex is not None and + not self.argument.variadic), + invalidEnumValueFatal=self.invalidEnumValueFatal, + defaultValue=self.argument.defaultValue, + treatNullAs=self.argument.treatNullAs, + isEnforceRange=self.argument.enforceRange, + isClamp=self.argument.clamp, + lenientFloatCode=self.lenientFloatCode, + isMember="Variadic" if self.argument.variadic else False, + allowTreatNonCallableAsNull=self.argument.allowTreatNonCallableAsNull(), + sourceDescription=self.argDescription) + + if not self.argument.variadic: + return instantiateJSToNativeConversion( + typeConversion, + self.replacementVariables, + self.argcAndIndex is not None).define() + + # Variadic arguments get turned into a sequence. + if typeConversion.dealWithOptional: + raise TypeError("Shouldn't have optional things in variadics") + if typeConversion.holderType is not None: + raise TypeError("Shouldn't need holders for variadics") + + replacer = dict(self.argcAndIndex, **self.replacementVariables) + replacer["seqType"] = CGTemplatedType("binding_detail::AutoSequence", + typeConversion.declType).define() + if typeNeedsRooting(self.argument.type): + rooterDecl = ("SequenceRooter<%s> ${holderName}(cx, &${declName});\n" % + typeConversion.declType.define()) + else: + rooterDecl = "" + replacer["elemType"] = typeConversion.declType.define() + + # NOTE: Keep this in sync with sequence conversions as needed + variadicConversion = string.Template( + "${seqType} ${declName};\n" + + rooterDecl + + dedent(""" + if (${argc} > ${index}) { + if (!${declName}.SetCapacity(${argc} - ${index}, mozilla::fallible)) { + JS_ReportOutOfMemory(cx); + return false; + } + for (uint32_t variadicArg = ${index}; variadicArg < ${argc}; ++variadicArg) { + ${elemType}& slot = *${declName}.AppendElement(mozilla::fallible); + """) + ).substitute(replacer) + + val = string.Template("args[variadicArg]").substitute(replacer) + variadicConversion += indent( + string.Template(typeConversion.template).substitute({ + "val": val, + "maybeMutableVal": val, + "declName": "slot", + # We only need holderName here to handle isExternal() + # interfaces, which use an internal holder for the + # conversion even when forceOwningType ends up true. + "holderName": "tempHolder", + # Use the same ${obj} as for the variadic arg itself + "obj": replacer["obj"], + "passedToJSImpl": toStringBool(isJSImplementedDescriptor(self.descriptorProvider)) + }), 4) + + variadicConversion += (" }\n" + "}\n") + return variadicConversion + + +def getMaybeWrapValueFuncForType(type): + # Callbacks might actually be DOM objects; nothing prevents a page from + # doing that. + if type.isCallback() or type.isCallbackInterface() or type.isObject(): + if type.nullable(): + return "MaybeWrapObjectOrNullValue" + return "MaybeWrapObjectValue" + # Spidermonkey interfaces are never DOM objects. Neither are sequences or + # dictionaries, since those are always plain JS objects. + if type.isSpiderMonkeyInterface() or type.isDictionary() or type.isSequence(): + if type.nullable(): + return "MaybeWrapNonDOMObjectOrNullValue" + return "MaybeWrapNonDOMObjectValue" + if type.isAny(): + return "MaybeWrapValue" + + # For other types, just go ahead an fall back on MaybeWrapValue for now: + # it's always safe to do, and shouldn't be particularly slow for any of + # them + return "MaybeWrapValue" + + +sequenceWrapLevel = 0 +mozMapWrapLevel = 0 + + +def getWrapTemplateForType(type, descriptorProvider, result, successCode, + returnsNewObject, exceptionCode, typedArraysAreStructs, + isConstructorRetval=False): + """ + Reflect a C++ value stored in "result", of IDL type "type" into JS. The + "successCode" is the code to run once we have successfully done the + conversion and must guarantee that execution of the conversion template + stops once the successCode has executed (e.g. by doing a 'return', or by + doing a 'break' if the entire conversion template is inside a block that + the 'break' will exit). + + If typedArraysAreStructs is true, then if the type is a typed array, + "result" is one of the dom::TypedArray subclasses, not a JSObject*. + + The resulting string should be used with string.Template. It + needs the following keys when substituting: + + jsvalHandle: something that can be passed to methods taking a + JS::MutableHandle<JS::Value>. This can be a + JS::MutableHandle<JS::Value> or a JS::Rooted<JS::Value>*. + jsvalRef: something that can have .address() called on it to get a + JS::Value* and .set() called on it to set it to a JS::Value. + This can be a JS::MutableHandle<JS::Value> or a + JS::Rooted<JS::Value>. + obj: a JS::Handle<JSObject*>. + + Returns (templateString, infallibility of conversion template) + """ + if successCode is None: + successCode = "return true;\n" + + def setUndefined(): + return _setValue("", setter="setUndefined") + + def setNull(): + return _setValue("", setter="setNull") + + def setInt32(value): + return _setValue(value, setter="setInt32") + + def setString(value): + return _setValue(value, setter="setString") + + def setObject(value, wrapAsType=None): + return _setValue(value, wrapAsType=wrapAsType, setter="setObject") + + def setObjectOrNull(value, wrapAsType=None): + return _setValue(value, wrapAsType=wrapAsType, setter="setObjectOrNull") + + def setUint32(value): + return _setValue(value, setter="setNumber") + + def setDouble(value): + return _setValue("JS_NumberValue(%s)" % value) + + def setBoolean(value): + return _setValue(value, setter="setBoolean") + + def _setValue(value, wrapAsType=None, setter="set"): + """ + Returns the code to set the jsval to value. + + If wrapAsType is not None, then will wrap the resulting value using the + function that getMaybeWrapValueFuncForType(wrapAsType) returns. + Otherwise, no wrapping will be done. + """ + if wrapAsType is None: + tail = successCode + else: + tail = fill( + """ + if (!${maybeWrap}(cx, $${jsvalHandle})) { + $*{exceptionCode} + } + $*{successCode} + """, + maybeWrap=getMaybeWrapValueFuncForType(wrapAsType), + exceptionCode=exceptionCode, + successCode=successCode) + return ("${jsvalRef}.%s(%s);\n" % (setter, value)) + tail + + def wrapAndSetPtr(wrapCall, failureCode=None): + """ + Returns the code to set the jsval by calling "wrapCall". "failureCode" + is the code to run if calling "wrapCall" fails + """ + if failureCode is None: + failureCode = exceptionCode + return fill( + """ + if (!${wrapCall}) { + $*{failureCode} + } + $*{successCode} + """, + wrapCall=wrapCall, + failureCode=failureCode, + successCode=successCode) + + if type is None or type.isVoid(): + return (setUndefined(), True) + + if (type.isSequence() or type.isMozMap()) and type.nullable(): + # These are both wrapped in Nullable<> + recTemplate, recInfall = getWrapTemplateForType(type.inner, descriptorProvider, + "%s.Value()" % result, successCode, + returnsNewObject, exceptionCode, + typedArraysAreStructs) + code = fill( + """ + + if (${result}.IsNull()) { + $*{setNull} + } + $*{recTemplate} + """, + result=result, + setNull=setNull(), + recTemplate=recTemplate) + return code, recInfall + + if type.isSequence(): + # Now do non-nullable sequences. Our success code is just to break to + # where we set the element in the array. Note that we bump the + # sequenceWrapLevel around this call so that nested sequence conversions + # will use different iteration variables. + global sequenceWrapLevel + index = "sequenceIdx%d" % sequenceWrapLevel + sequenceWrapLevel += 1 + innerTemplate = wrapForType( + type.inner, descriptorProvider, + { + 'result': "%s[%s]" % (result, index), + 'successCode': "break;\n", + 'jsvalRef': "tmp", + 'jsvalHandle': "&tmp", + 'returnsNewObject': returnsNewObject, + 'exceptionCode': exceptionCode, + 'obj': "returnArray", + 'typedArraysAreStructs': typedArraysAreStructs + }) + sequenceWrapLevel -= 1 + code = fill( + """ + + uint32_t length = ${result}.Length(); + JS::Rooted<JSObject*> returnArray(cx, JS_NewArrayObject(cx, length)); + if (!returnArray) { + $*{exceptionCode} + } + // Scope for 'tmp' + { + JS::Rooted<JS::Value> tmp(cx); + for (uint32_t ${index} = 0; ${index} < length; ++${index}) { + // Control block to let us common up the JS_DefineElement calls when there + // are different ways to succeed at wrapping the object. + do { + $*{innerTemplate} + } while (0); + if (!JS_DefineElement(cx, returnArray, ${index}, tmp, + JSPROP_ENUMERATE)) { + $*{exceptionCode} + } + } + } + $*{set} + """, + result=result, + exceptionCode=exceptionCode, + index=index, + innerTemplate=innerTemplate, + set=setObject("*returnArray")) + + return (code, False) + + if type.isMozMap(): + # Now do non-nullable MozMap. Our success code is just to break to + # where we define the property on the object. Note that we bump the + # mozMapWrapLevel around this call so that nested MozMap conversions + # will use different temp value names. + global mozMapWrapLevel + valueName = "mozMapValue%d" % mozMapWrapLevel + mozMapWrapLevel += 1 + innerTemplate = wrapForType( + type.inner, descriptorProvider, + { + 'result': valueName, + 'successCode': "break;\n", + 'jsvalRef': "tmp", + 'jsvalHandle': "&tmp", + 'returnsNewObject': returnsNewObject, + 'exceptionCode': exceptionCode, + 'obj': "returnObj", + 'typedArraysAreStructs': typedArraysAreStructs + }) + mozMapWrapLevel -= 1 + code = fill( + """ + + nsTArray<nsString> keys; + ${result}.GetKeys(keys); + JS::Rooted<JSObject*> returnObj(cx, JS_NewPlainObject(cx)); + if (!returnObj) { + $*{exceptionCode} + } + // Scope for 'tmp' + { + JS::Rooted<JS::Value> tmp(cx); + for (size_t idx = 0; idx < keys.Length(); ++idx) { + auto& ${valueName} = ${result}.Get(keys[idx]); + // Control block to let us common up the JS_DefineUCProperty calls when there + // are different ways to succeed at wrapping the value. + do { + $*{innerTemplate} + } while (0); + if (!JS_DefineUCProperty(cx, returnObj, keys[idx].get(), + keys[idx].Length(), tmp, + JSPROP_ENUMERATE)) { + $*{exceptionCode} + } + } + } + $*{set} + """, + result=result, + exceptionCode=exceptionCode, + valueName=valueName, + innerTemplate=innerTemplate, + set=setObject("*returnObj")) + + return (code, False) + + if type.isGeckoInterface() and not type.isCallbackInterface(): + descriptor = descriptorProvider.getDescriptor(type.unroll().inner.identifier.name) + if type.nullable(): + wrappingCode = ("if (!%s) {\n" % (result) + + indent(setNull()) + + "}\n") + else: + wrappingCode = "" + + if not descriptor.interface.isExternal(): + if descriptor.wrapperCache: + wrapMethod = "GetOrCreateDOMReflector" + wrapArgs = "cx, %s, ${jsvalHandle}" % result + else: + # Hack: the "Promise" interface is OK to return from + # non-newobject things even when it's not wrappercached; that + # happens when using SpiderMonkey promises, and the WrapObject() + # method will just return the existing reflector, which is just + # not stored in a wrappercache. + if (not returnsNewObject and + descriptor.interface.identifier.name != "Promise"): + raise MethodNotNewObjectError(descriptor.interface.identifier.name) + wrapMethod = "WrapNewBindingNonWrapperCachedObject" + wrapArgs = "cx, ${obj}, %s, ${jsvalHandle}" % result + if isConstructorRetval: + wrapArgs += ", desiredProto" + wrap = "%s(%s)" % (wrapMethod, wrapArgs) + if not descriptor.hasXPConnectImpls: + # Can only fail to wrap as a new-binding object + # if they already threw an exception. + # XXX Assertion disabled for now, see bug 991271. + failed = ("MOZ_ASSERT(true || JS_IsExceptionPending(cx));\n" + + exceptionCode) + else: + if descriptor.notflattened: + raise TypeError("%s has XPConnect impls but not flattened; " + "fallback won't work correctly" % + descriptor.interface.identifier.name) + # Try old-style wrapping for bindings which might be XPConnect impls. + failed = wrapAndSetPtr("HandleNewBindingWrappingFailure(cx, ${obj}, %s, ${jsvalHandle})" % result) + else: + if descriptor.notflattened: + getIID = "&NS_GET_IID(%s), " % descriptor.nativeType + else: + getIID = "" + wrap = "WrapObject(cx, %s, %s${jsvalHandle})" % (result, getIID) + failed = None + + wrappingCode += wrapAndSetPtr(wrap, failed) + return (wrappingCode, False) + + if type.isDOMString() or type.isUSVString(): + if type.nullable(): + return (wrapAndSetPtr("xpc::StringToJsval(cx, %s, ${jsvalHandle})" % result), False) + else: + return (wrapAndSetPtr("xpc::NonVoidStringToJsval(cx, %s, ${jsvalHandle})" % result), False) + + if type.isByteString(): + if type.nullable(): + return (wrapAndSetPtr("ByteStringToJsval(cx, %s, ${jsvalHandle})" % result), False) + else: + return (wrapAndSetPtr("NonVoidByteStringToJsval(cx, %s, ${jsvalHandle})" % result), False) + + if type.isEnum(): + if type.nullable(): + resultLoc = "%s.Value()" % result + else: + resultLoc = result + conversion = fill( + """ + if (!ToJSValue(cx, ${result}, $${jsvalHandle})) { + $*{exceptionCode} + } + $*{successCode} + """, + result=resultLoc, + exceptionCode=exceptionCode, + successCode=successCode) + + if type.nullable(): + conversion = CGIfElseWrapper( + "%s.IsNull()" % result, + CGGeneric(setNull()), + CGGeneric(conversion)).define() + return conversion, False + + if type.isCallback() or type.isCallbackInterface(): + wrapCode = setObject( + "*GetCallbackFromCallbackObject(%(result)s)", + wrapAsType=type) + if type.nullable(): + wrapCode = ( + "if (%(result)s) {\n" + + indent(wrapCode) + + "} else {\n" + + indent(setNull()) + + "}\n") + wrapCode = wrapCode % {"result": result} + return wrapCode, False + + if type.isAny(): + # See comments in GetOrCreateDOMReflector explaining why we need + # to wrap here. + # NB: _setValue(..., type-that-is-any) calls JS_WrapValue(), so is fallible + head = "JS::ExposeValueToActiveJS(%s);\n" % result + return (head + _setValue(result, wrapAsType=type), False) + + if (type.isObject() or (type.isSpiderMonkeyInterface() and + not typedArraysAreStructs)): + # See comments in GetOrCreateDOMReflector explaining why we need + # to wrap here. + if type.nullable(): + toValue = "%s" + setter = setObjectOrNull + head = """if (%s) { + JS::ExposeObjectToActiveJS(%s); + } + """ % (result, result) + else: + toValue = "*%s" + setter = setObject + head = "JS::ExposeObjectToActiveJS(%s);\n" % result + # NB: setObject{,OrNull}(..., some-object-type) calls JS_WrapValue(), so is fallible + return (head + setter(toValue % result, wrapAsType=type), False) + + if not (type.isUnion() or type.isPrimitive() or type.isDictionary() or + type.isDate() or + (type.isSpiderMonkeyInterface() and typedArraysAreStructs)): + raise TypeError("Need to learn to wrap %s" % type) + + if type.nullable(): + recTemplate, recInfal = getWrapTemplateForType(type.inner, descriptorProvider, + "%s.Value()" % result, successCode, + returnsNewObject, exceptionCode, + typedArraysAreStructs) + return ("if (%s.IsNull()) {\n" % result + + indent(setNull()) + + "}\n" + + recTemplate, recInfal) + + if type.isSpiderMonkeyInterface(): + assert typedArraysAreStructs + # See comments in GetOrCreateDOMReflector explaining why we need + # to wrap here. + # NB: setObject(..., some-object-type) calls JS_WrapValue(), so is fallible + return (setObject("*%s.Obj()" % result, + wrapAsType=type), False) + + if type.isUnion(): + return (wrapAndSetPtr("%s.ToJSVal(cx, ${obj}, ${jsvalHandle})" % result), + False) + + if type.isDictionary(): + return (wrapAndSetPtr("%s.ToObjectInternal(cx, ${jsvalHandle})" % result), + False) + + if type.isDate(): + return (wrapAndSetPtr("%s.ToDateObject(cx, ${jsvalHandle})" % result), + False) + + tag = type.tag() + + if tag in [IDLType.Tags.int8, IDLType.Tags.uint8, IDLType.Tags.int16, + IDLType.Tags.uint16, IDLType.Tags.int32]: + return (setInt32("int32_t(%s)" % result), True) + + elif tag in [IDLType.Tags.int64, IDLType.Tags.uint64, + IDLType.Tags.unrestricted_float, IDLType.Tags.float, + IDLType.Tags.unrestricted_double, IDLType.Tags.double]: + # XXXbz will cast to double do the "even significand" thing that webidl + # calls for for 64-bit ints? Do we care? + return (setDouble("double(%s)" % result), True) + + elif tag == IDLType.Tags.uint32: + return (setUint32(result), True) + + elif tag == IDLType.Tags.bool: + return (setBoolean(result), True) + + else: + raise TypeError("Need to learn to wrap primitive: %s" % type) + + +def wrapForType(type, descriptorProvider, templateValues): + """ + Reflect a C++ value of IDL type "type" into JS. TemplateValues is a dict + that should contain: + + * 'jsvalRef': something that can have .address() called on it to get a + JS::Value* and .set() called on it to set it to a JS::Value. + This can be a JS::MutableHandle<JS::Value> or a + JS::Rooted<JS::Value>. + * 'jsvalHandle': something that can be passed to methods taking a + JS::MutableHandle<JS::Value>. This can be a + JS::MutableHandle<JS::Value> or a JS::Rooted<JS::Value>*. + * 'obj' (optional): the name of the variable that contains the JSObject to + use as a scope when wrapping, if not supplied 'obj' + will be used as the name + * 'result' (optional): the name of the variable in which the C++ value is + stored, if not supplied 'result' will be used as + the name + * 'successCode' (optional): the code to run once we have successfully + done the conversion, if not supplied 'return + true;' will be used as the code. The + successCode must ensure that once it runs no + more of the conversion template will be + executed (e.g. by doing a 'return' or 'break' + as appropriate). + * 'returnsNewObject' (optional): If true, we're wrapping for the return + value of a [NewObject] method. Assumed + false if not set. + * 'exceptionCode' (optional): Code to run when a JS exception is thrown. + The default is "return false;". The code + passed here must return. + * 'isConstructorRetval' (optional): If true, we're wrapping a constructor + return value. + """ + wrap = getWrapTemplateForType( + type, descriptorProvider, + templateValues.get('result', 'result'), + templateValues.get('successCode', None), + templateValues.get('returnsNewObject', False), + templateValues.get('exceptionCode', "return false;\n"), + templateValues.get('typedArraysAreStructs', False), + isConstructorRetval=templateValues.get('isConstructorRetval', False))[0] + + defaultValues = {'obj': 'obj'} + return string.Template(wrap).substitute(defaultValues, **templateValues) + + +def infallibleForMember(member, type, descriptorProvider): + """ + Determine the fallibility of changing a C++ value of IDL type "type" into + JS for the given attribute. Apart from returnsNewObject, all the defaults + are used, since the fallbility does not change based on the boolean values, + and the template will be discarded. + + CURRENT ASSUMPTIONS: + We assume that successCode for wrapping up return values cannot contain + failure conditions. + """ + return getWrapTemplateForType(type, descriptorProvider, 'result', None, + memberReturnsNewObject(member), "return false;\n", + False)[1] + + +def leafTypeNeedsCx(type, retVal): + return (type.isAny() or type.isObject() or + (retVal and type.isSpiderMonkeyInterface())) + + +def leafTypeNeedsScopeObject(type, retVal): + return retVal and type.isSpiderMonkeyInterface() + + +def leafTypeNeedsRooting(type): + return leafTypeNeedsCx(type, False) or type.isSpiderMonkeyInterface() + + +def typeNeedsRooting(type): + return typeMatchesLambda(type, + lambda t: leafTypeNeedsRooting(t)) + + +def typeNeedsCx(type, retVal=False): + return typeMatchesLambda(type, + lambda t: leafTypeNeedsCx(t, retVal)) + + +def typeNeedsScopeObject(type, retVal=False): + return typeMatchesLambda(type, + lambda t: leafTypeNeedsScopeObject(t, retVal)) + + +def typeMatchesLambda(type, func): + if type is None: + return False + if type.nullable(): + return typeMatchesLambda(type.inner, func) + if type.isSequence() or type.isMozMap(): + return typeMatchesLambda(type.inner, func) + if type.isUnion(): + return any(typeMatchesLambda(t, func) for t in + type.unroll().flatMemberTypes) + if type.isDictionary(): + return dictionaryMatchesLambda(type.inner, func) + return func(type) + + +def dictionaryMatchesLambda(dictionary, func): + return (any(typeMatchesLambda(m.type, func) for m in dictionary.members) or + (dictionary.parent and dictionaryMatchesLambda(dictionary.parent, func))) + + +# Whenever this is modified, please update CGNativeMember.getRetvalInfo as +# needed to keep the types compatible. +def getRetvalDeclarationForType(returnType, descriptorProvider, + isMember=False): + """ + Returns a tuple containing five things: + + 1) A CGThing for the type of the return value, or None if there is no need + for a return value. + + 2) A value indicating the kind of ourparam to pass the value as. Valid + options are None to not pass as an out param at all, "ref" (to pass a + reference as an out param), and "ptr" (to pass a pointer as an out + param). + + 3) A CGThing for a tracer for the return value, or None if no tracing is + needed. + + 4) An argument string to pass to the retval declaration + constructor or None if there are no arguments. + + 5) The name of a function that needs to be called with the return value + before using it, or None if no function needs to be called. + """ + if returnType is None or returnType.isVoid(): + # Nothing to declare + return None, None, None, None, None + if returnType.isPrimitive() and returnType.tag() in builtinNames: + result = CGGeneric(builtinNames[returnType.tag()]) + if returnType.nullable(): + result = CGTemplatedType("Nullable", result) + return result, None, None, None, None + if returnType.isDOMString() or returnType.isUSVString(): + if isMember: + return CGGeneric("nsString"), "ref", None, None, None + return CGGeneric("DOMString"), "ref", None, None, None + if returnType.isByteString(): + return CGGeneric("nsCString"), "ref", None, None, None + if returnType.isEnum(): + result = CGGeneric(returnType.unroll().inner.identifier.name) + if returnType.nullable(): + result = CGTemplatedType("Nullable", result) + return result, None, None, None, None + if returnType.isGeckoInterface(): + result = CGGeneric(descriptorProvider.getDescriptor( + returnType.unroll().inner.identifier.name).nativeType) + conversion = None + if isMember: + result = CGGeneric("StrongPtrForMember<%s>::Type" % result.define()) + else: + conversion = CGGeneric("StrongOrRawPtr<%s>" % result.define()) + result = CGGeneric("auto") + return result, None, None, None, conversion + if returnType.isCallback(): + name = returnType.unroll().callback.identifier.name + return CGGeneric("RefPtr<%s>" % name), None, None, None, None + if returnType.isAny(): + if isMember: + return CGGeneric("JS::Value"), None, None, None, None + return CGGeneric("JS::Rooted<JS::Value>"), "ptr", None, "cx", None + if returnType.isObject() or returnType.isSpiderMonkeyInterface(): + if isMember: + return CGGeneric("JSObject*"), None, None, None, None + return CGGeneric("JS::Rooted<JSObject*>"), "ptr", None, "cx", None + if returnType.isSequence(): + nullable = returnType.nullable() + if nullable: + returnType = returnType.inner + result, _, _, _, _ = getRetvalDeclarationForType(returnType.inner, + descriptorProvider, + isMember="Sequence") + # While we have our inner type, set up our rooter, if needed + if not isMember and typeNeedsRooting(returnType): + rooter = CGGeneric("SequenceRooter<%s > resultRooter(cx, &result);\n" % + result.define()) + else: + rooter = None + result = CGTemplatedType("nsTArray", result) + if nullable: + result = CGTemplatedType("Nullable", result) + return result, "ref", rooter, None, None + if returnType.isMozMap(): + nullable = returnType.nullable() + if nullable: + returnType = returnType.inner + result, _, _, _, _ = getRetvalDeclarationForType(returnType.inner, + descriptorProvider, + isMember="MozMap") + # While we have our inner type, set up our rooter, if needed + if not isMember and typeNeedsRooting(returnType): + rooter = CGGeneric("MozMapRooter<%s> resultRooter(cx, &result);\n" % + result.define()) + else: + rooter = None + result = CGTemplatedType("MozMap", result) + if nullable: + result = CGTemplatedType("Nullable", result) + return result, "ref", rooter, None, None + if returnType.isDictionary(): + nullable = returnType.nullable() + dictName = CGDictionary.makeDictionaryName(returnType.unroll().inner) + result = CGGeneric(dictName) + if not isMember and typeNeedsRooting(returnType): + if nullable: + result = CGTemplatedType("NullableRootedDictionary", result) + else: + result = CGTemplatedType("RootedDictionary", result) + resultArgs = "cx" + else: + if nullable: + result = CGTemplatedType("Nullable", result) + resultArgs = None + return result, "ref", None, resultArgs, None + if returnType.isUnion(): + result = CGGeneric(CGUnionStruct.unionTypeName(returnType.unroll(), True)) + if not isMember and typeNeedsRooting(returnType): + if returnType.nullable(): + result = CGTemplatedType("NullableRootedUnion", result) + else: + result = CGTemplatedType("RootedUnion", result) + resultArgs = "cx" + else: + if returnType.nullable(): + result = CGTemplatedType("Nullable", result) + resultArgs = None + return result, "ref", None, resultArgs, None + if returnType.isDate(): + result = CGGeneric("Date") + if returnType.nullable(): + result = CGTemplatedType("Nullable", result) + return result, None, None, None, None + raise TypeError("Don't know how to declare return value for %s" % + returnType) + + +def needCx(returnType, arguments, extendedAttributes, considerTypes, + static=False): + return (not static and considerTypes and + (typeNeedsCx(returnType, True) or + any(typeNeedsCx(a.type) for a in arguments)) or + 'implicitJSContext' in extendedAttributes) + + +def needScopeObject(returnType, arguments, extendedAttributes, + isWrapperCached, considerTypes, isMember): + """ + isMember should be true if we're dealing with an attribute + annotated as [StoreInSlot]. + """ + return (considerTypes and not isWrapperCached and + ((not isMember and typeNeedsScopeObject(returnType, True)) or + any(typeNeedsScopeObject(a.type) for a in arguments))) + + +class CGCallGenerator(CGThing): + """ + A class to generate an actual call to a C++ object. Assumes that the C++ + object is stored in a variable whose name is given by the |object| argument. + + needsSubjectPrincipal is a boolean indicating whether the call should + receive the subject nsIPrincipal as argument. + + needsCallerType is a boolean indicating whether the call should receive + a PrincipalType for the caller. + + isFallible is a boolean indicating whether the call should be fallible. + + resultVar: If the returnType is not void, then the result of the call is + stored in a C++ variable named by resultVar. The caller is responsible for + declaring the result variable. If the caller doesn't care about the result + value, resultVar can be omitted. + """ + def __init__(self, isFallible, needsSubjectPrincipal, needsCallerType, + arguments, argsPre, returnType, extendedAttributes, descriptor, + nativeMethodName, static, object="self", argsPost=[], + resultVar=None): + CGThing.__init__(self) + + result, resultOutParam, resultRooter, resultArgs, resultConversion = \ + getRetvalDeclarationForType(returnType, descriptor) + + args = CGList([CGGeneric(arg) for arg in argsPre], ", ") + for a, name in arguments: + arg = CGGeneric(name) + + # Now constify the things that need it + def needsConst(a): + if a.type.isDictionary(): + return True + if a.type.isSequence(): + return True + if a.type.isMozMap(): + return True + # isObject() types are always a JS::Rooted, whether + # nullable or not, and it turns out a const JS::Rooted + # is not very helpful at all (in particular, it won't + # even convert to a JS::Handle). + # XXX bz Well, why not??? + if a.type.nullable() and not a.type.isObject(): + return True + if a.type.isString(): + return True + if a.canHaveMissingValue(): + # This will need an Optional or it's a variadic; + # in both cases it should be const. + return True + if a.type.isUnion(): + return True + if a.type.isSpiderMonkeyInterface(): + return True + return False + if needsConst(a): + arg = CGWrapper(arg, pre="Constify(", post=")") + # And convert NonNull<T> to T& + if (((a.type.isGeckoInterface() or a.type.isCallback()) and not a.type.nullable()) or + a.type.isDOMString()): + arg = CGWrapper(arg, pre="NonNullHelper(", post=")") + args.append(arg) + + needResultDecl = False + + # Return values that go in outparams go here + if resultOutParam is not None: + if resultVar is None: + needResultDecl = True + resultVar = "result" + if resultOutParam == "ref": + args.append(CGGeneric(resultVar)) + else: + assert resultOutParam == "ptr" + args.append(CGGeneric("&" + resultVar)) + + if needsSubjectPrincipal: + args.append(CGGeneric("subjectPrincipal")) + + if needsCallerType: + args.append(CGGeneric("callerType")) + + if isFallible: + args.append(CGGeneric("rv")) + args.extend(CGGeneric(arg) for arg in argsPost) + + # Build up our actual call + self.cgRoot = CGList([]) + + call = CGGeneric(nativeMethodName) + if not static: + call = CGWrapper(call, pre="%s->" % object) + call = CGList([call, CGWrapper(args, pre="(", post=")")]) + if resultConversion is not None: + call = CGList([resultConversion, CGWrapper(call, pre="(", post=")")]) + if resultVar is None and result is not None: + needResultDecl = True + resultVar = "result" + + if needResultDecl: + if resultRooter is not None: + self.cgRoot.prepend(resultRooter) + if resultArgs is not None: + resultArgsStr = "(%s)" % resultArgs + else: + resultArgsStr = "" + result = CGWrapper(result, post=(" %s%s" % (resultVar, resultArgsStr))) + if resultOutParam is None and resultArgs is None: + call = CGList([result, CGWrapper(call, pre="(", post=")")]) + else: + self.cgRoot.prepend(CGWrapper(result, post=";\n")) + if resultOutParam is None: + call = CGWrapper(call, pre=resultVar + " = ") + elif result is not None: + assert resultOutParam is None + call = CGWrapper(call, pre=resultVar + " = ") + + call = CGWrapper(call, post=";\n") + self.cgRoot.append(call) + + if needsSubjectPrincipal: + getPrincipal = dedent( + """ + JSCompartment* compartment = js::GetContextCompartment(cx); + MOZ_ASSERT(compartment); + JSPrincipals* principals = JS_GetCompartmentPrincipals(compartment); + """) + + if descriptor.interface.isExposedInAnyWorker(): + self.cgRoot.prepend(CGGeneric(fill( + """ + Maybe<nsIPrincipal*> subjectPrincipal; + if (NS_IsMainThread()) { + $*{getPrincipal} + subjectPrincipal.emplace(nsJSPrincipals::get(principals)); + } + """, + getPrincipal=getPrincipal))) + else: + self.cgRoot.prepend(CGGeneric(fill( + """ + $*{getPrincipal} + // Initializing a nonnull is pretty darn annoying... + NonNull<nsIPrincipal> subjectPrincipal; + subjectPrincipal = static_cast<nsIPrincipal*>(nsJSPrincipals::get(principals)); + """, + getPrincipal=getPrincipal))) + + if needsCallerType: + # Note that we do not want to use + # IsCallerChrome/ThreadsafeIsCallerChrome directly because those + # will pull in the check for UniversalXPConnect, which we ideally + # don't want to have in the new thing we're doing here. If not + # NS_IsMainThread(), though, we'll go ahead and call + # ThreasafeIsCallerChrome(), since that won't mess with + # UnivesalXPConnect and we don't want to worry about the right + # worker includes here. + callerCheck = CGGeneric("callerType = nsContentUtils::IsSystemPrincipal(nsContentUtils::SubjectPrincipal()) ? CallerType::System : CallerType::NonSystem;\n") + if descriptor.interface.isExposedInAnyWorker(): + callerCheck = CGIfElseWrapper( + "NS_IsMainThread()", + callerCheck, + CGGeneric("callerType = nsContentUtils::ThreadsafeIsCallerChrome() ? CallerType::System : CallerType::NonSystem;\n")); + self.cgRoot.prepend(callerCheck) + self.cgRoot.prepend(CGGeneric("CallerType callerType;\n")) + + if isFallible: + self.cgRoot.prepend(CGGeneric("binding_detail::FastErrorResult rv;\n")) + self.cgRoot.append(CGGeneric(dedent( + """ + if (MOZ_UNLIKELY(rv.MaybeSetPendingException(cx))) { + return false; + } + """))) + + self.cgRoot.append(CGGeneric("MOZ_ASSERT(!JS_IsExceptionPending(cx));\n")) + + def define(self): + return self.cgRoot.define() + + +def getUnionMemberName(type): + if type.isGeckoInterface(): + return type.inner.identifier.name + if type.isEnum(): + return type.inner.identifier.name + return type.name + + +class MethodNotNewObjectError(Exception): + def __init__(self, typename): + self.typename = typename + +# A counter for making sure that when we're wrapping up things in +# nested sequences we don't use the same variable name to iterate over +# different sequences. +sequenceWrapLevel = 0 +mapWrapLevel = 0 + + +def wrapTypeIntoCurrentCompartment(type, value, isMember=True): + """ + Take the thing named by "value" and if it contains "any", + "object", or spidermonkey-interface types inside return a CGThing + that will wrap them into the current compartment. + """ + if type.isAny(): + assert not type.nullable() + if isMember: + value = "JS::MutableHandle<JS::Value>::fromMarkedLocation(&%s)" % value + else: + value = "&" + value + return CGGeneric("if (!JS_WrapValue(cx, %s)) {\n" + " return false;\n" + "}\n" % value) + + if type.isObject(): + if isMember: + value = "JS::MutableHandle<JSObject*>::fromMarkedLocation(&%s)" % value + else: + value = "&" + value + return CGGeneric("if (!JS_WrapObject(cx, %s)) {\n" + " return false;\n" + "}\n" % value) + + if type.isSpiderMonkeyInterface(): + origValue = value + if type.nullable(): + value = "%s.Value()" % value + wrapCode = CGGeneric("if (!%s.WrapIntoNewCompartment(cx)) {\n" + " return false;\n" + "}\n" % value) + if type.nullable(): + wrapCode = CGIfWrapper(wrapCode, "!%s.IsNull()" % origValue) + return wrapCode + + if type.isSequence(): + origValue = value + origType = type + if type.nullable(): + type = type.inner + value = "%s.Value()" % value + global sequenceWrapLevel + index = "indexName%d" % sequenceWrapLevel + sequenceWrapLevel += 1 + wrapElement = wrapTypeIntoCurrentCompartment(type.inner, + "%s[%s]" % (value, index)) + sequenceWrapLevel -= 1 + if not wrapElement: + return None + wrapCode = CGWrapper(CGIndenter(wrapElement), + pre=("for (uint32_t %s = 0; %s < %s.Length(); ++%s) {\n" % + (index, index, value, index)), + post="}\n") + if origType.nullable(): + wrapCode = CGIfWrapper(wrapCode, "!%s.IsNull()" % origValue) + return wrapCode + + if type.isMozMap(): + origValue = value + origType = type + if type.nullable(): + type = type.inner + value = "%s.Value()" % value + global mapWrapLevel + key = "mapName%d" % mapWrapLevel + mapWrapLevel += 1 + wrapElement = wrapTypeIntoCurrentCompartment(type.inner, + "%s.Get(%sKeys[%sIndex])" % (value, key, key)) + mapWrapLevel -= 1 + if not wrapElement: + return None + wrapCode = CGWrapper(CGIndenter(wrapElement), + pre=(""" + nsTArray<nsString> %sKeys; + %s.GetKeys(%sKeys); + for (uint32_t %sIndex = 0; %sIndex < %sKeys.Length(); ++%sIndex) { + """ % (key, value, key, key, key, key, key)), + 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) 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.canHaveMissingValue() + if isOptional: + value = value + ".Value()" + wrap = wrapTypeIntoCurrentCompartment(arg.type, value, isMember) + if wrap and isOptional: + wrap = CGIfWrapper(wrap, "%s.WasPassed()" % origValue) + return wrap + + +def needsContainsHack(m): + return m.getExtendedAttribute("ReturnValueNeedsContainsHack") + +def needsCallerType(m): + return m.getExtendedAttribute("NeedsCallerType") + +class CGPerSignatureCall(CGThing): + """ + This class handles the guts of generating code for a particular + call signature. A call signature consists of four things: + + 1) A return type, which can be None to indicate that there is no + actual return value (e.g. this is an attribute setter) or an + IDLType if there's an IDL type involved (including |void|). + 2) An argument list, which is allowed to be empty. + 3) A name of a native method to call. + 4) Whether or not this method is static. Note that this only controls how + the method is called (|self->nativeMethodName(...)| vs + |nativeMethodName(...)|). + + We also need to know whether this is a method or a getter/setter + to do error reporting correctly. + + The idlNode parameter can be either a method or an attr. We can query + |idlNode.identifier| in both cases, so we can be agnostic between the two. + """ + # XXXbz For now each entry in the argument list is either an + # IDLArgument or a FakeArgument, but longer-term we may want to + # have ways of flagging things like JSContext* or optional_argc in + # there. + + def __init__(self, returnType, arguments, nativeMethodName, static, + descriptor, idlNode, argConversionStartsAt=0, getter=False, + setter=False, isConstructor=False, useCounterName=None, + resultVar=None): + assert idlNode.isMethod() == (not getter and not setter) + assert idlNode.isAttr() == (getter or setter) + # Constructors are always static + assert not isConstructor or static + + CGThing.__init__(self) + self.returnType = returnType + self.descriptor = descriptor + self.idlNode = idlNode + self.extendedAttributes = descriptor.getExtendedAttributes(idlNode, + getter=getter, + setter=setter) + self.arguments = arguments + self.argCount = len(arguments) + self.isConstructor = isConstructor + cgThings = [] + + # Here, we check if the current getter, setter, method, interface or + # inherited interfaces have the UnsafeInPrerendering extended attribute + # and if so, we add a check to make sure it is safe. + if (idlNode.getExtendedAttribute("UnsafeInPrerendering") or + descriptor.interface.getExtendedAttribute("UnsafeInPrerendering") or + any(i.getExtendedAttribute("UnsafeInPrerendering") + for i in descriptor.interface.getInheritedInterfaces())): + cgThings.append(CGGeneric(dedent( + """ + if (!mozilla::dom::EnforceNotInPrerendering(cx, obj)) { + // Return false from the JSNative in order to trigger + // an uncatchable exception. + MOZ_ASSERT(!JS_IsExceptionPending(cx)); + return false; + } + """))) + + deprecated = (idlNode.getExtendedAttribute("Deprecated") or + (idlNode.isStatic() and descriptor.interface.getExtendedAttribute("Deprecated"))) + if deprecated: + cgThings.append(CGGeneric(dedent( + """ + DeprecationWarning(cx, obj, nsIDocument::e%s); + """ % deprecated[0]))) + + lenientFloatCode = None + if (idlNode.getExtendedAttribute('LenientFloat') is not None and + (setter or idlNode.isMethod())): + cgThings.append(CGGeneric(dedent( + """ + bool foundNonFiniteFloat = false; + """))) + lenientFloatCode = "foundNonFiniteFloat = true;\n" + + argsPre = [] + if idlNode.isStatic(): + # If we're a constructor, "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(fill( + """ + GlobalObject global(cx, ${obj}); + if (global.Failed()) { + return false; + } + + """, + obj=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. Also, JSContext is not needed for the static case + # since GlobalObject already contains the context. + needsCx = needCx(returnType, arguments, self.extendedAttributes, + not descriptor.interface.isJSImplemented(), static) + if needsCx: + argsPre.append("cx") + + # Hack for making Promise.prototype.then work well over Xrays. + if (not idlNode.isStatic() and + descriptor.name == "Promise" and + idlNode.isMethod() and + idlNode.identifier.name == "then"): + cgThings.append(CGGeneric(dedent( + """ + JS::Rooted<JSObject*> calleeGlobal(cx, xpc::XrayAwareCalleeGlobal(&args.callee())); + """))) + argsPre.append("calleeGlobal") + + needsUnwrap = False + argsPost = [] + if isConstructor: + if descriptor.name == "Promise": + # Hack for Promise for now: pass in our desired proto so the + # implementation can create the reflector with the right proto. + argsPost.append("desiredProto") + # Also, we do not want to enter the content compartment when the + # Promise constructor is called via Xrays, because we want to + # create our callback functions that we will hand to our caller + # in the Xray compartment. The reason we want to do that is the + # following situation, over Xrays: + # + # contentWindow.Promise.race([Promise.resolve(5)]) + # + # Ideally this would work. Internally, race() does a + # contentWindow.Promise.resolve() on everything in the array. + # Per spec, to support subclassing, + # contentWindow.Promise.resolve has to do: + # + # var resolve, reject; + # var p = new contentWindow.Promise(function(a, b) { + # resolve = a; + # reject = b; + # }); + # resolve(arg); + # return p; + # + # where "arg" is, in this case, the chrome-side return value of + # Promise.resolve(5). But if the "resolve" function in that + # case were created in the content compartment, then calling it + # would wrap "arg" in an opaque wrapper, and that function tries + # to get .then off the argument, which would throw. So we need + # to create the "resolve" function in the chrome compartment, + # and hence want to be running the entire Promise constructor + # (which creates that function) in the chrome compartment in + # this case. So don't set needsUnwrap here. + else: + needsUnwrap = True + needsUnwrappedVar = False + unwrappedVar = "obj" + elif descriptor.interface.isJSImplemented(): + if not idlNode.isStatic(): + needsUnwrap = True + needsUnwrappedVar = True + argsPost.append("js::GetObjectCompartment(unwrappedObj ? *unwrappedObj : obj)") + elif needScopeObject(returnType, arguments, self.extendedAttributes, + descriptor.wrapperCache, True, + idlNode.getExtendedAttribute("StoreInSlot")): + needsUnwrap = True + needsUnwrappedVar = True + argsPre.append("unwrappedObj ? *unwrappedObj : obj") + + if idlNode.isStatic() and not isConstructor and descriptor.name == "Promise": + # Hack for Promise for now: pass in the "this" value to + # Promise static methods. + argsPre.append("args.thisv()") + + if needsUnwrap and needsUnwrappedVar: + # We cannot assign into obj because it's a Handle, not a + # MutableHandle, so we need a separate Rooted. + cgThings.append(CGGeneric("Maybe<JS::Rooted<JSObject*> > unwrappedObj;\n")) + unwrappedVar = "unwrappedObj.ref()" + + if idlNode.isMethod() and idlNode.isLegacycaller(): + # If we can have legacycaller with identifier, we can't + # just use the idlNode to determine whether we're + # generating code for the legacycaller or not. + assert idlNode.isIdentifierLess() + # Pass in our thisVal + argsPre.append("args.thisv()") + + ourName = "%s.%s" % (descriptor.interface.identifier.name, + idlNode.identifier.name) + if idlNode.isMethod(): + argDescription = "argument %(index)d of " + ourName + elif setter: + argDescription = "value being assigned to %s" % ourName + else: + assert self.argCount == 0 + + if needsUnwrap: + # It's very important that we construct our unwrappedObj, if we need + # to do it, before we might start setting up Rooted things for our + # arguments, so that we don't violate the stack discipline Rooted + # depends on. + cgThings.append(CGGeneric( + "bool objIsXray = xpc::WrapperFactory::IsXrayWrapper(obj);\n")) + if needsUnwrappedVar: + cgThings.append(CGIfWrapper( + CGGeneric("unwrappedObj.emplace(cx, obj);\n"), + "objIsXray")) + + for i in range(argConversionStartsAt, self.argCount): + cgThings.append( + CGArgumentConverter(arguments[i], i, self.descriptor, + argDescription % {"index": i + 1}, + idlNode, invalidEnumValueFatal=not setter, + lenientFloatCode=lenientFloatCode)) + + # Now that argument processing is done, enforce the LenientFloat stuff + if lenientFloatCode: + if setter: + foundNonFiniteFloatBehavior = "return true;\n" + else: + assert idlNode.isMethod() + foundNonFiniteFloatBehavior = dedent( + """ + args.rval().setUndefined(); + return true; + """) + cgThings.append(CGGeneric(fill( + """ + if (foundNonFiniteFloat) { + $*{returnSteps} + } + """, + returnSteps=foundNonFiniteFloatBehavior))) + + if needsUnwrap: + # Something depends on having the unwrapped object, so unwrap it now. + xraySteps = [] + # XXXkhuey we should be able to MOZ_ASSERT that ${obj} is + # not null. + xraySteps.append( + CGGeneric(fill( + """ + ${obj} = js::CheckedUnwrap(${obj}); + if (!${obj}) { + return false; + } + """, + obj=unwrappedVar))) + if isConstructor: + # If we're called via an xray, we need to enter the underlying + # object's compartment and then wrap up all of our arguments into + # that compartment as needed. This is all happening after we've + # already done the conversions from JS values to WebIDL (C++) + # values, so we only need to worry about cases where there are 'any' + # or 'object' types, or other things that we represent as actual + # JSAPI types, present. Effectively, we're emulating a + # CrossCompartmentWrapper, but working with the C++ types, not the + # original list of JS::Values. + cgThings.append(CGGeneric("Maybe<JSAutoCompartment> ac;\n")) + xraySteps.append(CGGeneric("ac.emplace(cx, obj);\n")) + xraySteps.append(CGGeneric(dedent( + """ + if (!JS_WrapObject(cx, &desiredProto)) { + return false; + } + """))) + xraySteps.extend( + wrapArgIntoCurrentCompartment(arg, argname, isMember=False) + for arg, argname in self.getArguments()) + + cgThings.append( + CGIfWrapper(CGList(xraySteps), + "objIsXray")) + + # If this is a method that was generated by a maplike/setlike + # interface, use the maplike/setlike generator to fill in the body. + # Otherwise, use CGCallGenerator to call the native method. + if idlNode.isMethod() and idlNode.isMaplikeOrSetlikeOrIterableMethod(): + if (idlNode.maplikeOrSetlikeOrIterable.isMaplike() or + idlNode.maplikeOrSetlikeOrIterable.isSetlike()): + cgThings.append(CGMaplikeOrSetlikeMethodGenerator(descriptor, + idlNode.maplikeOrSetlikeOrIterable, + idlNode.identifier.name)) + else: + cgThings.append(CGIterableMethodGenerator(descriptor, + idlNode.maplikeOrSetlikeOrIterable, + idlNode.identifier.name)) + else: + cgThings.append(CGCallGenerator( + self.isFallible(), + idlNode.getExtendedAttribute('NeedsSubjectPrincipal'), + needsCallerType(idlNode), + self.getArguments(), argsPre, returnType, + self.extendedAttributes, descriptor, + nativeMethodName, + static, argsPost=argsPost, resultVar=resultVar)) + + if useCounterName: + # Generate a telemetry call for when [UseCounter] is used. + code = "SetDocumentAndPageUseCounter(cx, obj, eUseCounter_%s);\n" % useCounterName + cgThings.append(CGGeneric(code)) + + self.cgRoot = CGList(cgThings) + + def getArguments(self): + return [(a, "arg" + str(i)) for i, a in enumerate(self.arguments)] + + def isFallible(self): + return 'infallible' not in self.extendedAttributes + + def wrap_return_value(self): + wrapCode = "" + + returnsNewObject = memberReturnsNewObject(self.idlNode) + if (returnsNewObject and + self.returnType.isGeckoInterface()): + wrapCode += dedent( + """ + static_assert(!IsPointer<decltype(result)>::value, + "NewObject implies that we need to keep the object alive with a strong reference."); + """) + + setSlot = self.idlNode.isAttr() and self.idlNode.slotIndices is not None + if setSlot: + # For attributes in slots, we want to do some + # post-processing once we've wrapped them. + successCode = "break;\n" + else: + successCode = None + + resultTemplateValues = { + 'jsvalRef': 'args.rval()', + 'jsvalHandle': 'args.rval()', + 'returnsNewObject': returnsNewObject, + 'isConstructorRetval': self.isConstructor, + 'successCode': successCode, + # 'obj' in this dictionary is the thing whose compartment we are + # trying to do the to-JS conversion in. We're going to put that + # thing in a variable named "conversionScope" if setSlot is true. + # Otherwise, just use "obj" for lack of anything better. + 'obj': "conversionScope" if setSlot else "obj" + } + try: + wrapCode += wrapForType(self.returnType, self.descriptor, resultTemplateValues) + except MethodNotNewObjectError, err: + assert not returnsNewObject + raise TypeError("%s being returned from non-NewObject method or property %s.%s" % + (err.typename, + self.descriptor.interface.identifier.name, + self.idlNode.identifier.name)) + if setSlot: + # When using a slot on the Xray expando, we need to make sure that + # our initial conversion to a JS::Value is done in the caller + # compartment. When using a slot on our reflector, we want to do + # the conversion in the compartment of that reflector (that is, + # slotStorage). In both cases we want to make sure that we finally + # set up args.rval() to be in the caller compartment. We also need + # to make sure that the conversion steps happen inside a do/while + # that they can break out of on success. + # + # Of course we always have to wrap the value into the slotStorage + # compartment before we store it in slotStorage. + + # postConversionSteps are the steps that run while we're still in + # the compartment we do our conversion in but after we've finished + # the initial conversion into args.rval(). + postConversionSteps = "" + if needsContainsHack(self.idlNode): + # Define a .contains on the object that has the same value as + # .includes; needed for backwards compat in extensions as we + # migrate some DOMStringLists to FrozenArray. + postConversionSteps += dedent( + """ + if (args.rval().isObject() && nsContentUtils::ThreadsafeIsCallerChrome()) { + JS::Rooted<JSObject*> rvalObj(cx, &args.rval().toObject()); + JS::Rooted<JS::Value> includesVal(cx); + if (!JS_GetProperty(cx, rvalObj, "includes", &includesVal) || + !JS_DefineProperty(cx, rvalObj, "contains", includesVal, JSPROP_ENUMERATE)) { + return false; + } + } + + """) + if self.idlNode.getExtendedAttribute("Frozen"): + assert self.idlNode.type.isSequence() or self.idlNode.type.isDictionary() + freezeValue = CGGeneric( + "JS::Rooted<JSObject*> rvalObj(cx, &args.rval().toObject());\n" + "if (!JS_FreezeObject(cx, rvalObj)) {\n" + " return false;\n" + "}\n") + if self.idlNode.type.nullable(): + freezeValue = CGIfWrapper(freezeValue, + "args.rval().isObject()") + postConversionSteps += freezeValue.define() + + # slotStorageSteps are steps that run once we have entered the + # slotStorage compartment. + slotStorageSteps= fill( + """ + // Make a copy so that we don't do unnecessary wrapping on args.rval(). + JS::Rooted<JS::Value> storedVal(cx, args.rval()); + if (!${maybeWrap}(cx, &storedVal)) { + return false; + } + js::SetReservedSlot(slotStorage, slotIndex, storedVal); + """, + maybeWrap=getMaybeWrapValueFuncForType(self.idlNode.type)) + + checkForXray = mayUseXrayExpandoSlots(self.descriptor, self.idlNode) + + # For the case of Cached attributes, go ahead and preserve our + # wrapper if needed. We need to do this because otherwise the + # wrapper could get garbage-collected and the cached value would + # suddenly disappear, but the whole premise of cached values is that + # they never change without explicit action on someone's part. We + # don't do this for StoreInSlot, since those get dealt with during + # wrapper setup, and failure would involve us trying to clear an + # already-preserved wrapper. + if (self.idlNode.getExtendedAttribute("Cached") and + self.descriptor.wrapperCache): + preserveWrapper = dedent( + """ + PreserveWrapper(self); + """) + if checkForXray: + preserveWrapper = fill( + """ + if (!isXray) { + // In the Xray case we don't need to do this, because getting the + // expando object already preserved our wrapper. + $*{preserveWrapper} + } + """, + preserveWrapper=preserveWrapper) + slotStorageSteps += preserveWrapper + + if checkForXray: + conversionScope = "isXray ? obj : slotStorage" + else: + conversionScope = "slotStorage" + + wrapCode = fill( + """ + { + JS::Rooted<JSObject*> conversionScope(cx, ${conversionScope}); + JSAutoCompartment ac(cx, conversionScope); + do { // block we break out of when done wrapping + $*{wrapCode} + } while (0); + $*{postConversionSteps} + } + { // And now store things in the compartment of our slotStorage. + JSAutoCompartment ac(cx, slotStorage); + $*{slotStorageSteps} + } + // And now make sure args.rval() is in the caller compartment + return ${maybeWrap}(cx, args.rval()); + """, + conversionScope=conversionScope, + wrapCode=wrapCode, + postConversionSteps=postConversionSteps, + slotStorageSteps=slotStorageSteps, + maybeWrap=getMaybeWrapValueFuncForType(self.idlNode.type)) + return wrapCode + + def define(self): + return (self.cgRoot.define() + self.wrap_return_value()) + + +class CGSwitch(CGList): + """ + A class to generate code for a switch statement. + + Takes three constructor arguments: an expression, a list of cases, + and an optional default. + + Each case is a CGCase. The default is a CGThing for the body of + the default case, if any. + """ + def __init__(self, expression, cases, default=None): + CGList.__init__(self, [CGIndenter(c) for c in cases]) + self.prepend(CGGeneric("switch (" + expression + ") {\n")) + if default is not None: + self.append( + CGIndenter( + CGWrapper( + CGIndenter(default), + pre="default: {\n", + post=" break;\n}\n"))) + + self.append(CGGeneric("}\n")) + + +class CGCase(CGList): + """ + A class to generate code for a case statement. + + Takes three constructor arguments: an expression, a CGThing for + the body (allowed to be None if there is no body), and an optional + argument (defaulting to False) for whether to fall through. + """ + def __init__(self, expression, body, fallThrough=False): + CGList.__init__(self, []) + self.append(CGGeneric("case " + expression + ": {\n")) + bodyList = CGList([body]) + if fallThrough: + bodyList.append(CGGeneric("MOZ_FALLTHROUGH;\n")) + else: + bodyList.append(CGGeneric("break;\n")) + self.append(CGIndenter(bodyList)) + self.append(CGGeneric("}\n")) + + +class CGMethodCall(CGThing): + """ + A class to generate selection of a method signature from a set of + signatures and generation of a call to that signature. + """ + def __init__(self, nativeMethodName, static, descriptor, method, + isConstructor=False, constructorName=None): + CGThing.__init__(self) + + if isConstructor: + assert constructorName is not None + methodName = constructorName + else: + methodName = "%s.%s" % (descriptor.interface.identifier.name, method.identifier.name) + argDesc = "argument %d of " + methodName + + if method.getExtendedAttribute("UseCounter"): + useCounterName = methodName.replace(".", "_") + else: + useCounterName = None + + if method.isStatic(): + nativeType = descriptor.nativeType + staticTypeOverride = PropertyDefiner.getStringAttr(method, "StaticClassOverride") + if (staticTypeOverride): + nativeType = staticTypeOverride + nativeMethodName = "%s::%s" % (nativeType, nativeMethodName) + + def requiredArgCount(signature): + arguments = signature[1] + if len(arguments) == 0: + return 0 + requiredArgs = len(arguments) + while requiredArgs and arguments[requiredArgs-1].optional: + requiredArgs -= 1 + return requiredArgs + + def getPerSignatureCall(signature, argConversionStartsAt=0): + return CGPerSignatureCall(signature[0], signature[1], + nativeMethodName, static, descriptor, + method, + argConversionStartsAt=argConversionStartsAt, + isConstructor=isConstructor, + useCounterName=useCounterName) + + signatures = method.signatures() + if len(signatures) == 1: + # Special case: we can just do a per-signature method call + # here for our one signature and not worry about switching + # on anything. + signature = signatures[0] + self.cgRoot = CGList([getPerSignatureCall(signature)]) + requiredArgs = requiredArgCount(signature) + + # Skip required arguments check for maplike/setlike interfaces, as + # they can have arguments which are not passed, and are treated as + # if undefined had been explicitly passed. + if requiredArgs > 0 and not method.isMaplikeOrSetlikeOrIterableMethod(): + code = fill( + """ + if (MOZ_UNLIKELY(args.length() < ${requiredArgs})) { + return ThrowErrorMessage(cx, MSG_MISSING_ARGUMENTS, "${methodName}"); + } + """, + requiredArgs=requiredArgs, + methodName=methodName) + self.cgRoot.prepend(CGGeneric(code)) + return + + # Need to find the right overload + maxArgCount = method.maxArgCount + allowedArgCounts = method.allowedArgCounts + + argCountCases = [] + for argCountIdx, argCount in enumerate(allowedArgCounts): + possibleSignatures = method.signaturesForArgCount(argCount) + + # Try to optimize away cases when the next argCount in the list + # will have the same code as us; if it does, we can fall through to + # that case. + if argCountIdx+1 < len(allowedArgCounts): + nextPossibleSignatures = method.signaturesForArgCount(allowedArgCounts[argCountIdx+1]) + else: + nextPossibleSignatures = None + if possibleSignatures == nextPossibleSignatures: + # Same set of signatures means we better have the same + # distinguishing index. So we can in fact just fall through to + # the next case here. + assert (len(possibleSignatures) == 1 or + (method.distinguishingIndexForArgCount(argCount) == + method.distinguishingIndexForArgCount(allowedArgCounts[argCountIdx+1]))) + argCountCases.append(CGCase(str(argCount), None, True)) + continue + + if len(possibleSignatures) == 1: + # easy case! + signature = possibleSignatures[0] + argCountCases.append( + CGCase(str(argCount), getPerSignatureCall(signature))) + continue + + distinguishingIndex = method.distinguishingIndexForArgCount(argCount) + + def distinguishingArgument(signature): + args = signature[1] + if distinguishingIndex < len(args): + return args[distinguishingIndex] + assert args[-1].variadic + return args[-1] + + def distinguishingType(signature): + return distinguishingArgument(signature).type + + for sig in possibleSignatures: + # We should not have "any" args at distinguishingIndex, + # since we have multiple possible signatures remaining, + # but "any" is never distinguishable from anything else. + assert not distinguishingType(sig).isAny() + # We can't handle unions at the distinguishing index. + if distinguishingType(sig).isUnion(): + raise TypeError("No support for unions as distinguishing " + "arguments yet: %s" % + distinguishingArgument(sig).location) + # We don't support variadics as the distinguishingArgument yet. + # If you want to add support, consider this case: + # + # void(long... foo); + # void(long bar, Int32Array baz); + # + # in which we have to convert argument 0 to long before picking + # an overload... but all the variadic stuff needs to go into a + # single array in case we pick that overload, so we have to have + # machinery for converting argument 0 to long and then either + # placing it in the variadic bit or not. Or something. We may + # be able to loosen this restriction if the variadic arg is in + # fact at distinguishingIndex, perhaps. Would need to + # double-check. + if distinguishingArgument(sig).variadic: + raise TypeError("No support for variadics as distinguishing " + "arguments yet: %s" % + distinguishingArgument(sig).location) + + # Convert all our arguments up to the distinguishing index. + # Doesn't matter which of the possible signatures we use, since + # they all have the same types up to that point; just use + # possibleSignatures[0] + caseBody = [CGArgumentConverter(possibleSignatures[0][1][i], + i, descriptor, + argDesc % (i + 1), method) + for i in range(0, distinguishingIndex)] + + # Select the right overload from our set. + distinguishingArg = "args[%d]" % distinguishingIndex + + def tryCall(signature, indent, isDefinitelyObject=False, + isNullOrUndefined=False): + assert not isDefinitelyObject or not isNullOrUndefined + assert isDefinitelyObject or isNullOrUndefined + if isDefinitelyObject: + failureCode = "break;\n" + else: + failureCode = None + type = distinguishingType(signature) + # The argument at index distinguishingIndex can't possibly be + # unset here, because we've already checked that argc is large + # enough that we can examine this argument. But note that we + # still want to claim that optional arguments are optional, in + # case undefined was passed in. + argIsOptional = distinguishingArgument(signature).canHaveMissingValue() + testCode = instantiateJSToNativeConversion( + getJSToNativeConversionInfo(type, descriptor, + failureCode=failureCode, + isDefinitelyObject=isDefinitelyObject, + isNullOrUndefined=isNullOrUndefined, + isOptional=argIsOptional, + sourceDescription=(argDesc % (distinguishingIndex + 1))), + { + "declName": "arg%d" % distinguishingIndex, + "holderName": ("arg%d" % distinguishingIndex) + "_holder", + "val": distinguishingArg, + "obj": "obj", + "haveValue": "args.hasDefined(%d)" % distinguishingIndex, + "passedToJSImpl": toStringBool(isJSImplementedDescriptor(descriptor)) + }, + checkForValue=argIsOptional) + caseBody.append(CGIndenter(testCode, indent)) + + # If we got this far, we know we unwrapped to the right + # C++ type, so just do the call. Start conversion with + # distinguishingIndex + 1, since we already converted + # distinguishingIndex. + caseBody.append(CGIndenter( + getPerSignatureCall(signature, distinguishingIndex + 1), + indent)) + + def hasConditionalConversion(type): + """ + Return whether the argument conversion for this type will be + conditional on the type of incoming JS value. For example, for + interface types the conversion is conditional on the incoming + value being isObject(). + + For the types for which this returns false, we do not have to + output extra isUndefined() or isNullOrUndefined() cases, because + null/undefined values will just fall through into our + unconditional conversion. + """ + if type.isString() or type.isEnum(): + return False + if type.isBoolean(): + distinguishingTypes = (distinguishingType(s) for s in + possibleSignatures) + return any(t.isString() or t.isEnum() or t.isNumeric() + for t in distinguishingTypes) + if type.isNumeric(): + distinguishingTypes = (distinguishingType(s) for s in + possibleSignatures) + return any(t.isString() or t.isEnum() + for t in distinguishingTypes) + return True + + def needsNullOrUndefinedCase(type): + """ + Return true if the type needs a special isNullOrUndefined() case + """ + return ((type.nullable() and + hasConditionalConversion(type)) or + type.isDictionary()) + + # First check for undefined and optional distinguishing arguments + # and output a special branch for that case. Note that we don't + # use distinguishingArgument here because we actualy want to + # exclude variadic arguments. Also note that we skip this check if + # we plan to output a isNullOrUndefined() special case for this + # argument anyway, since that will subsume our isUndefined() check. + # This is safe, because there can be at most one nullable + # distinguishing argument, so if we're it we'll definitely get + # picked up by the nullable handling. Also, we can skip this check + # if the argument has an unconditional conversion later on. + undefSigs = [s for s in possibleSignatures if + distinguishingIndex < len(s[1]) and + s[1][distinguishingIndex].optional and + hasConditionalConversion(s[1][distinguishingIndex].type) and + not needsNullOrUndefinedCase(s[1][distinguishingIndex].type)] + # Can't have multiple signatures with an optional argument at the + # same index. + assert len(undefSigs) < 2 + if len(undefSigs) > 0: + caseBody.append(CGGeneric("if (%s.isUndefined()) {\n" % + distinguishingArg)) + tryCall(undefSigs[0], 2, isNullOrUndefined=True) + caseBody.append(CGGeneric("}\n")) + + # Next, check for null or undefined. That means looking for + # nullable arguments at the distinguishing index and outputting a + # separate branch for them. But if the nullable argument has an + # unconditional conversion, we don't need to do that. The reason + # for that is that at most one argument at the distinguishing index + # is nullable (since two nullable arguments are not + # distinguishable), and null/undefined values will always fall + # through to the unconditional conversion we have, if any, since + # they will fail whatever the conditions on the input value are for + # our other conversions. + nullOrUndefSigs = [s for s in possibleSignatures + if needsNullOrUndefinedCase(distinguishingType(s))] + # Can't have multiple nullable types here + assert len(nullOrUndefSigs) < 2 + if len(nullOrUndefSigs) > 0: + caseBody.append(CGGeneric("if (%s.isNullOrUndefined()) {\n" % + distinguishingArg)) + tryCall(nullOrUndefSigs[0], 2, isNullOrUndefined=True) + caseBody.append(CGGeneric("}\n")) + + # Now check for distinguishingArg being various kinds of objects. + # The spec says to check for the following things in order: + # 1) A platform object that's not a platform array object, being + # passed to an interface or "object" arg. + # 2) A Date object being passed to a Date or "object" arg. + # 3) A RegExp object being passed to a RegExp or "object" arg. + # 4) A callable object being passed to a callback or "object" arg. + # 5) An iterable object being passed to a sequence arg. + # 6) Any non-Date and non-RegExp object being passed to a + # array or callback interface or dictionary or + # "object" arg. + + # First grab all the overloads that have a non-callback interface + # (which includes typed arrays and arraybuffers) at the + # distinguishing index. We can also include the ones that have an + # "object" here, since if those are present no other object-typed + # argument will be. + objectSigs = [ + s for s in possibleSignatures + if (distinguishingType(s).isObject() or + distinguishingType(s).isNonCallbackInterface())] + + # And all the overloads that take Date + objectSigs.extend(s for s in possibleSignatures + if distinguishingType(s).isDate()) + + # And all the overloads that take callbacks + objectSigs.extend(s for s in possibleSignatures + if distinguishingType(s).isCallback()) + + # And all the overloads that take sequences + objectSigs.extend(s for s in possibleSignatures + if distinguishingType(s).isSequence()) + + # Now append all the overloads that take a dictionary or callback + # interface or MozMap. There should be only one of these! + genericObjectSigs = [ + s for s in possibleSignatures + if (distinguishingType(s).isDictionary() or + distinguishingType(s).isMozMap() or + distinguishingType(s).isCallbackInterface())] + assert len(genericObjectSigs) <= 1 + objectSigs.extend(genericObjectSigs) + + # There might be more than one thing in objectSigs; we need to check + # which ones we unwrap to. + if len(objectSigs) > 0: + # Here it's enough to guard on our argument being an object. The + # code for unwrapping non-callback interfaces, typed arrays, + # sequences, and Dates will just bail out and move on to + # the next overload if the object fails to unwrap correctly, + # while "object" accepts any object anyway. We could even not + # do the isObject() check up front here, but in cases where we + # have multiple object overloads it makes sense to do it only + # once instead of for each overload. That will also allow the + # unwrapping test to skip having to do codegen for the + # null-or-undefined case, which we already handled above. + caseBody.append(CGGeneric("if (%s.isObject()) {\n" % + distinguishingArg)) + for sig in objectSigs: + caseBody.append(CGIndenter(CGGeneric("do {\n"))) + # Indent by 4, since we need to indent further + # than our "do" statement + tryCall(sig, 4, isDefinitelyObject=True) + caseBody.append(CGIndenter(CGGeneric("} while (0);\n"))) + + caseBody.append(CGGeneric("}\n")) + + # Now we only have to consider booleans, numerics, and strings. If + # we only have one of them, then we can just output it. But if not, + # then we need to output some of the cases conditionally: if we have + # a string overload, then boolean and numeric are conditional, and + # if not then boolean is conditional if we have a numeric overload. + def findUniqueSignature(filterLambda): + sigs = filter(filterLambda, possibleSignatures) + assert len(sigs) < 2 + if len(sigs) > 0: + return sigs[0] + return None + + stringSignature = findUniqueSignature( + lambda s: (distinguishingType(s).isString() or + distinguishingType(s).isEnum())) + numericSignature = findUniqueSignature( + lambda s: distinguishingType(s).isNumeric()) + booleanSignature = findUniqueSignature( + lambda s: distinguishingType(s).isBoolean()) + + if stringSignature or numericSignature: + booleanCondition = "%s.isBoolean()" + else: + booleanCondition = None + + if stringSignature: + numericCondition = "%s.isNumber()" + else: + numericCondition = None + + def addCase(sig, condition): + sigCode = getPerSignatureCall(sig, distinguishingIndex) + if condition: + sigCode = CGIfWrapper(sigCode, + condition % distinguishingArg) + caseBody.append(sigCode) + + if booleanSignature: + addCase(booleanSignature, booleanCondition) + if numericSignature: + addCase(numericSignature, numericCondition) + if stringSignature: + addCase(stringSignature, None) + + if (not booleanSignature and not numericSignature and + not stringSignature): + # Just throw; we have no idea what we're supposed to + # do with this. + caseBody.append(CGGeneric( + 'return ThrowErrorMessage(cx, MSG_OVERLOAD_RESOLUTION_FAILED, "%d", "%d", "%s");\n' % + (distinguishingIndex + 1, argCount, methodName))) + + argCountCases.append(CGCase(str(argCount), CGList(caseBody))) + + overloadCGThings = [] + overloadCGThings.append( + CGGeneric("unsigned argcount = std::min(args.length(), %du);\n" % + maxArgCount)) + overloadCGThings.append( + CGSwitch("argcount", + argCountCases, + CGGeneric('return ThrowErrorMessage(cx, MSG_MISSING_ARGUMENTS, "%s");\n' % + methodName))) + overloadCGThings.append( + CGGeneric('MOZ_CRASH("We have an always-returning default case");\n' + 'return false;\n')) + self.cgRoot = CGList(overloadCGThings) + + def define(self): + return self.cgRoot.define() + + +class CGGetterCall(CGPerSignatureCall): + """ + A class to generate a native object getter call for a particular IDL + getter. + """ + def __init__(self, returnType, nativeMethodName, descriptor, attr): + if attr.getExtendedAttribute("UseCounter"): + useCounterName = "%s_%s_getter" % (descriptor.interface.identifier.name, + attr.identifier.name) + else: + useCounterName = None + if attr.isStatic(): + nativeMethodName = "%s::%s" % (descriptor.nativeType, nativeMethodName) + CGPerSignatureCall.__init__(self, returnType, [], nativeMethodName, + attr.isStatic(), descriptor, attr, + getter=True, useCounterName=useCounterName) + + +class CGNavigatorGetterCall(CGPerSignatureCall): + """ + A class to generate a native object getter call for an IDL getter for a + property generated by NavigatorProperty. + """ + def __init__(self, returnType, _, descriptor, attr): + nativeMethodName = "%s::ConstructNavigatorObject" % (toBindingNamespace(returnType.inner.identifier.name)) + CGPerSignatureCall.__init__(self, returnType, [], nativeMethodName, + True, descriptor, attr, getter=True) + + def getArguments(self): + # The navigator object should be associated with the global of + # the navigator it's coming from, which will be the global of + # the object whose slot it gets cached in. That's stored in + # "slotStorage". + return [(FakeArgument(BuiltinTypes[IDLBuiltinType.Types.object], + self.idlNode), + "slotStorage")] + + +class FakeIdentifier(): + def __init__(self, name): + self.name = name + + +class FakeArgument(): + """ + A class that quacks like an IDLArgument. This is used to make + setters look like method calls or for special operations. + """ + def __init__(self, type, interfaceMember, name="arg", allowTreatNonCallableAsNull=False): + self.type = type + self.optional = False + self.variadic = False + self.defaultValue = None + self._allowTreatNonCallableAsNull = allowTreatNonCallableAsNull + # For FakeArguments generated by maplike/setlike convenience functions, + # we won't have an interfaceMember to pass in. + if interfaceMember: + self.treatNullAs = interfaceMember.treatNullAs + else: + self.treatNullAs = "Default" + if isinstance(interfaceMember, IDLAttribute): + self.enforceRange = interfaceMember.enforceRange + self.clamp = interfaceMember.clamp + else: + self.enforceRange = False + self.clamp = False + + self.identifier = FakeIdentifier(name) + + def allowTreatNonCallableAsNull(self): + return self._allowTreatNonCallableAsNull + + def canHaveMissingValue(self): + return False + + +class CGSetterCall(CGPerSignatureCall): + """ + A class to generate a native object setter call for a particular IDL + setter. + """ + def __init__(self, argType, nativeMethodName, descriptor, attr): + if attr.getExtendedAttribute("UseCounter"): + useCounterName = "%s_%s_setter" % (descriptor.interface.identifier.name, + attr.identifier.name) + else: + useCounterName = None + if attr.isStatic(): + nativeMethodName = "%s::%s" % (descriptor.nativeType, nativeMethodName) + CGPerSignatureCall.__init__(self, None, + [FakeArgument(argType, attr, allowTreatNonCallableAsNull=True)], + nativeMethodName, attr.isStatic(), + descriptor, attr, setter=True, useCounterName=useCounterName) + + def wrap_return_value(self): + attr = self.idlNode + if self.descriptor.wrapperCache and attr.slotIndices is not None: + if attr.getExtendedAttribute("StoreInSlot"): + args = "cx, self" + else: + args = "self" + clearSlot = ("%s(%s);\n" % + (MakeClearCachedValueNativeName(self.idlNode), args)) + else: + clearSlot = "" + + # We have no return value + return ("\n" + "%s" + "return true;\n" % clearSlot) + + +class CGAbstractBindingMethod(CGAbstractStaticMethod): + """ + Common class to generate the JSNatives for all our methods, getters, and + setters. This will generate the function declaration and unwrap the + |this| object. Subclasses are expected to override the generate_code + function to do the rest of the work. This function should return a + CGThing which is already properly indented. + + getThisObj should be code for getting a JSObject* for the binding + object. If this is None, we will auto-generate code based on + descriptor to do the right thing. "" can be passed in if the + binding object is already stored in 'obj'. + + callArgs should be code for getting a JS::CallArgs into a variable + called 'args'. This can be "" if there is already such a variable + around. + + If allowCrossOriginThis is true, then this-unwrapping will first do an + UncheckedUnwrap and after that operate on the result. + """ + def __init__(self, descriptor, name, args, unwrapFailureCode=None, + getThisObj=None, + callArgs="JS::CallArgs args = JS::CallArgsFromVp(argc, vp);\n", + allowCrossOriginThis=False): + CGAbstractStaticMethod.__init__(self, descriptor, name, "bool", args) + + if unwrapFailureCode is None: + self.unwrapFailureCode = 'return ThrowErrorMessage(cx, MSG_THIS_DOES_NOT_IMPLEMENT_INTERFACE, "Value", "%s");\n' % descriptor.interface.identifier.name + else: + self.unwrapFailureCode = unwrapFailureCode + + if getThisObj == "": + self.getThisObj = None + else: + if getThisObj is None: + if descriptor.interface.isOnGlobalProtoChain(): + ensureCondition = "!args.thisv().isNullOrUndefined() && !args.thisv().isObject()" + getThisObj = "args.thisv().isObject() ? &args.thisv().toObject() : js::GetGlobalForObjectCrossCompartment(&args.callee())" + else: + ensureCondition = "!args.thisv().isObject()" + getThisObj = "&args.thisv().toObject()" + unwrapFailureCode = self.unwrapFailureCode % {'securityError': 'false'} + ensureThisObj = CGIfWrapper(CGGeneric(unwrapFailureCode), + ensureCondition) + else: + ensureThisObj = None + self.getThisObj = CGList( + [ensureThisObj, + CGGeneric("JS::Rooted<JSObject*> obj(cx, %s);\n" % + getThisObj)]) + self.callArgs = callArgs + self.allowCrossOriginThis = allowCrossOriginThis + + def definition_body(self): + body = self.callArgs + if self.getThisObj is not None: + body += self.getThisObj.define() + "\n" + body += "%s* self;\n" % self.descriptor.nativeType + body += dedent( + """ + JS::Rooted<JS::Value> rootSelf(cx, JS::ObjectValue(*obj)); + """) + + # Our descriptor might claim that we're not castable, simply because + # we're someone's consequential interface. But for this-unwrapping, we + # know that we're the real deal. So fake a descriptor here for + # consumption by CastableObjectUnwrapper. + body += str(CastableObjectUnwrapper( + self.descriptor, + "rootSelf", + "&rootSelf", + "self", + self.unwrapFailureCode, + allowCrossOriginObj=self.allowCrossOriginThis)) + + return body + self.generate_code().define() + + def generate_code(self): + assert False # Override me + + +class CGAbstractStaticBindingMethod(CGAbstractStaticMethod): + """ + Common class to generate the JSNatives for all our static methods, getters + and setters. This will generate the function declaration and unwrap the + global object. Subclasses are expected to override the generate_code + function to do the rest of the work. This function should return a + CGThing which is already properly indented. + """ + def __init__(self, descriptor, name): + CGAbstractStaticMethod.__init__(self, descriptor, name, "bool", + JSNativeArguments()) + + def definition_body(self): + # Make sure that "obj" is in the same compartment as "cx", since we'll + # later use it to wrap return values. + unwrap = dedent(""" + JS::CallArgs args = JS::CallArgsFromVp(argc, vp); + JS::Rooted<JSObject*> obj(cx, &args.callee()); + + """) + return unwrap + self.generate_code().define() + + def generate_code(self): + assert False # Override me + + +def MakeNativeName(name): + return name[0].upper() + IDLToCIdentifier(name[1:]) + + +class CGGenericMethod(CGAbstractBindingMethod): + """ + A class for generating the C++ code for an IDL method. + + If allowCrossOriginThis is true, then this-unwrapping will first do an + UncheckedUnwrap and after that operate on the result. + """ + def __init__(self, descriptor, allowCrossOriginThis=False): + unwrapFailureCode = ( + 'return ThrowInvalidThis(cx, args, %%(securityError)s, "%s");\n' % + descriptor.interface.identifier.name) + name = "genericCrossOriginMethod" if allowCrossOriginThis else "genericMethod" + CGAbstractBindingMethod.__init__(self, descriptor, name, + JSNativeArguments(), + unwrapFailureCode=unwrapFailureCode, + allowCrossOriginThis=allowCrossOriginThis) + + def generate_code(self): + return CGGeneric(dedent(""" + const JSJitInfo *info = FUNCTION_VALUE_TO_JITINFO(args.calleev()); + MOZ_ASSERT(info->type() == JSJitInfo::Method); + JSJitMethodOp method = info->method; + bool ok = method(cx, obj, self, JSJitMethodCallArgs(args)); + #ifdef DEBUG + if (ok) { + AssertReturnTypeMatchesJitinfo(info, args.rval()); + } + #endif + return ok; + """)) + + +class CGGenericPromiseReturningMethod(CGAbstractBindingMethod): + """ + A class for generating the C++ code for an IDL method that returns a Promise. + + Does not handle cross-origin this. + """ + def __init__(self, descriptor): + unwrapFailureCode = dedent(""" + ThrowInvalidThis(cx, args, %%(securityError)s, "%s");\n + return ConvertExceptionToPromise(cx, xpc::XrayAwareCalleeGlobal(callee), + args.rval());\n""" % + descriptor.interface.identifier.name) + + name = "genericPromiseReturningMethod" + customCallArgs = dedent(""" + JS::CallArgs args = JS::CallArgsFromVp(argc, vp); + // Make sure to save the callee before someone maybe messes with rval(). + JS::Rooted<JSObject*> callee(cx, &args.callee()); + """) + + CGAbstractBindingMethod.__init__(self, descriptor, name, + JSNativeArguments(), + callArgs=customCallArgs, + unwrapFailureCode=unwrapFailureCode) + + def generate_code(self): + return CGGeneric(dedent(""" + const JSJitInfo *info = FUNCTION_VALUE_TO_JITINFO(args.calleev()); + MOZ_ASSERT(info->type() == JSJitInfo::Method); + JSJitMethodOp method = info->method; + bool ok = method(cx, obj, self, JSJitMethodCallArgs(args)); + if (ok) { + #ifdef DEBUG + AssertReturnTypeMatchesJitinfo(info, args.rval()); + #endif + return true; + } + + MOZ_ASSERT(info->returnType() == JSVAL_TYPE_OBJECT); + return ConvertExceptionToPromise(cx, xpc::XrayAwareCalleeGlobal(callee), + args.rval()); + """)) + + +class CGSpecializedMethod(CGAbstractStaticMethod): + """ + A class for generating the C++ code for a specialized method that the JIT + can call with lower overhead. + """ + def __init__(self, descriptor, method): + self.method = method + name = CppKeywords.checkMethodName(IDLToCIdentifier(method.identifier.name)) + args = [Argument('JSContext*', 'cx'), + Argument('JS::Handle<JSObject*>', 'obj'), + Argument('%s*' % descriptor.nativeType, 'self'), + Argument('const JSJitMethodCallArgs&', 'args')] + CGAbstractStaticMethod.__init__(self, descriptor, name, 'bool', args) + + def definition_body(self): + nativeName = CGSpecializedMethod.makeNativeName(self.descriptor, + self.method) + return CGMethodCall(nativeName, self.method.isStatic(), self.descriptor, + self.method).define() + + @staticmethod + def makeNativeName(descriptor, method): + name = method.identifier.name + return MakeNativeName(descriptor.binaryNameFor(name)) + + +class CGMethodPromiseWrapper(CGAbstractStaticMethod): + """ + A class for generating a wrapper around another method that will + convert exceptions to promises. + """ + def __init__(self, descriptor, methodToWrap): + self.method = methodToWrap + name = self.makeName(methodToWrap.name) + args = list(methodToWrap.args) + CGAbstractStaticMethod.__init__(self, descriptor, name, 'bool', args) + + def definition_body(self): + return fill( + """ + // Make sure to save the callee before someone maybe messes + // with rval(). + JS::Rooted<JSObject*> callee(cx, &args.callee()); + bool ok = ${methodName}(${args}); + if (ok) { + return true; + } + return ConvertExceptionToPromise(cx, xpc::XrayAwareCalleeGlobal(callee), + args.rval()); + """, + methodName=self.method.name, + args=", ".join(arg.name for arg in self.args)) + + @staticmethod + def makeName(methodName): + return methodName + "_promiseWrapper" + + +class CGJsonifierMethod(CGSpecializedMethod): + def __init__(self, descriptor, method): + assert method.isJsonifier() + CGSpecializedMethod.__init__(self, descriptor, method) + + def definition_body(self): + ret = dedent(""" + JS::Rooted<JSObject*> result(cx, JS_NewPlainObject(cx)); + if (!result) { + return false; + } + """) + + jsonDescriptors = [self.descriptor] + interface = self.descriptor.interface.parent + while interface: + descriptor = self.descriptor.getDescriptor(interface.identifier.name) + if descriptor.operations['Jsonifier']: + jsonDescriptors.append(descriptor) + interface = interface.parent + + # Iterate the array in reverse: oldest ancestor first + for descriptor in jsonDescriptors[::-1]: + ret += fill( + """ + if (!${parentclass}::JsonifyAttributes(cx, obj, self, result)) { + return false; + } + """, + parentclass=toBindingNamespace(descriptor.name) + ) + ret += ('args.rval().setObject(*result);\n' + 'return true;\n') + return ret + + +class CGLegacyCallHook(CGAbstractBindingMethod): + """ + Call hook for our object + """ + def __init__(self, descriptor): + self._legacycaller = descriptor.operations["LegacyCaller"] + # Our "self" is actually the callee in this case, not the thisval. + CGAbstractBindingMethod.__init__( + self, descriptor, LEGACYCALLER_HOOK_NAME, + JSNativeArguments(), getThisObj="&args.callee()") + + def define(self): + if not self._legacycaller: + return "" + return CGAbstractBindingMethod.define(self) + + def generate_code(self): + name = self._legacycaller.identifier.name + nativeName = MakeNativeName(self.descriptor.binaryNameFor(name)) + return CGMethodCall(nativeName, False, self.descriptor, + self._legacycaller) + + +class CGResolveHook(CGAbstractClassHook): + """ + Resolve hook for objects that have the NeedResolve extended attribute. + """ + def __init__(self, descriptor): + assert descriptor.interface.getExtendedAttribute("NeedResolve") + + args = [Argument('JSContext*', 'cx'), + Argument('JS::Handle<JSObject*>', 'obj'), + Argument('JS::Handle<jsid>', 'id'), + Argument('bool*', 'resolvedp')] + CGAbstractClassHook.__init__(self, descriptor, RESOLVE_HOOK_NAME, + "bool", args) + + def generate_code(self): + return dedent(""" + JS::Rooted<JS::PropertyDescriptor> desc(cx); + if (!self->DoResolve(cx, obj, id, &desc)) { + return false; + } + if (!desc.object()) { + return true; + } + // If desc.value() is undefined, then the DoResolve call + // has already defined it on the object. Don't try to also + // define it. + if (!desc.value().isUndefined()) { + desc.attributesRef() |= JSPROP_RESOLVING; + if (!JS_DefinePropertyById(cx, obj, id, desc)) { + return false; + } + } + *resolvedp = true; + return true; + """) + + def definition_body(self): + if self.descriptor.isGlobal(): + # Resolve standard classes + prefix = dedent(""" + if (!ResolveGlobal(cx, obj, id, resolvedp)) { + return false; + } + if (*resolvedp) { + return true; + } + + """) + else: + prefix = "" + return prefix + CGAbstractClassHook.definition_body(self) + + +class CGMayResolveHook(CGAbstractStaticMethod): + """ + Resolve hook for objects that have the NeedResolve extended attribute. + """ + def __init__(self, descriptor): + assert descriptor.interface.getExtendedAttribute("NeedResolve") + + args = [Argument('const JSAtomState&', 'names'), + Argument('jsid', 'id'), + Argument('JSObject*', 'maybeObj')] + CGAbstractStaticMethod.__init__(self, descriptor, MAY_RESOLVE_HOOK_NAME, + "bool", args) + + def definition_body(self): + if self.descriptor.isGlobal(): + # Check whether this would resolve as a standard class. + prefix = dedent(""" + if (MayResolveGlobal(names, id, maybeObj)) { + return true; + } + + """) + else: + prefix = "" + return (prefix + + "return %s::MayResolve(id);\n" % self.descriptor.nativeType) + + +class CGEnumerateHook(CGAbstractBindingMethod): + """ + Enumerate hook for objects with custom hooks. + """ + def __init__(self, descriptor): + assert descriptor.interface.getExtendedAttribute("NeedResolve") + + args = [Argument('JSContext*', 'cx'), + Argument('JS::Handle<JSObject*>', 'obj')] + # Our "self" is actually the "obj" argument in this case, not the thisval. + CGAbstractBindingMethod.__init__( + self, descriptor, ENUMERATE_HOOK_NAME, + args, getThisObj="", callArgs="") + + def generate_code(self): + return CGGeneric(dedent(""" + AutoTArray<nsString, 8> names; + binding_detail::FastErrorResult rv; + self->GetOwnPropertyNames(cx, names, rv); + if (rv.MaybeSetPendingException(cx)) { + return false; + } + bool dummy; + for (uint32_t i = 0; i < names.Length(); ++i) { + if (!JS_HasUCProperty(cx, obj, names[i].get(), names[i].Length(), &dummy)) { + return false; + } + } + return true; + """)) + + def definition_body(self): + if self.descriptor.isGlobal(): + # Enumerate standard classes + prefix = dedent(""" + if (!EnumerateGlobal(cx, obj)) { + return false; + } + + """) + else: + prefix = "" + return prefix + CGAbstractBindingMethod.definition_body(self) + + +class CppKeywords(): + """ + A class for checking if method names declared in webidl + are not in conflict with C++ keywords. + """ + keywords = frozenset([ + 'alignas', 'alignof', 'and', 'and_eq', 'asm', 'assert', 'auto', 'bitand', 'bitor', 'bool', + 'break', 'case', 'catch', 'char', 'char16_t', 'char32_t', 'class', 'compl', 'const', + 'constexpr', 'const_cast', 'continue', 'decltype', 'default', 'delete', 'do', 'double', + 'dynamic_cast', 'else', 'enum', 'explicit', 'export', 'extern', 'false', 'final', 'float', + 'for', 'friend', 'goto', 'if', 'inline', 'int', 'long', 'mutable', 'namespace', 'new', + 'noexcept', 'not', 'not_eq', 'nullptr', 'operator', 'or', 'or_eq', 'override', 'private', + 'protected', 'public', 'register', 'reinterpret_cast', 'return', 'short', 'signed', + 'sizeof', 'static', 'static_assert', 'static_cast', 'struct', 'switch', 'template', 'this', + 'thread_local', 'throw', 'true', 'try', 'typedef', 'typeid', 'typename', 'union', + 'unsigned', 'using', 'virtual', 'void', 'volatile', 'wchar_t', 'while', 'xor', 'xor_eq']) + + @staticmethod + def checkMethodName(name): + # Double '_' because 'assert' and '_assert' cannot be used in MS2013 compiler. + # Bug 964892 and bug 963560. + if name in CppKeywords.keywords: + name = '_' + name + '_' + return name + + +class CGStaticMethod(CGAbstractStaticBindingMethod): + """ + A class for generating the C++ code for an IDL static method. + """ + def __init__(self, descriptor, method): + self.method = method + name = CppKeywords.checkMethodName(IDLToCIdentifier(method.identifier.name)) + CGAbstractStaticBindingMethod.__init__(self, descriptor, name) + + def generate_code(self): + nativeName = CGSpecializedMethod.makeNativeName(self.descriptor, + self.method) + return CGMethodCall(nativeName, True, self.descriptor, self.method) + + +class CGGenericGetter(CGAbstractBindingMethod): + """ + A class for generating the C++ code for an IDL attribute getter. + """ + def __init__(self, descriptor, lenientThis=False, allowCrossOriginThis=False): + if lenientThis: + name = "genericLenientGetter" + unwrapFailureCode = dedent(""" + MOZ_ASSERT(!JS_IsExceptionPending(cx)); + if (!ReportLenientThisUnwrappingFailure(cx, &args.callee())) { + return false; + } + args.rval().set(JS::UndefinedValue()); + return true; + """) + else: + if allowCrossOriginThis: + name = "genericCrossOriginGetter" + else: + name = "genericGetter" + unwrapFailureCode = ( + 'return ThrowInvalidThis(cx, args, %%(securityError)s, "%s");\n' % + descriptor.interface.identifier.name) + CGAbstractBindingMethod.__init__(self, descriptor, name, JSNativeArguments(), + unwrapFailureCode, + allowCrossOriginThis=allowCrossOriginThis) + + def generate_code(self): + return CGGeneric(dedent(""" + const JSJitInfo *info = FUNCTION_VALUE_TO_JITINFO(args.calleev()); + MOZ_ASSERT(info->type() == JSJitInfo::Getter); + JSJitGetterOp getter = info->getter; + bool ok = getter(cx, obj, self, JSJitGetterCallArgs(args)); + #ifdef DEBUG + if (ok) { + AssertReturnTypeMatchesJitinfo(info, args.rval()); + } + #endif + return ok; + """)) + + +class CGSpecializedGetter(CGAbstractStaticMethod): + """ + A class for generating the code for a specialized attribute getter + that the JIT can call with lower overhead. + """ + def __init__(self, descriptor, attr): + self.attr = attr + name = 'get_' + IDLToCIdentifier(attr.identifier.name) + args = [ + Argument('JSContext*', 'cx'), + Argument('JS::Handle<JSObject*>', 'obj'), + Argument('%s*' % descriptor.nativeType, 'self'), + Argument('JSJitGetterCallArgs', 'args') + ] + CGAbstractStaticMethod.__init__(self, descriptor, name, "bool", args) + + def definition_body(self): + if self.attr.isMaplikeOrSetlikeAttr(): + # If the interface is maplike/setlike, there will be one getter + # method for the size property of the backing object. Due to having + # to unpack the backing object from the slot, this requires its own + # generator. + return getMaplikeOrSetlikeSizeGetterBody(self.descriptor, self.attr) + nativeName = CGSpecializedGetter.makeNativeName(self.descriptor, + self.attr) + if self.attr.slotIndices is not None: + if self.descriptor.hasXPConnectImpls: + raise TypeError("Interface '%s' has XPConnect impls, so we " + "can't use our slot for property '%s'!" % + (self.descriptor.interface.identifier.name, + self.attr.identifier.name)) + + # We're going to store this return value in a slot on some object, + # to cache it. The question is, which object? For dictionary and + # sequence return values, we want to use a slot on the Xray expando + # if we're called via Xrays, and a slot on our reflector otherwise. + # On the other hand, when dealing with some interfacce types + # (navigator properties, window.document) we want to avoid calling + # the getter more than once. In the case of navigator properties + # that's because the getter actually creates a new object each time. + # In the case of window.document, it's because the getter can start + # returning null, which would get hidden in he non-Xray case by the + # fact that it's [StoreOnSlot], so the cached version is always + # around. + # + # The upshot is that we use the reflector slot for any getter whose + # type is a gecko interface, whether we're called via Xrays or not. + # Since [Cached] and [StoreInSlot] cannot be used with "NewObject", + # we know that in the interface type case the returned object is + # wrappercached. So creating Xrays to it is reasonable. + if mayUseXrayExpandoSlots(self.descriptor, self.attr): + prefix = fill( + """ + // Have to either root across the getter call or reget after. + bool isXray; + JS::Rooted<JSObject*> slotStorage(cx, GetCachedSlotStorageObject(cx, obj, &isXray)); + if (!slotStorage) { + return false; + } + const size_t slotIndex = isXray ? ${xraySlotIndex} : ${slotIndex}; + """, + xraySlotIndex=memberXrayExpandoReservedSlot(self.attr, + self.descriptor), + slotIndex=memberReservedSlot(self.attr, self.descriptor)) + else: + prefix = fill( + """ + // Have to either root across the getter call or reget after. + JS::Rooted<JSObject*> slotStorage(cx, js::UncheckedUnwrap(obj, /* stopAtWindowProxy = */ false)); + MOZ_ASSERT(IsDOMObject(slotStorage)); + const size_t slotIndex = ${slotIndex}; + """, + slotIndex=memberReservedSlot(self.attr, self.descriptor)) + + prefix += fill( + """ + MOZ_ASSERT(JSCLASS_RESERVED_SLOTS(js::GetObjectClass(slotStorage)) > slotIndex); + { + // Scope for cachedVal + JS::Value cachedVal = js::GetReservedSlot(slotStorage, slotIndex); + if (!cachedVal.isUndefined()) { + args.rval().set(cachedVal); + // The cached value is in the compartment of slotStorage, + // so wrap into the caller compartment as needed. + return ${maybeWrap}(cx, args.rval()); + } + } + + """, + maybeWrap=getMaybeWrapValueFuncForType(self.attr.type)) + else: + prefix = "" + + if self.attr.navigatorObjectGetter: + cgGetterCall = CGNavigatorGetterCall + else: + cgGetterCall = CGGetterCall + return (prefix + + cgGetterCall(self.attr.type, nativeName, + self.descriptor, self.attr).define()) + + @staticmethod + def makeNativeName(descriptor, attr): + name = attr.identifier.name + nativeName = MakeNativeName(descriptor.binaryNameFor(name)) + _, resultOutParam, _, _, _ = getRetvalDeclarationForType(attr.type, + descriptor) + infallible = ('infallible' in + descriptor.getExtendedAttributes(attr, getter=True)) + if resultOutParam or attr.type.nullable() or not infallible: + nativeName = "Get" + nativeName + return nativeName + + +class CGStaticGetter(CGAbstractStaticBindingMethod): + """ + A class for generating the C++ code for an IDL static attribute getter. + """ + def __init__(self, descriptor, attr): + self.attr = attr + name = 'get_' + IDLToCIdentifier(attr.identifier.name) + CGAbstractStaticBindingMethod.__init__(self, descriptor, name) + + def generate_code(self): + nativeName = CGSpecializedGetter.makeNativeName(self.descriptor, + self.attr) + return CGGetterCall(self.attr.type, nativeName, self.descriptor, + self.attr) + + +class CGGenericSetter(CGAbstractBindingMethod): + """ + A class for generating the C++ code for an IDL attribute setter. + """ + def __init__(self, descriptor, lenientThis=False, allowCrossOriginThis=False): + if lenientThis: + name = "genericLenientSetter" + unwrapFailureCode = dedent(""" + MOZ_ASSERT(!JS_IsExceptionPending(cx)); + if (!ReportLenientThisUnwrappingFailure(cx, &args.callee())) { + return false; + } + args.rval().set(JS::UndefinedValue()); + return true; + """) + else: + if allowCrossOriginThis: + name = "genericCrossOriginSetter" + else: + name = "genericSetter" + unwrapFailureCode = ( + 'return ThrowInvalidThis(cx, args, %%(securityError)s, "%s");\n' % + descriptor.interface.identifier.name) + + CGAbstractBindingMethod.__init__(self, descriptor, name, JSNativeArguments(), + unwrapFailureCode, + allowCrossOriginThis=allowCrossOriginThis) + + def generate_code(self): + return CGGeneric(fill( + """ + if (args.length() == 0) { + return ThrowErrorMessage(cx, MSG_MISSING_ARGUMENTS, "${name} attribute setter"); + } + const JSJitInfo *info = FUNCTION_VALUE_TO_JITINFO(args.calleev()); + MOZ_ASSERT(info->type() == JSJitInfo::Setter); + JSJitSetterOp setter = info->setter; + if (!setter(cx, obj, self, JSJitSetterCallArgs(args))) { + return false; + } + args.rval().setUndefined(); + #ifdef DEBUG + AssertReturnTypeMatchesJitinfo(info, args.rval()); + #endif + return true; + """, + name=self.descriptor.interface.identifier.name)) + + +class CGSpecializedSetter(CGAbstractStaticMethod): + """ + A class for generating the code for a specialized attribute setter + that the JIT can call with lower overhead. + """ + def __init__(self, descriptor, attr): + self.attr = attr + name = 'set_' + IDLToCIdentifier(attr.identifier.name) + args = [Argument('JSContext*', 'cx'), + Argument('JS::Handle<JSObject*>', 'obj'), + Argument('%s*' % descriptor.nativeType, 'self'), + Argument('JSJitSetterCallArgs', 'args')] + CGAbstractStaticMethod.__init__(self, descriptor, name, "bool", args) + + def definition_body(self): + nativeName = CGSpecializedSetter.makeNativeName(self.descriptor, + self.attr) + return CGSetterCall(self.attr.type, nativeName, self.descriptor, + self.attr).define() + + @staticmethod + def makeNativeName(descriptor, attr): + name = attr.identifier.name + return "Set" + MakeNativeName(descriptor.binaryNameFor(name)) + + +class CGStaticSetter(CGAbstractStaticBindingMethod): + """ + A class for generating the C++ code for an IDL static attribute setter. + """ + def __init__(self, descriptor, attr): + self.attr = attr + name = 'set_' + IDLToCIdentifier(attr.identifier.name) + CGAbstractStaticBindingMethod.__init__(self, descriptor, name) + + def generate_code(self): + nativeName = CGSpecializedSetter.makeNativeName(self.descriptor, + self.attr) + checkForArg = CGGeneric(fill( + """ + if (args.length() == 0) { + return ThrowErrorMessage(cx, MSG_MISSING_ARGUMENTS, "${name} setter"); + } + """, + name=self.attr.identifier.name)) + call = CGSetterCall(self.attr.type, nativeName, self.descriptor, + self.attr) + return CGList([checkForArg, call]) + + +class CGSpecializedForwardingSetter(CGSpecializedSetter): + """ + A class for generating the code for a specialized attribute setter with + PutForwards that the JIT can call with lower overhead. + """ + def __init__(self, descriptor, attr): + CGSpecializedSetter.__init__(self, descriptor, attr) + + def definition_body(self): + attrName = self.attr.identifier.name + forwardToAttrName = self.attr.getExtendedAttribute("PutForwards")[0] + # JS_GetProperty and JS_SetProperty can only deal with ASCII + assert all(ord(c) < 128 for c in attrName) + assert all(ord(c) < 128 for c in forwardToAttrName) + return fill( + """ + JS::Rooted<JS::Value> v(cx); + if (!JS_GetProperty(cx, obj, "${attr}", &v)) { + return false; + } + + if (!v.isObject()) { + return ThrowErrorMessage(cx, MSG_NOT_OBJECT, "${interface}.${attr}"); + } + + JS::Rooted<JSObject*> targetObj(cx, &v.toObject()); + return JS_SetProperty(cx, targetObj, "${forwardToAttrName}", args[0]); + """, + attr=attrName, + interface=self.descriptor.interface.identifier.name, + forwardToAttrName=forwardToAttrName) + + +class CGSpecializedReplaceableSetter(CGSpecializedSetter): + """ + A class for generating the code for a specialized attribute setter with + Replaceable that the JIT can call with lower overhead. + """ + def __init__(self, descriptor, attr): + CGSpecializedSetter.__init__(self, descriptor, attr) + + def definition_body(self): + attrName = self.attr.identifier.name + # JS_DefineProperty can only deal with ASCII + assert all(ord(c) < 128 for c in attrName) + return ('return JS_DefineProperty(cx, obj, "%s", args[0], JSPROP_ENUMERATE);\n' % + attrName) + + +class CGSpecializedLenientSetter(CGSpecializedSetter): + """ + A class for generating the code for a specialized attribute setter with + LenientSetter that the JIT can call with lower overhead. + """ + def __init__(self, descriptor, attr): + CGSpecializedSetter.__init__(self, descriptor, attr) + + def definition_body(self): + attrName = self.attr.identifier.name + # JS_DefineProperty can only deal with ASCII + assert all(ord(c) < 128 for c in attrName) + return dedent(""" + DeprecationWarning(cx, obj, nsIDocument::eLenientSetter); + return true; + """) + + +def memberReturnsNewObject(member): + return member.getExtendedAttribute("NewObject") is not None + + +class CGMemberJITInfo(CGThing): + """ + A class for generating the JITInfo for a property that points to + our specialized getter and setter. + """ + def __init__(self, descriptor, member): + self.member = member + self.descriptor = descriptor + + def declare(self): + return "" + + def defineJitInfo(self, infoName, opName, opType, infallible, movable, + eliminatable, aliasSet, alwaysInSlot, lazilyInSlot, + slotIndex, returnTypes, args): + """ + aliasSet is a JSJitInfo::AliasSet value, without the "JSJitInfo::" bit. + + args is None if we don't want to output argTypes for some + reason (e.g. we have overloads or we're not a method) and + otherwise an iterable of the arguments for this method. + """ + assert(not movable or aliasSet != "AliasEverything") # Can't move write-aliasing things + assert(not alwaysInSlot or movable) # Things always in slots had better be movable + assert(not eliminatable or aliasSet != "AliasEverything") # Can't eliminate write-aliasing things + assert(not alwaysInSlot or eliminatable) # Things always in slots had better be eliminatable + + def jitInfoInitializer(isTypedMethod): + initializer = fill( + """ + { + { ${opName} }, + { prototypes::id::${name} }, + { PrototypeTraits<prototypes::id::${name}>::Depth }, + JSJitInfo::${opType}, + JSJitInfo::${aliasSet}, /* aliasSet. Not relevant for setters. */ + ${returnType}, /* returnType. Not relevant for setters. */ + ${isInfallible}, /* isInfallible. False in setters. */ + ${isMovable}, /* isMovable. Not relevant for setters. */ + ${isEliminatable}, /* isEliminatable. Not relevant for setters. */ + ${isAlwaysInSlot}, /* isAlwaysInSlot. Only relevant for getters. */ + ${isLazilyCachedInSlot}, /* isLazilyCachedInSlot. Only relevant for getters. */ + ${isTypedMethod}, /* isTypedMethod. Only relevant for methods. */ + ${slotIndex} /* Reserved slot index, if we're stored in a slot, else 0. */ + } + """, + opName=opName, + name=self.descriptor.name, + opType=opType, + aliasSet=aliasSet, + returnType=reduce(CGMemberJITInfo.getSingleReturnType, returnTypes, + ""), + isInfallible=toStringBool(infallible), + isMovable=toStringBool(movable), + isEliminatable=toStringBool(eliminatable), + isAlwaysInSlot=toStringBool(alwaysInSlot), + isLazilyCachedInSlot=toStringBool(lazilyInSlot), + isTypedMethod=toStringBool(isTypedMethod), + slotIndex=slotIndex) + return initializer.rstrip() + + slotAssert = fill( + """ + static_assert(${slotIndex} <= JSJitInfo::maxSlotIndex, "We won't fit"); + static_assert(${slotIndex} < ${classReservedSlots}, "There is no slot for us"); + """, + slotIndex=slotIndex, + classReservedSlots=INSTANCE_RESERVED_SLOTS + self.descriptor.interface.totalMembersInSlots) + if args is not None: + argTypes = "%s_argTypes" % infoName + args = [CGMemberJITInfo.getJSArgType(arg.type) for arg in args] + args.append("JSJitInfo::ArgTypeListEnd") + argTypesDecl = ( + "static const JSJitInfo::ArgType %s[] = { %s };\n" % + (argTypes, ", ".join(args))) + return fill( + """ + $*{argTypesDecl} + static const JSTypedMethodJitInfo ${infoName} = { + ${jitInfo}, + ${argTypes} + }; + $*{slotAssert} + """, + argTypesDecl=argTypesDecl, + infoName=infoName, + jitInfo=indent(jitInfoInitializer(True)), + argTypes=argTypes, + slotAssert=slotAssert) + + return fill( + """ + static const JSJitInfo ${infoName} = ${jitInfo}; + $*{slotAssert} + """, + infoName=infoName, + jitInfo=jitInfoInitializer(False), + slotAssert=slotAssert) + + def define(self): + if self.member.isAttr(): + getterinfo = ("%s_getterinfo" % + IDLToCIdentifier(self.member.identifier.name)) + # We need the cast here because JSJitGetterOp has a "void* self" + # while we have the right type. + getter = ("(JSJitGetterOp)get_%s" % + IDLToCIdentifier(self.member.identifier.name)) + getterinfal = "infallible" in self.descriptor.getExtendedAttributes(self.member, getter=True) + + movable = self.mayBeMovable() and getterinfal + eliminatable = self.mayBeEliminatable() and getterinfal + aliasSet = self.aliasSet() + + getterinfal = getterinfal and infallibleForMember(self.member, self.member.type, self.descriptor) + isAlwaysInSlot = self.member.getExtendedAttribute("StoreInSlot") + if self.member.slotIndices is not None: + assert isAlwaysInSlot or self.member.getExtendedAttribute("Cached") + isLazilyCachedInSlot = not isAlwaysInSlot + slotIndex = memberReservedSlot(self.member, self.descriptor) + # We'll statically assert that this is not too big in + # CGUpdateMemberSlotsMethod, in the case when + # isAlwaysInSlot is true. + else: + isLazilyCachedInSlot = False + slotIndex = "0" + + result = self.defineJitInfo(getterinfo, getter, "Getter", + getterinfal, movable, eliminatable, + aliasSet, isAlwaysInSlot, + isLazilyCachedInSlot, slotIndex, + [self.member.type], None) + if (not self.member.readonly or + self.member.getExtendedAttribute("PutForwards") is not None or + self.member.getExtendedAttribute("Replaceable") is not None or + self.member.getExtendedAttribute("LenientSetter") is not None): + setterinfo = ("%s_setterinfo" % + IDLToCIdentifier(self.member.identifier.name)) + # Actually a JSJitSetterOp, but JSJitGetterOp is first in the + # union. + setter = ("(JSJitGetterOp)set_%s" % + IDLToCIdentifier(self.member.identifier.name)) + # Setters are always fallible, since they have to do a typed unwrap. + result += self.defineJitInfo(setterinfo, setter, "Setter", + False, False, False, "AliasEverything", + False, False, "0", + [BuiltinTypes[IDLBuiltinType.Types.void]], + None) + return result + if self.member.isMethod(): + methodinfo = ("%s_methodinfo" % + IDLToCIdentifier(self.member.identifier.name)) + name = CppKeywords.checkMethodName( + IDLToCIdentifier(self.member.identifier.name)) + if self.member.returnsPromise(): + name = CGMethodPromiseWrapper.makeName(name) + # Actually a JSJitMethodOp, but JSJitGetterOp is first in the union. + method = ("(JSJitGetterOp)%s" % name) + + # Methods are infallible if they are infallible, have no arguments + # to unwrap, and have a return type that's infallible to wrap up for + # return. + sigs = self.member.signatures() + if len(sigs) != 1: + # Don't handle overloading. If there's more than one signature, + # one of them must take arguments. + methodInfal = False + args = None + movable = False + eliminatable = False + else: + sig = sigs[0] + # For methods that affect nothing, it's OK to set movable to our + # notion of infallible on the C++ side, without considering + # argument conversions, since argument conversions that can + # reliably throw would be effectful anyway and the jit doesn't + # move effectful things. + hasInfallibleImpl = "infallible" in self.descriptor.getExtendedAttributes(self.member) + movable = self.mayBeMovable() and hasInfallibleImpl + eliminatable = self.mayBeEliminatable() and hasInfallibleImpl + # XXXbz can we move the smarts about fallibility due to arg + # conversions into the JIT, using our new args stuff? + if (len(sig[1]) != 0 or + not infallibleForMember(self.member, sig[0], self.descriptor)): + # We have arguments or our return-value boxing can fail + methodInfal = False + else: + methodInfal = hasInfallibleImpl + # For now, only bother to output args if we're side-effect-free. + if self.member.affects == "Nothing": + args = sig[1] + else: + args = None + + aliasSet = self.aliasSet() + result = self.defineJitInfo(methodinfo, method, "Method", + methodInfal, movable, eliminatable, + aliasSet, False, False, "0", + [s[0] for s in sigs], args) + return result + raise TypeError("Illegal member type to CGPropertyJITInfo") + + def mayBeMovable(self): + """ + Returns whether this attribute or method may be movable, just + based on Affects/DependsOn annotations. + """ + affects = self.member.affects + dependsOn = self.member.dependsOn + assert affects in IDLInterfaceMember.AffectsValues + assert dependsOn in IDLInterfaceMember.DependsOnValues + # Things that are DependsOn=DeviceState are not movable, because we + # don't want them coalesced with each other or loop-hoisted, since + # their return value can change even if nothing is going on from our + # point of view. + return (affects == "Nothing" and + (dependsOn != "Everything" and dependsOn != "DeviceState")) + + def mayBeEliminatable(self): + """ + Returns whether this attribute or method may be eliminatable, just + based on Affects/DependsOn annotations. + """ + # dependsOn shouldn't affect this decision at all, except in jitinfo we + # have no way to express "Depends on everything, affects nothing", + # because we only have three alias set values: AliasNone ("depends on + # nothing, affects nothing"), AliasDOMSets ("depends on DOM sets, + # affects nothing"), AliasEverything ("depends on everything, affects + # everything"). So the [Affects=Nothing, DependsOn=Everything] case + # gets encoded as AliasEverything and defineJitInfo asserts that if our + # alias state is AliasEverything then we're not eliminatable (because it + # thinks we might have side-effects at that point). Bug 1155796 is + # tracking possible solutions for this. + affects = self.member.affects + dependsOn = self.member.dependsOn + assert affects in IDLInterfaceMember.AffectsValues + assert dependsOn in IDLInterfaceMember.DependsOnValues + return affects == "Nothing" and dependsOn != "Everything" + + def aliasSet(self): + """ + Returns the alias set to store in the jitinfo. This may not be the + effective alias set the JIT uses, depending on whether we have enough + information about our args to allow the JIT to prove that effectful + argument conversions won't happen. + """ + dependsOn = self.member.dependsOn + assert dependsOn in IDLInterfaceMember.DependsOnValues + + if dependsOn == "Nothing" or dependsOn == "DeviceState": + assert self.member.affects == "Nothing" + return "AliasNone" + + if dependsOn == "DOMState": + assert self.member.affects == "Nothing" + return "AliasDOMSets" + + return "AliasEverything" + + @staticmethod + def getJSReturnTypeTag(t): + if t.nullable(): + # Sometimes it might return null, sometimes not + return "JSVAL_TYPE_UNKNOWN" + if t.isVoid(): + # No return, every time + return "JSVAL_TYPE_UNDEFINED" + if t.isSequence(): + return "JSVAL_TYPE_OBJECT" + if t.isMozMap(): + return "JSVAL_TYPE_OBJECT" + if t.isGeckoInterface(): + return "JSVAL_TYPE_OBJECT" + if t.isString(): + return "JSVAL_TYPE_STRING" + if t.isEnum(): + return "JSVAL_TYPE_STRING" + if t.isCallback(): + return "JSVAL_TYPE_OBJECT" + if t.isAny(): + # The whole point is to return various stuff + return "JSVAL_TYPE_UNKNOWN" + if t.isObject(): + return "JSVAL_TYPE_OBJECT" + if t.isSpiderMonkeyInterface(): + return "JSVAL_TYPE_OBJECT" + if t.isUnion(): + u = t.unroll() + if u.hasNullableType: + # Might be null or not + return "JSVAL_TYPE_UNKNOWN" + return reduce(CGMemberJITInfo.getSingleReturnType, + u.flatMemberTypes, "") + if t.isDictionary(): + return "JSVAL_TYPE_OBJECT" + if t.isDate(): + return "JSVAL_TYPE_OBJECT" + if not t.isPrimitive(): + raise TypeError("No idea what type " + str(t) + " is.") + tag = t.tag() + if tag == IDLType.Tags.bool: + return "JSVAL_TYPE_BOOLEAN" + if tag in [IDLType.Tags.int8, IDLType.Tags.uint8, + IDLType.Tags.int16, IDLType.Tags.uint16, + IDLType.Tags.int32]: + return "JSVAL_TYPE_INT32" + if tag in [IDLType.Tags.int64, IDLType.Tags.uint64, + IDLType.Tags.unrestricted_float, IDLType.Tags.float, + IDLType.Tags.unrestricted_double, IDLType.Tags.double]: + # These all use JS_NumberValue, which can return int or double. + # But TI treats "double" as meaning "int or double", so we're + # good to return JSVAL_TYPE_DOUBLE here. + return "JSVAL_TYPE_DOUBLE" + if tag != IDLType.Tags.uint32: + raise TypeError("No idea what type " + str(t) + " is.") + # uint32 is sometimes int and sometimes double. + return "JSVAL_TYPE_DOUBLE" + + @staticmethod + def getSingleReturnType(existingType, t): + type = CGMemberJITInfo.getJSReturnTypeTag(t) + if existingType == "": + # First element of the list; just return its type + return type + + if type == existingType: + return existingType + if ((type == "JSVAL_TYPE_DOUBLE" and + existingType == "JSVAL_TYPE_INT32") or + (existingType == "JSVAL_TYPE_DOUBLE" and + type == "JSVAL_TYPE_INT32")): + # Promote INT32 to DOUBLE as needed + return "JSVAL_TYPE_DOUBLE" + # Different types + return "JSVAL_TYPE_UNKNOWN" + + @staticmethod + def getJSArgType(t): + assert not t.isVoid() + if t.nullable(): + # Sometimes it might return null, sometimes not + return "JSJitInfo::ArgType(JSJitInfo::Null | %s)" % CGMemberJITInfo.getJSArgType(t.inner) + if t.isSequence(): + return "JSJitInfo::Object" + if t.isGeckoInterface(): + return "JSJitInfo::Object" + if t.isString(): + return "JSJitInfo::String" + if t.isEnum(): + return "JSJitInfo::String" + if t.isCallback(): + return "JSJitInfo::Object" + if t.isAny(): + # The whole point is to return various stuff + return "JSJitInfo::Any" + if t.isObject(): + return "JSJitInfo::Object" + if t.isSpiderMonkeyInterface(): + return "JSJitInfo::Object" + if t.isUnion(): + u = t.unroll() + type = "JSJitInfo::Null" if u.hasNullableType else "" + return ("JSJitInfo::ArgType(%s)" % + reduce(CGMemberJITInfo.getSingleArgType, + u.flatMemberTypes, type)) + if t.isDictionary(): + return "JSJitInfo::Object" + if t.isDate(): + return "JSJitInfo::Object" + if not t.isPrimitive(): + raise TypeError("No idea what type " + str(t) + " is.") + tag = t.tag() + if tag == IDLType.Tags.bool: + return "JSJitInfo::Boolean" + if tag in [IDLType.Tags.int8, IDLType.Tags.uint8, + IDLType.Tags.int16, IDLType.Tags.uint16, + IDLType.Tags.int32]: + return "JSJitInfo::Integer" + if tag in [IDLType.Tags.int64, IDLType.Tags.uint64, + IDLType.Tags.unrestricted_float, IDLType.Tags.float, + IDLType.Tags.unrestricted_double, IDLType.Tags.double]: + # These all use JS_NumberValue, which can return int or double. + # But TI treats "double" as meaning "int or double", so we're + # good to return JSVAL_TYPE_DOUBLE here. + return "JSJitInfo::Double" + if tag != IDLType.Tags.uint32: + raise TypeError("No idea what type " + str(t) + " is.") + # uint32 is sometimes int and sometimes double. + return "JSJitInfo::Double" + + @staticmethod + def getSingleArgType(existingType, t): + type = CGMemberJITInfo.getJSArgType(t) + if existingType == "": + # First element of the list; just return its type + return type + + if type == existingType: + return existingType + return "%s | %s" % (existingType, type) + + +class CGStaticMethodJitinfo(CGGeneric): + """ + A class for generating the JITInfo for a promise-returning static method. + """ + def __init__(self, method): + CGGeneric.__init__( + self, + "\n" + "static const JSJitInfo %s_methodinfo = {\n" + " { (JSJitGetterOp)%s },\n" + " { prototypes::id::_ID_Count }, { 0 }, JSJitInfo::StaticMethod,\n" + " JSJitInfo::AliasEverything, JSVAL_TYPE_MISSING, false, false,\n" + " false, false, 0\n" + "};\n" % + (IDLToCIdentifier(method.identifier.name), + CppKeywords.checkMethodName( + IDLToCIdentifier(method.identifier.name)))) + + +def getEnumValueName(value): + # Some enum values can be empty strings. Others might have weird + # characters in them. Deal with the former by returning "_empty", + # deal with possible name collisions from that by throwing if the + # enum value is actually "_empty", and throw on any value + # containing non-ASCII chars for now. Replace all chars other than + # [0-9A-Za-z_] with '_'. + if re.match("[^\x20-\x7E]", value): + raise SyntaxError('Enum value "' + value + '" contains non-ASCII characters') + if re.match("^[0-9]", value): + return '_' + value + value = re.sub(r'[^0-9A-Za-z_]', '_', value) + if re.match("^_[A-Z]|__", value): + raise SyntaxError('Enum value "' + value + '" is reserved by the C++ spec') + if value == "_empty": + raise SyntaxError('"_empty" is not an IDL enum value we support yet') + if value == "": + return "_empty" + nativeName = MakeNativeName(value) + if nativeName == "EndGuard_": + raise SyntaxError('Enum value "' + value + '" cannot be used because it' + ' collides with our internal EndGuard_ value. Please' + ' rename our internal EndGuard_ to something else') + return nativeName + +class CGEnumToJSValue(CGAbstractMethod): + def __init__(self, enum): + enumType = enum.identifier.name + self.stringsArray = enumType + "Values::" + ENUM_ENTRY_VARIABLE_NAME + CGAbstractMethod.__init__(self, None, "ToJSValue", "bool", + [Argument("JSContext*", "aCx"), + Argument(enumType, "aArgument"), + Argument("JS::MutableHandle<JS::Value>", + "aValue")]) + + def definition_body(self): + return fill( + """ + MOZ_ASSERT(uint32_t(aArgument) < ArrayLength(${strings})); + JSString* resultStr = + JS_NewStringCopyN(aCx, ${strings}[uint32_t(aArgument)].value, + ${strings}[uint32_t(aArgument)].length); + if (!resultStr) { + return false; + } + aValue.setString(resultStr); + return true; + """, + strings=self.stringsArray) + + +class CGEnum(CGThing): + def __init__(self, enum): + CGThing.__init__(self) + self.enum = enum + strings = CGNamespace( + self.stringsNamespace(), + CGGeneric(declare=("extern const EnumEntry %s[%d];\n" % + (ENUM_ENTRY_VARIABLE_NAME, self.nEnumStrings())), + define=fill( + """ + extern const EnumEntry ${name}[${count}] = { + $*{entries} + { nullptr, 0 } + }; + """, + name=ENUM_ENTRY_VARIABLE_NAME, + count=self.nEnumStrings(), + entries=''.join('{"%s", %d},\n' % (val, len(val)) + for val in self.enum.values())))) + toJSValue = CGEnumToJSValue(enum) + self.cgThings = CGList([strings, toJSValue], "\n") + + def stringsNamespace(self): + return self.enum.identifier.name + "Values" + + def nEnumStrings(self): + return len(self.enum.values()) + 1 + + def declare(self): + decl = fill( + """ + enum class ${name} : uint32_t { + $*{enums} + EndGuard_ + }; + """, + name=self.enum.identifier.name, + enums=",\n".join(map(getEnumValueName, self.enum.values())) + ",\n") + strings = CGNamespace(self.stringsNamespace(), + CGGeneric(declare="extern const EnumEntry %s[%d];\n" + % (ENUM_ENTRY_VARIABLE_NAME, self.nEnumStrings()))) + return decl + "\n" + self.cgThings.declare() + + def define(self): + return self.cgThings.define() + + def deps(self): + return self.enum.getDeps() + + +def getUnionAccessorSignatureType(type, descriptorProvider): + """ + Returns the types that are used in the getter and setter signatures for + union types + """ + # Flat member types have already unwrapped nullables. + assert not type.nullable() + + if type.isSequence() or type.isMozMap(): + if type.isSequence(): + wrapperType = "Sequence" + else: + wrapperType = "MozMap" + # We don't use the returned template here, so it's OK to just pass no + # sourceDescription. + elementInfo = getJSToNativeConversionInfo(type.inner, + descriptorProvider, + isMember=wrapperType) + return CGTemplatedType(wrapperType, elementInfo.declType, + isConst=True, isReference=True) + + # Nested unions are unwrapped automatically into our flatMemberTypes. + assert not type.isUnion() + + if type.isGeckoInterface(): + descriptor = descriptorProvider.getDescriptor( + type.unroll().inner.identifier.name) + typeName = CGGeneric(descriptor.nativeType) + # Allow null pointers for old-binding classes. + if type.unroll().inner.isExternal(): + typeName = CGWrapper(typeName, post="*") + else: + typeName = CGWrapper(typeName, post="&") + return typeName + + if type.isSpiderMonkeyInterface(): + typeName = CGGeneric(type.name) + return CGWrapper(typeName, post=" const &") + + if type.isDOMString() or type.isUSVString(): + return CGGeneric("const nsAString&") + + if type.isByteString(): + return CGGeneric("const nsCString&") + + if type.isEnum(): + return CGGeneric(type.inner.identifier.name) + + if type.isCallback(): + return CGGeneric("%s&" % type.unroll().callback.identifier.name) + + if type.isAny(): + return CGGeneric("JS::Value") + + if type.isObject(): + return CGGeneric("JSObject*") + + if type.isDictionary(): + return CGGeneric("const %s&" % type.inner.identifier.name) + + if not type.isPrimitive(): + raise TypeError("Need native type for argument type '%s'" % str(type)) + + return CGGeneric(builtinNames[type.tag()]) + + +def getUnionTypeTemplateVars(unionType, type, descriptorProvider, + ownsMembers=False): + name = getUnionMemberName(type) + holderName = "m" + name + "Holder" + + # By the time tryNextCode is invoked, we're guaranteed the union has been + # constructed as some type, since we've been trying to convert into the + # corresponding member. + prefix = "" if ownsMembers else "mUnion." + tryNextCode = ("$*{destroyHolder}\n" + "%sDestroy%s();\n" + "tryNext = true;\n" + "return true;\n" % (prefix, name)) + + conversionInfo = getJSToNativeConversionInfo( + type, descriptorProvider, failureCode=tryNextCode, + isDefinitelyObject=not type.isDictionary(), + isMember=("OwningUnion" if ownsMembers else None), + sourceDescription="member of %s" % unionType) + + if conversionInfo.holderType is not None: + assert not ownsMembers + destroyHolder = "%s.reset();\n" % holderName + else: + destroyHolder = "" + + ctorNeedsCx = conversionInfo.declArgs == "cx" + ctorArgs = "cx" if ctorNeedsCx else "" + + structType = conversionInfo.declType.define() + externalType = getUnionAccessorSignatureType(type, descriptorProvider).define() + + if type.isObject(): + if ownsMembers: + body = dedent(""" + MOZ_ASSERT(mType == eUninitialized); + mValue.mObject.SetValue(obj); + mType = eObject; + """) + else: + body = dedent(""" + MOZ_ASSERT(mUnion.mType == mUnion.eUninitialized); + mUnion.mValue.mObject.SetValue(cx, obj); + mUnion.mType = mUnion.eObject; + """) + + # It's a bit sketchy to do the security check after setting the value, + # but it keeps the code cleaner and lets us avoid rooting |obj| over the + # call to CallerSubsumes(). + body = body + dedent(""" + if (passedToJSImpl && !CallerSubsumes(obj)) { + ThrowErrorMessage(cx, MSG_PERMISSION_DENIED_TO_PASS_ARG, "%s"); + return false; + } + return true; + """) + + setter = ClassMethod("SetToObject", "bool", + [Argument("JSContext*", "cx"), + Argument("JSObject*", "obj"), + Argument("bool", "passedToJSImpl", default="false")], + inline=True, bodyInHeader=True, + body=body) + + else: + # Important: we need to not have our declName involve + # maybe-GCing operations. + if conversionInfo.holderType is not None: + holderArgs = conversionInfo.holderArgs + if holderArgs is None: + holderArgs = "" + initHolder = "%s.emplace(%s);\n" % (holderName, holderArgs) + else: + initHolder = "" + + jsConversion = fill( + initHolder + conversionInfo.template, + val="value", + maybeMutableVal="value", + declName="memberSlot", + holderName=(holderName if ownsMembers else "%s.ref()" % holderName), + destroyHolder=destroyHolder, + passedToJSImpl="passedToJSImpl") + + jsConversion = fill( + """ + tryNext = false; + { // scope for memberSlot + ${structType}& memberSlot = RawSetAs${name}(${ctorArgs}); + $*{jsConversion} + } + return true; + """, + structType=structType, + name=name, + ctorArgs=ctorArgs, + jsConversion=jsConversion) + + if ownsMembers: + handleType = "JS::Handle<JS::Value>" + else: + handleType = "JS::MutableHandle<JS::Value>" + + setter = ClassMethod("TrySetTo" + name, "bool", + [Argument("JSContext*", "cx"), + Argument(handleType, "value"), + Argument("bool&", "tryNext"), + Argument("bool", "passedToJSImpl", default="false")], + inline=not ownsMembers, + bodyInHeader=not ownsMembers, + body=jsConversion) + + return { + "name": name, + "structType": structType, + "externalType": externalType, + "setter": setter, + "holderType": conversionInfo.holderType.define() if conversionInfo.holderType else None, + "ctorArgs": ctorArgs, + "ctorArgList": [Argument("JSContext*", "cx")] if ctorNeedsCx else [] + } + + +class CGUnionStruct(CGThing): + def __init__(self, type, descriptorProvider, ownsMembers=False): + CGThing.__init__(self) + self.type = type.unroll() + self.descriptorProvider = descriptorProvider + self.ownsMembers = ownsMembers + self.struct = self.getStruct() + + def declare(self): + return self.struct.declare() + + def define(self): + return self.struct.define() + + def deps(self): + return self.type.getDeps() + + def getStruct(self): + + members = [ClassMember("mType", "Type", body="eUninitialized"), + ClassMember("mValue", "Value")] + ctor = ClassConstructor([], bodyInHeader=True, visibility="public", + explicit=True) + + methods = [] + enumValues = ["eUninitialized"] + toJSValCases = [CGCase("eUninitialized", CGGeneric("return false;\n"))] + destructorCases = [CGCase("eUninitialized", None)] + assignmentCases = [ + CGCase("eUninitialized", + CGGeneric('MOZ_ASSERT(mType == eUninitialized,\n' + ' "We need to destroy ourselves?");\n'))] + traceCases = [] + unionValues = [] + if self.type.hasNullableType: + enumValues.append("eNull") + methods.append(ClassMethod("IsNull", "bool", [], const=True, inline=True, + body="return mType == eNull;\n", + bodyInHeader=True)) + methods.append(ClassMethod("SetNull", "void", [], inline=True, + body=("Uninit();\n" + "mType = eNull;\n"), + bodyInHeader=True)) + destructorCases.append(CGCase("eNull", None)) + assignmentCases.append(CGCase("eNull", + CGGeneric("MOZ_ASSERT(mType == eUninitialized);\n" + "mType = eNull;\n"))) + toJSValCases.append(CGCase("eNull", CGGeneric("rval.setNull();\n" + "return true;\n"))) + + hasObjectType = any(t.isObject() for t in self.type.flatMemberTypes) + for t in self.type.flatMemberTypes: + vars = getUnionTypeTemplateVars(self.type, + t, self.descriptorProvider, + ownsMembers=self.ownsMembers) + if vars["name"] != "Object" or self.ownsMembers: + body = fill( + """ + if (mType == e${name}) { + return mValue.m${name}.Value(); + } + %s + mType = e${name}; + return mValue.m${name}.SetValue(${ctorArgs}); + """, + **vars) + + # bodyInHeader must be false for return values because they own + # their union members and we don't want include headers in + # UnionTypes.h just to call Addref/Release + methods.append(ClassMethod( + "RawSetAs" + vars["name"], + vars["structType"] + "&", + vars["ctorArgList"], + bodyInHeader=not self.ownsMembers, + body=body % "MOZ_ASSERT(mType == eUninitialized);")) + uninit = "Uninit();" + if hasObjectType and not self.ownsMembers: + uninit = 'MOZ_ASSERT(mType != eObject, "This will not play well with Rooted");\n' + uninit + methods.append(ClassMethod( + "SetAs" + vars["name"], + vars["structType"] + "&", + vars["ctorArgList"], + bodyInHeader=not self.ownsMembers, + body=body % uninit)) + if self.ownsMembers: + methods.append(vars["setter"]) + # Provide a SetStringData() method to support string defaults. + if t.isByteString(): + methods.append( + ClassMethod("SetStringData", "void", + [Argument("const nsCString::char_type*", "aData"), + Argument("nsCString::size_type", "aLength")], + inline=True, bodyInHeader=True, + body="RawSetAs%s().Assign(aData, aLength);\n" % t.name)) + elif t.isString(): + methods.append( + ClassMethod("SetStringData", "void", + [Argument("const nsString::char_type*", "aData"), + Argument("nsString::size_type", "aLength")], + inline=True, bodyInHeader=True, + body="RawSetAs%s().Assign(aData, aLength);\n" % t.name)) + + body = fill( + """ + MOZ_ASSERT(Is${name}(), "Wrong type!"); + mValue.m${name}.Destroy(); + mType = eUninitialized; + """, + **vars) + methods.append(ClassMethod("Destroy" + vars["name"], + "void", + [], + visibility="private", + bodyInHeader=not self.ownsMembers, + body=body)) + + body = fill("return mType == e${name};\n", **vars) + methods.append(ClassMethod("Is" + vars["name"], + "bool", + [], + const=True, + bodyInHeader=True, + body=body)) + + body = fill( + """ + MOZ_ASSERT(Is${name}(), "Wrong type!"); + return mValue.m${name}.Value(); + """, + **vars) + # The non-const version of GetAs* returns our internal type + getterReturnType = "%s&" % vars["structType"] + methods.append(ClassMethod("GetAs" + vars["name"], + getterReturnType, + [], + bodyInHeader=True, + body=body)) + # The const version of GetAs* returns our internal type + # for owning unions, but our external type for non-owning + # ones. + if self.ownsMembers: + getterReturnType = "%s const &" % vars["structType"] + else: + getterReturnType = vars["externalType"] + methods.append(ClassMethod("GetAs" + vars["name"], + getterReturnType, + [], + const=True, + bodyInHeader=True, + body=body)) + + unionValues.append( + fill("UnionMember<${structType} > m${name}", **vars)) + enumValues.append("e" + vars["name"]) + + skipToJSVal = False + try: + toJSValCases.append( + CGCase("e" + vars["name"], + self.getConversionToJS(vars, t))) + except MethodNotNewObjectError: + # If we can't have a ToJSVal() because one of our members can + # only be returned from [NewObject] methods, then just skip + # generating ToJSVal. + skipToJSVal = True + destructorCases.append( + CGCase("e" + vars["name"], + CGGeneric("Destroy%s();\n" % vars["name"]))) + assignmentCases.append( + CGCase("e" + vars["name"], + CGGeneric("SetAs%s() = aOther.GetAs%s();\n" % + (vars["name"], vars["name"])))) + if self.ownsMembers and typeNeedsRooting(t): + if t.isObject(): + traceCases.append( + CGCase("e" + vars["name"], + CGGeneric('JS::UnsafeTraceRoot(trc, %s, "%s");\n' % + ("&mValue.m" + vars["name"] + ".Value()", + "mValue.m" + vars["name"])))) + elif t.isDictionary(): + traceCases.append( + CGCase("e" + vars["name"], + CGGeneric("mValue.m%s.Value().TraceDictionary(trc);\n" % + vars["name"]))) + elif t.isSequence(): + traceCases.append( + CGCase("e" + vars["name"], + CGGeneric("DoTraceSequence(trc, mValue.m%s.Value());\n" % + vars["name"]))) + elif t.isMozMap(): + traceCases.append( + CGCase("e" + vars["name"], + CGGeneric("TraceMozMap(trc, mValue.m%s.Value());\n" % + vars["name"]))) + else: + assert t.isSpiderMonkeyInterface() + traceCases.append( + CGCase("e" + vars["name"], + CGGeneric("mValue.m%s.Value().TraceSelf(trc);\n" % + vars["name"]))) + + dtor = CGSwitch("mType", destructorCases).define() + + methods.append(ClassMethod("Uninit", "void", [], + visibility="public", body=dtor, + bodyInHeader=not self.ownsMembers, + inline=not self.ownsMembers)) + + if not skipToJSVal: + methods.append( + ClassMethod( + "ToJSVal", + "bool", + [ + Argument("JSContext*", "cx"), + Argument("JS::Handle<JSObject*>", "scopeObj"), + Argument("JS::MutableHandle<JS::Value>", "rval") + ], + body=CGSwitch("mType", toJSValCases, + default=CGGeneric("return false;\n")).define() + "\nreturn false;\n", + const=True)) + + constructors = [ctor] + selfName = CGUnionStruct.unionTypeName(self.type, self.ownsMembers) + if self.ownsMembers: + if traceCases: + traceBody = CGSwitch("mType", traceCases, + default=CGGeneric("")).define() + else: + traceBody = "" + methods.append(ClassMethod("TraceUnion", "void", + [Argument("JSTracer*", "trc")], + body=traceBody)) + if CGUnionStruct.isUnionCopyConstructible(self.type): + constructors.append( + ClassConstructor( + [Argument("const %s&" % selfName, "aOther")], + bodyInHeader=True, + visibility="public", + explicit=True, + body="*this = aOther;\n")) + methods.append(ClassMethod( + "operator=", "void", + [Argument("const %s&" % selfName, "aOther")], + body=CGSwitch("aOther.mType", assignmentCases).define())) + disallowCopyConstruction = False + else: + disallowCopyConstruction = True + else: + disallowCopyConstruction = True + + if self.ownsMembers: + friend = " friend void ImplCycleCollectionUnlink(%s& aUnion);\n" % CGUnionStruct.unionTypeName(self.type, True) + else: + friend = " friend class %sArgument;\n" % str(self.type) + + bases = [ClassBase("AllOwningUnionBase")] if self.ownsMembers else [] + return CGClass(selfName, + bases=bases, + members=members, + constructors=constructors, + methods=methods, + disallowCopyConstruction=disallowCopyConstruction, + extradeclarations=friend, + destructor=ClassDestructor(visibility="public", + body="Uninit();\n", + bodyInHeader=True), + enums=[ClassEnum("Type", enumValues, visibility="private")], + unions=[ClassUnion("Value", unionValues, visibility="private")]) + + def getConversionToJS(self, templateVars, type): + assert not type.nullable() # flatMemberTypes never has nullable types + val = "mValue.m%(name)s.Value()" % templateVars + wrapCode = wrapForType( + type, self.descriptorProvider, + { + "jsvalRef": "rval", + "jsvalHandle": "rval", + "obj": "scopeObj", + "result": val, + "typedArraysAreStructs": True + }) + return CGGeneric(wrapCode) + + @staticmethod + def isUnionCopyConstructible(type): + return all(isTypeCopyConstructible(t) for t in type.flatMemberTypes) + + @staticmethod + def unionTypeName(type, ownsMembers): + """ + Returns a string name for this known union type. + """ + assert type.isUnion() and not type.nullable() + return ("Owning" if ownsMembers else "") + type.name + + @staticmethod + def unionTypeDecl(type, ownsMembers): + """ + Returns a string for declaring this possibly-nullable union type. + """ + assert type.isUnion() + nullable = type.nullable() + if nullable: + type = type.inner + decl = CGGeneric(CGUnionStruct.unionTypeName(type, ownsMembers)) + if nullable: + decl = CGTemplatedType("Nullable", decl) + return decl.define() + + +class CGUnionConversionStruct(CGThing): + def __init__(self, type, descriptorProvider): + CGThing.__init__(self) + self.type = type.unroll() + self.descriptorProvider = descriptorProvider + + def declare(self): + + structName = str(self.type) + members = [ClassMember("mUnion", structName + "&", + body="const_cast<%s&>(aUnion)" % structName)] + # Argument needs to be a const ref because that's all Maybe<> allows + ctor = ClassConstructor([Argument("const %s&" % structName, "aUnion")], + bodyInHeader=True, + visibility="public", + explicit=True) + methods = [] + + if self.type.hasNullableType: + methods.append(ClassMethod("SetNull", "bool", [], + body=("MOZ_ASSERT(mUnion.mType == mUnion.eUninitialized);\n" + "mUnion.mType = mUnion.eNull;\n" + "return true;\n"), + inline=True, bodyInHeader=True)) + + for t in self.type.flatMemberTypes: + vars = getUnionTypeTemplateVars(self.type, + t, self.descriptorProvider) + methods.append(vars["setter"]) + if vars["name"] != "Object": + body = fill( + """ + MOZ_ASSERT(mUnion.mType == mUnion.eUninitialized); + mUnion.mType = mUnion.e${name}; + return mUnion.mValue.m${name}.SetValue(${ctorArgs}); + """, + **vars) + methods.append(ClassMethod("RawSetAs" + vars["name"], + vars["structType"] + "&", + vars["ctorArgList"], + bodyInHeader=True, + body=body, + visibility="private")) + # Provide a SetStringData() method to support string defaults. + if t.isByteString(): + methods.append( + ClassMethod("SetStringData", "void", + [Argument("const nsDependentCString::char_type*", "aData"), + Argument("nsDependentCString::size_type", "aLength")], + inline=True, bodyInHeader=True, + body="RawSetAs%s().Rebind(aData, aLength);\n" % t.name)) + elif t.isString(): + methods.append( + ClassMethod("SetStringData", "void", + [Argument("const nsDependentString::char_type*", "aData"), + Argument("nsDependentString::size_type", "aLength")], + inline=True, bodyInHeader=True, + body="RawSetAs%s().Rebind(aData, aLength);\n" % t.name)) + + if vars["holderType"] is not None: + holderType = CGTemplatedType("Maybe", + CGGeneric(vars["holderType"])).define() + members.append(ClassMember("m%sHolder" % vars["name"], + holderType)) + + return CGClass(structName + "Argument", + members=members, + constructors=[ctor], + methods=methods, + disallowCopyConstruction=True).declare() + + def define(self): + return "" + + def deps(self): + return set() + + +class ClassItem: + """ Use with CGClass """ + def __init__(self, name, visibility): + self.name = name + self.visibility = visibility + + def declare(self, cgClass): + assert False + + def define(self, cgClass): + assert False + + +class ClassBase(ClassItem): + def __init__(self, name, visibility='public'): + ClassItem.__init__(self, name, visibility) + + def declare(self, cgClass): + return '%s %s' % (self.visibility, self.name) + + def define(self, cgClass): + # Only in the header + return '' + + +class ClassMethod(ClassItem): + def __init__(self, name, returnType, args, inline=False, static=False, + virtual=False, const=False, bodyInHeader=False, + templateArgs=None, visibility='public', body=None, + breakAfterReturnDecl="\n", + breakAfterSelf="\n", override=False): + """ + override indicates whether to flag the method as override + """ + assert not override or virtual + assert not (override and static) + self.returnType = returnType + self.args = args + self.inline = inline or bodyInHeader + self.static = static + self.virtual = virtual + self.const = const + self.bodyInHeader = bodyInHeader + self.templateArgs = templateArgs + self.body = body + self.breakAfterReturnDecl = breakAfterReturnDecl + self.breakAfterSelf = breakAfterSelf + self.override = override + ClassItem.__init__(self, name, visibility) + + def getDecorators(self, declaring): + decorators = [] + if self.inline: + decorators.append('inline') + if declaring: + if self.static: + decorators.append('static') + if self.virtual: + decorators.append('virtual') + if decorators: + return ' '.join(decorators) + ' ' + return '' + + def getBody(self): + # Override me or pass a string to constructor + assert self.body is not None + return self.body + + def declare(self, cgClass): + templateClause = ('template <%s>\n' % ', '.join(self.templateArgs) + if self.bodyInHeader and self.templateArgs else '') + args = ', '.join([a.declare() for a in self.args]) + if self.bodyInHeader: + body = indent(self.getBody()) + body = '\n{\n' + body + '}\n' + else: + body = ';\n' + + return fill( + "${templateClause}${decorators}${returnType}${breakAfterReturnDecl}" + "${name}(${args})${const}${override}${body}" + "${breakAfterSelf}", + templateClause=templateClause, + decorators=self.getDecorators(True), + returnType=self.returnType, + breakAfterReturnDecl=self.breakAfterReturnDecl, + name=self.name, + args=args, + const=' const' if self.const else '', + override=' override' if self.override else '', + body=body, + breakAfterSelf=self.breakAfterSelf) + + def define(self, cgClass): + if self.bodyInHeader: + return '' + + templateArgs = cgClass.templateArgs + if templateArgs: + if cgClass.templateSpecialization: + templateArgs = \ + templateArgs[len(cgClass.templateSpecialization):] + + if templateArgs: + templateClause = \ + 'template <%s>\n' % ', '.join([str(a) for a in templateArgs]) + else: + templateClause = '' + + return fill( + """ + ${templateClause}${decorators}${returnType} + ${className}::${name}(${args})${const} + { + $*{body} + } + """, + templateClause=templateClause, + decorators=self.getDecorators(False), + returnType=self.returnType, + className=cgClass.getNameString(), + name=self.name, + args=', '.join([a.define() for a in self.args]), + const=' const' if self.const else '', + body=self.getBody()) + + +class ClassUsingDeclaration(ClassItem): + """ + Used for importing a name from a base class into a CGClass + + baseClass is the name of the base class to import the name from + + name is the name to import + + visibility determines the visibility of the name (public, + protected, private), defaults to public. + """ + def __init__(self, baseClass, name, visibility='public'): + self.baseClass = baseClass + ClassItem.__init__(self, name, visibility) + + def declare(self, cgClass): + return "using %s::%s;\n\n" % (self.baseClass, self.name) + + def define(self, cgClass): + return '' + + +class ClassConstructor(ClassItem): + """ + Used for adding a constructor to a CGClass. + + args is a list of Argument objects that are the arguments taken by the + constructor. + + inline should be True if the constructor should be marked inline. + + bodyInHeader should be True if the body should be placed in the class + declaration in the header. + + visibility determines the visibility of the constructor (public, + protected, private), defaults to private. + + explicit should be True if the constructor should be marked explicit. + + baseConstructors is a list of strings containing calls to base constructors, + defaults to None. + + body contains a string with the code for the constructor, defaults to empty. + """ + def __init__(self, args, inline=False, bodyInHeader=False, + visibility="private", explicit=False, constexpr=False, baseConstructors=None, + body=""): + assert not (inline and constexpr) + assert not (bodyInHeader and constexpr) + self.args = args + self.inline = inline or bodyInHeader + self.bodyInHeader = bodyInHeader or constexpr + self.explicit = explicit + self.constexpr = constexpr + self.baseConstructors = baseConstructors or [] + self.body = body + ClassItem.__init__(self, None, visibility) + + def getDecorators(self, declaring): + decorators = [] + if self.explicit: + decorators.append('explicit') + if self.inline and declaring: + decorators.append('inline') + if self.constexpr and declaring: + decorators.append('constexpr') + if decorators: + return ' '.join(decorators) + ' ' + return '' + + def getInitializationList(self, cgClass): + items = [str(c) for c in self.baseConstructors] + for m in cgClass.members: + if not m.static: + initialize = m.body + if initialize: + items.append(m.name + "(" + initialize + ")") + + if len(items) > 0: + return '\n : ' + ',\n '.join(items) + return '' + + def getBody(self): + return self.body + + def declare(self, cgClass): + args = ', '.join([a.declare() for a in self.args]) + if self.bodyInHeader: + body = self.getInitializationList(cgClass) + '\n{\n' + indent(self.getBody()) + '}\n' + else: + body = ';\n' + + return fill( + "${decorators}${className}(${args})${body}\n", + decorators=self.getDecorators(True), + className=cgClass.getNameString(), + args=args, + body=body) + + def define(self, cgClass): + if self.bodyInHeader: + return '' + + return fill( + """ + ${decorators} + ${className}::${className}(${args})${initializationList} + { + $*{body} + } + """, + decorators=self.getDecorators(False), + className=cgClass.getNameString(), + args=', '.join([a.define() for a in self.args]), + initializationList=self.getInitializationList(cgClass), + body=self.getBody()) + + +class ClassDestructor(ClassItem): + """ + Used for adding a destructor to a CGClass. + + inline should be True if the destructor should be marked inline. + + bodyInHeader should be True if the body should be placed in the class + declaration in the header. + + visibility determines the visibility of the destructor (public, + protected, private), defaults to private. + + body contains a string with the code for the destructor, defaults to empty. + + virtual determines whether the destructor is virtual, defaults to False. + """ + def __init__(self, inline=False, bodyInHeader=False, + visibility="private", body='', virtual=False): + self.inline = inline or bodyInHeader + self.bodyInHeader = bodyInHeader + self.body = body + self.virtual = virtual + ClassItem.__init__(self, None, visibility) + + def getDecorators(self, declaring): + decorators = [] + if self.virtual and declaring: + decorators.append('virtual') + if self.inline and declaring: + decorators.append('inline') + if decorators: + return ' '.join(decorators) + ' ' + return '' + + def getBody(self): + return self.body + + def declare(self, cgClass): + if self.bodyInHeader: + body = '\n{\n' + indent(self.getBody()) + '}\n' + else: + body = ';\n' + + return fill( + "${decorators}~${className}()${body}\n", + decorators=self.getDecorators(True), + className=cgClass.getNameString(), + body=body) + + def define(self, cgClass): + if self.bodyInHeader: + return '' + return fill( + """ + ${decorators} + ${className}::~${className}() + { + $*{body} + } + """, + decorators=self.getDecorators(False), + className=cgClass.getNameString(), + body=self.getBody()) + + +class ClassMember(ClassItem): + def __init__(self, name, type, visibility="private", static=False, + body=None, hasIgnoreInitCheckFlag=False): + self.type = type + self.static = static + self.body = body + self.hasIgnoreInitCheckFlag = hasIgnoreInitCheckFlag; + ClassItem.__init__(self, name, visibility) + + def declare(self, cgClass): + return '%s%s%s %s;\n' % ('static ' if self.static else '', + 'MOZ_INIT_OUTSIDE_CTOR ' + if self.hasIgnoreInitCheckFlag else '', + self.type, self.name) + + def define(self, cgClass): + if not self.static: + return '' + if self.body: + body = " = " + self.body + else: + body = "" + return '%s %s::%s%s;\n' % (self.type, cgClass.getNameString(), + self.name, body) + + +class ClassTypedef(ClassItem): + def __init__(self, name, type, visibility="public"): + self.type = type + ClassItem.__init__(self, name, visibility) + + def declare(self, cgClass): + return 'typedef %s %s;\n' % (self.type, self.name) + + def define(self, cgClass): + # Only goes in the header + return '' + + +class ClassEnum(ClassItem): + def __init__(self, name, entries, values=None, visibility="public"): + self.entries = entries + self.values = values + ClassItem.__init__(self, name, visibility) + + def declare(self, cgClass): + entries = [] + for i in range(0, len(self.entries)): + if not self.values or i >= len(self.values): + entry = '%s' % self.entries[i] + else: + entry = '%s = %s' % (self.entries[i], self.values[i]) + entries.append(entry) + name = '' if not self.name else ' ' + self.name + return 'enum%s\n{\n%s\n};\n' % (name, indent(',\n'.join(entries))) + + def define(self, cgClass): + # Only goes in the header + return '' + + +class ClassUnion(ClassItem): + def __init__(self, name, entries, visibility="public"): + self.entries = [entry + ";\n" for entry in entries] + ClassItem.__init__(self, name, visibility) + + def declare(self, cgClass): + return "union %s\n{\n%s\n};\n" % (self.name, indent(''.join(self.entries))) + + def define(self, cgClass): + # Only goes in the header + return '' + + +class CGClass(CGThing): + def __init__(self, name, bases=[], members=[], constructors=[], + destructor=None, methods=[], + typedefs=[], enums=[], unions=[], templateArgs=[], + templateSpecialization=[], isStruct=False, + disallowCopyConstruction=False, indent='', + decorators='', + extradeclarations='', + extradefinitions=''): + CGThing.__init__(self) + self.name = name + self.bases = bases + self.members = members + self.constructors = constructors + # We store our single destructor in a list, since all of our + # code wants lists of members. + self.destructors = [destructor] if destructor else [] + self.methods = methods + self.typedefs = typedefs + self.enums = enums + self.unions = unions + self.templateArgs = templateArgs + self.templateSpecialization = templateSpecialization + self.isStruct = isStruct + self.disallowCopyConstruction = disallowCopyConstruction + self.indent = indent + self.defaultVisibility = 'public' if isStruct else 'private' + self.decorators = decorators + self.extradeclarations = extradeclarations + self.extradefinitions = extradefinitions + + def getNameString(self): + className = self.name + if self.templateSpecialization: + className += '<%s>' % ', '.join([str(a) + for a in self.templateSpecialization]) + return className + + def declare(self): + result = '' + if self.templateArgs: + templateArgs = [a.declare() for a in self.templateArgs] + templateArgs = templateArgs[len(self.templateSpecialization):] + result += ('template <%s>\n' % + ','.join([str(a) for a in templateArgs])) + + type = 'struct' if self.isStruct else 'class' + + if self.templateSpecialization: + specialization = \ + '<%s>' % ', '.join([str(a) for a in self.templateSpecialization]) + else: + specialization = '' + + myself = '%s %s%s' % (type, self.name, specialization) + if self.decorators != '': + myself += " " + self.decorators + result += myself + + if self.bases: + inherit = ' : ' + result += inherit + # Grab our first base + baseItems = [CGGeneric(b.declare(self)) for b in self.bases] + bases = baseItems[:1] + # Indent the rest + bases.extend(CGIndenter(b, len(myself) + len(inherit)) + for b in baseItems[1:]) + result += ",\n".join(b.define() for b in bases) + + result += '\n{\n' + + result += self.extradeclarations + + def declareMembers(cgClass, memberList, defaultVisibility): + members = {'private': [], 'protected': [], 'public': []} + + for member in memberList: + members[member.visibility].append(member) + + if defaultVisibility == 'public': + order = ['public', 'protected', 'private'] + else: + order = ['private', 'protected', 'public'] + + result = '' + + lastVisibility = defaultVisibility + for visibility in order: + list = members[visibility] + if list: + if visibility != lastVisibility: + result += visibility + ':\n' + for member in list: + result += indent(member.declare(cgClass)) + lastVisibility = visibility + return (result, lastVisibility) + + if self.disallowCopyConstruction: + class DisallowedCopyConstructor(object): + def __init__(self): + self.visibility = "private" + + def declare(self, cgClass): + name = cgClass.getNameString() + return ("%s(const %s&) = delete;\n" + "void operator=(const %s&) = delete;\n" % (name, name, name)) + + disallowedCopyConstructors = [DisallowedCopyConstructor()] + else: + disallowedCopyConstructors = [] + + order = [self.enums, self.unions, + self.typedefs, self.members, + self.constructors + disallowedCopyConstructors, + self.destructors, self.methods] + + lastVisibility = self.defaultVisibility + pieces = [] + for memberList in order: + code, lastVisibility = declareMembers(self, memberList, lastVisibility) + + if code: + code = code.rstrip() + "\n" # remove extra blank lines at the end + pieces.append(code) + + result += '\n'.join(pieces) + result += '};\n' + result = indent(result, len(self.indent)) + return result + + def define(self): + def defineMembers(cgClass, memberList, itemCount, separator=''): + result = '' + for member in memberList: + if itemCount != 0: + result = result + separator + definition = member.define(cgClass) + if definition: + # Member variables would only produce empty lines here. + result += definition + itemCount += 1 + return (result, itemCount) + + order = [(self.members, ''), (self.constructors, '\n'), + (self.destructors, '\n'), (self.methods, '\n')] + + result = self.extradefinitions + itemCount = 0 + for memberList, separator in order: + memberString, itemCount = defineMembers(self, memberList, + itemCount, separator) + result = result + memberString + return result + + +class CGResolveOwnProperty(CGAbstractStaticMethod): + def __init__(self, descriptor): + args = [Argument('JSContext*', 'cx'), + Argument('JS::Handle<JSObject*>', 'wrapper'), + Argument('JS::Handle<JSObject*>', 'obj'), + Argument('JS::Handle<jsid>', 'id'), + Argument('JS::MutableHandle<JS::PropertyDescriptor>', 'desc'), + ] + CGAbstractStaticMethod.__init__(self, descriptor, "ResolveOwnProperty", + "bool", args) + + def definition_body(self): + return "return js::GetProxyHandler(obj)->getOwnPropertyDescriptor(cx, wrapper, id, desc);\n" + + +class CGResolveOwnPropertyViaResolve(CGAbstractBindingMethod): + """ + An implementation of Xray ResolveOwnProperty stuff for things that have a + resolve hook. + """ + def __init__(self, descriptor): + args = [Argument('JSContext*', 'cx'), + Argument('JS::Handle<JSObject*>', 'wrapper'), + Argument('JS::Handle<JSObject*>', 'obj'), + Argument('JS::Handle<jsid>', 'id'), + Argument('JS::MutableHandle<JS::PropertyDescriptor>', 'desc')] + CGAbstractBindingMethod.__init__(self, descriptor, + "ResolveOwnPropertyViaResolve", + args, getThisObj="", + callArgs="") + + def generate_code(self): + return CGGeneric(dedent(""" + { + // Since we're dealing with an Xray, do the resolve on the + // underlying object first. That gives it a chance to + // define properties on the actual object as needed, and + // then use the fact that it created the objects as a flag + // to avoid re-resolving the properties if someone deletes + // them. + JSAutoCompartment ac(cx, obj); + JS::Rooted<JS::PropertyDescriptor> objDesc(cx); + if (!self->DoResolve(cx, obj, id, &objDesc)) { + return false; + } + // If desc.value() is undefined, then the DoResolve call + // has already defined the property on the object. Don't + // try to also define it. + if (objDesc.object() && + !objDesc.value().isUndefined() && + !JS_DefinePropertyById(cx, obj, id, objDesc)) { + return false; + } + } + return self->DoResolve(cx, wrapper, id, desc); + """)) + + +class CGEnumerateOwnProperties(CGAbstractStaticMethod): + def __init__(self, descriptor): + args = [Argument('JSContext*', 'cx'), + Argument('JS::Handle<JSObject*>', 'wrapper'), + Argument('JS::Handle<JSObject*>', 'obj'), + Argument('JS::AutoIdVector&', 'props')] + CGAbstractStaticMethod.__init__(self, descriptor, + "EnumerateOwnProperties", "bool", args) + + def definition_body(self): + return "return js::GetProxyHandler(obj)->ownPropertyKeys(cx, wrapper, props);\n" + + +class CGEnumerateOwnPropertiesViaGetOwnPropertyNames(CGAbstractBindingMethod): + """ + An implementation of Xray EnumerateOwnProperties stuff for things + that have a resolve hook. + """ + def __init__(self, descriptor): + args = [Argument('JSContext*', 'cx'), + Argument('JS::Handle<JSObject*>', 'wrapper'), + Argument('JS::Handle<JSObject*>', 'obj'), + Argument('JS::AutoIdVector&', 'props')] + CGAbstractBindingMethod.__init__(self, descriptor, + "EnumerateOwnPropertiesViaGetOwnPropertyNames", + args, getThisObj="", + callArgs="") + + def generate_code(self): + return CGGeneric(dedent(""" + AutoTArray<nsString, 8> names; + binding_detail::FastErrorResult rv; + self->GetOwnPropertyNames(cx, names, rv); + if (rv.MaybeSetPendingException(cx)) { + return false; + } + // OK to pass null as "proxy" because it's ignored if + // shadowPrototypeProperties is true + return AppendNamedPropertyIds(cx, nullptr, names, true, props); + """)) + + +class CGPrototypeTraitsClass(CGClass): + def __init__(self, descriptor, indent=''): + templateArgs = [Argument('prototypes::ID', 'PrototypeID')] + templateSpecialization = ['prototypes::id::' + descriptor.name] + enums = [ClassEnum('', ['Depth'], + [descriptor.interface.inheritanceDepth()])] + CGClass.__init__(self, 'PrototypeTraits', indent=indent, + templateArgs=templateArgs, + templateSpecialization=templateSpecialization, + enums=enums, isStruct=True) + + def deps(self): + return set() + + +class CGClassForwardDeclare(CGThing): + def __init__(self, name, isStruct=False): + CGThing.__init__(self) + self.name = name + self.isStruct = isStruct + + def declare(self): + type = 'struct' if self.isStruct else 'class' + return '%s %s;\n' % (type, self.name) + + def define(self): + # Header only + return '' + + def deps(self): + return set() + + +class CGProxySpecialOperation(CGPerSignatureCall): + """ + Base class for classes for calling an indexed or named special operation + (don't use this directly, use the derived classes below). + + If checkFound is False, will just assert that the prop is found instead of + checking that it is before wrapping the value. + + resultVar: See the docstring for CGCallGenerator. + + foundVar: For getters and deleters, the generated code can also set a bool + variable, declared by the caller, if the given indexed or named property + already existed. If the caller wants this, it should pass the name of the + bool variable as the foundVar keyword argument to the constructor. The + caller is responsible for declaring the variable and initializing it to + false. + """ + def __init__(self, descriptor, operation, checkFound=True, + argumentHandleValue=None, resultVar=None, foundVar=None): + self.checkFound = checkFound + self.foundVar = foundVar or "found" + + nativeName = MakeNativeName(descriptor.binaryNameFor(operation)) + operation = descriptor.operations[operation] + assert len(operation.signatures()) == 1 + signature = operation.signatures()[0] + + returnType, arguments = signature + + # We pass len(arguments) as the final argument so that the + # CGPerSignatureCall won't do any argument conversion of its own. + CGPerSignatureCall.__init__(self, returnType, arguments, nativeName, + False, descriptor, operation, + len(arguments), resultVar=resultVar) + + if operation.isSetter() or operation.isCreator(): + # arguments[0] is the index or name of the item that we're setting. + argument = arguments[1] + info = getJSToNativeConversionInfo( + argument.type, descriptor, + treatNullAs=argument.treatNullAs, + sourceDescription=("value being assigned to %s setter" % + descriptor.interface.identifier.name)) + if argumentHandleValue is None: + argumentHandleValue = "desc.value()" + rootedValue = fill( + """ + JS::Rooted<JS::Value> rootedValue(cx, ${argumentHandleValue}); + """, + argumentHandleValue = argumentHandleValue) + templateValues = { + "declName": argument.identifier.name, + "holderName": argument.identifier.name + "_holder", + "val": argumentHandleValue, + "maybeMutableVal": "&rootedValue", + "obj": "obj", + "passedToJSImpl": "false" + } + self.cgRoot.prepend(instantiateJSToNativeConversion(info, templateValues)) + # rootedValue needs to come before the conversion, so we + # need to prepend it last. + self.cgRoot.prepend(CGGeneric(rootedValue)) + elif operation.isGetter() or operation.isDeleter(): + if foundVar is None: + self.cgRoot.prepend(CGGeneric("bool found = false;\n")) + + def getArguments(self): + args = [(a, a.identifier.name) for a in self.arguments] + if self.idlNode.isGetter() or self.idlNode.isDeleter(): + args.append((FakeArgument(BuiltinTypes[IDLBuiltinType.Types.boolean], + self.idlNode), + self.foundVar)) + return args + + def wrap_return_value(self): + if not self.idlNode.isGetter() or self.templateValues is None: + return "" + + wrap = CGGeneric(wrapForType(self.returnType, self.descriptor, self.templateValues)) + if self.checkFound: + wrap = CGIfWrapper(wrap, self.foundVar) + else: + wrap = CGList([CGGeneric("MOZ_ASSERT(" + self.foundVar + ");\n"), wrap]) + return "\n" + wrap.define() + + +class CGProxyIndexedOperation(CGProxySpecialOperation): + """ + Class to generate a call to an indexed operation. + + If doUnwrap is False, the caller is responsible for making sure a variable + named 'self' holds the C++ object somewhere where the code we generate + will see it. + + If checkFound is False, will just assert that the prop is found instead of + checking that it is before wrapping the value. + + resultVar: See the docstring for CGCallGenerator. + + foundVar: See the docstring for CGProxySpecialOperation. + """ + def __init__(self, descriptor, name, doUnwrap=True, checkFound=True, + argumentHandleValue=None, resultVar=None, foundVar=None): + self.doUnwrap = doUnwrap + CGProxySpecialOperation.__init__(self, descriptor, name, checkFound, + argumentHandleValue=argumentHandleValue, + resultVar=resultVar, + foundVar=foundVar) + + def define(self): + # Our first argument is the id we're getting. + argName = self.arguments[0].identifier.name + if argName == "index": + # We already have our index in a variable with that name + setIndex = "" + else: + setIndex = "uint32_t %s = index;\n" % argName + if self.doUnwrap: + unwrap = "%s* self = UnwrapProxy(proxy);\n" % self.descriptor.nativeType + else: + unwrap = "" + return (setIndex + unwrap + + CGProxySpecialOperation.define(self)) + + +class CGProxyIndexedGetter(CGProxyIndexedOperation): + """ + Class to generate a call to an indexed getter. If templateValues is not None + the returned value will be wrapped with wrapForType using templateValues. + + If doUnwrap is False, the caller is responsible for making sure a variable + named 'self' holds the C++ object somewhere where the code we generate + will see it. + + If checkFound is False, will just assert that the prop is found instead of + checking that it is before wrapping the value. + + foundVar: See the docstring for CGProxySpecialOperation. + """ + def __init__(self, descriptor, templateValues=None, doUnwrap=True, + checkFound=True, foundVar=None): + self.templateValues = templateValues + CGProxyIndexedOperation.__init__(self, descriptor, 'IndexedGetter', + doUnwrap, checkFound, foundVar=foundVar) + + +class CGProxyIndexedPresenceChecker(CGProxyIndexedGetter): + """ + Class to generate a call that checks whether an indexed property exists. + + For now, we just delegate to CGProxyIndexedGetter + + foundVar: See the docstring for CGProxySpecialOperation. + """ + def __init__(self, descriptor, foundVar): + CGProxyIndexedGetter.__init__(self, descriptor, foundVar=foundVar) + self.cgRoot.append(CGGeneric("(void)result;\n")) + + +class CGProxyIndexedSetter(CGProxyIndexedOperation): + """ + Class to generate a call to an indexed setter. + """ + def __init__(self, descriptor, argumentHandleValue=None): + CGProxyIndexedOperation.__init__(self, descriptor, 'IndexedSetter', + argumentHandleValue=argumentHandleValue) + + +class CGProxyNamedOperation(CGProxySpecialOperation): + """ + Class to generate a call to a named operation. + + 'value' is the jsval to use for the name; None indicates that it should be + gotten from the property id. + + resultVar: See the docstring for CGCallGenerator. + + foundVar: See the docstring for CGProxySpecialOperation. + """ + def __init__(self, descriptor, name, value=None, argumentHandleValue=None, + resultVar=None, foundVar=None): + CGProxySpecialOperation.__init__(self, descriptor, name, + argumentHandleValue=argumentHandleValue, + resultVar=resultVar, + foundVar=foundVar) + self.value = value + + def define(self): + # Our first argument is the id we're getting. + argName = self.arguments[0].identifier.name + if argName == "id": + # deal with the name collision + decls = "JS::Rooted<jsid> id_(cx, id);\n" + idName = "id_" + else: + decls = "" + idName = "id" + + decls += "binding_detail::FakeString %s;\n" % argName + + main = fill( + """ + ${nativeType}* self = UnwrapProxy(proxy); + $*{op} + """, + nativeType=self.descriptor.nativeType, + op=CGProxySpecialOperation.define(self)) + + if self.value is None: + return fill( + """ + $*{decls} + bool isSymbol; + if (!ConvertIdToString(cx, ${idName}, ${argName}, isSymbol)) { + return false; + } + if (!isSymbol) { + $*{main} + } + """, + decls=decls, + idName=idName, + argName=argName, + main=main) + + # Sadly, we have to set up nameVal even if we have an atom id, + # because we don't know for sure, and we can end up needing it + # so it needs to be higher up the stack. Using a Maybe here + # seems like probable overkill. + return fill( + """ + $*{decls} + JS::Rooted<JS::Value> nameVal(cx, ${value}); + if (!nameVal.isSymbol()) { + if (!ConvertJSValueToString(cx, nameVal, eStringify, eStringify, + ${argName})) { + return false; + } + $*{main} + } + """, + decls=decls, + value=self.value, + argName=argName, + main=main) + + +class CGProxyNamedGetter(CGProxyNamedOperation): + """ + Class to generate a call to an named getter. If templateValues is not None + the returned value will be wrapped with wrapForType using templateValues. + 'value' is the jsval to use for the name; None indicates that it should be + gotten from the property id. + + foundVar: See the docstring for CGProxySpecialOperation. + """ + def __init__(self, descriptor, templateValues=None, value=None, + foundVar=None): + self.templateValues = templateValues + CGProxyNamedOperation.__init__(self, descriptor, 'NamedGetter', value, + foundVar=foundVar) + + +class CGProxyNamedPresenceChecker(CGProxyNamedGetter): + """ + Class to generate a call that checks whether a named property exists. + + For now, we just delegate to CGProxyNamedGetter + + foundVar: See the docstring for CGProxySpecialOperation. + """ + def __init__(self, descriptor, foundVar=None): + CGProxyNamedGetter.__init__(self, descriptor, foundVar=foundVar) + self.cgRoot.append(CGGeneric("(void)result;\n")) + + +class CGProxyNamedSetter(CGProxyNamedOperation): + """ + Class to generate a call to a named setter. + """ + def __init__(self, descriptor, argumentHandleValue=None): + CGProxyNamedOperation.__init__(self, descriptor, 'NamedSetter', + argumentHandleValue=argumentHandleValue) + + +class CGProxyNamedDeleter(CGProxyNamedOperation): + """ + Class to generate a call to a named deleter. + + resultVar: See the docstring for CGCallGenerator. + + foundVar: See the docstring for CGProxySpecialOperation. + """ + def __init__(self, descriptor, resultVar=None, foundVar=None): + CGProxyNamedOperation.__init__(self, descriptor, 'NamedDeleter', + resultVar=resultVar, + foundVar=foundVar) + + +class CGProxyIsProxy(CGAbstractMethod): + def __init__(self, descriptor): + args = [Argument('JSObject*', 'obj')] + CGAbstractMethod.__init__(self, descriptor, "IsProxy", "bool", args, alwaysInline=True) + + def declare(self): + return "" + + def definition_body(self): + return "return js::IsProxy(obj) && js::GetProxyHandler(obj) == DOMProxyHandler::getInstance();\n" + + +class CGProxyUnwrap(CGAbstractMethod): + def __init__(self, descriptor): + args = [Argument('JSObject*', 'obj')] + CGAbstractMethod.__init__(self, descriptor, "UnwrapProxy", descriptor.nativeType + '*', args, alwaysInline=True) + + def declare(self): + return "" + + def definition_body(self): + return fill( + """ + MOZ_ASSERT(js::IsProxy(obj)); + if (js::GetProxyHandler(obj) != DOMProxyHandler::getInstance()) { + MOZ_ASSERT(xpc::WrapperFactory::IsXrayWrapper(obj)); + obj = js::UncheckedUnwrap(obj); + } + MOZ_ASSERT(IsProxy(obj)); + return static_cast<${type}*>(js::GetProxyPrivate(obj).toPrivate()); + """, + type=self.descriptor.nativeType) + + +class CGDOMJSProxyHandler_getOwnPropDescriptor(ClassMethod): + def __init__(self, descriptor): + args = [Argument('JSContext*', 'cx'), + Argument('JS::Handle<JSObject*>', 'proxy'), + Argument('JS::Handle<jsid>', 'id'), + Argument('bool', 'ignoreNamedProps'), + Argument('JS::MutableHandle<JS::PropertyDescriptor>', 'desc')] + ClassMethod.__init__(self, "getOwnPropDescriptor", "bool", args, + virtual=True, override=True, const=True) + self.descriptor = descriptor + + def getBody(self): + indexedGetter = self.descriptor.operations['IndexedGetter'] + indexedSetter = self.descriptor.operations['IndexedSetter'] + + if self.descriptor.supportsIndexedProperties(): + readonly = toStringBool(indexedSetter is None) + fillDescriptor = "FillPropertyDescriptor(desc, proxy, %s);\nreturn true;\n" % readonly + templateValues = { + 'jsvalRef': 'desc.value()', + 'jsvalHandle': 'desc.value()', + 'obj': 'proxy', + 'successCode': fillDescriptor + } + getIndexed = fill( + """ + uint32_t index = GetArrayIndexFromId(cx, id); + if (IsArrayIndex(index)) { + $*{callGetter} + } + + """, + callGetter=CGProxyIndexedGetter(self.descriptor, templateValues).define()) + else: + getIndexed = "" + + if self.descriptor.supportsNamedProperties(): + operations = self.descriptor.operations + readonly = toStringBool(operations['NamedSetter'] is None) + fillDescriptor = ( + "FillPropertyDescriptor(desc, proxy, %s, %s);\n" + "return true;\n" % + (readonly, + toStringBool(self.descriptor.namedPropertiesEnumerable))) + templateValues = {'jsvalRef': 'desc.value()', 'jsvalHandle': 'desc.value()', + 'obj': 'proxy', 'successCode': fillDescriptor} + + computeCondition = dedent(""" + bool hasOnProto; + if (!HasPropertyOnPrototype(cx, proxy, id, &hasOnProto)) { + return false; + } + callNamedGetter = !hasOnProto; + """) + if self.descriptor.interface.getExtendedAttribute('OverrideBuiltins'): + computeCondition = fill( + """ + if (!isXray) { + callNamedGetter = true; + } else { + $*{hasOnProto} + } + """, + hasOnProto=computeCondition) + + outerCondition = "!ignoreNamedProps" + if self.descriptor.supportsIndexedProperties(): + outerCondition = "!IsArrayIndex(index) && " + outerCondition + + namedGetCode = CGProxyNamedGetter(self.descriptor, + templateValues).define() + namedGet = fill(""" + bool callNamedGetter = false; + if (${outerCondition}) { + $*{computeCondition} + } + if (callNamedGetter) { + $*{namedGetCode} + } + """, + outerCondition=outerCondition, + computeCondition=computeCondition, + namedGetCode=namedGetCode) + namedGet += "\n" + else: + namedGet = "" + + return fill( + """ + bool isXray = xpc::WrapperFactory::IsXrayWrapper(proxy); + $*{getIndexed} + JS::Rooted<JSObject*> expando(cx); + if (!isXray && (expando = GetExpandoObject(proxy))) { + if (!JS_GetOwnPropertyDescriptorById(cx, expando, id, desc)) { + return false; + } + if (desc.object()) { + // Pretend the property lives on the wrapper. + desc.object().set(proxy); + return true; + } + } + + $*{namedGet} + desc.object().set(nullptr); + return true; + """, + getIndexed=getIndexed, + namedGet=namedGet) + + +class CGDOMJSProxyHandler_defineProperty(ClassMethod): + def __init__(self, descriptor): + # The usual convention is to name the ObjectOpResult out-parameter + # `result`, but that name is a bit overloaded around here. + args = [Argument('JSContext*', 'cx'), + Argument('JS::Handle<JSObject*>', 'proxy'), + Argument('JS::Handle<jsid>', 'id'), + Argument('JS::Handle<JS::PropertyDescriptor>', 'desc'), + Argument('JS::ObjectOpResult&', 'opresult'), + Argument('bool*', 'defined')] + ClassMethod.__init__(self, "defineProperty", "bool", args, virtual=True, override=True, const=True) + self.descriptor = descriptor + + def getBody(self): + set = "" + + indexedSetter = self.descriptor.operations['IndexedSetter'] + if indexedSetter: + if self.descriptor.operations['IndexedCreator'] is not indexedSetter: + raise TypeError("Can't handle creator that's different from the setter") + set += fill( + """ + uint32_t index = GetArrayIndexFromId(cx, id); + if (IsArrayIndex(index)) { + *defined = true; + $*{callSetter} + return opresult.succeed(); + } + """, + callSetter=CGProxyIndexedSetter(self.descriptor).define()) + elif self.descriptor.supportsIndexedProperties(): + # We allow untrusted content to prevent Xrays from setting a + # property if that property is an indexed property and we have no + # indexed setter. That's how the object would normally behave if + # you tried to set the property on it. That means we don't need to + # do anything special for Xrays here. + set += dedent( + """ + if (IsArrayIndex(GetArrayIndexFromId(cx, id))) { + *defined = true; + return opresult.failNoIndexedSetter(); + } + """) + + namedSetter = self.descriptor.operations['NamedSetter'] + if namedSetter: + if self.descriptor.hasUnforgeableMembers: + raise TypeError("Can't handle a named setter on an interface " + "that has unforgeables. Figure out how that " + "should work!") + if self.descriptor.operations['NamedCreator'] is not namedSetter: + raise TypeError("Can't handle creator that's different from the setter") + # If we support indexed properties, we won't get down here for + # indices, so we can just do our setter unconditionally here. + set += fill( + """ + *defined = true; + $*{callSetter} + + return opresult.succeed(); + """, + callSetter=CGProxyNamedSetter(self.descriptor).define()) + else: + # We allow untrusted content to prevent Xrays from setting a + # property if that property is already a named property on the + # object and we have no named setter. That's how the object would + # normally behave if you tried to set the property on it. That + # means we don't need to do anything special for Xrays here. + if self.descriptor.supportsNamedProperties(): + set += fill( + """ + bool found = false; + $*{presenceChecker} + + if (found) { + *defined = true; + return opresult.failNoNamedSetter(); + } + """, + presenceChecker=CGProxyNamedPresenceChecker(self.descriptor, foundVar="found").define()) + set += ("return mozilla::dom::DOMProxyHandler::defineProperty(%s);\n" % + ", ".join(a.name for a in self.args)) + return set + + +def getDeleterBody(descriptor, type, foundVar=None): + """ + type should be "Named" or "Indexed" + + The possible outcomes: + - an error happened (the emitted code returns false) + - own property not found (foundVar=false, deleteSucceeded=true) + - own property found and deleted (foundVar=true, deleteSucceeded=true) + - own property found but can't be deleted (foundVar=true, deleteSucceeded=false) + """ + assert type in ("Named", "Indexed") + deleter = descriptor.operations[type + 'Deleter'] + if deleter: + assert type == "Named" + assert foundVar is not None + if descriptor.hasUnforgeableMembers: + raise TypeError("Can't handle a deleter on an interface " + "that has unforgeables. Figure out how " + "that should work!") + # See if the deleter method is fallible. + t = deleter.signatures()[0][0] + if t.isPrimitive() and not t.nullable() and t.tag() == IDLType.Tags.bool: + # The deleter method has a boolean return value. When a + # property is found, the return value indicates whether it + # was successfully deleted. + setDS = fill( + """ + if (!${foundVar}) { + deleteSucceeded = true; + } + """, + foundVar=foundVar) + else: + # No boolean return value: if a property is found, + # deleting it always succeeds. + setDS = "deleteSucceeded = true;\n" + + body = (CGProxyNamedDeleter(descriptor, + resultVar="deleteSucceeded", + foundVar=foundVar).define() + + setDS) + elif getattr(descriptor, "supports%sProperties" % type)(): + presenceCheckerClass = globals()["CGProxy%sPresenceChecker" % type] + foundDecl = "" + if foundVar is None: + foundVar = "found" + foundDecl = "bool found = false;\n" + body = fill( + """ + $*{foundDecl} + $*{presenceChecker} + deleteSucceeded = !${foundVar}; + """, + foundDecl=foundDecl, + presenceChecker=presenceCheckerClass(descriptor, foundVar=foundVar).define(), + foundVar=foundVar) + else: + body = None + return body + + +class CGDeleteNamedProperty(CGAbstractStaticMethod): + def __init__(self, descriptor): + args = [Argument('JSContext*', 'cx'), + Argument('JS::Handle<JSObject*>', 'xray'), + Argument('JS::Handle<JSObject*>', 'proxy'), + Argument('JS::Handle<jsid>', 'id'), + Argument('JS::ObjectOpResult&', 'opresult')] + CGAbstractStaticMethod.__init__(self, descriptor, "DeleteNamedProperty", + "bool", args) + + def definition_body(self): + return fill( + """ + MOZ_ASSERT(xpc::WrapperFactory::IsXrayWrapper(xray)); + MOZ_ASSERT(js::IsProxy(proxy)); + MOZ_ASSERT(!xpc::WrapperFactory::IsXrayWrapper(proxy)); + JSAutoCompartment ac(cx, proxy); + bool deleteSucceeded; + bool found = false; + $*{namedBody} + if (!found || deleteSucceeded) { + return opresult.succeed(); + } + return opresult.failCantDelete(); + """, + namedBody=getDeleterBody(self.descriptor, "Named", foundVar="found")) + + +class CGDOMJSProxyHandler_delete(ClassMethod): + def __init__(self, descriptor): + args = [Argument('JSContext*', 'cx'), + Argument('JS::Handle<JSObject*>', 'proxy'), + Argument('JS::Handle<jsid>', 'id'), + Argument('JS::ObjectOpResult&', 'opresult')] + ClassMethod.__init__(self, "delete_", "bool", args, + virtual=True, override=True, const=True) + self.descriptor = descriptor + + def getBody(self): + delete = dedent(""" + MOZ_ASSERT(!xpc::WrapperFactory::IsXrayWrapper(proxy), + "Should not have a XrayWrapper here"); + + """) + + indexedBody = getDeleterBody(self.descriptor, "Indexed") + if indexedBody is not None: + delete += fill( + """ + uint32_t index = GetArrayIndexFromId(cx, id); + if (IsArrayIndex(index)) { + bool deleteSucceeded; + $*{indexedBody} + return deleteSucceeded ? opresult.succeed() : opresult.failCantDelete(); + } + """, + indexedBody=indexedBody) + + namedBody = getDeleterBody(self.descriptor, "Named", foundVar="found") + if namedBody is not None: + delete += dedent( + """ + // Try named delete only if the named property visibility + // algorithm says the property is visible. + bool tryNamedDelete = true; + { // Scope for expando + JS::Rooted<JSObject*> expando(cx, DOMProxyHandler::GetExpandoObject(proxy)); + if (expando) { + bool hasProp; + if (!JS_HasPropertyById(cx, expando, id, &hasProp)) { + return false; + } + tryNamedDelete = !hasProp; + } + } + """) + + if not self.descriptor.interface.getExtendedAttribute('OverrideBuiltins'): + delete += dedent( + """ + if (tryNamedDelete) { + bool hasOnProto; + if (!HasPropertyOnPrototype(cx, proxy, id, &hasOnProto)) { + return false; + } + tryNamedDelete = !hasOnProto; + } + """) + + # We always return above for an index id in the case when we support + # indexed properties, so we can just treat the id as a name + # unconditionally here. + delete += fill( + """ + if (tryNamedDelete) { + bool found = false; + bool deleteSucceeded; + $*{namedBody} + if (found) { + return deleteSucceeded ? opresult.succeed() : opresult.failCantDelete(); + } + } + """, + namedBody=namedBody) + + delete += dedent(""" + + return dom::DOMProxyHandler::delete_(cx, proxy, id, opresult); + """) + + return delete + + +class CGDOMJSProxyHandler_ownPropNames(ClassMethod): + def __init__(self, descriptor, ): + args = [Argument('JSContext*', 'cx'), + Argument('JS::Handle<JSObject*>', 'proxy'), + Argument('unsigned', 'flags'), + Argument('JS::AutoIdVector&', 'props')] + ClassMethod.__init__(self, "ownPropNames", "bool", args, + virtual=True, override=True, const=True) + self.descriptor = descriptor + + def getBody(self): + # Per spec, we do indices, then named props, then everything else + if self.descriptor.supportsIndexedProperties(): + addIndices = dedent(""" + + uint32_t length = UnwrapProxy(proxy)->Length(); + MOZ_ASSERT(int32_t(length) >= 0); + for (int32_t i = 0; i < int32_t(length); ++i) { + if (!props.append(INT_TO_JSID(i))) { + return false; + } + } + """) + else: + addIndices = "" + + if self.descriptor.supportsNamedProperties(): + if self.descriptor.interface.getExtendedAttribute('OverrideBuiltins'): + shadow = "!isXray" + else: + shadow = "false" + addNames = fill( + """ + nsTArray<nsString> names; + UnwrapProxy(proxy)->GetSupportedNames(names); + if (!AppendNamedPropertyIds(cx, proxy, names, ${shadow}, props)) { + return false; + } + """, + shadow=shadow) + if not self.descriptor.namedPropertiesEnumerable: + addNames = CGIfWrapper(CGGeneric(addNames), + "flags & JSITER_HIDDEN").define() + addNames = "\n" + addNames + else: + addNames = "" + + return fill( + """ + bool isXray = xpc::WrapperFactory::IsXrayWrapper(proxy); + $*{addIndices} + $*{addNames} + + JS::Rooted<JSObject*> expando(cx); + if (!isXray && (expando = DOMProxyHandler::GetExpandoObject(proxy)) && + !js::GetPropertyKeys(cx, expando, flags, &props)) { + return false; + } + + return true; + """, + addIndices=addIndices, + addNames=addNames) + + +class CGDOMJSProxyHandler_hasOwn(ClassMethod): + def __init__(self, descriptor): + args = [Argument('JSContext*', 'cx'), + Argument('JS::Handle<JSObject*>', 'proxy'), + Argument('JS::Handle<jsid>', 'id'), + Argument('bool*', 'bp')] + ClassMethod.__init__(self, "hasOwn", "bool", args, + virtual=True, override=True, const=True) + self.descriptor = descriptor + + def getBody(self): + if self.descriptor.supportsIndexedProperties(): + indexed = fill( + """ + uint32_t index = GetArrayIndexFromId(cx, id); + if (IsArrayIndex(index)) { + bool found = false; + $*{presenceChecker} + + *bp = found; + return true; + } + + """, + presenceChecker=CGProxyIndexedPresenceChecker(self.descriptor, foundVar="found").define()) + else: + indexed = "" + + if self.descriptor.supportsNamedProperties(): + # If we support indexed properties we always return above for index + # property names, so no need to check for those here. + named = fill( + """ + bool found = false; + $*{presenceChecker} + + *bp = found; + """, + presenceChecker=CGProxyNamedPresenceChecker(self.descriptor, foundVar="found").define()) + if not self.descriptor.interface.getExtendedAttribute('OverrideBuiltins'): + named = fill( + """ + bool hasOnProto; + if (!HasPropertyOnPrototype(cx, proxy, id, &hasOnProto)) { + return false; + } + if (!hasOnProto) { + $*{protoLacksProperty} + return true; + } + """, + protoLacksProperty=named) + named += "*bp = false;\n" + else: + named += "\n" + else: + named = "*bp = false;\n" + + return fill( + """ + MOZ_ASSERT(!xpc::WrapperFactory::IsXrayWrapper(proxy), + "Should not have a XrayWrapper here"); + + $*{indexed} + + JS::Rooted<JSObject*> expando(cx, GetExpandoObject(proxy)); + if (expando) { + bool b = true; + bool ok = JS_HasPropertyById(cx, expando, id, &b); + *bp = !!b; + if (!ok || *bp) { + return ok; + } + } + + $*{named} + return true; + """, + indexed=indexed, + named=named) + + +class CGDOMJSProxyHandler_get(ClassMethod): + def __init__(self, descriptor): + args = [Argument('JSContext*', 'cx'), + Argument('JS::Handle<JSObject*>', 'proxy'), + Argument('JS::Handle<JS::Value>', 'receiver'), + Argument('JS::Handle<jsid>', 'id'), + Argument('JS::MutableHandle<JS::Value>', 'vp')] + ClassMethod.__init__(self, "get", "bool", args, + virtual=True, override=True, const=True) + self.descriptor = descriptor + + def getBody(self): + getUnforgeableOrExpando = dedent(""" + { // Scope for expando + JS::Rooted<JSObject*> expando(cx, DOMProxyHandler::GetExpandoObject(proxy)); + if (expando) { + bool hasProp; + if (!JS_HasPropertyById(cx, expando, id, &hasProp)) { + return false; + } + + if (hasProp) { + // Forward the get to the expando object, but our receiver is whatever our + // receiver is. + return JS_ForwardGetPropertyTo(cx, expando, id, receiver, vp); + } + } + } + """) + + templateValues = {'jsvalRef': 'vp', 'jsvalHandle': 'vp', 'obj': 'proxy'} + + if self.descriptor.supportsIndexedProperties(): + getIndexedOrExpando = fill( + """ + uint32_t index = GetArrayIndexFromId(cx, id); + if (IsArrayIndex(index)) { + $*{callGetter} + // Even if we don't have this index, we don't forward the + // get on to our expando object. + } else { + $*{getUnforgeableOrExpando} + } + """, + callGetter=CGProxyIndexedGetter(self.descriptor, templateValues).define(), + getUnforgeableOrExpando=getUnforgeableOrExpando) + else: + getIndexedOrExpando = getUnforgeableOrExpando + + if self.descriptor.supportsNamedProperties(): + getNamed = CGProxyNamedGetter(self.descriptor, templateValues) + if self.descriptor.supportsIndexedProperties(): + getNamed = CGIfWrapper(getNamed, "!IsArrayIndex(index)") + getNamed = getNamed.define() + "\n" + else: + getNamed = "" + + getOnPrototype = dedent(""" + bool foundOnPrototype; + if (!GetPropertyOnPrototype(cx, proxy, receiver, id, &foundOnPrototype, vp)) { + return false; + } + + if (foundOnPrototype) { + return true; + } + + """) + if self.descriptor.interface.getExtendedAttribute('OverrideBuiltins'): + getNamed = getNamed + getOnPrototype + else: + getNamed = getOnPrototype + getNamed + + return fill( + """ + MOZ_ASSERT(!xpc::WrapperFactory::IsXrayWrapper(proxy), + "Should not have a XrayWrapper here"); + + $*{indexedOrExpando} + + $*{named} + vp.setUndefined(); + return true; + """, + indexedOrExpando=getIndexedOrExpando, + named=getNamed) + + +class CGDOMJSProxyHandler_setCustom(ClassMethod): + def __init__(self, descriptor): + args = [Argument('JSContext*', 'cx'), + Argument('JS::Handle<JSObject*>', 'proxy'), + Argument('JS::Handle<jsid>', 'id'), + Argument('JS::Handle<JS::Value>', 'v'), + Argument('bool*', 'done')] + ClassMethod.__init__(self, "setCustom", "bool", args, virtual=True, override=True, const=True) + self.descriptor = descriptor + + def getBody(self): + assertion = ("MOZ_ASSERT(!xpc::WrapperFactory::IsXrayWrapper(proxy),\n" + ' "Should not have a XrayWrapper here");\n') + + # Correctness first. If we have a NamedSetter and [OverrideBuiltins], + # always call the NamedSetter and never do anything else. + namedSetter = self.descriptor.operations['NamedSetter'] + if (namedSetter is not None and + self.descriptor.interface.getExtendedAttribute('OverrideBuiltins')): + # Check assumptions. + if self.descriptor.supportsIndexedProperties(): + raise ValueError("In interface " + self.descriptor.name + ": " + + "Can't cope with [OverrideBuiltins] and an indexed getter") + if self.descriptor.operations['NamedCreator'] is not namedSetter: + raise ValueError("In interface " + self.descriptor.name + ": " + + "Can't cope with named setter that is not also a named creator") + if self.descriptor.hasUnforgeableMembers: + raise ValueError("In interface " + self.descriptor.name + ": " + + "Can't cope with [OverrideBuiltins] and unforgeable members") + + callSetter = CGProxyNamedSetter(self.descriptor, argumentHandleValue="v") + return (assertion + + callSetter.define() + + "*done = true;\n" + "return true;\n") + + # As an optimization, if we are going to call an IndexedSetter, go + # ahead and call it and have done. + indexedSetter = self.descriptor.operations['IndexedSetter'] + if indexedSetter is not None: + if self.descriptor.operations['IndexedCreator'] is not indexedSetter: + raise ValueError("In interface " + self.descriptor.name + ": " + + "Can't cope with indexed setter that is not " + + "also an indexed creator") + setIndexed = fill( + """ + uint32_t index = GetArrayIndexFromId(cx, id); + if (IsArrayIndex(index)) { + $*{callSetter} + *done = true; + return true; + } + + """, + callSetter=CGProxyIndexedSetter(self.descriptor, + argumentHandleValue="v").define()) + else: + setIndexed = "" + + return (assertion + + setIndexed + + "*done = false;\n" + "return true;\n") + + +class CGDOMJSProxyHandler_className(ClassMethod): + def __init__(self, descriptor): + args = [Argument('JSContext*', 'cx'), + Argument('JS::Handle<JSObject*>', 'proxy')] + ClassMethod.__init__(self, "className", "const char*", args, + virtual=True, override=True, const=True) + self.descriptor = descriptor + + def getBody(self): + return 'return "%s";\n' % self.descriptor.name + + +class CGDOMJSProxyHandler_finalizeInBackground(ClassMethod): + def __init__(self, descriptor): + args = [Argument('const JS::Value&', 'priv')] + ClassMethod.__init__(self, "finalizeInBackground", "bool", args, + virtual=True, override=True, const=True) + self.descriptor = descriptor + + def getBody(self): + return "return false;\n" + + +class CGDOMJSProxyHandler_finalize(ClassMethod): + def __init__(self, descriptor): + args = [Argument('JSFreeOp*', 'fop'), Argument('JSObject*', 'proxy')] + ClassMethod.__init__(self, "finalize", "void", args, + virtual=True, override=True, const=True) + self.descriptor = descriptor + + def getBody(self): + return (("%s* self = UnwrapPossiblyNotInitializedDOMObject<%s>(proxy);\n" % + (self.descriptor.nativeType, self.descriptor.nativeType)) + + finalizeHook(self.descriptor, FINALIZE_HOOK_NAME, self.args[0].name).define()) + + +class CGDOMJSProxyHandler_getElements(ClassMethod): + def __init__(self, descriptor): + assert descriptor.supportsIndexedProperties() + + args = [Argument('JSContext*', 'cx'), + Argument('JS::Handle<JSObject*>', 'proxy'), + Argument('uint32_t', 'begin'), + Argument('uint32_t', 'end'), + Argument('js::ElementAdder*', 'adder')] + ClassMethod.__init__(self, "getElements", "bool", args, virtual=True, override=True, const=True) + self.descriptor = descriptor + + def getBody(self): + # Just like ownPropertyKeys we'll assume that we have no holes, so + # we have all properties from 0 to length. If that ever changes + # (unlikely), we'll need to do something a bit more clever with how we + # forward on to our ancestor. + + templateValues = { + 'jsvalRef': 'temp', + 'jsvalHandle': '&temp', + 'obj': 'proxy', + 'successCode': ("if (!adder->append(cx, temp)) return false;\n" + "continue;\n") + } + get = CGProxyIndexedGetter(self.descriptor, templateValues, False, False).define() + + return fill( + """ + JS::Rooted<JS::Value> temp(cx); + MOZ_ASSERT(!xpc::WrapperFactory::IsXrayWrapper(proxy), + "Should not have a XrayWrapper here"); + + ${nativeType}* self = UnwrapProxy(proxy); + uint32_t length = self->Length(); + // Compute the end of the indices we'll get ourselves + uint32_t ourEnd = std::max(begin, std::min(end, length)); + + for (uint32_t index = begin; index < ourEnd; ++index) { + $*{get} + } + + if (end > ourEnd) { + JS::Rooted<JSObject*> proto(cx); + if (!js::GetObjectProto(cx, proxy, &proto)) { + return false; + } + return js::GetElementsWithAdder(cx, proto, proxy, ourEnd, end, adder); + } + + return true; + """, + nativeType=self.descriptor.nativeType, + get=get) + + +class CGDOMJSProxyHandler_getInstance(ClassMethod): + def __init__(self): + ClassMethod.__init__(self, "getInstance", "const DOMProxyHandler*", [], static=True) + + def getBody(self): + return dedent(""" + static const DOMProxyHandler instance; + return &instance; + """) + + +class CGDOMJSProxyHandler_getPrototypeIfOrdinary(ClassMethod): + def __init__(self): + args = [Argument('JSContext*', 'cx'), + Argument('JS::Handle<JSObject*>', 'proxy'), + Argument('bool*', 'isOrdinary'), + Argument('JS::MutableHandle<JSObject*>', 'proto')] + + ClassMethod.__init__(self, "getPrototypeIfOrdinary", "bool", args, + virtual=True, override=True, const=True) + + def getBody(self): + return dedent(""" + *isOrdinary = false; + return true; + """) + + +class CGDOMJSProxyHandler_call(ClassMethod): + def __init__(self): + args = [Argument('JSContext*', 'cx'), + Argument('JS::Handle<JSObject*>', 'proxy'), + Argument('const JS::CallArgs&', 'args')] + + ClassMethod.__init__(self, "call", "bool", args, virtual=True, override=True, const=True) + + def getBody(self): + return fill( + """ + return js::ForwardToNative(cx, ${legacyCaller}, args); + """, + legacyCaller=LEGACYCALLER_HOOK_NAME) + + +class CGDOMJSProxyHandler_isCallable(ClassMethod): + def __init__(self): + ClassMethod.__init__(self, "isCallable", "bool", + [Argument('JSObject*', 'obj')], + virtual=True, override=True, const=True) + + def getBody(self): + return dedent(""" + return true; + """) + + +class CGDOMJSProxyHandler(CGClass): + def __init__(self, descriptor): + assert (descriptor.supportsIndexedProperties() or + descriptor.supportsNamedProperties() or + descriptor.hasNonOrdinaryGetPrototypeOf()) + methods = [CGDOMJSProxyHandler_getOwnPropDescriptor(descriptor), + CGDOMJSProxyHandler_defineProperty(descriptor), + ClassUsingDeclaration("mozilla::dom::DOMProxyHandler", + "defineProperty"), + CGDOMJSProxyHandler_ownPropNames(descriptor), + CGDOMJSProxyHandler_hasOwn(descriptor), + CGDOMJSProxyHandler_get(descriptor), + CGDOMJSProxyHandler_className(descriptor), + CGDOMJSProxyHandler_finalizeInBackground(descriptor), + CGDOMJSProxyHandler_finalize(descriptor), + CGDOMJSProxyHandler_getInstance(), + CGDOMJSProxyHandler_delete(descriptor)] + constructors = [ + ClassConstructor( + [], + constexpr=True, + visibility="public", + explicit=True) + ] + + if descriptor.supportsIndexedProperties(): + methods.append(CGDOMJSProxyHandler_getElements(descriptor)) + if (descriptor.operations['IndexedSetter'] is not None or + (descriptor.operations['NamedSetter'] is not None and + descriptor.interface.getExtendedAttribute('OverrideBuiltins'))): + methods.append(CGDOMJSProxyHandler_setCustom(descriptor)) + if descriptor.hasNonOrdinaryGetPrototypeOf(): + methods.append(CGDOMJSProxyHandler_getPrototypeIfOrdinary()) + if descriptor.operations['LegacyCaller']: + methods.append(CGDOMJSProxyHandler_call()) + methods.append(CGDOMJSProxyHandler_isCallable()) + + if descriptor.interface.getExtendedAttribute('OverrideBuiltins'): + parentClass = 'ShadowingDOMProxyHandler' + else: + parentClass = 'mozilla::dom::DOMProxyHandler' + + CGClass.__init__(self, 'DOMProxyHandler', + bases=[ClassBase(parentClass)], + constructors=constructors, + methods=methods) + + +class CGDOMJSProxyHandlerDeclarer(CGThing): + """ + A class for declaring a DOMProxyHandler. + """ + def __init__(self, handlerThing): + self.handlerThing = handlerThing + + def declare(self): + # Our class declaration should happen when we're defining + return "" + + def define(self): + return self.handlerThing.declare() + + +class CGDOMJSProxyHandlerDefiner(CGThing): + """ + A class for defining a DOMProxyHandler. + """ + def __init__(self, handlerThing): + self.handlerThing = handlerThing + + def declare(self): + return "" + + def define(self): + return self.handlerThing.define() + + +def stripTrailingWhitespace(text): + tail = '\n' if text.endswith('\n') else '' + lines = text.splitlines() + return '\n'.join(line.rstrip() for line in lines) + tail + + +class MemberProperties: + def __init__(self): + self.isGenericMethod = False + self.isCrossOriginMethod = False + self.isPromiseReturningMethod = False + self.isGenericGetter = False + self.isLenientGetter = False + self.isCrossOriginGetter = False + self.isGenericSetter = False + self.isLenientSetter = False + self.isCrossOriginSetter = False + self.isJsonifier = False + + +def memberProperties(m, descriptor): + props = MemberProperties() + if m.isMethod(): + if m == descriptor.operations['Jsonifier']: + props.isGenericMethod = descriptor.needsSpecialGenericOps() + props.isJsonifier = True + elif (not m.isIdentifierLess() or m == descriptor.operations['Stringifier']): + if not m.isStatic() and descriptor.interface.hasInterfacePrototypeObject(): + if descriptor.needsSpecialGenericOps(): + if m.returnsPromise(): + props.isPromiseReturningMethod = True + else: + props.isGenericMethod = True + if m.getExtendedAttribute("CrossOriginCallable"): + props.isCrossOriginMethod = True + elif m.isAttr(): + if not m.isStatic() and descriptor.interface.hasInterfacePrototypeObject(): + if m.hasLenientThis(): + props.isLenientGetter = True + elif m.getExtendedAttribute("CrossOriginReadable"): + props.isCrossOriginGetter = True + elif descriptor.needsSpecialGenericOps(): + props.isGenericGetter = True + if not m.readonly: + if not m.isStatic() and descriptor.interface.hasInterfacePrototypeObject(): + if m.hasLenientThis(): + props.isLenientSetter = True + elif IsCrossOriginWritable(m, descriptor): + props.isCrossOriginSetter = True + elif descriptor.needsSpecialGenericOps(): + props.isGenericSetter = True + elif m.getExtendedAttribute("PutForwards"): + if IsCrossOriginWritable(m, descriptor): + props.isCrossOriginSetter = True + elif descriptor.needsSpecialGenericOps(): + props.isGenericSetter = True + elif (m.getExtendedAttribute("Replaceable") or + m.getExtendedAttribute("LenientSetter")): + if descriptor.needsSpecialGenericOps(): + props.isGenericSetter = True + + return props + + +class CGDescriptor(CGThing): + def __init__(self, descriptor): + CGThing.__init__(self) + + assert not descriptor.concrete or descriptor.interface.hasInterfacePrototypeObject() + + self._deps = descriptor.interface.getDeps() + + cgThings = [] + cgThings.append(CGGeneric(declare="typedef %s NativeType;\n" % + descriptor.nativeType)) + parent = descriptor.interface.parent + if parent: + cgThings.append(CGGeneric("static_assert(IsRefcounted<NativeType>::value == IsRefcounted<%s::NativeType>::value,\n" + " \"Can't inherit from an interface with a different ownership model.\");\n" % + toBindingNamespace(descriptor.parentPrototypeName))) + + # These are set to true if at least one non-static + # method/getter/setter or jsonifier exist on the interface. + (hasMethod, hasGetter, hasLenientGetter, hasSetter, hasLenientSetter, + hasPromiseReturningMethod) = False, False, False, False, False, False + jsonifierMethod = None + crossOriginMethods, crossOriginGetters, crossOriginSetters = set(), set(), set() + unscopableNames = list() + for n in descriptor.interface.namedConstructors: + cgThings.append(CGClassConstructor(descriptor, n, + NamedConstructorName(n))) + for m in descriptor.interface.members: + if m.isMethod() and m.identifier.name == 'queryInterface': + continue + + props = memberProperties(m, descriptor) + + if m.isMethod(): + if m.getExtendedAttribute("Unscopable"): + assert not m.isStatic() + unscopableNames.append(m.identifier.name) + if props.isJsonifier: + jsonifierMethod = m + elif not m.isIdentifierLess() or m == descriptor.operations['Stringifier']: + if m.isStatic(): + assert descriptor.interface.hasInterfaceObject() + cgThings.append(CGStaticMethod(descriptor, m)) + if m.returnsPromise(): + cgThings.append(CGStaticMethodJitinfo(m)) + elif descriptor.interface.hasInterfacePrototypeObject(): + specializedMethod = CGSpecializedMethod(descriptor, m) + cgThings.append(specializedMethod) + if m.returnsPromise(): + cgThings.append(CGMethodPromiseWrapper(descriptor, specializedMethod)) + cgThings.append(CGMemberJITInfo(descriptor, m)) + if props.isCrossOriginMethod: + crossOriginMethods.add(m.identifier.name) + # If we've hit the maplike/setlike member itself, go ahead and + # generate its convenience functions. + elif m.isMaplikeOrSetlike(): + cgThings.append(CGMaplikeOrSetlikeHelperGenerator(descriptor, m)) + elif m.isAttr(): + if m.stringifier: + raise TypeError("Stringifier attributes not supported yet. " + "See bug 824857.\n" + "%s" % m.location) + if m.getExtendedAttribute("Unscopable"): + assert not m.isStatic() + unscopableNames.append(m.identifier.name) + if m.isStatic(): + assert descriptor.interface.hasInterfaceObject() + cgThings.append(CGStaticGetter(descriptor, m)) + elif descriptor.interface.hasInterfacePrototypeObject(): + if isNonExposedNavigatorObjectGetter(m, descriptor): + continue + cgThings.append(CGSpecializedGetter(descriptor, m)) + if props.isCrossOriginGetter: + crossOriginGetters.add(m.identifier.name) + if not m.readonly: + if m.isStatic(): + assert descriptor.interface.hasInterfaceObject() + cgThings.append(CGStaticSetter(descriptor, m)) + elif descriptor.interface.hasInterfacePrototypeObject(): + cgThings.append(CGSpecializedSetter(descriptor, m)) + if props.isCrossOriginSetter: + crossOriginSetters.add(m.identifier.name) + elif m.getExtendedAttribute("PutForwards"): + cgThings.append(CGSpecializedForwardingSetter(descriptor, m)) + if props.isCrossOriginSetter: + crossOriginSetters.add(m.identifier.name) + elif m.getExtendedAttribute("Replaceable"): + cgThings.append(CGSpecializedReplaceableSetter(descriptor, m)) + elif m.getExtendedAttribute("LenientSetter"): + cgThings.append(CGSpecializedLenientSetter(descriptor, m)) + if (not m.isStatic() and + descriptor.interface.hasInterfacePrototypeObject()): + cgThings.append(CGMemberJITInfo(descriptor, m)) + + hasMethod = hasMethod or props.isGenericMethod + hasPromiseReturningMethod = (hasPromiseReturningMethod or + props.isPromiseReturningMethod) + hasGetter = hasGetter or props.isGenericGetter + hasLenientGetter = hasLenientGetter or props.isLenientGetter + hasSetter = hasSetter or props.isGenericSetter + hasLenientSetter = hasLenientSetter or props.isLenientSetter + + if jsonifierMethod: + cgThings.append(CGJsonifyAttributesMethod(descriptor)) + cgThings.append(CGJsonifierMethod(descriptor, jsonifierMethod)) + cgThings.append(CGMemberJITInfo(descriptor, jsonifierMethod)) + if hasMethod: + cgThings.append(CGGenericMethod(descriptor)) + if hasPromiseReturningMethod: + cgThings.append(CGGenericPromiseReturningMethod(descriptor)) + if len(crossOriginMethods): + cgThings.append(CGGenericMethod(descriptor, + allowCrossOriginThis=True)) + if hasGetter: + cgThings.append(CGGenericGetter(descriptor)) + if hasLenientGetter: + cgThings.append(CGGenericGetter(descriptor, lenientThis=True)) + if len(crossOriginGetters): + cgThings.append(CGGenericGetter(descriptor, + allowCrossOriginThis=True)) + if hasSetter: + cgThings.append(CGGenericSetter(descriptor)) + if hasLenientSetter: + cgThings.append(CGGenericSetter(descriptor, lenientThis=True)) + if len(crossOriginSetters): + cgThings.append(CGGenericSetter(descriptor, + allowCrossOriginThis=True)) + + if descriptor.interface.isNavigatorProperty(): + cgThings.append(CGConstructNavigatorObject(descriptor)) + + if descriptor.concrete and not descriptor.proxy: + if wantsAddProperty(descriptor): + cgThings.append(CGAddPropertyHook(descriptor)) + + # Always have a finalize hook, regardless of whether the class + # wants a custom hook. + cgThings.append(CGClassFinalizeHook(descriptor)) + + if descriptor.concrete and descriptor.wrapperCache: + cgThings.append(CGClassObjectMovedHook(descriptor)) + + # Generate the _ClearCachedFooValue methods before the property arrays that use them. + if descriptor.interface.isJSImplemented(): + for m in clearableCachedAttrs(descriptor): + cgThings.append(CGJSImplClearCachedValueMethod(descriptor, m)) + + # Need to output our generated hasinstance bits before + # PropertyArrays tries to use them. + if (descriptor.interface.hasInterfaceObject() and + NeedsGeneratedHasInstance(descriptor)): + cgThings.append(CGHasInstanceHook(descriptor)) + + properties = PropertyArrays(descriptor) + cgThings.append(CGGeneric(define=str(properties))) + cgThings.append(CGNativeProperties(descriptor, properties)) + + if descriptor.interface.hasInterfaceObject(): + cgThings.append(CGClassConstructor(descriptor, + descriptor.interface.ctor())) + cgThings.append(CGInterfaceObjectJSClass(descriptor, properties)) + cgThings.append(CGNamedConstructors(descriptor)) + + cgThings.append(CGLegacyCallHook(descriptor)) + if descriptor.interface.getExtendedAttribute("NeedResolve"): + cgThings.append(CGResolveHook(descriptor)) + cgThings.append(CGMayResolveHook(descriptor)) + cgThings.append(CGEnumerateHook(descriptor)) + + if descriptor.hasNamedPropertiesObject: + cgThings.append(CGGetNamedPropertiesObjectMethod(descriptor)) + + if descriptor.interface.hasInterfacePrototypeObject(): + cgThings.append(CGPrototypeJSClass(descriptor, properties)) + + if ((descriptor.interface.hasInterfaceObject() or descriptor.interface.isNavigatorProperty()) and + not descriptor.interface.isExternal() and + descriptor.isExposedConditionally()): + cgThings.append(CGConstructorEnabled(descriptor)) + + if descriptor.registersGlobalNamesOnWindow: + cgThings.append(CGDefineDOMInterfaceMethod(descriptor)) + + if (descriptor.interface.hasMembersInSlots() and + descriptor.interface.hasChildInterfaces()): + raise TypeError("We don't support members in slots on " + "non-leaf interfaces like %s" % + descriptor.interface.identifier.name) + + if descriptor.concrete: + if descriptor.proxy: + if descriptor.interface.totalMembersInSlots != 0: + raise TypeError("We can't have extra reserved slots for " + "proxy interface %s" % + descriptor.interface.identifier.name) + cgThings.append(CGGeneric(fill( + """ + static_assert(IsBaseOf<nsISupports, ${nativeType} >::value, + "We don't support non-nsISupports native classes for " + "proxy-based bindings yet"); + + """, + nativeType=descriptor.nativeType))) + if not descriptor.wrapperCache: + raise TypeError("We need a wrappercache to support expandos for proxy-based " + "bindings (" + descriptor.name + ")") + handlerThing = CGDOMJSProxyHandler(descriptor) + cgThings.append(CGDOMJSProxyHandlerDeclarer(handlerThing)) + cgThings.append(CGProxyIsProxy(descriptor)) + cgThings.append(CGProxyUnwrap(descriptor)) + cgThings.append(CGDOMJSProxyHandlerDefiner(handlerThing)) + cgThings.append(CGDOMProxyJSClass(descriptor)) + else: + cgThings.append(CGDOMJSClass(descriptor)) + cgThings.append(CGGetJSClassMethod(descriptor)) + if descriptor.interface.hasMembersInSlots(): + cgThings.append(CGUpdateMemberSlotsMethod(descriptor)) + + if descriptor.isGlobal(): + assert descriptor.wrapperCache + cgThings.append(CGWrapGlobalMethod(descriptor, properties)) + elif descriptor.wrapperCache: + cgThings.append(CGWrapWithCacheMethod(descriptor, properties)) + cgThings.append(CGWrapMethod(descriptor)) + else: + cgThings.append(CGWrapNonWrapperCacheMethod(descriptor, + properties)) + + # Set up our Xray callbacks as needed. This needs to come + # after we have our DOMProxyHandler defined. + if descriptor.wantsXrays: + if descriptor.concrete and descriptor.proxy: + cgThings.append(CGResolveOwnProperty(descriptor)) + cgThings.append(CGEnumerateOwnProperties(descriptor)) + if descriptor.needsXrayNamedDeleterHook(): + cgThings.append(CGDeleteNamedProperty(descriptor)) + elif descriptor.needsXrayResolveHooks(): + cgThings.append(CGResolveOwnPropertyViaResolve(descriptor)) + cgThings.append(CGEnumerateOwnPropertiesViaGetOwnPropertyNames(descriptor)) + if descriptor.wantsXrayExpandoClass: + cgThings.append(CGXrayExpandoJSClass(descriptor)) + + # Now that we have our ResolveOwnProperty/EnumerateOwnProperties stuff + # done, set up our NativePropertyHooks. + cgThings.append(CGNativePropertyHooks(descriptor, properties)) + + # If we're not wrappercached, we don't know how to clear our + # cached values, since we can't get at the JSObject. + if descriptor.wrapperCache: + cgThings.extend(CGClearCachedValueMethod(descriptor, m) for + m in clearableCachedAttrs(descriptor)) + + haveUnscopables = (len(unscopableNames) != 0 and + descriptor.interface.hasInterfacePrototypeObject()) + if haveUnscopables: + cgThings.append( + CGList([CGGeneric("static const char* const unscopableNames[] = {"), + CGIndenter(CGList([CGGeneric('"%s"' % name) for + name in unscopableNames] + + [CGGeneric("nullptr")], ",\n")), + CGGeneric("};\n")], "\n")) + + # CGCreateInterfaceObjectsMethod needs to come after our + # CGDOMJSClass and unscopables, if any. + cgThings.append(CGCreateInterfaceObjectsMethod(descriptor, properties, + haveUnscopables)) + + # CGGetProtoObjectMethod and CGGetConstructorObjectMethod need + # to come after CGCreateInterfaceObjectsMethod. + if descriptor.interface.hasInterfacePrototypeObject(): + cgThings.append(CGGetProtoObjectHandleMethod(descriptor)) + if descriptor.interface.hasChildInterfaces(): + cgThings.append(CGGetProtoObjectMethod(descriptor)) + if descriptor.interface.hasInterfaceObject(): + cgThings.append(CGGetConstructorObjectHandleMethod(descriptor)) + cgThings.append(CGGetConstructorObjectMethod(descriptor)) + + # See whether we need we need to generate an IsPermitted method + if crossOriginGetters or crossOriginSetters or crossOriginMethods: + cgThings.append(CGIsPermittedMethod(descriptor, + crossOriginGetters, + crossOriginSetters, + crossOriginMethods)) + + cgThings = CGList((CGIndenter(t, declareOnly=True) for t in cgThings), "\n") + cgThings = CGWrapper(cgThings, pre='\n', post='\n') + self.cgRoot = CGWrapper(CGNamespace(toBindingNamespace(descriptor.name), + cgThings), + post='\n') + + def declare(self): + return self.cgRoot.declare() + + def define(self): + return self.cgRoot.define() + + def deps(self): + return self._deps + + +class CGNamespacedEnum(CGThing): + def __init__(self, namespace, enumName, names, values, comment=""): + + if not values: + values = [] + + # Account for explicit enum values. + entries = [] + for i in range(0, len(names)): + if len(values) > i and values[i] is not None: + entry = "%s = %s" % (names[i], values[i]) + else: + entry = names[i] + entries.append(entry) + + # Append a Count. + entries.append('_' + enumName + '_Count') + + # Indent. + entries = [' ' + e for e in entries] + + # Build the enum body. + enumstr = comment + 'enum %s : uint16_t\n{\n%s\n};\n' % (enumName, ',\n'.join(entries)) + curr = CGGeneric(declare=enumstr) + + # Add some whitespace padding. + curr = CGWrapper(curr, pre='\n', post='\n') + + # Add the namespace. + curr = CGNamespace(namespace, curr) + + # Add the typedef + typedef = '\ntypedef %s::%s %s;\n\n' % (namespace, enumName, enumName) + curr = CGList([curr, CGGeneric(declare=typedef)]) + + # Save the result. + self.node = curr + + def declare(self): + return self.node.declare() + + def define(self): + return "" + + +def initIdsClassMethod(identifiers, atomCacheName): + idinit = ['!atomsCache->%s.init(cx, "%s")' % + (CGDictionary.makeIdName(id), + id) + for id in identifiers] + idinit.reverse() + body = fill( + """ + MOZ_ASSERT(!*reinterpret_cast<jsid**>(atomsCache)); + + // Initialize these in reverse order so that any failure leaves the first one + // uninitialized. + if (${idinit}) { + return false; + } + return true; + """, + idinit=" ||\n ".join(idinit)) + return ClassMethod("InitIds", "bool", [ + Argument("JSContext*", "cx"), + Argument("%s*" % atomCacheName, "atomsCache") + ], static=True, body=body, visibility="private") + + +class CGDictionary(CGThing): + def __init__(self, dictionary, descriptorProvider): + self.dictionary = dictionary + self.descriptorProvider = descriptorProvider + self.needToInitIds = len(dictionary.members) > 0 + self.memberInfo = [ + (member, + getJSToNativeConversionInfo( + member.type, + descriptorProvider, + isEnforceRange=member.enforceRange, + isClamp=member.clamp, + isMember="Dictionary", + isOptional=member.canHaveMissingValue(), + defaultValue=member.defaultValue, + sourceDescription=self.getMemberSourceDescription(member))) + for member in dictionary.members] + + # If we have a union member containing something in the same + # file as us, bail: the C++ includes won't work out. + for member in dictionary.members: + type = member.type.unroll() + if type.isUnion(): + for t in type.flatMemberTypes: + if (t.isDictionary() and + CGHeaders.getDeclarationFilename(t.inner) == + CGHeaders.getDeclarationFilename(dictionary)): + raise TypeError( + "Dictionary contains a union that contains a " + "dictionary in the same WebIDL file. This won't " + "compile. Move the inner dictionary to a " + "different file.\n%s\n%s" % + (t.location, t.inner.location)) + self.structs = self.getStructs() + + def declare(self): + return self.structs.declare() + + def define(self): + return self.structs.define() + + def base(self): + if self.dictionary.parent: + return self.makeClassName(self.dictionary.parent) + return "DictionaryBase" + + def initMethod(self): + """ + This function outputs the body of the Init() method for the dictionary. + + For the most part, this is some bookkeeping for our atoms so + we can avoid atomizing strings all the time, then we just spit + out the getMemberConversion() output for each member, + separated by newlines. + + """ + body = dedent(""" + // Passing a null JSContext is OK only if we're initing from null, + // Since in that case we will not have to do any property gets + MOZ_ASSERT_IF(!cx, val.isNull()); + """) + + if self.needToInitIds: + body += fill( + """ + ${dictName}Atoms* atomsCache = nullptr; + if (cx) { + atomsCache = GetAtomCache<${dictName}Atoms>(cx); + if (!*reinterpret_cast<jsid**>(atomsCache) && !InitIds(cx, atomsCache)) { + return false; + } + } + + """, + dictName=self.makeClassName(self.dictionary)) + + if self.dictionary.parent: + body += fill( + """ + // Per spec, we init the parent's members first + if (!${dictName}::Init(cx, val)) { + return false; + } + + """, + dictName=self.makeClassName(self.dictionary.parent)) + else: + body += dedent( + """ + { // scope for isConvertible + bool isConvertible; + if (!IsConvertibleToDictionary(cx, val, &isConvertible)) { + return false; + } + if (!isConvertible) { + return ThrowErrorMessage(cx, MSG_NOT_DICTIONARY, sourceDescription); + } + } + + """) + + memberInits = [self.getMemberConversion(m).define() + for m in self.memberInfo] + if memberInits: + body += fill( + """ + bool isNull = val.isNullOrUndefined(); + // We only need these if !isNull, in which case we have |cx|. + Maybe<JS::Rooted<JSObject *> > object; + Maybe<JS::Rooted<JS::Value> > temp; + if (!isNull) { + MOZ_ASSERT(cx); + object.emplace(cx, &val.toObject()); + temp.emplace(cx); + } + $*{memberInits} + """, + memberInits="\n".join(memberInits)) + + body += "return true;\n" + + return ClassMethod("Init", "bool", [ + Argument('JSContext*', 'cx'), + Argument('JS::Handle<JS::Value>', 'val'), + Argument('const char*', 'sourceDescription', default='"Value"'), + Argument('bool', 'passedToJSImpl', default='false') + ], body=body) + + def initFromJSONMethod(self): + return ClassMethod( + "Init", "bool", + [Argument('const nsAString&', 'aJSON')], + body=dedent(""" + AutoJSAPI jsapi; + JSObject* cleanGlobal = SimpleGlobalObject::Create(SimpleGlobalObject::GlobalType::BindingDetail); + if (!cleanGlobal) { + return false; + } + if (!jsapi.Init(cleanGlobal)) { + return false; + } + JSContext* cx = jsapi.cx(); + JS::Rooted<JS::Value> json(cx); + bool ok = ParseJSON(cx, aJSON, &json); + NS_ENSURE_TRUE(ok, false); + return Init(cx, json); + """)) + + def toJSONMethod(self): + return ClassMethod( + "ToJSON", "bool", + [Argument('nsAString&', 'aJSON')], + body=dedent(""" + AutoJSAPI jsapi; + jsapi.Init(); + JSContext *cx = jsapi.cx(); + // It's safe to use UnprivilegedJunkScopeOrWorkerGlobal here + // because we'll only be creating objects, in ways that have no + // side-effects, followed by a call to JS::ToJSONMaybeSafely, + // which likewise guarantees no side-effects for the sorts of + // things we will pass it. + JSAutoCompartment ac(cx, binding_detail::UnprivilegedJunkScopeOrWorkerGlobal()); + JS::Rooted<JS::Value> val(cx); + if (!ToObjectInternal(cx, &val)) { + return false; + } + JS::Rooted<JSObject*> obj(cx, &val.toObject()); + return StringifyToJSON(cx, obj, aJSON); + """), const=True) + + def toObjectInternalMethod(self): + body = "" + if self.needToInitIds: + body += fill( + """ + ${dictName}Atoms* atomsCache = GetAtomCache<${dictName}Atoms>(cx); + if (!*reinterpret_cast<jsid**>(atomsCache) && !InitIds(cx, atomsCache)) { + return false; + } + + """, + dictName=self.makeClassName(self.dictionary)) + + if self.dictionary.parent: + body += fill( + """ + // Per spec, we define the parent's members first + if (!${dictName}::ToObjectInternal(cx, rval)) { + return false; + } + JS::Rooted<JSObject*> obj(cx, &rval.toObject()); + + """, + dictName=self.makeClassName(self.dictionary.parent)) + else: + body += dedent( + """ + JS::Rooted<JSObject*> obj(cx, JS_NewPlainObject(cx)); + if (!obj) { + return false; + } + rval.set(JS::ObjectValue(*obj)); + + """) + + if self.memberInfo: + body += "\n".join(self.getMemberDefinition(m).define() + for m in self.memberInfo) + body += "\nreturn true;\n" + + return ClassMethod("ToObjectInternal", "bool", [ + Argument('JSContext*', 'cx'), + Argument('JS::MutableHandle<JS::Value>', 'rval'), + ], const=True, body=body) + + def initIdsMethod(self): + assert self.needToInitIds + return initIdsClassMethod([m.identifier.name for m in self.dictionary.members], + "%sAtoms" % self.makeClassName(self.dictionary)) + + def traceDictionaryMethod(self): + body = "" + if self.dictionary.parent: + cls = self.makeClassName(self.dictionary.parent) + body += "%s::TraceDictionary(trc);\n" % cls + + memberTraces = [self.getMemberTrace(m) + for m in self.dictionary.members + if typeNeedsRooting(m.type)] + + if memberTraces: + body += "\n".join(memberTraces) + + return ClassMethod("TraceDictionary", "void", [ + Argument("JSTracer*", "trc"), + ], body=body) + + def assignmentOperator(self): + body = CGList([]) + if self.dictionary.parent: + body.append(CGGeneric( + "%s::operator=(aOther);\n" % + self.makeClassName(self.dictionary.parent))) + for m, _ in self.memberInfo: + memberName = self.makeMemberName(m.identifier.name) + if m.canHaveMissingValue(): + memberAssign = CGGeneric(fill( + """ + ${name}.Reset(); + if (aOther.${name}.WasPassed()) { + ${name}.Construct(aOther.${name}.Value()); + } + """, + name=memberName)) + else: + memberAssign = CGGeneric( + "%s = aOther.%s;\n" % (memberName, memberName)) + body.append(memberAssign) + return ClassMethod( + "operator=", "void", + [Argument("const %s&" % self.makeClassName(self.dictionary), + "aOther")], + body=body.define()) + + def getStructs(self): + d = self.dictionary + selfName = self.makeClassName(d) + members = [ClassMember(self.makeMemberName(m[0].identifier.name), + self.getMemberType(m), + visibility="public", + body=self.getMemberInitializer(m), + hasIgnoreInitCheckFlag=True) + for m in self.memberInfo] + if d.parent: + # We always want to init our parent with our non-initializing + # constructor arg, because either we're about to init ourselves (and + # hence our parent) or we don't want any init happening. + baseConstructors = [ + "%s(%s)" % (self.makeClassName(d.parent), + self.getNonInitializingCtorArg()) + ] + else: + baseConstructors = None + ctors = [ + ClassConstructor( + [], + visibility="public", + baseConstructors=baseConstructors, + body=( + "// Safe to pass a null context if we pass a null value\n" + "Init(nullptr, JS::NullHandleValue);\n")), + ClassConstructor( + [Argument("const FastDictionaryInitializer&", "")], + visibility="public", + baseConstructors=baseConstructors, + explicit=True, + bodyInHeader=True, + body='// Do nothing here; this is used by our "Fast" subclass\n') + ] + methods = [] + + if self.needToInitIds: + methods.append(self.initIdsMethod()) + + methods.append(self.initMethod()) + canBeRepresentedAsJSON = self.dictionarySafeToJSONify(self.dictionary) + if canBeRepresentedAsJSON: + methods.append(self.initFromJSONMethod()) + try: + methods.append(self.toObjectInternalMethod()) + if canBeRepresentedAsJSON: + methods.append(self.toJSONMethod()) + except MethodNotNewObjectError: + # If we can't have a ToObjectInternal() because one of our members + # can only be returned from [NewObject] methods, then just skip + # generating ToObjectInternal() and ToJSON (since the latter depens + # on the former). + pass + methods.append(self.traceDictionaryMethod()) + + if CGDictionary.isDictionaryCopyConstructible(d): + disallowCopyConstruction = False + # Note: no base constructors because our operator= will + # deal with that. + ctors.append(ClassConstructor([Argument("const %s&" % selfName, + "aOther")], + bodyInHeader=True, + visibility="public", + explicit=True, + body="*this = aOther;\n")) + methods.append(self.assignmentOperator()) + else: + disallowCopyConstruction = True + + struct = CGClass(selfName, + bases=[ClassBase(self.base())], + members=members, + constructors=ctors, + methods=methods, + isStruct=True, + disallowCopyConstruction=disallowCopyConstruction) + + fastDictionaryCtor = ClassConstructor( + [], + visibility="public", + bodyInHeader=True, + baseConstructors=["%s(%s)" % + (selfName, + self.getNonInitializingCtorArg())], + body="// Doesn't matter what int we pass to the parent constructor\n") + + fastStruct = CGClass("Fast" + selfName, + bases=[ClassBase(selfName)], + constructors=[fastDictionaryCtor], + isStruct=True) + + return CGList([struct, + CGNamespace('binding_detail', fastStruct)], + "\n") + + def deps(self): + return self.dictionary.getDeps() + + @staticmethod + def makeDictionaryName(dictionary): + return dictionary.identifier.name + + def makeClassName(self, dictionary): + return self.makeDictionaryName(dictionary) + + @staticmethod + def makeMemberName(name): + return "m" + name[0].upper() + IDLToCIdentifier(name[1:]) + + def getMemberType(self, memberInfo): + _, conversionInfo = memberInfo + # We can't handle having a holderType here + assert conversionInfo.holderType is None + declType = conversionInfo.declType + if conversionInfo.dealWithOptional: + declType = CGTemplatedType("Optional", declType) + return declType.define() + + def getMemberConversion(self, memberInfo): + """ + A function that outputs the initialization of a single dictionary + member from the given dictionary value. + + We start with our conversionInfo, which tells us how to + convert a JS::Value to whatever type this member is. We + substiture the template from the conversionInfo with values + that point to our "temp" JS::Value and our member (which is + the C++ value we want to produce). The output is a string of + code to do the conversion. We store this string in + conversionReplacements["convert"]. + + Now we have three different ways we might use (or skip) this + string of code, depending on whether the value is required, + optional with default value, or optional without default + value. We set up a template in the 'conversion' variable for + exactly how to do this, then substitute into it from the + conversionReplacements dictionary. + """ + member, conversionInfo = memberInfo + replacements = { + "val": "temp.ref()", + "maybeMutableVal": "temp.ptr()", + "declName": self.makeMemberName(member.identifier.name), + # We need a holder name for external interfaces, but + # it's scoped down to the conversion so we can just use + # anything we want. + "holderName": "holder", + "passedToJSImpl": "passedToJSImpl" + } + # We can't handle having a holderType here + assert conversionInfo.holderType is None + if conversionInfo.dealWithOptional: + replacements["declName"] = "(" + replacements["declName"] + ".Value())" + if member.defaultValue: + replacements["haveValue"] = "!isNull && !temp->isUndefined()" + + propId = self.makeIdName(member.identifier.name) + propGet = ("JS_GetPropertyById(cx, *object, atomsCache->%s, temp.ptr())" % + propId) + + conversionReplacements = { + "prop": self.makeMemberName(member.identifier.name), + "convert": string.Template(conversionInfo.template).substitute(replacements), + "propGet": propGet + } + # The conversion code will only run where a default value or a value passed + # by the author needs to get converted, so we can remember if we have any + # members present here. + conversionReplacements["convert"] += "mIsAnyMemberPresent = true;\n" + setTempValue = CGGeneric(dedent( + """ + if (!${propGet}) { + return false; + } + """)) + conditions = getConditionList(member, "cx", "*object") + if len(conditions) != 0: + setTempValue = CGIfElseWrapper(conditions.define(), + setTempValue, + CGGeneric("temp->setUndefined();\n")) + setTempValue = CGIfWrapper(setTempValue, "!isNull") + conversion = setTempValue.define() + if member.defaultValue: + if (member.type.isUnion() and + (not member.type.nullable() or + not isinstance(member.defaultValue, IDLNullValue))): + # Since this has a default value, it might have been initialized + # already. Go ahead and uninit it before we try to init it + # again. + memberName = self.makeMemberName(member.identifier.name) + if member.type.nullable(): + conversion += fill( + """ + if (!${memberName}.IsNull()) { + ${memberName}.Value().Uninit(); + } + """, + memberName=memberName) + else: + conversion += "%s.Uninit();\n" % memberName + conversion += "${convert}" + elif not conversionInfo.dealWithOptional: + # We're required, but have no default value. Make sure + # that we throw if we have no value provided. + conversion += dedent( + """ + if (!isNull && !temp->isUndefined()) { + ${convert} + } else if (cx) { + // Don't error out if we have no cx. In that + // situation the caller is default-constructing us and we'll + // just assume they know what they're doing. + return ThrowErrorMessage(cx, MSG_MISSING_REQUIRED_DICTIONARY_MEMBER, + "%s"); + } + """ % self.getMemberSourceDescription(member)) + conversionReplacements["convert"] = indent(conversionReplacements["convert"]).rstrip() + else: + conversion += ( + "if (!isNull && !temp->isUndefined()) {\n" + " ${prop}.Construct();\n" + "${convert}" + "}\n") + conversionReplacements["convert"] = indent(conversionReplacements["convert"]) + + return CGGeneric( + string.Template(conversion).substitute(conversionReplacements)) + + def getMemberDefinition(self, memberInfo): + member = memberInfo[0] + declType = memberInfo[1].declType + memberLoc = self.makeMemberName(member.identifier.name) + if not member.canHaveMissingValue(): + memberData = memberLoc + else: + # The data is inside the Optional<> + memberData = "%s.InternalValue()" % memberLoc + + # If you have to change this list (which you shouldn't!), make sure it + # continues to match the list in test_Object.prototype_props.html + if (member.identifier.name in + ["constructor", "toSource", "toString", "toLocaleString", "valueOf", + "watch", "unwatch", "hasOwnProperty", "isPrototypeOf", + "propertyIsEnumerable", "__defineGetter__", "__defineSetter__", + "__lookupGetter__", "__lookupSetter__", "__proto__"]): + raise TypeError("'%s' member of %s dictionary shadows " + "a property of Object.prototype, and Xrays to " + "Object can't handle that.\n" + "%s" % + (member.identifier.name, + self.dictionary.identifier.name, + member.location)) + + propDef = ( + 'JS_DefinePropertyById(cx, obj, atomsCache->%s, temp, JSPROP_ENUMERATE)' % + self.makeIdName(member.identifier.name)) + + innerTemplate = wrapForType( + member.type, self.descriptorProvider, + { + 'result': "currentValue", + 'successCode': ("if (!%s) {\n" + " return false;\n" + "}\n" + "break;\n" % propDef), + 'jsvalRef': "temp", + 'jsvalHandle': "&temp", + 'returnsNewObject': False, + # 'obj' can just be allowed to be the string "obj", since that + # will be our dictionary object, which is presumably itself in + # the right scope. + 'typedArraysAreStructs': True + }) + conversion = CGGeneric(innerTemplate) + conversion = CGWrapper(conversion, + pre=("JS::Rooted<JS::Value> temp(cx);\n" + "%s const & currentValue = %s;\n" % + (declType.define(), memberData) + )) + + # Now make sure that our successCode can actually break out of the + # conversion. This incidentally gives us a scope for 'temp' and + # 'currentValue'. + conversion = CGWrapper( + CGIndenter(conversion), + pre=("do {\n" + " // block for our 'break' successCode and scope for 'temp' and 'currentValue'\n"), + post="} while(0);\n") + if member.canHaveMissingValue(): + # Only do the conversion if we have a value + conversion = CGIfWrapper(conversion, "%s.WasPassed()" % memberLoc) + conditions = getConditionList(member, "cx", "obj") + if len(conditions) != 0: + conversion = CGIfWrapper(conversion, conditions.define()) + return conversion + + def getMemberTrace(self, member): + type = member.type + assert typeNeedsRooting(type) + memberLoc = self.makeMemberName(member.identifier.name) + if not member.canHaveMissingValue(): + memberData = memberLoc + else: + # The data is inside the Optional<> + memberData = "%s.Value()" % memberLoc + + memberName = "%s.%s" % (self.makeClassName(self.dictionary), + memberLoc) + + if type.isObject(): + trace = CGGeneric('JS::UnsafeTraceRoot(trc, %s, "%s");\n' % + ("&"+memberData, memberName)) + if type.nullable(): + trace = CGIfWrapper(trace, memberData) + elif type.isAny(): + trace = CGGeneric('JS::UnsafeTraceRoot(trc, %s, "%s");\n' % + ("&"+memberData, memberName)) + elif (type.isSequence() or type.isDictionary() or + type.isSpiderMonkeyInterface() or type.isUnion()): + if type.nullable(): + memberNullable = memberData + memberData = "%s.Value()" % memberData + if type.isSequence(): + trace = CGGeneric('DoTraceSequence(trc, %s);\n' % memberData) + elif type.isDictionary(): + trace = CGGeneric('%s.TraceDictionary(trc);\n' % memberData) + elif type.isUnion(): + trace = CGGeneric('%s.TraceUnion(trc);\n' % memberData) + else: + assert type.isSpiderMonkeyInterface() + trace = CGGeneric('%s.TraceSelf(trc);\n' % memberData) + if type.nullable(): + trace = CGIfWrapper(trace, "!%s.IsNull()" % memberNullable) + elif type.isMozMap(): + # If you implement this, add a MozMap<object> to + # TestInterfaceJSDictionary and test it in test_bug1036214.html + # to make sure we end up with the correct security properties. + assert False + else: + assert False # unknown type + + if member.canHaveMissingValue(): + trace = CGIfWrapper(trace, "%s.WasPassed()" % memberLoc) + + return trace.define() + + def getMemberInitializer(self, memberInfo): + """ + Get the right initializer for the member. Most members don't need one, + but we need to pre-initialize 'any' and 'object' that have a default + value, so they're safe to trace at all times. + """ + member, _ = memberInfo + if member.canHaveMissingValue(): + # Allowed missing value means no need to set it up front, since it's + # inside an Optional and won't get traced until it's actually set + # up. + return None + type = member.type + if type.isAny(): + return "JS::UndefinedValue()" + if type.isObject(): + return "nullptr" + if type.isDictionary(): + # When we construct ourselves, we don't want to init our member + # dictionaries. Either we're being constructed-but-not-initialized + # ourselves (and then we don't want to init them) or we're about to + # init ourselves and then we'll init them anyway. + return CGDictionary.getNonInitializingCtorArg() + return None + + def getMemberSourceDescription(self, member): + return ("'%s' member of %s" % + (member.identifier.name, self.dictionary.identifier.name)) + + @staticmethod + def makeIdName(name): + return IDLToCIdentifier(name) + "_id" + + @staticmethod + def getNonInitializingCtorArg(): + return "FastDictionaryInitializer()" + + @staticmethod + def isDictionaryCopyConstructible(dictionary): + if (dictionary.parent and + not CGDictionary.isDictionaryCopyConstructible(dictionary.parent)): + return False + return all(isTypeCopyConstructible(m.type) for m in dictionary.members) + + @staticmethod + def typeSafeToJSONify(type): + """ + Determine whether the given type is safe to convert to JSON. The + restriction is that this needs to be safe while in a global controlled + by an adversary, and "safe" means no side-effects when the JS + representation of this type is converted to JSON. That means that we + have to be pretty restrictive about what things we can allow. For + example, "object" is out, because it may have accessor properties on it. + """ + if type.nullable(): + # Converting null to JSON is always OK. + return CGDictionary.typeSafeToJSONify(type.inner) + + if type.isSequence(): + # Sequences are arrays we create ourselves, with no holes. They + # should be safe if their contents are safe, as long as we suppress + # invocation of .toJSON on objects. + return CGDictionary.typeSafeToJSONify(type.inner) + + if type.isUnion(): + # OK if everything in it is ok. + return all(CGDictionary.typeSafeToJSONify(t) + for t in type.flatMemberTypes) + + if type.isDictionary(): + # OK if the dictionary is OK + return CGDictionary.dictionarySafeToJSONify(type.inner) + + if type.isString() or type.isEnum(): + # Strings are always OK. + return True + + if type.isPrimitive(): + # Primitives (numbers and booleans) are ok, as long as + # they're not unrestricted float/double. + return not type.isFloat() or not type.isUnrestricted() + + return False + + @staticmethod + def dictionarySafeToJSONify(dictionary): + # The dictionary itself is OK, so we're good if all our types are. + return all(CGDictionary.typeSafeToJSONify(m.type) + for m in dictionary.members) + + +class CGRegisterWorkerBindings(CGAbstractMethod): + def __init__(self, config): + CGAbstractMethod.__init__(self, None, 'RegisterWorkerBindings', 'bool', + [Argument('JSContext*', 'aCx'), + Argument('JS::Handle<JSObject*>', 'aObj')]) + self.config = config + + def definition_body(self): + descriptors = self.config.getDescriptors(hasInterfaceObject=True, + isExposedInAnyWorker=True, + register=True) + conditions = [] + for desc in descriptors: + bindingNS = toBindingNamespace(desc.name) + condition = "!%s::GetConstructorObject(aCx)" % bindingNS + if desc.isExposedConditionally(): + condition = ( + "%s::ConstructorEnabled(aCx, aObj) && " % bindingNS + + condition) + conditions.append(condition) + lines = [CGIfWrapper(CGGeneric("return false;\n"), condition) for + condition in conditions] + lines.append(CGGeneric("return true;\n")) + return CGList(lines, "\n").define() + +class CGRegisterWorkerDebuggerBindings(CGAbstractMethod): + def __init__(self, config): + CGAbstractMethod.__init__(self, None, 'RegisterWorkerDebuggerBindings', 'bool', + [Argument('JSContext*', 'aCx'), + Argument('JS::Handle<JSObject*>', 'aObj')]) + self.config = config + + def definition_body(self): + descriptors = self.config.getDescriptors(hasInterfaceObject=True, + isExposedInWorkerDebugger=True, + register=True) + conditions = [] + for desc in descriptors: + bindingNS = toBindingNamespace(desc.name) + condition = "!%s::GetConstructorObject(aCx)" % bindingNS + if desc.isExposedConditionally(): + condition = ( + "%s::ConstructorEnabled(aCx, aObj) && " % bindingNS + + condition) + conditions.append(condition) + lines = [CGIfWrapper(CGGeneric("return false;\n"), condition) for + condition in conditions] + lines.append(CGGeneric("return true;\n")) + return CGList(lines, "\n").define() + +class CGRegisterWorkletBindings(CGAbstractMethod): + def __init__(self, config): + CGAbstractMethod.__init__(self, None, 'RegisterWorkletBindings', 'bool', + [Argument('JSContext*', 'aCx'), + Argument('JS::Handle<JSObject*>', 'aObj')]) + self.config = config + + def definition_body(self): + descriptors = self.config.getDescriptors(hasInterfaceObject=True, + isExposedInAnyWorklet=True, + register=True) + conditions = [] + for desc in descriptors: + bindingNS = toBindingNamespace(desc.name) + condition = "!%s::GetConstructorObject(aCx)" % bindingNS + if desc.isExposedConditionally(): + condition = ( + "%s::ConstructorEnabled(aCx, aObj) && " % bindingNS + + condition) + conditions.append(condition) + lines = [CGIfWrapper(CGGeneric("return false;\n"), condition) for + condition in conditions] + lines.append(CGGeneric("return true;\n")) + return CGList(lines, "\n").define() + +class CGResolveSystemBinding(CGAbstractMethod): + def __init__(self, config): + CGAbstractMethod.__init__(self, None, 'ResolveSystemBinding', 'bool', + [Argument('JSContext*', 'aCx'), + Argument('JS::Handle<JSObject*>', 'aObj'), + Argument('JS::Handle<jsid>', 'aId'), + Argument('bool*', 'aResolvedp')]) + self.config = config + + def definition_body(self): + descriptors = self.config.getDescriptors(hasInterfaceObject=True, + isExposedInSystemGlobals=True, + register=True) + + def descNameToId(name): + return "s%s_id" % name + jsidNames = [descNameToId(desc.name) for desc in descriptors] + jsidDecls = CGList(CGGeneric("static jsid %s;\n" % name) + for name in jsidNames) + + jsidInits = CGList( + (CGIfWrapper( + CGGeneric("return false;\n"), + '!AtomizeAndPinJSString(aCx, %s, "%s")' % + (descNameToId(desc.name), desc.interface.identifier.name)) + for desc in descriptors), + "\n") + jsidInits.append(CGGeneric("idsInited = true;\n")) + jsidInits = CGIfWrapper(jsidInits, "!idsInited") + jsidInits = CGList([CGGeneric("static bool idsInited = false;\n"), + jsidInits]) + + definitions = CGList([], "\n") + for desc in descriptors: + bindingNS = toBindingNamespace(desc.name) + defineCode = "!%s::GetConstructorObject(aCx)" % bindingNS + defineCode = CGIfWrapper(CGGeneric("return false;\n"), defineCode) + defineCode = CGList([defineCode, + CGGeneric("*aResolvedp = true;\n")]) + + condition = "JSID_IS_VOID(aId) || aId == %s" % descNameToId(desc.name) + if desc.isExposedConditionally(): + condition = "(%s) && %s::ConstructorEnabled(aCx, aObj)" % (condition, bindingNS) + + definitions.append(CGIfWrapper(defineCode, condition)) + + return CGList([CGGeneric("MOZ_ASSERT(NS_IsMainThread());\n"), + jsidDecls, + jsidInits, + definitions, + CGGeneric("return true;\n")], + "\n").define() + + +def getGlobalNames(config): + names = [] + for desc in config.getDescriptors(registersGlobalNamesOnWindow=True): + names.append((desc.name, desc)) + names.extend((n.identifier.name, desc) for n in desc.interface.namedConstructors) + return names + +class CGGlobalNamesString(CGGeneric): + def __init__(self, config): + globalNames = getGlobalNames(config) + currentOffset = 0 + strings = [] + for (name, _) in globalNames: + strings.append('/* %i */ "%s\\0"' % (currentOffset, name)) + currentOffset += len(name) + 1 # Add trailing null. + define = fill(""" + const uint32_t WebIDLGlobalNameHash::sCount = ${count}; + + const char WebIDLGlobalNameHash::sNames[] = + $*{strings} + + """, + count=len(globalNames), + strings="\n".join(strings) + ";\n") + + CGGeneric.__init__(self, define=define) + + +class CGRegisterGlobalNames(CGAbstractMethod): + def __init__(self, config): + CGAbstractMethod.__init__(self, None, 'RegisterWebIDLGlobalNames', + 'void', []) + self.config = config + + def definition_body(self): + def getCheck(desc): + if not desc.isExposedConditionally(): + return "nullptr" + return "%sBinding::ConstructorEnabled" % desc.name + + define = "" + currentOffset = 0 + for (name, desc) in getGlobalNames(self.config): + length = len(name) + define += "WebIDLGlobalNameHash::Register(%i, %i, %sBinding::DefineDOMInterface, %s);\n" % (currentOffset, length, desc.name, getCheck(desc)) + currentOffset += length + 1 # Add trailing null. + return define + + +def dependencySortObjects(objects, dependencyGetter, nameGetter): + """ + Sort IDL objects with dependencies on each other such that if A + depends on B then B will come before A. This is needed for + declaring C++ classes in the right order, for example. Objects + that have no dependencies are just sorted by name. + + objects should be something that can produce a set of objects + (e.g. a set, iterator, list, etc). + + dependencyGetter is something that, given an object, should return + the set of objects it depends on. + """ + # XXXbz this will fail if we have two webidl files F1 and F2 such that F1 + # declares an object which depends on an object in F2, and F2 declares an + # object (possibly a different one!) that depends on an object in F1. The + # good news is that I expect this to never happen. + sortedObjects = [] + objects = set(objects) + while len(objects) != 0: + # Find the dictionaries that don't depend on anything else + # anymore and move them over. + toMove = [o for o in objects if + len(dependencyGetter(o) & objects) == 0] + if len(toMove) == 0: + raise TypeError("Loop in dependency graph\n" + + "\n".join(o.location for o in objects)) + objects = objects - set(toMove) + sortedObjects.extend(sorted(toMove, key=nameGetter)) + return sortedObjects + + +class ForwardDeclarationBuilder: + """ + Create a canonical representation of a set of namespaced forward + declarations. + """ + def __init__(self): + """ + The set of declarations is represented as a tree of nested namespaces. + Each tree node has a set of declarations |decls| and a dict |children|. + Each declaration is a pair consisting of the class name and a boolean + that is true iff the class is really a struct. |children| maps the + names of inner namespaces to the declarations in that namespace. + """ + self.decls = set() + self.children = {} + + def _ensureNonTemplateType(self, type): + if "<" in type: + # This is a templated type. We don't really know how to + # forward-declare those, and trying to do it naively is not going to + # go well (e.g. we may have :: characters inside the type we're + # templated on!). Just bail out. + raise TypeError("Attempt to use ForwardDeclarationBuilder on " + "templated type %s. We don't know how to do that " + "yet." % type) + + def _listAdd(self, namespaces, name, isStruct=False): + """ + Add a forward declaration, where |namespaces| is a list of namespaces. + |name| should not contain any other namespaces. + """ + if namespaces: + child = self.children.setdefault(namespaces[0], ForwardDeclarationBuilder()) + child._listAdd(namespaces[1:], name, isStruct) + else: + assert '::' not in name + self.decls.add((name, isStruct)) + + def addInMozillaDom(self, name, isStruct=False): + """ + Add a forward declaration to the mozilla::dom:: namespace. |name| should not + contain any other namespaces. + """ + self._ensureNonTemplateType(name); + self._listAdd(["mozilla", "dom"], name, isStruct) + + def add(self, nativeType, isStruct=False): + """ + Add a forward declaration, where |nativeType| is a string containing + the type and its namespaces, in the usual C++ way. + """ + self._ensureNonTemplateType(nativeType); + components = nativeType.split('::') + self._listAdd(components[:-1], components[-1], isStruct) + + def _build(self, atTopLevel): + """ + Return a codegenerator for the forward declarations. + """ + decls = [] + if self.decls: + decls.append(CGList([CGClassForwardDeclare(cname, isStruct) + for cname, isStruct in sorted(self.decls)])) + for namespace, child in sorted(self.children.iteritems()): + decls.append(CGNamespace(namespace, child._build(atTopLevel=False), declareOnly=True)) + + cg = CGList(decls, "\n") + if not atTopLevel and len(decls) + len(self.decls) > 1: + cg = CGWrapper(cg, pre='\n', post='\n') + return cg + + def build(self): + return self._build(atTopLevel=True) + + def forwardDeclareForType(self, t, config): + t = t.unroll() + if t.isGeckoInterface(): + name = t.inner.identifier.name + try: + desc = config.getDescriptor(name) + self.add(desc.nativeType) + except NoSuchDescriptorError: + pass + + # Note: Spidermonkey interfaces are typedefs, so can't be + # forward-declared + elif t.isCallback(): + self.addInMozillaDom(t.callback.identifier.name) + elif t.isDictionary(): + self.addInMozillaDom(t.inner.identifier.name, isStruct=True) + elif t.isCallbackInterface(): + self.addInMozillaDom(t.inner.identifier.name) + elif t.isUnion(): + # Forward declare both the owning and non-owning version, + # since we don't know which one we might want + self.addInMozillaDom(CGUnionStruct.unionTypeName(t, False)) + self.addInMozillaDom(CGUnionStruct.unionTypeName(t, True)) + elif t.isMozMap(): + self.forwardDeclareForType(t.inner, config) + # Don't need to do anything for void, primitive, string, any or object. + # There may be some other cases we are missing. + + +class CGForwardDeclarations(CGWrapper): + """ + Code generate the forward declarations for a header file. + additionalDeclarations is a list of tuples containing a classname and a + boolean. If the boolean is true we will declare a struct, otherwise we'll + declare a class. + """ + def __init__(self, config, descriptors, callbacks, + dictionaries, callbackInterfaces, additionalDeclarations=[]): + builder = ForwardDeclarationBuilder() + + # Needed for at least Wrap. + for d in descriptors: + # If this is a generated iterator interface, we only create these + # in the generated bindings, and don't need to forward declare. + if d.interface.isIteratorInterface(): + continue + builder.add(d.nativeType) + # If we're an interface and we have a maplike/setlike declaration, + # we'll have helper functions exposed to the native side of our + # bindings, which will need to show up in the header. If either of + # our key/value types are interfaces, they'll be passed as + # arguments to helper functions, and they'll need to be forward + # declared in the header. + if d.interface.maplikeOrSetlikeOrIterable: + if d.interface.maplikeOrSetlikeOrIterable.hasKeyType(): + builder.forwardDeclareForType(d.interface.maplikeOrSetlikeOrIterable.keyType, + config) + if d.interface.maplikeOrSetlikeOrIterable.hasValueType(): + builder.forwardDeclareForType(d.interface.maplikeOrSetlikeOrIterable.valueType, + config) + + # We just about always need NativePropertyHooks + builder.addInMozillaDom("NativePropertyHooks", isStruct=True) + builder.addInMozillaDom("ProtoAndIfaceCache") + # Add the atoms cache type, even if we don't need it. + for d in descriptors: + # Iterators have native types that are template classes, so + # creating an 'Atoms' cache type doesn't work for them, and is one + # of the cases where we don't need it anyways. + if d.interface.isIteratorInterface(): + continue + builder.add(d.nativeType + "Atoms", isStruct=True) + + for callback in callbacks: + builder.addInMozillaDom(callback.identifier.name) + for t in getTypesFromCallback(callback): + builder.forwardDeclareForType(t, config) + + for d in callbackInterfaces: + builder.add(d.nativeType) + builder.add(d.nativeType + "Atoms", isStruct=True) + for t in getTypesFromDescriptor(d): + builder.forwardDeclareForType(t, config) + + for d in dictionaries: + if len(d.members) > 0: + builder.addInMozillaDom(d.identifier.name + "Atoms", isStruct=True) + for t in getTypesFromDictionary(d): + builder.forwardDeclareForType(t, config) + + for className, isStruct in additionalDeclarations: + builder.add(className, isStruct=isStruct) + + CGWrapper.__init__(self, builder.build()) + + +class CGBindingRoot(CGThing): + """ + Root codegen class for binding generation. Instantiate the class, and call + declare or define to generate header or cpp code (respectively). + """ + def __init__(self, config, prefix, webIDLFile): + bindingHeaders = dict.fromkeys(( + 'mozilla/dom/NonRefcountedDOMObject.h', + ), + True) + bindingDeclareHeaders = dict.fromkeys(( + 'mozilla/dom/BindingDeclarations.h', + 'mozilla/dom/Nullable.h', + 'mozilla/ErrorResult.h', + ), + True) + + descriptors = config.getDescriptors(webIDLFile=webIDLFile, + hasInterfaceOrInterfacePrototypeObject=True) + + unionTypes = UnionsForFile(config, webIDLFile) + + (unionHeaders, unionImplheaders, unionDeclarations, traverseMethods, + unlinkMethods, unionStructs) = UnionTypes(unionTypes, config) + + bindingDeclareHeaders.update(dict.fromkeys(unionHeaders, True)) + bindingHeaders.update(dict.fromkeys(unionImplheaders, True)) + bindingDeclareHeaders["mozilla/dom/UnionMember.h"] = len(unionStructs) > 0 + bindingDeclareHeaders["mozilla/dom/FakeString.h"] = len(unionStructs) > 0 + # BindingUtils.h is only needed for SetToObject. + # If it stops being inlined or stops calling CallerSubsumes + # both this bit and the bit in UnionTypes can be removed. + bindingDeclareHeaders["mozilla/dom/BindingUtils.h"] = any(d.isObject() for t in unionTypes + for d in t.flatMemberTypes) + bindingDeclareHeaders["mozilla/dom/IterableIterator.h"] = any(d.interface.isIteratorInterface() or + d.interface.isIterable() for d in descriptors) + + def descriptorHasCrossOriginProperties(desc): + def hasCrossOriginProperty(m): + props = memberProperties(m, desc) + return (props.isCrossOriginMethod or + props.isCrossOriginGetter or + props.isCrossOriginSetter) + + return any(hasCrossOriginProperty(m) for m in desc.interface.members) + + bindingDeclareHeaders["jsapi.h"] = any(descriptorHasCrossOriginProperties(d) for d in descriptors) + bindingDeclareHeaders["jspubtd.h"] = not bindingDeclareHeaders["jsapi.h"] + bindingDeclareHeaders["js/RootingAPI.h"] = not bindingDeclareHeaders["jsapi.h"] + + def descriptorRequiresPreferences(desc): + iface = desc.interface + return any(m.getExtendedAttribute("Pref") for m in iface.members + [iface]) + + def descriptorDeprecated(desc): + iface = desc.interface + return any(m.getExtendedAttribute("Deprecated") for m in iface.members + [iface]) + + bindingHeaders["nsIDocument.h"] = any( + descriptorDeprecated(d) for d in descriptors) + bindingHeaders["mozilla/Preferences.h"] = any( + descriptorRequiresPreferences(d) for d in descriptors) + bindingHeaders["mozilla/dom/DOMJSProxyHandler.h"] = any( + d.concrete and d.proxy for d in descriptors) + + def descriptorHasChromeOnly(desc): + ctor = desc.interface.ctor() + + return (any(isChromeOnly(a) or needsContainsHack(a) or + needsCallerType(a) + for a in desc.interface.members) or + desc.interface.getExtendedAttribute("ChromeOnly") is not None or + # JS-implemented interfaces with an interface object get a + # chromeonly _create method. And interfaces with an + # interface object might have a ChromeOnly constructor. + (desc.interface.hasInterfaceObject() and + (desc.interface.isJSImplemented() or + (ctor and isChromeOnly(ctor)))) or + # JS-implemented interfaces with clearable cached + # attrs have chromeonly _clearFoo methods. + (desc.interface.isJSImplemented() and + any(clearableCachedAttrs(desc)))) + + # XXXkhuey ugly hack but this is going away soon. + bindingHeaders['xpcprivate.h'] = webIDLFile.endswith("EventTarget.webidl") + + hasThreadChecks = any(d.hasThreadChecks() for d in descriptors) + bindingHeaders["nsThreadUtils.h"] = hasThreadChecks + + dictionaries = config.getDictionaries(webIDLFile) + + def dictionaryHasChromeOnly(dictionary): + while dictionary: + if (any(isChromeOnly(m) for m in dictionary.members)): + return True + dictionary = dictionary.parent + return False + + bindingHeaders["nsContentUtils.h"] = ( + any(descriptorHasChromeOnly(d) for d in descriptors) or + any(dictionaryHasChromeOnly(d) for d in dictionaries)) + hasNonEmptyDictionaries = any( + len(dict.members) > 0 for dict in dictionaries) + callbacks = config.getCallbacks(webIDLFile) + callbackDescriptors = config.getDescriptors(webIDLFile=webIDLFile, + isCallback=True) + jsImplemented = config.getDescriptors(webIDLFile=webIDLFile, + isJSImplemented=True) + bindingDeclareHeaders["nsWeakReference.h"] = jsImplemented + bindingHeaders["nsIGlobalObject.h"] = jsImplemented + bindingHeaders["AtomList.h"] = hasNonEmptyDictionaries or jsImplemented or callbackDescriptors + + def descriptorClearsPropsInSlots(descriptor): + if not descriptor.wrapperCache: + return False + return any(m.isAttr() and m.getExtendedAttribute("StoreInSlot") + for m in descriptor.interface.members) + bindingHeaders["nsJSUtils.h"] = any(descriptorClearsPropsInSlots(d) for d in descriptors) + + # Do codegen for all the enums + enums = config.getEnums(webIDLFile) + cgthings = [CGEnum(e) for e in enums] + + hasCode = (descriptors or callbackDescriptors or dictionaries or + callbacks) + bindingHeaders["mozilla/dom/BindingUtils.h"] = hasCode + bindingHeaders["mozilla/OwningNonNull.h"] = hasCode + bindingHeaders["mozilla/dom/BindingDeclarations.h"] = ( + not hasCode and enums) + + bindingHeaders["WrapperFactory.h"] = descriptors + bindingHeaders["mozilla/dom/DOMJSClass.h"] = descriptors + bindingHeaders["mozilla/dom/ScriptSettings.h"] = dictionaries # AutoJSAPI + # Ensure we see our enums in the generated .cpp file, for the ToJSValue + # method body. Also ensure that we see jsapi.h. + if enums: + bindingHeaders[CGHeaders.getDeclarationFilename(enums[0])] = True + bindingHeaders["jsapi.h"] = True + + # For things that have [UseCounter] + def descriptorRequiresTelemetry(desc): + iface = desc.interface + return any(m.getExtendedAttribute("UseCounter") for m in iface.members) + bindingHeaders["mozilla/UseCounter.h"] = any( + descriptorRequiresTelemetry(d) for d in descriptors) + bindingHeaders["mozilla/dom/SimpleGlobalObject.h"] = any( + CGDictionary.dictionarySafeToJSONify(d) for d in dictionaries) + bindingHeaders["XrayWrapper.h"] = any( + d.wantsXrays and d.wantsXrayExpandoClass for d in descriptors) + bindingHeaders["mozilla/dom/XrayExpandoClass.h"] = any( + d.wantsXrays for d in descriptors) + + cgthings.extend(traverseMethods) + cgthings.extend(unlinkMethods) + + # Do codegen for all the dictionaries. We have to be a bit careful + # here, because we have to generate these in order from least derived + # to most derived so that class inheritance works out. We also have to + # generate members before the dictionary that contains them. + + def getDependenciesFromType(type): + if type.isDictionary(): + return set([type.unroll().inner]) + if type.isSequence(): + return getDependenciesFromType(type.unroll()) + if type.isUnion(): + return set([type.unroll()]) + return set() + + def getDependencies(unionTypeOrDictionary): + if isinstance(unionTypeOrDictionary, IDLDictionary): + deps = set() + if unionTypeOrDictionary.parent: + deps.add(unionTypeOrDictionary.parent) + for member in unionTypeOrDictionary.members: + deps |= getDependenciesFromType(member.type) + return deps + + assert unionTypeOrDictionary.isType() and unionTypeOrDictionary.isUnion() + deps = set() + for member in unionTypeOrDictionary.flatMemberTypes: + deps |= getDependenciesFromType(member) + return deps + + def getName(unionTypeOrDictionary): + if isinstance(unionTypeOrDictionary, IDLDictionary): + return unionTypeOrDictionary.identifier.name + + assert unionTypeOrDictionary.isType() and unionTypeOrDictionary.isUnion() + return unionTypeOrDictionary.name + + for t in dependencySortObjects(dictionaries + unionStructs, getDependencies, getName): + if t.isDictionary(): + cgthings.append(CGDictionary(t, config)) + else: + assert t.isUnion() + cgthings.append(CGUnionStruct(t, config)) + cgthings.append(CGUnionStruct(t, config, True)) + + # Do codegen for all the callbacks. + cgthings.extend(CGCallbackFunction(c, config) for c in callbacks) + + cgthings.extend([CGNamespace('binding_detail', CGFastCallback(c)) + for c in callbacks]) + + # Do codegen for all the descriptors + cgthings.extend([CGDescriptor(x) for x in descriptors]) + + # Do codegen for all the callback interfaces. + cgthings.extend([CGCallbackInterface(x) for x in callbackDescriptors]) + + cgthings.extend([CGNamespace('binding_detail', + CGFastCallback(x.interface)) + for x in callbackDescriptors]) + + # Do codegen for JS implemented classes + def getParentDescriptor(desc): + if not desc.interface.parent: + return set() + return {desc.getDescriptor(desc.interface.parent.identifier.name)} + for x in dependencySortObjects(jsImplemented, getParentDescriptor, + lambda d: d.interface.identifier.name): + cgthings.append(CGCallbackInterface(x, typedArraysAreStructs=True)) + cgthings.append(CGJSImplClass(x)) + + # And make sure we have the right number of newlines at the end + curr = CGWrapper(CGList(cgthings, "\n\n"), post="\n\n") + + # Wrap all of that in our namespaces. + curr = CGNamespace.build(['mozilla', 'dom'], + CGWrapper(curr, pre="\n")) + + curr = CGList([CGForwardDeclarations(config, descriptors, + callbacks, + dictionaries, + callbackDescriptors + jsImplemented, + additionalDeclarations=unionDeclarations), + curr], + "\n") + + # Add header includes. + bindingHeaders = [header + for header, include in bindingHeaders.iteritems() + if include] + bindingDeclareHeaders = [header + for header, include in bindingDeclareHeaders.iteritems() + if include] + + curr = CGHeaders(descriptors, + dictionaries, + callbacks, + callbackDescriptors, + bindingDeclareHeaders, + bindingHeaders, + prefix, + curr, + config, + jsImplemented) + + # Add include guards. + curr = CGIncludeGuard(prefix, curr) + + # Add the auto-generated comment. + curr = CGWrapper( + curr, + pre=(AUTOGENERATED_WITH_SOURCE_WARNING_COMMENT % + os.path.basename(webIDLFile))) + + # Store the final result. + self.root = curr + + def declare(self): + return stripTrailingWhitespace(self.root.declare()) + + def define(self): + return stripTrailingWhitespace(self.root.define()) + + def deps(self): + return self.root.deps() + + +class CGNativeMember(ClassMethod): + def __init__(self, descriptorProvider, member, name, signature, extendedAttrs, + breakAfter=True, passJSBitsAsNeeded=True, visibility="public", + typedArraysAreStructs=True, variadicIsSequence=False, + resultNotAddRefed=False, + virtual=False, + override=False): + """ + If typedArraysAreStructs is false, typed arrays will be passed as + JS::Handle<JSObject*>. If it's true they will be passed as one of the + dom::TypedArray subclasses. + + If passJSBitsAsNeeded is false, we don't automatically pass in a + JSContext* or a JSObject* based on the return and argument types. We + can still pass it based on 'implicitJSContext' annotations. + """ + self.descriptorProvider = descriptorProvider + self.member = member + self.extendedAttrs = extendedAttrs + self.resultAlreadyAddRefed = not resultNotAddRefed + self.passJSBitsAsNeeded = passJSBitsAsNeeded + self.typedArraysAreStructs = typedArraysAreStructs + self.variadicIsSequence = variadicIsSequence + breakAfterSelf = "\n" if breakAfter else "" + ClassMethod.__init__(self, name, + self.getReturnType(signature[0], False), + self.getArgs(signature[0], signature[1]), + static=member.isStatic(), + # Mark our getters, which are attrs that + # have a non-void return type, as const. + const=(not member.isStatic() and member.isAttr() and + not signature[0].isVoid()), + breakAfterReturnDecl=" ", + breakAfterSelf=breakAfterSelf, + visibility=visibility, + virtual=virtual, + override=override) + + def getReturnType(self, type, isMember): + return self.getRetvalInfo(type, isMember)[0] + + def getRetvalInfo(self, type, isMember): + """ + Returns a tuple: + + The first element is the type declaration for the retval + + The second element is a default value that can be used on error returns. + For cases whose behavior depends on isMember, the second element will be + None if isMember is true. + + The third element is a template for actually returning a value stored in + "${declName}" and "${holderName}". This means actually returning it if + we're not outparam, else assigning to the "retval" outparam. If + isMember is true, this can be None, since in that case the caller will + never examine this value. + """ + if type.isVoid(): + return "void", "", "" + if type.isPrimitive() and type.tag() in builtinNames: + result = CGGeneric(builtinNames[type.tag()]) + defaultReturnArg = "0" + if type.nullable(): + result = CGTemplatedType("Nullable", result) + defaultReturnArg = "" + return (result.define(), + "%s(%s)" % (result.define(), defaultReturnArg), + "return ${declName};\n") + if type.isDOMString() or type.isUSVString(): + if isMember: + # No need for a third element in the isMember case + return "nsString", None, None + # Outparam + return "void", "", "aRetVal = ${declName};\n" + if type.isByteString(): + if isMember: + # No need for a third element in the isMember case + return "nsCString", None, None + # Outparam + return "void", "", "aRetVal = ${declName};\n" + if type.isEnum(): + enumName = type.unroll().inner.identifier.name + if type.nullable(): + enumName = CGTemplatedType("Nullable", + CGGeneric(enumName)).define() + defaultValue = "%s()" % enumName + else: + defaultValue = "%s(0)" % enumName + return enumName, defaultValue, "return ${declName};\n" + if type.isGeckoInterface(): + iface = type.unroll().inner + result = CGGeneric(self.descriptorProvider.getDescriptor( + iface.identifier.name).prettyNativeType) + if self.resultAlreadyAddRefed: + if isMember: + holder = "RefPtr" + else: + holder = "already_AddRefed" + if memberReturnsNewObject(self.member) or isMember: + warning = "" + else: + warning = "// Return a raw pointer here to avoid refcounting, but make sure it's safe (the object should be kept alive by the callee).\n" + result = CGWrapper(result, + pre=("%s%s<" % (warning, holder)), + post=">") + else: + result = CGWrapper(result, post="*") + # Since we always force an owning type for callback return values, + # our ${declName} is an OwningNonNull or RefPtr. So we can just + # .forget() to get our already_AddRefed. + return result.define(), "nullptr", "return ${declName}.forget();\n" + if type.isCallback(): + return ("already_AddRefed<%s>" % type.unroll().callback.identifier.name, + "nullptr", "return ${declName}.forget();\n") + if type.isAny(): + if isMember: + # No need for a third element in the isMember case + return "JS::Value", None, None + # Outparam + return "void", "", "aRetVal.set(${declName});\n" + + if type.isObject(): + if isMember: + # No need for a third element in the isMember case + return "JSObject*", None, None + return "void", "", "aRetVal.set(${declName});\n" + if type.isSpiderMonkeyInterface(): + if isMember: + # No need for a third element in the isMember case + return "JSObject*", None, None + if type.nullable(): + returnCode = "${declName}.IsNull() ? nullptr : ${declName}.Value().Obj()" + else: + returnCode = "${declName}.Obj()" + return "void", "", "aRetVal.set(%s);\n" % returnCode + if type.isSequence(): + # If we want to handle sequence-of-sequences return values, we're + # going to need to fix example codegen to not produce nsTArray<void> + # for the relevant argument... + assert not isMember + # Outparam. + if type.nullable(): + returnCode = dedent(""" + if (${declName}.IsNull()) { + aRetVal.SetNull(); + } else { + aRetVal.SetValue().SwapElements(${declName}.Value()); + } + """) + else: + returnCode = "aRetVal.SwapElements(${declName});\n" + return "void", "", returnCode + if type.isMozMap(): + # If we want to handle MozMap-of-MozMap return values, we're + # going to need to fix example codegen to not produce MozMap<void> + # for the relevant argument... + assert not isMember + # In this case we convert directly into our outparam to start with + return "void", "", "" + if type.isDate(): + result = CGGeneric("Date") + if type.nullable(): + result = CGTemplatedType("Nullable", result) + return (result.define(), "%s()" % result.define(), + "return ${declName};\n") + if type.isDictionary(): + if isMember: + # Only the first member of the tuple matters here, but return + # bogus values for the others in case someone decides to use + # them. + return CGDictionary.makeDictionaryName(type.inner), None, None + # In this case we convert directly into our outparam to start with + return "void", "", "" + if type.isUnion(): + if isMember: + # Only the first member of the tuple matters here, but return + # bogus values for the others in case someone decides to use + # them. + return CGUnionStruct.unionTypeDecl(type, True), None, None + # In this case we convert directly into our outparam to start with + return "void", "", "" + + raise TypeError("Don't know how to declare return value for %s" % + type) + + def getArgs(self, returnType, argList): + args = [self.getArg(arg) for arg in argList] + # Now the outparams + if returnType.isDOMString() or returnType.isUSVString(): + args.append(Argument("nsString&", "aRetVal")) + elif returnType.isByteString(): + args.append(Argument("nsCString&", "aRetVal")) + elif returnType.isSequence(): + nullable = returnType.nullable() + if nullable: + returnType = returnType.inner + # And now the actual underlying type + elementDecl = self.getReturnType(returnType.inner, True) + type = CGTemplatedType("nsTArray", CGGeneric(elementDecl)) + if nullable: + type = CGTemplatedType("Nullable", type) + args.append(Argument("%s&" % type.define(), "aRetVal")) + elif returnType.isMozMap(): + nullable = returnType.nullable() + if nullable: + returnType = returnType.inner + # And now the actual underlying type + elementDecl = self.getReturnType(returnType.inner, True) + type = CGTemplatedType("MozMap", CGGeneric(elementDecl)) + if nullable: + type = CGTemplatedType("Nullable", type) + args.append(Argument("%s&" % type.define(), "aRetVal")) + elif returnType.isDictionary(): + nullable = returnType.nullable() + if nullable: + returnType = returnType.inner + dictType = CGGeneric(CGDictionary.makeDictionaryName(returnType.inner)) + if nullable: + dictType = CGTemplatedType("Nullable", dictType) + args.append(Argument("%s&" % dictType.define(), "aRetVal")) + elif returnType.isUnion(): + args.append(Argument("%s&" % + CGUnionStruct.unionTypeDecl(returnType, True), + "aRetVal")) + elif returnType.isAny(): + args.append(Argument("JS::MutableHandle<JS::Value>", "aRetVal")) + elif returnType.isObject() or returnType.isSpiderMonkeyInterface(): + args.append(Argument("JS::MutableHandle<JSObject*>", "aRetVal")) + + # And the nsIPrincipal + if self.member.getExtendedAttribute('NeedsSubjectPrincipal'): + # Cheat and assume self.descriptorProvider is a descriptor + if self.descriptorProvider.interface.isExposedInAnyWorker(): + args.append(Argument("Maybe<nsIPrincipal*>", "aSubjectPrincipal")) + else: + args.append(Argument("nsIPrincipal&", "aPrincipal")) + # And the caller type, if desired. + if needsCallerType(self.member): + args.append(Argument("CallerType", "aCallerType")) + # And the ErrorResult + if 'infallible' not in self.extendedAttrs: + # Use aRv so it won't conflict with local vars named "rv" + args.append(Argument("ErrorResult&", "aRv")) + # The legacycaller thisval + if self.member.isMethod() and self.member.isLegacycaller(): + # If it has an identifier, we can't deal with it yet + assert self.member.isIdentifierLess() + args.insert(0, Argument("const JS::Value&", "aThisVal")) + # And jscontext bits. + if needCx(returnType, argList, self.extendedAttrs, + self.passJSBitsAsNeeded, self.member.isStatic()): + args.insert(0, Argument("JSContext*", "cx")) + if needScopeObject(returnType, argList, self.extendedAttrs, + self.descriptorProvider.wrapperCache, + self.passJSBitsAsNeeded, + self.member.getExtendedAttribute("StoreInSlot")): + args.insert(1, Argument("JS::Handle<JSObject*>", "obj")) + # And if we're static, a global + if self.member.isStatic(): + args.insert(0, Argument("const GlobalObject&", "global")) + return args + + def doGetArgType(self, type, optional, isMember): + """ + The main work of getArgType. Returns a string type decl, whether this + is a const ref, as well as whether the type should be wrapped in + Nullable as needed. + + isMember can be false or one of the strings "Sequence", "Variadic", + "MozMap" + """ + if type.isSequence(): + nullable = type.nullable() + if nullable: + type = type.inner + elementType = type.inner + argType = self.getArgType(elementType, False, "Sequence")[0] + decl = CGTemplatedType("Sequence", argType) + return decl.define(), True, True + + if type.isMozMap(): + nullable = type.nullable() + if nullable: + type = type.inner + elementType = type.inner + argType = self.getArgType(elementType, False, "MozMap")[0] + decl = CGTemplatedType("MozMap", argType) + return decl.define(), True, True + + if type.isUnion(): + # unionTypeDecl will handle nullable types, so return False for + # auto-wrapping in Nullable + return CGUnionStruct.unionTypeDecl(type, isMember), True, False + + if type.isGeckoInterface() and not type.isCallbackInterface(): + iface = type.unroll().inner + argIsPointer = type.nullable() or iface.isExternal() + forceOwningType = (iface.isCallback() or isMember or + iface.identifier.name == "Promise") + if argIsPointer: + if (optional or isMember) and forceOwningType: + typeDecl = "RefPtr<%s>" + else: + typeDecl = "%s*" + else: + if optional or isMember: + if forceOwningType: + typeDecl = "OwningNonNull<%s>" + else: + typeDecl = "NonNull<%s>" + else: + typeDecl = "%s&" + return ((typeDecl % + self.descriptorProvider.getDescriptor(iface.identifier.name).prettyNativeType), + False, False) + + if type.isSpiderMonkeyInterface(): + if not self.typedArraysAreStructs: + return "JS::Handle<JSObject*>", False, False + + # Unroll for the name, in case we're nullable. + return type.unroll().name, True, True + + if type.isDOMString() or type.isUSVString(): + if isMember: + declType = "nsString" + else: + declType = "nsAString" + return declType, True, False + + if type.isByteString(): + declType = "nsCString" + return declType, True, False + + if type.isEnum(): + return type.unroll().inner.identifier.name, False, True + + if type.isCallback() or type.isCallbackInterface(): + forceOwningType = optional or isMember + if type.nullable(): + if forceOwningType: + declType = "RefPtr<%s>" + else: + declType = "%s*" + else: + if forceOwningType: + declType = "OwningNonNull<%s>" + else: + declType = "%s&" + if type.isCallback(): + name = type.unroll().callback.identifier.name + else: + name = type.unroll().inner.identifier.name + return declType % name, False, False + + if type.isAny(): + # Don't do the rooting stuff for variadics for now + if isMember: + declType = "JS::Value" + else: + declType = "JS::Handle<JS::Value>" + return declType, False, False + + if type.isObject(): + if isMember: + declType = "JSObject*" + else: + declType = "JS::Handle<JSObject*>" + return declType, False, False + + if type.isDictionary(): + typeName = CGDictionary.makeDictionaryName(type.inner) + return typeName, True, True + + if type.isDate(): + return "Date", False, True + + assert type.isPrimitive() + + return builtinNames[type.tag()], False, True + + def getArgType(self, type, optional, isMember): + """ + Get the type of an argument declaration. Returns the type CGThing, and + whether this should be a const ref. + + isMember can be False, "Sequence", or "Variadic" + """ + decl, ref, handleNullable = self.doGetArgType(type, optional, isMember) + decl = CGGeneric(decl) + if handleNullable and type.nullable(): + decl = CGTemplatedType("Nullable", decl) + ref = True + if isMember == "Variadic": + arrayType = "Sequence" if self.variadicIsSequence else "nsTArray" + decl = CGTemplatedType(arrayType, decl) + ref = True + elif optional: + # Note: All variadic args claim to be optional, but we can just use + # empty arrays to represent them not being present. + decl = CGTemplatedType("Optional", decl) + ref = True + return (decl, ref) + + def getArg(self, arg): + """ + Get the full argument declaration for an argument + """ + decl, ref = self.getArgType(arg.type, arg.canHaveMissingValue(), + "Variadic" if arg.variadic else False) + if ref: + decl = CGWrapper(decl, pre="const ", post="&") + + return Argument(decl.define(), arg.identifier.name) + + def arguments(self): + return self.member.signatures()[0][1] + + +class CGExampleMethod(CGNativeMember): + def __init__(self, descriptor, method, signature, isConstructor, breakAfter=True): + CGNativeMember.__init__(self, descriptor, method, + CGSpecializedMethod.makeNativeName(descriptor, + method), + signature, + descriptor.getExtendedAttributes(method), + breakAfter=breakAfter, + variadicIsSequence=True) + + def declare(self, cgClass): + assert self.member.isMethod() + # We skip declaring ourselves if this is a maplike/setlike/iterable + # method, because those get implemented automatically by the binding + # machinery, so the implementor of the interface doesn't have to worry + # about it. + if self.member.isMaplikeOrSetlikeOrIterableMethod(): + return '' + return CGNativeMember.declare(self, cgClass); + + def define(self, cgClass): + return '' + + +class CGExampleGetter(CGNativeMember): + def __init__(self, descriptor, attr): + CGNativeMember.__init__(self, descriptor, attr, + CGSpecializedGetter.makeNativeName(descriptor, + attr), + (attr.type, []), + descriptor.getExtendedAttributes(attr, + getter=True)) + + def declare(self, cgClass): + assert self.member.isAttr() + # We skip declaring ourselves if this is a maplike/setlike attr (in + # practice, "size"), because those get implemented automatically by the + # binding machinery, so the implementor of the interface doesn't have to + # worry about it. + if self.member.isMaplikeOrSetlikeAttr(): + return '' + return CGNativeMember.declare(self, cgClass); + + def define(self, cgClass): + return '' + + +class CGExampleSetter(CGNativeMember): + def __init__(self, descriptor, attr): + CGNativeMember.__init__(self, descriptor, attr, + CGSpecializedSetter.makeNativeName(descriptor, + attr), + (BuiltinTypes[IDLBuiltinType.Types.void], + [FakeArgument(attr.type, attr)]), + descriptor.getExtendedAttributes(attr, + setter=True)) + + def define(self, cgClass): + return '' + + +class CGBindingImplClass(CGClass): + """ + Common codegen for generating a C++ implementation of a WebIDL interface + """ + def __init__(self, descriptor, cgMethod, cgGetter, cgSetter, wantGetParent=True, wrapMethodName="WrapObject", skipStaticMethods=False): + """ + cgMethod, cgGetter and cgSetter are classes used to codegen methods, + getters and setters. + """ + self.descriptor = descriptor + self._deps = descriptor.interface.getDeps() + + iface = descriptor.interface + + self.methodDecls = [] + + def appendMethod(m, isConstructor=False): + sigs = m.signatures() + for s in sigs[:-1]: + # Don't put a blank line after overloads, until we + # get to the last one. + self.methodDecls.append(cgMethod(descriptor, m, s, + isConstructor, + breakAfter=False)) + self.methodDecls.append(cgMethod(descriptor, m, sigs[-1], + isConstructor)) + + if iface.ctor(): + appendMethod(iface.ctor(), isConstructor=True) + for n in iface.namedConstructors: + appendMethod(n, isConstructor=True) + for m in iface.members: + if m.isMethod(): + if m.isIdentifierLess(): + continue + if not m.isStatic() or not skipStaticMethods: + appendMethod(m) + elif m.isAttr(): + self.methodDecls.append(cgGetter(descriptor, m)) + if not m.readonly: + self.methodDecls.append(cgSetter(descriptor, m)) + + # Now do the special operations + def appendSpecialOperation(name, op): + if op is None: + return + if name == "IndexedCreator" or name == "NamedCreator": + # These are identical to the setters + return + assert len(op.signatures()) == 1 + returnType, args = op.signatures()[0] + # Make a copy of the args, since we plan to modify them. + args = list(args) + if op.isGetter() or op.isDeleter(): + # This is a total hack. The '&' belongs with the + # type, not the name! But it works, and is simpler + # than trying to somehow make this pretty. + args.append(FakeArgument(BuiltinTypes[IDLBuiltinType.Types.boolean], + op, name="&found")) + if name == "Stringifier": + if op.isIdentifierLess(): + # XXXbz I wish we were consistent about our renaming here. + name = "Stringify" + else: + # We already added this method + return + if name == "LegacyCaller": + if op.isIdentifierLess(): + # XXXbz I wish we were consistent about our renaming here. + name = "LegacyCall" + else: + # We already added this method + return + if name == "Jsonifier": + # We already added this method + return + self.methodDecls.append( + CGNativeMember(descriptor, op, + name, + (returnType, args), + descriptor.getExtendedAttributes(op))) + # Sort things by name so we get stable ordering in the output. + ops = descriptor.operations.items() + ops.sort(key=lambda x: x[0]) + for name, op in ops: + appendSpecialOperation(name, op) + # If we support indexed properties, then we need a Length() + # method so we know which indices are supported. + if descriptor.supportsIndexedProperties(): + # But we don't need it if we already have an infallible + # "length" attribute, which we often do. + haveLengthAttr = any( + m for m in iface.members if m.isAttr() and + CGSpecializedGetter.makeNativeName(descriptor, m) == "Length") + if not haveLengthAttr: + self.methodDecls.append( + CGNativeMember(descriptor, FakeMember(), + "Length", + (BuiltinTypes[IDLBuiltinType.Types.unsigned_long], + []), + {"infallible": True})) + # And if we support named properties we need to be able to + # enumerate the supported names. + if descriptor.supportsNamedProperties(): + self.methodDecls.append( + CGNativeMember( + descriptor, FakeMember(), + "GetSupportedNames", + (IDLSequenceType(None, + BuiltinTypes[IDLBuiltinType.Types.domstring]), + []), + {"infallible": True})) + + wrapArgs = [Argument('JSContext*', 'aCx'), + Argument('JS::Handle<JSObject*>', 'aGivenProto')] + if not descriptor.wrapperCache: + wrapReturnType = "bool" + wrapArgs.append(Argument('JS::MutableHandle<JSObject*>', + 'aReflector')) + else: + wrapReturnType = "JSObject*" + self.methodDecls.insert(0, + ClassMethod(wrapMethodName, wrapReturnType, + wrapArgs, virtual=descriptor.wrapperCache, + breakAfterReturnDecl=" ", + override=descriptor.wrapperCache, + body=self.getWrapObjectBody())) + if wantGetParent: + self.methodDecls.insert(0, + ClassMethod("GetParentObject", + self.getGetParentObjectReturnType(), + [], const=True, + breakAfterReturnDecl=" ", + body=self.getGetParentObjectBody())) + + # Invoke CGClass.__init__ in any subclasses afterwards to do the actual codegen. + + def getWrapObjectBody(self): + return None + + def getGetParentObjectReturnType(self): + return ("// TODO: return something sensible here, and change the return type\n" + "%s*" % self.descriptor.nativeType.split('::')[-1]) + + def getGetParentObjectBody(self): + return None + + def deps(self): + return self._deps + + +class CGExampleClass(CGBindingImplClass): + """ + Codegen for the actual example class implementation for this descriptor + """ + def __init__(self, descriptor): + CGBindingImplClass.__init__(self, descriptor, + CGExampleMethod, CGExampleGetter, CGExampleSetter, + wantGetParent=descriptor.wrapperCache) + + self.parentIface = descriptor.interface.parent + if self.parentIface: + self.parentDesc = descriptor.getDescriptor( + self.parentIface.identifier.name) + bases = [ClassBase(self.nativeLeafName(self.parentDesc))] + else: + bases = [ClassBase("nsISupports /* or NonRefcountedDOMObject if this is a non-refcounted object */")] + if descriptor.wrapperCache: + bases.append(ClassBase("nsWrapperCache /* Change wrapperCache in the binding configuration if you don't want this */")) + + destructorVisibility = "protected" + if self.parentIface: + extradeclarations = ( + "public:\n" + " NS_DECL_ISUPPORTS_INHERITED\n" + " NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(%s, %s)\n" + "\n" % (self.nativeLeafName(descriptor), + self.nativeLeafName(self.parentDesc))) + else: + extradeclarations = ( + "public:\n" + " NS_DECL_CYCLE_COLLECTING_ISUPPORTS\n" + " NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(%s)\n" + "\n" % self.nativeLeafName(descriptor)) + + if descriptor.interface.hasChildInterfaces(): + decorators = "" + else: + decorators = "final" + + CGClass.__init__(self, self.nativeLeafName(descriptor), + bases=bases, + constructors=[ClassConstructor([], + visibility="public")], + destructor=ClassDestructor(visibility=destructorVisibility), + methods=self.methodDecls, + decorators=decorators, + extradeclarations=extradeclarations) + + def define(self): + # Just override CGClass and do our own thing + ctordtor = dedent(""" + ${nativeType}::${nativeType}() + { + // Add |MOZ_COUNT_CTOR(${nativeType});| for a non-refcounted object. + } + + ${nativeType}::~${nativeType}() + { + // Add |MOZ_COUNT_DTOR(${nativeType});| for a non-refcounted object. + } + """) + + if self.parentIface: + ccImpl = dedent(""" + + // Only needed for refcounted objects. + # error "If you don't have members that need cycle collection, + # then remove all the cycle collection bits from this + # implementation and the corresponding header. If you do, you + # want NS_IMPL_CYCLE_COLLECTION_INHERITED(${nativeType}, + # ${parentType}, your, members, here)" + NS_IMPL_ADDREF_INHERITED(${nativeType}, ${parentType}) + NS_IMPL_RELEASE_INHERITED(${nativeType}, ${parentType}) + NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(${nativeType}) + NS_INTERFACE_MAP_END_INHERITING(${parentType}) + + """) + else: + ccImpl = dedent(""" + + // Only needed for refcounted objects. + NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_0(${nativeType}) + NS_IMPL_CYCLE_COLLECTING_ADDREF(${nativeType}) + NS_IMPL_CYCLE_COLLECTING_RELEASE(${nativeType}) + NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(${nativeType}) + NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY + NS_INTERFACE_MAP_ENTRY(nsISupports) + NS_INTERFACE_MAP_END + + """) + + if self.descriptor.wrapperCache: + reflectorArg = "" + reflectorPassArg = "" + returnType = "JSObject*" + else: + reflectorArg = ", JS::MutableHandle<JSObject*> aReflector" + reflectorPassArg = ", aReflector" + returnType = "bool" + classImpl = ccImpl + ctordtor + "\n" + dedent(""" + ${returnType} + ${nativeType}::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto${reflectorArg}) + { + return ${ifaceName}Binding::Wrap(aCx, this, aGivenProto${reflectorPassArg}); + } + + """) + return string.Template(classImpl).substitute( + ifaceName=self.descriptor.name, + nativeType=self.nativeLeafName(self.descriptor), + parentType=self.nativeLeafName(self.parentDesc) if self.parentIface else "", + returnType=returnType, + reflectorArg=reflectorArg, + reflectorPassArg=reflectorPassArg) + + @staticmethod + def nativeLeafName(descriptor): + return descriptor.nativeType.split('::')[-1] + + +class CGExampleRoot(CGThing): + """ + Root codegen class for example implementation generation. Instantiate the + class and call declare or define to generate header or cpp code, + respectively. + """ + def __init__(self, config, interfaceName): + descriptor = config.getDescriptor(interfaceName) + + self.root = CGWrapper(CGExampleClass(descriptor), + pre="\n", post="\n") + + self.root = CGNamespace.build(["mozilla", "dom"], self.root) + + builder = ForwardDeclarationBuilder() + for member in descriptor.interface.members: + if not member.isAttr() and not member.isMethod(): + continue + if member.isStatic(): + builder.addInMozillaDom("GlobalObject") + if member.isAttr() and not member.isMaplikeOrSetlikeAttr(): + builder.forwardDeclareForType(member.type, config) + else: + assert member.isMethod() + if not member.isMaplikeOrSetlikeOrIterableMethod(): + for sig in member.signatures(): + builder.forwardDeclareForType(sig[0], config) + for arg in sig[1]: + builder.forwardDeclareForType(arg.type, config) + + self.root = CGList([builder.build(), + self.root], "\n") + + # Throw in our #includes + self.root = CGHeaders([], [], [], [], + ["nsWrapperCache.h", + "nsCycleCollectionParticipant.h", + "mozilla/Attributes.h", + "mozilla/ErrorResult.h", + "mozilla/dom/BindingDeclarations.h", + "js/TypeDecls.h"], + ["mozilla/dom/%s.h" % interfaceName, + ("mozilla/dom/%s" % + CGHeaders.getDeclarationFilename(descriptor.interface))], "", self.root) + + # And now some include guards + self.root = CGIncludeGuard(interfaceName, self.root) + + # And our license block comes before everything else + self.root = CGWrapper(self.root, pre=dedent(""" + /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ + /* vim:set ts=2 sw=2 sts=2 et cindent: */ + /* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + + """)) + + def declare(self): + return self.root.declare() + + def define(self): + return self.root.define() + + +def jsImplName(name): + return name + "JSImpl" + + +class CGJSImplMember(CGNativeMember): + """ + Base class for generating code for the members of the implementation class + for a JS-implemented WebIDL interface. + """ + def __init__(self, descriptorProvider, member, name, signature, + extendedAttrs, breakAfter=True, passJSBitsAsNeeded=True, + visibility="public", variadicIsSequence=False, + virtual=False, override=False): + CGNativeMember.__init__(self, descriptorProvider, member, name, + signature, extendedAttrs, breakAfter=breakAfter, + passJSBitsAsNeeded=passJSBitsAsNeeded, + visibility=visibility, + variadicIsSequence=variadicIsSequence, + virtual=virtual, + override=override) + self.body = self.getImpl() + + def getArgs(self, returnType, argList): + args = CGNativeMember.getArgs(self, returnType, argList) + args.append(Argument("JSCompartment*", "aCompartment", "nullptr")) + return args + + +class CGJSImplMethod(CGJSImplMember): + """ + Class for generating code for the methods for a JS-implemented WebIDL + interface. + """ + def __init__(self, descriptor, method, signature, isConstructor, breakAfter=True): + virtual = False + override = False + if (method.identifier.name == "eventListenerWasAdded" or + method.identifier.name == "eventListenerWasRemoved"): + virtual = True + override = True + + self.signature = signature + self.descriptor = descriptor + self.isConstructor = isConstructor + CGJSImplMember.__init__(self, descriptor, method, + CGSpecializedMethod.makeNativeName(descriptor, + method), + signature, + descriptor.getExtendedAttributes(method), + breakAfter=breakAfter, + variadicIsSequence=True, + passJSBitsAsNeeded=False, + virtual=virtual, + override=override) + + def getArgs(self, returnType, argList): + if self.isConstructor: + # Skip the JSCompartment bits for constructors; it's handled + # manually in getImpl. + return CGNativeMember.getArgs(self, returnType, argList) + return CGJSImplMember.getArgs(self, returnType, argList) + + def getImpl(self): + args = self.getArgs(self.signature[0], self.signature[1]) + if not self.isConstructor: + return 'return mImpl->%s(%s);\n' % (self.name, ", ".join(arg.name for arg in args)) + + assert self.descriptor.interface.isJSImplemented() + if self.name != 'Constructor': + raise TypeError("Named constructors are not supported for JS implemented WebIDL. See bug 851287.") + if len(self.signature[1]) != 0: + # The first two arguments to the constructor implementation are not + # arguments to the WebIDL constructor, so don't pass them to __Init() + assert args[0].argType == 'const GlobalObject&' + assert args[1].argType == 'JSContext*' + constructorArgs = [arg.name for arg in args[2:]] + constructorArgs.append("js::GetObjectCompartment(scopeObj)") + initCall = fill( + """ + // Wrap the object before calling __Init so that __DOM_IMPL__ is available. + JS::Rooted<JSObject*> scopeObj(cx, globalHolder->GetGlobalJSObject()); + MOZ_ASSERT(js::IsObjectInContextCompartment(scopeObj, cx)); + JS::Rooted<JS::Value> wrappedVal(cx); + if (!GetOrCreateDOMReflector(cx, impl, &wrappedVal)) { + //XXX Assertion disabled for now, see bug 991271. + MOZ_ASSERT(true || JS_IsExceptionPending(cx)); + aRv.Throw(NS_ERROR_UNEXPECTED); + return nullptr; + } + // Initialize the object with the constructor arguments. + impl->mImpl->__Init(${args}); + if (aRv.Failed()) { + return nullptr; + } + """, + args=", ".join(constructorArgs)) + else: + initCall = "" + return genConstructorBody(self.descriptor, initCall) + + +def genConstructorBody(descriptor, initCall=""): + return fill( + """ + JS::Rooted<JSObject*> jsImplObj(cx); + nsCOMPtr<nsIGlobalObject> globalHolder = + ConstructJSImplementation("${contractId}", global, &jsImplObj, aRv); + if (aRv.Failed()) { + return nullptr; + } + // Build the C++ implementation. + RefPtr<${implClass}> impl = new ${implClass}(jsImplObj, globalHolder); + $*{initCall} + return impl.forget(); + """, + contractId=descriptor.interface.getJSImplementation(), + implClass=descriptor.name, + initCall=initCall) + + +# We're always fallible +def callbackGetterName(attr, descriptor): + return "Get" + MakeNativeName( + descriptor.binaryNameFor(attr.identifier.name)) + + +def callbackSetterName(attr, descriptor): + return "Set" + MakeNativeName( + descriptor.binaryNameFor(attr.identifier.name)) + + +class CGJSImplClearCachedValueMethod(CGAbstractBindingMethod): + def __init__(self, descriptor, attr): + if attr.getExtendedAttribute("StoreInSlot"): + raise TypeError("[StoreInSlot] is not supported for JS-implemented WebIDL. See bug 1056325.") + + CGAbstractBindingMethod.__init__(self, descriptor, + MakeJSImplClearCachedValueNativeName(attr), + JSNativeArguments()) + self.attr = attr + + def generate_code(self): + return CGGeneric(fill( + """ + ${bindingNamespace}::${fnName}(self); + args.rval().setUndefined(); + return true; + """, + bindingNamespace=toBindingNamespace(self.descriptor.name), + fnName=MakeClearCachedValueNativeName(self.attr))) + + +class CGJSImplGetter(CGJSImplMember): + """ + Class for generating code for the getters of attributes for a JS-implemented + WebIDL interface. + """ + def __init__(self, descriptor, attr): + CGJSImplMember.__init__(self, descriptor, attr, + CGSpecializedGetter.makeNativeName(descriptor, + attr), + (attr.type, []), + descriptor.getExtendedAttributes(attr, + getter=True), + passJSBitsAsNeeded=False) + + def getImpl(self): + callbackArgs = [arg.name for arg in self.getArgs(self.member.type, [])] + return 'return mImpl->%s(%s);\n' % ( + callbackGetterName(self.member, self.descriptorProvider), + ", ".join(callbackArgs)) + + +class CGJSImplSetter(CGJSImplMember): + """ + Class for generating code for the setters of attributes for a JS-implemented + WebIDL interface. + """ + def __init__(self, descriptor, attr): + CGJSImplMember.__init__(self, descriptor, attr, + CGSpecializedSetter.makeNativeName(descriptor, + attr), + (BuiltinTypes[IDLBuiltinType.Types.void], + [FakeArgument(attr.type, attr)]), + descriptor.getExtendedAttributes(attr, + setter=True), + passJSBitsAsNeeded=False) + + def getImpl(self): + callbackArgs = [arg.name for arg in self.getArgs(BuiltinTypes[IDLBuiltinType.Types.void], + [FakeArgument(self.member.type, self.member)])] + return 'mImpl->%s(%s);\n' % ( + callbackSetterName(self.member, self.descriptorProvider), + ", ".join(callbackArgs)) + + +class CGJSImplClass(CGBindingImplClass): + def __init__(self, descriptor): + CGBindingImplClass.__init__(self, descriptor, CGJSImplMethod, CGJSImplGetter, CGJSImplSetter, skipStaticMethods=True) + + if descriptor.interface.parent: + parentClass = descriptor.getDescriptor( + descriptor.interface.parent.identifier.name).jsImplParent + baseClasses = [ClassBase(parentClass)] + isupportsDecl = "NS_DECL_ISUPPORTS_INHERITED\n" + ccDecl = ("NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(%s, %s)\n" % + (descriptor.name, parentClass)) + constructorBody = dedent(""" + // Make sure we're an nsWrapperCache already + MOZ_ASSERT(static_cast<nsWrapperCache*>(this)); + // And that our ancestor has not called SetIsNotDOMBinding() + MOZ_ASSERT(IsDOMBinding()); + """) + extradefinitions = fill( + """ + NS_IMPL_CYCLE_COLLECTION_INHERITED(${ifaceName}, ${parentClass}, mImpl, mParent) + NS_IMPL_ADDREF_INHERITED(${ifaceName}, ${parentClass}) + NS_IMPL_RELEASE_INHERITED(${ifaceName}, ${parentClass}) + NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(${ifaceName}) + NS_INTERFACE_MAP_END_INHERITING(${parentClass}) + """, + ifaceName=self.descriptor.name, + parentClass=parentClass) + else: + baseClasses = [ClassBase("nsSupportsWeakReference"), + ClassBase("nsWrapperCache")] + isupportsDecl = "NS_DECL_CYCLE_COLLECTING_ISUPPORTS\n" + ccDecl = ("NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(%s)\n" % + descriptor.name) + extradefinitions = fill( + """ + NS_IMPL_CYCLE_COLLECTION_CLASS(${ifaceName}) + NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(${ifaceName}) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mImpl) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mParent) + NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER + tmp->ClearWeakReferences(); + NS_IMPL_CYCLE_COLLECTION_UNLINK_END + NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(${ifaceName}) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mImpl) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mParent) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE_SCRIPT_OBJECTS + NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END + NS_IMPL_CYCLE_COLLECTION_TRACE_WRAPPERCACHE(${ifaceName}) + NS_IMPL_CYCLE_COLLECTING_ADDREF(${ifaceName}) + NS_IMPL_CYCLE_COLLECTING_RELEASE(${ifaceName}) + NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(${ifaceName}) + NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY + NS_INTERFACE_MAP_ENTRY(nsISupports) + NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference) + NS_INTERFACE_MAP_END + """, + ifaceName=self.descriptor.name) + + extradeclarations = fill( + """ + public: + $*{isupportsDecl} + $*{ccDecl} + + private: + RefPtr<${jsImplName}> mImpl; + nsCOMPtr<nsISupports> mParent; + + """, + isupportsDecl=isupportsDecl, + ccDecl=ccDecl, + jsImplName=jsImplName(descriptor.name)) + + if descriptor.interface.hasChildInterfaces(): + decorators = "" + # We need a protected virtual destructor our subclasses can use + destructor = ClassDestructor(virtual=True, visibility="protected") + else: + decorators = "final" + destructor = ClassDestructor(virtual=False, visibility="private") + + baseConstructors = [ + ("mImpl(new %s(nullptr, aJSImplObject, /* aIncumbentGlobal = */ nullptr))" % + jsImplName(descriptor.name)), + "mParent(aParent)"] + parentInterface = descriptor.interface.parent + while parentInterface: + if parentInterface.isJSImplemented(): + baseConstructors.insert( + 0, "%s(aJSImplObject, aParent)" % parentClass) + break + parentInterface = parentInterface.parent + if not parentInterface and descriptor.interface.parent: + # We only have C++ ancestors, so only pass along the window + baseConstructors.insert(0, + "%s(aParent)" % parentClass) + + constructor = ClassConstructor( + [Argument("JS::Handle<JSObject*>", "aJSImplObject"), + Argument("nsIGlobalObject*", "aParent")], + visibility="public", + baseConstructors=baseConstructors) + + self.methodDecls.append( + ClassMethod("_Create", + "bool", + JSNativeArguments(), + static=True, + body=self.getCreateFromExistingBody())) + + CGClass.__init__(self, descriptor.name, + bases=baseClasses, + constructors=[constructor], + destructor=destructor, + methods=self.methodDecls, + decorators=decorators, + extradeclarations=extradeclarations, + extradefinitions=extradefinitions) + + def getWrapObjectBody(self): + return fill( + """ + JS::Rooted<JSObject*> obj(aCx, ${name}Binding::Wrap(aCx, this, aGivenProto)); + if (!obj) { + return nullptr; + } + + // Now define it on our chrome object + JSAutoCompartment ac(aCx, mImpl->Callback()); + if (!JS_WrapObject(aCx, &obj)) { + return nullptr; + } + if (!JS_DefineProperty(aCx, mImpl->Callback(), "__DOM_IMPL__", obj, 0)) { + return nullptr; + } + return obj; + """, + name=self.descriptor.name) + + def getGetParentObjectReturnType(self): + return "nsISupports*" + + def getGetParentObjectBody(self): + return "return mParent;\n" + + def getCreateFromExistingBody(self): + # XXXbz we could try to get parts of this (e.g. the argument + # conversions) auto-generated by somehow creating an IDLMethod and + # adding it to our interface, but we'd still need to special-case the + # implementation slightly to have it not try to forward to the JS + # object... + return fill( + """ + JS::CallArgs args = JS::CallArgsFromVp(argc, vp); + if (args.length() < 2) { + return ThrowErrorMessage(cx, MSG_MISSING_ARGUMENTS, "${ifaceName}._create"); + } + if (!args[0].isObject()) { + return ThrowErrorMessage(cx, MSG_NOT_OBJECT, "Argument 1 of ${ifaceName}._create"); + } + if (!args[1].isObject()) { + return ThrowErrorMessage(cx, MSG_NOT_OBJECT, "Argument 2 of ${ifaceName}._create"); + } + + // GlobalObject will go through wrappers as needed for us, and + // is simpler than the right UnwrapArg incantation. + GlobalObject global(cx, &args[0].toObject()); + if (global.Failed()) { + return false; + } + nsCOMPtr<nsIGlobalObject> globalHolder = do_QueryInterface(global.GetAsSupports()); + MOZ_ASSERT(globalHolder); + JS::Rooted<JSObject*> arg(cx, &args[1].toObject()); + RefPtr<${implName}> impl = new ${implName}(arg, globalHolder); + MOZ_ASSERT(js::IsObjectInContextCompartment(arg, cx)); + return GetOrCreateDOMReflector(cx, impl, args.rval()); + """, + ifaceName=self.descriptor.interface.identifier.name, + implName=self.descriptor.name) + + +def isJSImplementedDescriptor(descriptorProvider): + return (isinstance(descriptorProvider, Descriptor) and + descriptorProvider.interface.isJSImplemented()) + + +class CGCallback(CGClass): + def __init__(self, idlObject, descriptorProvider, baseName, methods, + getters=[], setters=[]): + self.baseName = baseName + self._deps = idlObject.getDeps() + self.idlObject = idlObject + self.name = idlObject.identifier.name + if isJSImplementedDescriptor(descriptorProvider): + self.name = jsImplName(self.name) + # For our public methods that needThisHandling we want most of the + # same args and the same return type as what CallbackMember + # generates. So we want to take advantage of all its + # CGNativeMember infrastructure, but that infrastructure can't deal + # with templates and most especially template arguments. So just + # cheat and have CallbackMember compute all those things for us. + realMethods = [] + for method in methods: + if not isinstance(method, CallbackMember) or not method.needThisHandling: + realMethods.append(method) + else: + realMethods.extend(self.getMethodImpls(method)) + realMethods.append( + ClassMethod("operator==", "bool", + [Argument("const %s&" % self.name, "aOther")], + inline=True, bodyInHeader=True, + const=True, + body=("return %s::operator==(aOther);\n" % baseName))) + CGClass.__init__(self, self.name, + bases=[ClassBase(baseName)], + constructors=self.getConstructors(), + methods=realMethods+getters+setters) + + def getConstructors(self): + if (not self.idlObject.isInterface() and + not self.idlObject._treatNonObjectAsNull): + body = "MOZ_ASSERT(JS::IsCallable(mCallback));\n" + else: + # Not much we can assert about it, other than not being null, and + # CallbackObject does that already. + body = "" + return [ + ClassConstructor( + [Argument("JSContext*", "aCx"), + Argument("JS::Handle<JSObject*>", "aCallback"), + Argument("nsIGlobalObject*", "aIncumbentGlobal")], + bodyInHeader=True, + visibility="public", + explicit=True, + baseConstructors=[ + "%s(aCx, aCallback, aIncumbentGlobal)" % self.baseName, + ], + body=body), + ClassConstructor( + [Argument("JSContext*", "aCx"), + Argument("JS::Handle<JSObject*>", "aCallback"), + Argument("nsIGlobalObject*", "aIncumbentGlobal"), + Argument("const FastCallbackConstructor&", "")], + bodyInHeader=True, + visibility="public", + explicit=True, + baseConstructors=[ + "%s(aCx, aCallback, aIncumbentGlobal, FastCallbackConstructor())" % self.baseName, + ], + body=body), + ClassConstructor( + [Argument("JS::Handle<JSObject*>", "aCallback"), + Argument("JS::Handle<JSObject*>", "aAsyncStack"), + Argument("nsIGlobalObject*", "aIncumbentGlobal")], + bodyInHeader=True, + visibility="public", + explicit=True, + baseConstructors=[ + "%s(aCallback, aAsyncStack, aIncumbentGlobal)" % self.baseName, + ], + body=body)] + + def getMethodImpls(self, method): + assert method.needThisHandling + args = list(method.args) + # Strip out the JSContext*/JSObject* args + # that got added. + assert args[0].name == "cx" and args[0].argType == "JSContext*" + assert args[1].name == "aThisVal" and args[1].argType == "JS::Handle<JS::Value>" + args = args[2:] + + # Now remember which index the ErrorResult argument is at; + # we'll need this below. + assert args[-1].name == "aRv" and args[-1].argType == "ErrorResult&" + rvIndex = len(args) - 1 + assert rvIndex >= 0 + + # Record the names of all the arguments, so we can use them when we call + # the private method. + argnames = [arg.name for arg in args] + argnamesWithThis = ["s.GetContext()", "thisValJS"] + argnames + argnamesWithoutThis = ["s.GetContext()", "JS::UndefinedHandleValue"] + argnames + # Now that we've recorded the argnames for our call to our private + # method, insert our optional argument for the execution reason. + args.append(Argument("const char*", "aExecutionReason", + "nullptr")) + + # Make copies of the arg list for the two "without rv" overloads. Note + # that those don't need aExceptionHandling or aCompartment arguments + # because those would make not sense anyway: the only sane thing to do + # with exceptions in the "without rv" cases is to report them. + argsWithoutRv = list(args) + argsWithoutRv.pop(rvIndex) + argsWithoutThisAndRv = list(argsWithoutRv) + + # Add the potional argument for deciding whether the CallSetup should + # re-throw exceptions on aRv. + args.append(Argument("ExceptionHandling", "aExceptionHandling", + "eReportExceptions")) + # And the argument for communicating when exceptions should really be + # rethrown. In particular, even when aExceptionHandling is + # eRethrowExceptions they won't get rethrown if aCompartment is provided + # and its principal doesn't subsume either the callback or the + # exception. + args.append(Argument("JSCompartment*", "aCompartment", "nullptr")) + # And now insert our template argument. + argsWithoutThis = list(args) + args.insert(0, Argument("const T&", "thisVal")) + argsWithoutRv.insert(0, Argument("const T&", "thisVal")) + + argnamesWithoutThisAndRv = [arg.name for arg in argsWithoutThisAndRv] + argnamesWithoutThisAndRv.insert(rvIndex, "rv"); + # If we just leave things like that, and have no actual arguments in the + # IDL, we will end up trying to call the templated "without rv" overload + # with "rv" as the thisVal. That's no good. So explicitly append the + # aExceptionHandling and aCompartment values we need to end up matching + # the signature of our non-templated "with rv" overload. + argnamesWithoutThisAndRv.extend(["eReportExceptions", "nullptr"]) + + argnamesWithoutRv = [arg.name for arg in argsWithoutRv] + # Note that we need to insert at rvIndex + 1, since we inserted a + # thisVal arg at the start. + argnamesWithoutRv.insert(rvIndex + 1, "rv") + + errorReturn = method.getDefaultRetval() + + setupCall = fill( + """ + if (!aExecutionReason) { + aExecutionReason = "${executionReason}"; + } + CallSetup s(this, aRv, aExecutionReason, aExceptionHandling, aCompartment); + if (!s.GetContext()) { + MOZ_ASSERT(aRv.Failed()); + return${errorReturn}; + } + """, + errorReturn=errorReturn, + executionReason=method.getPrettyName()) + + bodyWithThis = fill( + """ + $*{setupCall} + JS::Rooted<JS::Value> thisValJS(s.GetContext()); + if (!ToJSValue(s.GetContext(), thisVal, &thisValJS)) { + aRv.Throw(NS_ERROR_FAILURE); + return${errorReturn}; + } + return ${methodName}(${callArgs}); + """, + setupCall=setupCall, + errorReturn=errorReturn, + methodName=method.name, + callArgs=", ".join(argnamesWithThis)) + bodyWithoutThis = fill( + """ + $*{setupCall} + return ${methodName}(${callArgs}); + """, + setupCall=setupCall, + errorReturn=errorReturn, + methodName=method.name, + callArgs=", ".join(argnamesWithoutThis)) + bodyWithThisWithoutRv = fill( + """ + IgnoredErrorResult rv; + return ${methodName}(${callArgs}); + """, + methodName=method.name, + callArgs=", ".join(argnamesWithoutRv)) + bodyWithoutThisAndRv = fill( + """ + IgnoredErrorResult rv; + return ${methodName}(${callArgs}); + """, + methodName=method.name, + callArgs=", ".join(argnamesWithoutThisAndRv)) + + return [ClassMethod(method.name, method.returnType, args, + bodyInHeader=True, + templateArgs=["typename T"], + body=bodyWithThis), + ClassMethod(method.name, method.returnType, argsWithoutThis, + bodyInHeader=True, + body=bodyWithoutThis), + ClassMethod(method.name, method.returnType, argsWithoutRv, + bodyInHeader=True, + templateArgs=["typename T"], + body=bodyWithThisWithoutRv), + ClassMethod(method.name, method.returnType, argsWithoutThisAndRv, + bodyInHeader=True, + body=bodyWithoutThisAndRv), + method] + + def deps(self): + return self._deps + + +class CGCallbackFunction(CGCallback): + def __init__(self, callback, descriptorProvider): + self.callback = callback + CGCallback.__init__(self, callback, descriptorProvider, + "CallbackFunction", + methods=[CallCallback(callback, descriptorProvider)]) + + def getConstructors(self): + return CGCallback.getConstructors(self) + [ + ClassConstructor( + [Argument("CallbackFunction*", "aOther")], + bodyInHeader=True, + visibility="public", + explicit=True, + baseConstructors=["CallbackFunction(aOther)"])] + + +class CGFastCallback(CGClass): + def __init__(self, idlObject): + self._deps = idlObject.getDeps() + baseName = idlObject.identifier.name + constructor = ClassConstructor( + [Argument("JSContext*", "aCx"), + Argument("JS::Handle<JSObject*>", "aCallback"), + Argument("nsIGlobalObject*", "aIncumbentGlobal")], + bodyInHeader=True, + visibility="public", + explicit=True, + baseConstructors=[ + "%s(aCx, aCallback, aIncumbentGlobal, FastCallbackConstructor())" % + baseName, + ], + body="") + + traceMethod = ClassMethod("Trace", "void", + [Argument("JSTracer*", "aTracer")], + inline=True, + bodyInHeader=True, + visibility="public", + body="%s::Trace(aTracer);\n" % baseName) + holdMethod = ClassMethod("HoldJSObjectsIfMoreThanOneOwner", "void", + [], + inline=True, + bodyInHeader=True, + visibility="public", + body=( + "%s::HoldJSObjectsIfMoreThanOneOwner();\n" % + baseName)) + + CGClass.__init__(self, "Fast%s" % baseName, + bases=[ClassBase(baseName)], + constructors=[constructor], + methods=[traceMethod, holdMethod]) + + def deps(self): + return self._deps + + +class CGCallbackInterface(CGCallback): + def __init__(self, descriptor, typedArraysAreStructs=False): + iface = descriptor.interface + attrs = [m for m in iface.members if m.isAttr() and not m.isStatic()] + getters = [CallbackGetter(a, descriptor, typedArraysAreStructs) + for a in attrs] + setters = [CallbackSetter(a, descriptor, typedArraysAreStructs) + for a in attrs if not a.readonly] + methods = [m for m in iface.members + if m.isMethod() and not m.isStatic() and not m.isIdentifierLess()] + methods = [CallbackOperation(m, sig, descriptor, typedArraysAreStructs) + for m in methods for sig in m.signatures()] + if iface.isJSImplemented() and iface.ctor(): + sigs = descriptor.interface.ctor().signatures() + if len(sigs) != 1: + raise TypeError("We only handle one constructor. See bug 869268.") + methods.append(CGJSImplInitOperation(sigs[0], descriptor)) + if any(m.isAttr() or m.isMethod() for m in iface.members) or (iface.isJSImplemented() and iface.ctor()): + methods.append(initIdsClassMethod([descriptor.binaryNameFor(m.identifier.name) + for m in iface.members + if m.isAttr() or m.isMethod()] + + (["__init"] if iface.isJSImplemented() and iface.ctor() else []), + iface.identifier.name + "Atoms")) + CGCallback.__init__(self, iface, descriptor, "CallbackInterface", + methods, getters=getters, setters=setters) + + +class FakeMember(): + def __init__(self, name=None): + self.treatNullAs = "Default" + if name is not None: + self.identifier = FakeIdentifier(name) + + def isStatic(self): + return False + + def isAttr(self): + return False + + def isMethod(self): + return False + + def getExtendedAttribute(self, name): + # Claim to be a [NewObject] so we can avoid the "return a raw pointer" + # comments CGNativeMember codegen would otherwise stick in. + if name == "NewObject": + return True + return None + + +class CallbackMember(CGNativeMember): + # XXXbz It's OK to use CallbackKnownNotGray for wrapScope because + # CallSetup already handled the unmark-gray bits for us. we don't have + # anything better to use for 'obj', really... + def __init__(self, sig, name, descriptorProvider, needThisHandling, + rethrowContentException=False, typedArraysAreStructs=False, + wrapScope='CallbackKnownNotGray()'): + """ + needThisHandling is True if we need to be able to accept a specified + thisObj, False otherwise. + """ + assert not rethrowContentException or not needThisHandling + + self.retvalType = sig[0] + self.originalSig = sig + args = sig[1] + self.argCount = len(args) + if self.argCount > 0: + # Check for variadic arguments + lastArg = args[self.argCount-1] + if lastArg.variadic: + self.argCountStr = ("(%d - 1) + %s.Length()" % + (self.argCount, lastArg.identifier.name)) + else: + self.argCountStr = "%d" % self.argCount + self.needThisHandling = needThisHandling + # If needThisHandling, we generate ourselves as private and the caller + # will handle generating public versions that handle the "this" stuff. + visibility = "private" if needThisHandling else "public" + self.rethrowContentException = rethrowContentException + + self.wrapScope = wrapScope + # We don't care, for callback codegen, whether our original member was + # a method or attribute or whatnot. Just always pass FakeMember() + # here. + CGNativeMember.__init__(self, descriptorProvider, FakeMember(), + name, (self.retvalType, args), + extendedAttrs={}, + passJSBitsAsNeeded=False, + visibility=visibility, + typedArraysAreStructs=typedArraysAreStructs) + # We have to do all the generation of our body now, because + # the caller relies on us throwing if we can't manage it. + self.exceptionCode = ("aRv.Throw(NS_ERROR_UNEXPECTED);\n" + "return%s;\n" % self.getDefaultRetval()) + self.body = self.getImpl() + + def getImpl(self): + setupCall = self.getCallSetup() + declRval = self.getRvalDecl() + if self.argCount > 0: + argvDecl = fill( + """ + JS::AutoValueVector argv(cx); + if (!argv.resize(${argCount})) { + aRv.Throw(NS_ERROR_OUT_OF_MEMORY); + return${errorReturn}; + } + """, + argCount=self.argCountStr, + errorReturn=self.getDefaultRetval()) + else: + # Avoid weird 0-sized arrays + argvDecl = "" + convertArgs = self.getArgConversions() + doCall = self.getCall() + returnResult = self.getResultConversion() + + return setupCall + declRval + argvDecl + convertArgs + doCall + returnResult + + def getResultConversion(self): + replacements = { + "val": "rval", + "holderName": "rvalHolder", + "declName": "rvalDecl", + # We actually want to pass in a null scope object here, because + # wrapping things into our current compartment (that of mCallback) + # is what we want. + "obj": "nullptr", + "passedToJSImpl": "false" + } + + if isJSImplementedDescriptor(self.descriptorProvider): + isCallbackReturnValue = "JSImpl" + else: + isCallbackReturnValue = "Callback" + sourceDescription = "return value of %s" % self.getPrettyName() + convertType = instantiateJSToNativeConversion( + getJSToNativeConversionInfo(self.retvalType, + self.descriptorProvider, + exceptionCode=self.exceptionCode, + isCallbackReturnValue=isCallbackReturnValue, + # Allow returning a callback type that + # allows non-callable objects. + allowTreatNonCallableAsNull=True, + sourceDescription=sourceDescription), + replacements) + assignRetval = string.Template( + self.getRetvalInfo(self.retvalType, + False)[2]).substitute(replacements) + type = convertType.define() + return type + assignRetval + + def getArgConversions(self): + # Just reget the arglist from self.originalSig, because our superclasses + # just have way to many members they like to clobber, so I can't find a + # safe member name to store it in. + argConversions = [self.getArgConversion(i, arg) + for i, arg in enumerate(self.originalSig[1])] + if not argConversions: + return "\n" + + # Do them back to front, so our argc modifications will work + # correctly, because we examine trailing arguments first. + argConversions.reverse() + # Wrap each one in a scope so that any locals it has don't leak out, and + # also so that we can just "break;" for our successCode. + argConversions = [CGWrapper(CGIndenter(CGGeneric(c)), + pre="do {\n", + post="} while (0);\n") + for c in argConversions] + if self.argCount > 0: + argConversions.insert(0, self.getArgcDecl()) + # And slap them together. + return CGList(argConversions, "\n").define() + "\n" + + def getArgConversion(self, i, arg): + argval = arg.identifier.name + + if arg.variadic: + argval = argval + "[idx]" + jsvalIndex = "%d + idx" % i + else: + jsvalIndex = "%d" % i + if arg.canHaveMissingValue(): + argval += ".Value()" + if arg.type.isDOMString(): + # XPConnect string-to-JS conversion wants to mutate the string. So + # let's give it a string it can mutate + # XXXbz if we try to do a sequence of strings, this will kinda fail. + result = "mutableStr" + prepend = "nsString mutableStr(%s);\n" % argval + else: + result = argval + prepend = "" + + try: + conversion = prepend + wrapForType( + arg.type, self.descriptorProvider, + { + 'result': result, + 'successCode': "continue;\n" if arg.variadic else "break;\n", + 'jsvalRef': "argv[%s]" % jsvalIndex, + 'jsvalHandle': "argv[%s]" % jsvalIndex, + 'obj': self.wrapScope, + 'returnsNewObject': False, + 'exceptionCode': self.exceptionCode, + 'typedArraysAreStructs': self.typedArraysAreStructs + }) + except MethodNotNewObjectError as err: + raise TypeError("%s being passed as an argument to %s but is not " + "wrapper cached, so can't be reliably converted to " + "a JS object." % + (err.typename, self.getPrettyName())) + if arg.variadic: + conversion = fill( + """ + for (uint32_t idx = 0; idx < ${arg}.Length(); ++idx) { + $*{conversion} + } + break; + """, + arg=arg.identifier.name, + conversion=conversion) + elif arg.canHaveMissingValue(): + conversion = fill( + """ + if (${argName}.WasPassed()) { + $*{conversion} + } else if (argc == ${iPlus1}) { + // This is our current trailing argument; reduce argc + --argc; + } else { + argv[${i}].setUndefined(); + } + """, + argName=arg.identifier.name, + conversion=conversion, + iPlus1=i + 1, + i=i) + return conversion + + def getDefaultRetval(self): + default = self.getRetvalInfo(self.retvalType, False)[1] + if len(default) != 0: + default = " " + default + return default + + def getArgs(self, returnType, argList): + args = CGNativeMember.getArgs(self, returnType, argList) + if not self.needThisHandling: + # Since we don't need this handling, we're the actual method that + # will be called, so we need an aRethrowExceptions argument. + if not self.rethrowContentException: + args.append(Argument("const char*", "aExecutionReason", + "nullptr")) + args.append(Argument("ExceptionHandling", "aExceptionHandling", + "eReportExceptions")) + args.append(Argument("JSCompartment*", "aCompartment", "nullptr")) + return args + # We want to allow the caller to pass in a "this" value, as + # well as a JSContext. + return [Argument("JSContext*", "cx"), + Argument("JS::Handle<JS::Value>", "aThisVal")] + args + + def getCallSetup(self): + if self.needThisHandling: + # It's been done for us already + return "" + callSetup = "CallSetup s(this, aRv" + if self.rethrowContentException: + # getArgs doesn't add the aExceptionHandling argument but does add + # aCompartment for us. + callSetup += ', "%s", eRethrowContentExceptions, aCompartment, /* aIsJSImplementedWebIDL = */ ' % self.getPrettyName() + callSetup += toStringBool(isJSImplementedDescriptor(self.descriptorProvider)) + else: + callSetup += ', "%s", aExceptionHandling, aCompartment' % self.getPrettyName() + callSetup += ");\n" + return fill( + """ + $*{callSetup} + JSContext* cx = s.GetContext(); + if (!cx) { + MOZ_ASSERT(aRv.Failed()); + return${errorReturn}; + } + """, + callSetup=callSetup, + errorReturn=self.getDefaultRetval()) + + def getArgcDecl(self): + return CGGeneric("unsigned argc = %s;\n" % self.argCountStr) + + @staticmethod + def ensureASCIIName(idlObject): + type = "attribute" if idlObject.isAttr() else "operation" + if re.match("[^\x20-\x7E]", idlObject.identifier.name): + raise SyntaxError('Callback %s name "%s" contains non-ASCII ' + "characters. We can't handle that. %s" % + (type, idlObject.identifier.name, + idlObject.location)) + if re.match('"', idlObject.identifier.name): + raise SyntaxError("Callback %s name '%s' contains " + "double-quote character. We can't handle " + "that. %s" % + (type, idlObject.identifier.name, + idlObject.location)) + + +class CallbackMethod(CallbackMember): + def __init__(self, sig, name, descriptorProvider, needThisHandling, + rethrowContentException=False, typedArraysAreStructs=False): + CallbackMember.__init__(self, sig, name, descriptorProvider, + needThisHandling, rethrowContentException, + typedArraysAreStructs=typedArraysAreStructs) + + def getRvalDecl(self): + return "JS::Rooted<JS::Value> rval(cx, JS::UndefinedValue());\n" + + def getCall(self): + if self.argCount > 0: + args = "JS::HandleValueArray::subarray(argv, 0, argc)" + else: + args = "JS::HandleValueArray::empty()" + + return fill( + """ + $*{declCallable} + $*{declThis} + if (${callGuard}!JS::Call(cx, ${thisVal}, callable, + ${args}, &rval)) { + aRv.NoteJSContextException(cx); + return${errorReturn}; + } + """, + declCallable=self.getCallableDecl(), + declThis=self.getThisDecl(), + callGuard=self.getCallGuard(), + thisVal=self.getThisVal(), + args=args, + errorReturn=self.getDefaultRetval()) + + +class CallCallback(CallbackMethod): + def __init__(self, callback, descriptorProvider): + self.callback = callback + CallbackMethod.__init__(self, callback.signatures()[0], "Call", + descriptorProvider, needThisHandling=True) + + def getThisDecl(self): + return "" + + def getThisVal(self): + return "aThisVal" + + def getCallableDecl(self): + return "JS::Rooted<JS::Value> callable(cx, JS::ObjectValue(*mCallback));\n" + + def getPrettyName(self): + return self.callback.identifier.name + + def getCallGuard(self): + if self.callback._treatNonObjectAsNull: + return "JS::IsCallable(mCallback) && " + return "" + + +class CallbackOperationBase(CallbackMethod): + """ + Common class for implementing various callback operations. + """ + def __init__(self, signature, jsName, nativeName, descriptor, + singleOperation, rethrowContentException=False, + typedArraysAreStructs=False): + self.singleOperation = singleOperation + self.methodName = descriptor.binaryNameFor(jsName) + CallbackMethod.__init__(self, signature, nativeName, descriptor, + singleOperation, rethrowContentException, + typedArraysAreStructs=typedArraysAreStructs) + + def getThisDecl(self): + if not self.singleOperation: + return "JS::Rooted<JS::Value> thisValue(cx, JS::ObjectValue(*mCallback));\n" + # This relies on getCallableDecl declaring a boolean + # isCallable in the case when we're a single-operation + # interface. + return dedent(""" + JS::Rooted<JS::Value> thisValue(cx, isCallable ? aThisVal.get() + : JS::ObjectValue(*mCallback)); + """) + + def getThisVal(self): + return "thisValue" + + def getCallableDecl(self): + getCallableFromProp = fill( + """ + ${atomCacheName}* atomsCache = GetAtomCache<${atomCacheName}>(cx); + if ((!*reinterpret_cast<jsid**>(atomsCache) && !InitIds(cx, atomsCache)) || + !GetCallableProperty(cx, atomsCache->${methodAtomName}, &callable)) { + aRv.Throw(NS_ERROR_UNEXPECTED); + return${errorReturn}; + } + """, + methodAtomName=CGDictionary.makeIdName(self.methodName), + atomCacheName=self.descriptorProvider.interface.identifier.name + "Atoms", + errorReturn=self.getDefaultRetval()) + if not self.singleOperation: + return 'JS::Rooted<JS::Value> callable(cx);\n' + getCallableFromProp + return fill( + """ + bool isCallable = JS::IsCallable(mCallback); + JS::Rooted<JS::Value> callable(cx); + if (isCallable) { + callable = JS::ObjectValue(*mCallback); + } else { + $*{getCallableFromProp} + } + """, + getCallableFromProp=getCallableFromProp) + + def getCallGuard(self): + return "" + + +class CallbackOperation(CallbackOperationBase): + """ + Codegen actual WebIDL operations on callback interfaces. + """ + def __init__(self, method, signature, descriptor, typedArraysAreStructs): + self.ensureASCIIName(method) + self.method = method + jsName = method.identifier.name + CallbackOperationBase.__init__(self, signature, + jsName, + MakeNativeName(descriptor.binaryNameFor(jsName)), + descriptor, descriptor.interface.isSingleOperationInterface(), + rethrowContentException=descriptor.interface.isJSImplemented(), + typedArraysAreStructs=typedArraysAreStructs) + + def getPrettyName(self): + return "%s.%s" % (self.descriptorProvider.interface.identifier.name, + self.method.identifier.name) + + +class CallbackAccessor(CallbackMember): + """ + Shared superclass for CallbackGetter and CallbackSetter. + """ + def __init__(self, attr, sig, name, descriptor, typedArraysAreStructs): + self.ensureASCIIName(attr) + self.attrName = attr.identifier.name + CallbackMember.__init__(self, sig, name, descriptor, + needThisHandling=False, + rethrowContentException=descriptor.interface.isJSImplemented(), + typedArraysAreStructs=typedArraysAreStructs) + + def getPrettyName(self): + return "%s.%s" % (self.descriptorProvider.interface.identifier.name, + self.attrName) + + +class CallbackGetter(CallbackAccessor): + def __init__(self, attr, descriptor, typedArraysAreStructs): + CallbackAccessor.__init__(self, attr, + (attr.type, []), + callbackGetterName(attr, descriptor), + descriptor, + typedArraysAreStructs) + + def getRvalDecl(self): + return "JS::Rooted<JS::Value> rval(cx, JS::UndefinedValue());\n" + + def getCall(self): + return fill( + """ + JS::Rooted<JSObject *> callback(cx, mCallback); + ${atomCacheName}* atomsCache = GetAtomCache<${atomCacheName}>(cx); + if ((!*reinterpret_cast<jsid**>(atomsCache) && !InitIds(cx, atomsCache)) || + !JS_GetPropertyById(cx, callback, atomsCache->${attrAtomName}, &rval)) { + aRv.Throw(NS_ERROR_UNEXPECTED); + return${errorReturn}; + } + """, + atomCacheName=self.descriptorProvider.interface.identifier.name + "Atoms", + attrAtomName=CGDictionary.makeIdName(self.descriptorProvider.binaryNameFor(self.attrName)), + errorReturn=self.getDefaultRetval()) + + +class CallbackSetter(CallbackAccessor): + def __init__(self, attr, descriptor, typedArraysAreStructs): + CallbackAccessor.__init__(self, attr, + (BuiltinTypes[IDLBuiltinType.Types.void], + [FakeArgument(attr.type, attr)]), + callbackSetterName(attr, descriptor), + descriptor, typedArraysAreStructs) + + def getRvalDecl(self): + # We don't need an rval + return "" + + def getCall(self): + return fill( + """ + MOZ_ASSERT(argv.length() == 1); + ${atomCacheName}* atomsCache = GetAtomCache<${atomCacheName}>(cx); + if ((!*reinterpret_cast<jsid**>(atomsCache) && !InitIds(cx, atomsCache)) || + !JS_SetPropertyById(cx, CallbackKnownNotGray(), atomsCache->${attrAtomName}, argv[0])) { + aRv.Throw(NS_ERROR_UNEXPECTED); + return${errorReturn}; + } + """, + atomCacheName=self.descriptorProvider.interface.identifier.name + "Atoms", + attrAtomName=CGDictionary.makeIdName(self.descriptorProvider.binaryNameFor(self.attrName)), + errorReturn=self.getDefaultRetval()) + + def getArgcDecl(self): + return None + + +class CGJSImplInitOperation(CallbackOperationBase): + """ + Codegen the __Init() method used to pass along constructor arguments for JS-implemented WebIDL. + """ + def __init__(self, sig, descriptor): + assert sig in descriptor.interface.ctor().signatures() + CallbackOperationBase.__init__(self, (BuiltinTypes[IDLBuiltinType.Types.void], sig[1]), + "__init", "__Init", descriptor, + singleOperation=False, + rethrowContentException=True, + typedArraysAreStructs=True) + + def getPrettyName(self): + return "__init" + + +def getMaplikeOrSetlikeErrorReturn(helperImpl): + """ + Generate return values based on whether a maplike or setlike generated + method is an interface method (which returns bool) or a helper function + (which uses ErrorResult). + """ + if helperImpl: + return dedent( + """ + aRv.Throw(NS_ERROR_UNEXPECTED); + return%s; + """ % helperImpl.getDefaultRetval()) + return "return false;\n" + + +def getMaplikeOrSetlikeBackingObject(descriptor, maplikeOrSetlike, helperImpl=None): + """ + Generate code to get/create a JS backing object for a maplike/setlike + declaration from the declaration slot. + """ + func_prefix = maplikeOrSetlike.maplikeOrSetlikeOrIterableType.title() + ret = fill( + """ + JS::Rooted<JSObject*> backingObj(cx); + bool created = false; + if (!Get${func_prefix}BackingObject(cx, obj, ${slot}, &backingObj, &created)) { + $*{errorReturn} + } + if (created) { + PreserveWrapper<${selfType}>(self); + } + """, + slot=memberReservedSlot(maplikeOrSetlike, descriptor), + func_prefix=func_prefix, + errorReturn=getMaplikeOrSetlikeErrorReturn(helperImpl), + selfType=descriptor.nativeType) + return ret + + +def getMaplikeOrSetlikeSizeGetterBody(descriptor, attr): + """ + Creates the body for the size getter method of maplike/setlike interfaces. + """ + # We should only have one declaration attribute currently + assert attr.identifier.name == "size" + assert attr.isMaplikeOrSetlikeAttr() + return fill( + """ + $*{getBackingObj} + uint32_t result = JS::${funcPrefix}Size(cx, backingObj); + MOZ_ASSERT(!JS_IsExceptionPending(cx)); + args.rval().setNumber(result); + return true; + """, + getBackingObj=getMaplikeOrSetlikeBackingObject(descriptor, + attr.maplikeOrSetlike), + funcPrefix=attr.maplikeOrSetlike.prefix) + + +class CGMaplikeOrSetlikeMethodGenerator(CGThing): + """ + Creates methods for maplike/setlike interfaces. It is expected that all + methods will be have a maplike/setlike object attached. Unwrapping/wrapping + will be taken care of by the usual method generation machinery in + CGMethodCall/CGPerSignatureCall. Functionality is filled in here instead of + using CGCallGenerator. + """ + def __init__(self, descriptor, maplikeOrSetlike, methodName, + helperImpl=None): + CGThing.__init__(self) + # True if this will be the body of a C++ helper function. + self.helperImpl = helperImpl + self.descriptor = descriptor + self.maplikeOrSetlike = maplikeOrSetlike + self.cgRoot = CGList([]) + impl_method_name = methodName + if impl_method_name[0] == "_": + # double underscore means this is a js-implemented chrome only rw + # function. Truncate the double underscore so calling the right + # underlying JSAPI function still works. + impl_method_name = impl_method_name[2:] + self.cgRoot.append(CGGeneric( + getMaplikeOrSetlikeBackingObject(self.descriptor, + self.maplikeOrSetlike, + self.helperImpl))) + self.returnStmt = getMaplikeOrSetlikeErrorReturn(self.helperImpl) + + # Generates required code for the method. Method descriptions included + # in definitions below. Throw if we don't have a method to fill in what + # we're looking for. + try: + methodGenerator = getattr(self, impl_method_name) + except AttributeError: + raise TypeError("Missing %s method definition '%s'" % + (self.maplikeOrSetlike.maplikeOrSetlikeType, + methodName)) + # Method generator returns tuple, containing: + # + # - a list of CGThings representing setup code for preparing to call + # the JS API function + # - a list of arguments needed for the JS API function we're calling + # - list of code CGThings needed for return value conversion. + (setupCode, arguments, setResult) = methodGenerator() + + # Create the actual method call, and then wrap it with the code to + # return the value if needed. + funcName = (self.maplikeOrSetlike.prefix + + MakeNativeName(impl_method_name)) + # Append the list of setup code CGThings + self.cgRoot.append(CGList(setupCode)) + # Create the JS API call + self.cgRoot.append(CGWrapper( + CGGeneric(fill( + """ + if (!JS::${funcName}(${args})) { + $*{errorReturn} + } + """, + funcName=funcName, + args=", ".join(["cx", "backingObj"] + arguments), + errorReturn=self.returnStmt)))) + # Append result conversion + self.cgRoot.append(CGList(setResult)) + + def mergeTuples(self, a, b): + """ + Expecting to take 2 tuples were all elements are lists, append the lists in + the second tuple to the lists in the first. + """ + return tuple([x + y for x, y in zip(a, b)]) + + def appendArgConversion(self, name): + """ + Generate code to convert arguments to JS::Values, so they can be + passed into JSAPI functions. + """ + return CGGeneric(fill( + """ + JS::Rooted<JS::Value> ${name}Val(cx); + if (!ToJSValue(cx, ${name}, &${name}Val)) { + $*{errorReturn} + } + """, + name=name, + errorReturn=self.returnStmt)) + + def appendKeyArgConversion(self): + """ + Generates the key argument for methods. Helper functions will use + an AutoValueVector, while interface methods have seperate JS::Values. + """ + if self.helperImpl: + return ([], ["argv[0]"], []) + return ([self.appendArgConversion("arg0")], ["arg0Val"], []) + + def appendKeyAndValueArgConversion(self): + """ + Generates arguments for methods that require a key and value. Helper + functions will use an AutoValueVector, while interface methods have + seperate JS::Values. + """ + r = self.appendKeyArgConversion() + if self.helperImpl: + return self.mergeTuples(r, ([], ["argv[1]"], [])) + return self.mergeTuples(r, ([self.appendArgConversion("arg1")], + ["arg1Val"], + [])) + + def appendIteratorResult(self): + """ + Generate code to output JSObject* return values, needed for functions that + return iterators. Iterators cannot currently be wrapped via Xrays. If + something that would return an iterator is called via Xray, fail early. + """ + # TODO: Bug 1173651 - Remove check once bug 1023984 is fixed. + code = CGGeneric(dedent( + """ + // TODO (Bug 1173651): Xrays currently cannot wrap iterators. Change + // after bug 1023984 is fixed. + if (xpc::WrapperFactory::IsXrayWrapper(obj)) { + JS_ReportErrorASCII(cx, "Xray wrapping of iterators not supported."); + return false; + } + JS::Rooted<JSObject*> result(cx); + JS::Rooted<JS::Value> v(cx); + """)) + arguments = "&v" + setResult = CGGeneric(dedent( + """ + result = &v.toObject(); + """)) + return ([code], [arguments], [setResult]) + + def appendSelfResult(self): + """ + Generate code to return the interface object itself. + """ + code = CGGeneric(dedent( + """ + JS::Rooted<JSObject*> result(cx); + """)) + setResult = CGGeneric(dedent( + """ + result = obj; + """)) + return ([code], [], [setResult]) + + def appendBoolResult(self): + if self.helperImpl: + return ([CGGeneric()], ["&aRetVal"], []) + return ([CGGeneric("bool result;\n")], ["&result"], []) + + def forEach(self): + """ + void forEach(callback c, any thisval); + + ForEach takes a callback, and a possible value to use as 'this'. The + callback needs to take value, key, and the interface object + implementing maplike/setlike. In order to make sure that the third arg + is our interface object instead of the map/set backing object, we + create a js function with the callback and original object in its + storage slots, then use a helper function in BindingUtils to make sure + the callback is called correctly. + """ + assert(not self.helperImpl) + code = [CGGeneric(dedent( + """ + // Create a wrapper function. + JSFunction* func = js::NewFunctionWithReserved(cx, ForEachHandler, 3, 0, nullptr); + if (!func) { + return false; + } + JS::Rooted<JSObject*> funcObj(cx, JS_GetFunctionObject(func)); + JS::Rooted<JS::Value> funcVal(cx, JS::ObjectValue(*funcObj)); + js::SetFunctionNativeReserved(funcObj, FOREACH_CALLBACK_SLOT, + JS::ObjectValue(*arg0)); + js::SetFunctionNativeReserved(funcObj, FOREACH_MAPLIKEORSETLIKEOBJ_SLOT, + JS::ObjectValue(*obj)); + """))] + arguments = ["funcVal", "arg1"] + return (code, arguments, []) + + def set(self): + """ + object set(key, value); + + Maplike only function, takes key and sets value to it, returns + interface object unless being called from a C++ helper. + """ + assert self.maplikeOrSetlike.isMaplike() + r = self.appendKeyAndValueArgConversion() + if self.helperImpl: + return r + return self.mergeTuples(r, self.appendSelfResult()) + + def add(self): + """ + object add(value); + + Setlike only function, adds value to set, returns interface object + unless being called from a C++ helper + """ + assert self.maplikeOrSetlike.isSetlike() + r = self.appendKeyArgConversion() + if self.helperImpl: + return r + return self.mergeTuples(r, self.appendSelfResult()) + + def get(self): + """ + type? get(key); + + Retrieves a value from a backing object based on the key. Returns value + if key is in backing object, undefined otherwise. + """ + assert self.maplikeOrSetlike.isMaplike() + r = self.appendKeyArgConversion() + code = [CGGeneric(dedent( + """ + JS::Rooted<JS::Value> result(cx); + """))] + arguments = ["&result"] + return self.mergeTuples(r, (code, arguments, [])) + + def has(self): + """ + bool has(key); + + Check if an entry exists in the backing object. Returns true if value + exists in backing object, false otherwise. + """ + return self.mergeTuples(self.appendKeyArgConversion(), + self.appendBoolResult()) + + def keys(self): + """ + object keys(); + + Returns new object iterator with all keys from backing object. + """ + return self.appendIteratorResult() + + def values(self): + """ + object values(); + + Returns new object iterator with all values from backing object. + """ + return self.appendIteratorResult() + + def entries(self): + """ + object entries(); + + Returns new object iterator with all keys and values from backing + object. Keys will be null for set. + """ + return self.appendIteratorResult() + + def clear(self): + """ + void clear(); + + Removes all entries from map/set. + """ + return ([], [], []) + + def delete(self): + """ + bool delete(key); + + Deletes an entry from the backing object. Returns true if value existed + in backing object, false otherwise. + """ + return self.mergeTuples(self.appendKeyArgConversion(), + self.appendBoolResult()) + + def define(self): + return self.cgRoot.define() + + +class CGMaplikeOrSetlikeHelperFunctionGenerator(CallbackMember): + """ + Generates code to allow C++ to perform operations on backing objects. Gets + a context from the binding wrapper, turns arguments into JS::Values (via + CallbackMember/CGNativeMember argument conversion), then uses + CGMaplikeOrSetlikeMethodGenerator to generate the body. + + """ + + class HelperFunction(CGAbstractMethod): + """ + Generates context retrieval code and rooted JSObject for interface for + CGMaplikeOrSetlikeMethodGenerator to use + """ + def __init__(self, descriptor, name, args, code, needsBoolReturn=False): + self.code = code + CGAbstractMethod.__init__(self, descriptor, name, + "bool" if needsBoolReturn else "void", + args) + + def definition_body(self): + return self.code + + def __init__(self, descriptor, maplikeOrSetlike, name, needsKeyArg=False, + needsValueArg=False, needsBoolReturn=False): + args = [] + self.maplikeOrSetlike = maplikeOrSetlike + self.needsBoolReturn = needsBoolReturn + if needsKeyArg: + args.append(FakeArgument(maplikeOrSetlike.keyType, None, 'aKey')) + if needsValueArg: + assert needsKeyArg + args.append(FakeArgument(maplikeOrSetlike.valueType, None, 'aValue')) + # Run CallbackMember init function to generate argument conversion code. + # wrapScope is set to 'obj' when generating maplike or setlike helper + # functions, as we don't have access to the CallbackPreserveColor + # method. + CallbackMember.__init__(self, + [BuiltinTypes[IDLBuiltinType.Types.void], args], + name, descriptor, False, + wrapScope='obj') + # Wrap CallbackMember body code into a CGAbstractMethod to make + # generation easier. + self.implMethod = CGMaplikeOrSetlikeHelperFunctionGenerator.HelperFunction( + descriptor, name, self.args, self.body, needsBoolReturn) + + def getCallSetup(self): + return dedent( + """ + MOZ_ASSERT(self); + AutoJSAPI jsapi; + jsapi.Init(); + JSContext* cx = jsapi.cx(); + // It's safe to use UnprivilegedJunkScopeOrWorkerGlobal here because + // all we want is to wrap into _some_ scope and then unwrap to find + // the reflector, and wrapping has no side-effects. + JSAutoCompartment tempCompartment(cx, binding_detail::UnprivilegedJunkScopeOrWorkerGlobal()); + JS::Rooted<JS::Value> v(cx); + if(!ToJSValue(cx, self, &v)) { + aRv.Throw(NS_ERROR_UNEXPECTED); + return%s; + } + // This is a reflector, but due to trying to name things + // similarly across method generators, it's called obj here. + JS::Rooted<JSObject*> obj(cx); + obj = js::UncheckedUnwrap(&v.toObject(), /* stopAtWindowProxy = */ false); + JSAutoCompartment reflectorCompartment(cx, obj); + """ % self.getDefaultRetval()) + + def getArgs(self, returnType, argList): + # We don't need the context or the value. We'll generate those instead. + args = CGNativeMember.getArgs(self, returnType, argList) + # Prepend a pointer to the binding object onto the arguments + return [Argument(self.descriptorProvider.nativeType + "*", "self")] + args + + def getResultConversion(self): + if self.needsBoolReturn: + return "return aRetVal;\n" + return "return;\n" + + def getRvalDecl(self): + if self.needsBoolReturn: + return "bool aRetVal;\n" + return "" + + def getArgcDecl(self): + # Don't need argc for anything. + return None + + def getDefaultRetval(self): + if self.needsBoolReturn: + return " false" + return "" + + def getCall(self): + return CGMaplikeOrSetlikeMethodGenerator(self.descriptorProvider, + self.maplikeOrSetlike, + self.name.lower(), + helperImpl=self).define() + + def getPrettyName(self): + return self.name + + def declare(self): + return self.implMethod.declare() + + def define(self): + return self.implMethod.define() + + +class CGMaplikeOrSetlikeHelperGenerator(CGNamespace): + """ + Declares and defines convenience methods for accessing backing objects on + setlike/maplike interface. Generates function signatures, un/packs + backing objects from slot, etc. + """ + def __init__(self, descriptor, maplikeOrSetlike): + self.descriptor = descriptor + # Since iterables are folded in with maplike/setlike, make sure we've + # got the right type here. + assert maplikeOrSetlike.isMaplike() or maplikeOrSetlike.isSetlike() + self.maplikeOrSetlike = maplikeOrSetlike + self.namespace = "%sHelpers" % (self.maplikeOrSetlike.maplikeOrSetlikeOrIterableType.title()) + self.helpers = [ + CGMaplikeOrSetlikeHelperFunctionGenerator(descriptor, + maplikeOrSetlike, + "Clear"), + CGMaplikeOrSetlikeHelperFunctionGenerator(descriptor, + maplikeOrSetlike, + "Delete", + needsKeyArg=True, + needsBoolReturn=True), + CGMaplikeOrSetlikeHelperFunctionGenerator(descriptor, + maplikeOrSetlike, + "Has", + needsKeyArg=True, + needsBoolReturn=True)] + if self.maplikeOrSetlike.isMaplike(): + self.helpers.append( + CGMaplikeOrSetlikeHelperFunctionGenerator(descriptor, + maplikeOrSetlike, + "Set", + needsKeyArg=True, + needsValueArg=True)) + else: + assert(self.maplikeOrSetlike.isSetlike()) + self.helpers.append( + CGMaplikeOrSetlikeHelperFunctionGenerator(descriptor, + maplikeOrSetlike, + "Add", + needsKeyArg=True)) + CGNamespace.__init__(self, self.namespace, CGList(self.helpers)) + + +class CGIterableMethodGenerator(CGGeneric): + """ + Creates methods for iterable interfaces. Unwrapping/wrapping + will be taken care of by the usual method generation machinery in + CGMethodCall/CGPerSignatureCall. Functionality is filled in here instead of + using CGCallGenerator. + """ + def __init__(self, descriptor, iterable, methodName): + if methodName == "forEach": + CGGeneric.__init__(self, fill( + """ + if (!JS::IsCallable(arg0)) { + ThrowErrorMessage(cx, MSG_NOT_CALLABLE, "Argument 1 of ${ifaceName}.forEach"); + return false; + } + JS::AutoValueArray<3> callArgs(cx); + callArgs[2].setObject(*obj); + JS::Rooted<JS::Value> ignoredReturnVal(cx); + for (size_t i = 0; i < self->GetIterableLength(); ++i) { + if (!ToJSValue(cx, self->GetValueAtIndex(i), callArgs[0])) { + return false; + } + if (!ToJSValue(cx, self->GetKeyAtIndex(i), callArgs[1])) { + return false; + } + if (!JS::Call(cx, arg1, arg0, JS::HandleValueArray(callArgs), + &ignoredReturnVal)) { + return false; + } + } + """, + ifaceName=descriptor.interface.identifier.name)) + return + CGGeneric.__init__(self, fill( + """ + typedef ${iterClass} itrType; + RefPtr<itrType> result(new itrType(self, + itrType::IterableIteratorType::${itrMethod}, + &${ifaceName}IteratorBinding::Wrap)); + """, + iterClass=iteratorNativeType(descriptor), + ifaceName=descriptor.interface.identifier.name, + itrMethod=methodName.title())) + + +class GlobalGenRoots(): + """ + Roots for global codegen. + + To generate code, call the method associated with the target, and then + call the appropriate define/declare method. + """ + + @staticmethod + def GeneratedAtomList(config): + # Atom enum + dictionaries = config.dictionaries + + structs = [] + + def memberToAtomCacheMember(binaryNameFor, m): + binaryMemberName = binaryNameFor(m.identifier.name) + return ClassMember(CGDictionary.makeIdName(binaryMemberName), + "PinnedStringId", visibility="public") + + def buildAtomCacheStructure(idlobj, binaryNameFor, members): + classMembers = [memberToAtomCacheMember(binaryNameFor, m) + for m in members] + structName = idlobj.identifier.name + "Atoms" + return (structName, + CGWrapper(CGClass(structName, + bases=None, + isStruct=True, + members=classMembers), post='\n')) + + for dict in dictionaries: + if len(dict.members) == 0: + continue + + structs.append(buildAtomCacheStructure(dict, lambda x: x, dict.members)) + + for d in (config.getDescriptors(isJSImplemented=True) + + config.getDescriptors(isCallback=True)): + members = [m for m in d.interface.members if m.isAttr() or m.isMethod()] + if d.interface.isJSImplemented() and d.interface.ctor(): + # We'll have an __init() method. + members.append(FakeMember('__init')) + if len(members) == 0: + continue + + structs.append(buildAtomCacheStructure(d.interface, + lambda x: d.binaryNameFor(x), + members)) + + structs.sort() + generatedStructs = [struct for structName, struct in structs] + structNames = [structName for structName, struct in structs] + + mainStruct = CGWrapper(CGClass("PerThreadAtomCache", + bases=[ClassBase(structName) for structName in structNames], + isStruct=True), + post='\n') + + structs = CGList(generatedStructs + [mainStruct]) + + # Wrap all of that in our namespaces. + curr = CGNamespace.build(['mozilla', 'dom'], + CGWrapper(structs, pre='\n')) + curr = CGWrapper(curr, post='\n') + + # Add include statement for PinnedStringId. + declareIncludes = ['mozilla/dom/BindingUtils.h'] + curr = CGHeaders([], [], [], [], declareIncludes, [], 'GeneratedAtomList', + curr) + + # Add include guards. + curr = CGIncludeGuard('GeneratedAtomList', curr) + + # Add the auto-generated comment. + curr = CGWrapper(curr, pre=AUTOGENERATED_WARNING_COMMENT) + + # Done. + return curr + + @staticmethod + def GeneratedEventList(config): + eventList = CGList([]) + for generatedEvent in config.generatedEvents: + eventList.append(CGGeneric(declare=("GENERATED_EVENT(%s)\n" % generatedEvent))) + return eventList + + @staticmethod + def PrototypeList(config): + + # Prototype ID enum. + descriptorsWithPrototype = config.getDescriptors(hasInterfacePrototypeObject=True) + protos = [d.name for d in descriptorsWithPrototype] + idEnum = CGNamespacedEnum('id', 'ID', ['_ID_Start'] + protos, + [0, '_ID_Start']) + idEnum = CGList([idEnum]) + + def fieldSizeAssert(amount, jitInfoField, message): + maxFieldValue = "(uint64_t(1) << (sizeof(((JSJitInfo*)nullptr)->%s) * 8))" % jitInfoField + return CGGeneric(declare="static_assert(%s < %s, \"%s\");\n\n" + % (amount, maxFieldValue, message)) + + idEnum.append(fieldSizeAssert("id::_ID_Count", "protoID", + "Too many prototypes!")) + + # Wrap all of that in our namespaces. + idEnum = CGNamespace.build(['mozilla', 'dom', 'prototypes'], + CGWrapper(idEnum, pre='\n')) + idEnum = CGWrapper(idEnum, post='\n') + + curr = CGList([CGGeneric(define="#include <stdint.h>\n\n"), + idEnum]) + + # Let things know the maximum length of the prototype chain. + maxMacroName = "MAX_PROTOTYPE_CHAIN_LENGTH" + maxMacro = CGGeneric(declare="#define " + maxMacroName + " " + str(config.maxProtoChainLength)) + curr.append(CGWrapper(maxMacro, post='\n\n')) + curr.append(fieldSizeAssert(maxMacroName, "depth", + "Some inheritance chain is too long!")) + + # Constructor ID enum. + constructors = [d.name for d in config.getDescriptors(hasInterfaceObject=True)] + idEnum = CGNamespacedEnum('id', 'ID', ['_ID_Start'] + constructors, + ['prototypes::id::_ID_Count', '_ID_Start']) + + # Wrap all of that in our namespaces. + idEnum = CGNamespace.build(['mozilla', 'dom', 'constructors'], + CGWrapper(idEnum, pre='\n')) + idEnum = CGWrapper(idEnum, post='\n') + + curr.append(idEnum) + + # Named properties object enum. + namedPropertiesObjects = [d.name for d in config.getDescriptors(hasNamedPropertiesObject=True)] + idEnum = CGNamespacedEnum('id', 'ID', ['_ID_Start'] + namedPropertiesObjects, + ['constructors::id::_ID_Count', '_ID_Start']) + + # Wrap all of that in our namespaces. + idEnum = CGNamespace.build(['mozilla', 'dom', 'namedpropertiesobjects'], + CGWrapper(idEnum, pre='\n')) + idEnum = CGWrapper(idEnum, post='\n') + + curr.append(idEnum) + + traitsDecls = [CGGeneric(declare=dedent(""" + template <prototypes::ID PrototypeID> + struct PrototypeTraits; + """))] + traitsDecls.extend(CGPrototypeTraitsClass(d) for d in descriptorsWithPrototype) + + ifaceNamesWithProto = [d.interface.identifier.name + for d in descriptorsWithPrototype] + traitsDecls.append(CGStringTable("NamesOfInterfacesWithProtos", + ifaceNamesWithProto)) + + traitsDecl = CGNamespace.build(['mozilla', 'dom'], + CGList(traitsDecls)) + + curr.append(traitsDecl) + + # Add include guards. + curr = CGIncludeGuard('PrototypeList', curr) + + # Add the auto-generated comment. + curr = CGWrapper(curr, pre=AUTOGENERATED_WARNING_COMMENT) + + # Done. + return curr + + @staticmethod + def RegisterBindings(config): + + curr = CGList([CGGlobalNamesString(config), CGRegisterGlobalNames(config)]) + + # Wrap all of that in our namespaces. + curr = CGNamespace.build(['mozilla', 'dom'], + CGWrapper(curr, post='\n')) + curr = CGWrapper(curr, post='\n') + + # Add the includes + defineIncludes = [CGHeaders.getDeclarationFilename(desc.interface) + for desc in config.getDescriptors(hasInterfaceObject=True, + isExposedInWindow=True, + register=True)] + defineIncludes.append('mozilla/dom/WebIDLGlobalNameHash.h') + defineIncludes.extend([CGHeaders.getDeclarationFilename(desc.interface) + for desc in config.getDescriptors(isNavigatorProperty=True, + register=True)]) + curr = CGHeaders([], [], [], [], [], defineIncludes, 'RegisterBindings', + curr) + + # Add include guards. + curr = CGIncludeGuard('RegisterBindings', curr) + + # Done. + return curr + + @staticmethod + def RegisterWorkerBindings(config): + + curr = CGRegisterWorkerBindings(config) + + # Wrap all of that in our namespaces. + curr = CGNamespace.build(['mozilla', 'dom'], + CGWrapper(curr, post='\n')) + curr = CGWrapper(curr, post='\n') + + # Add the includes + defineIncludes = [CGHeaders.getDeclarationFilename(desc.interface) + for desc in config.getDescriptors(hasInterfaceObject=True, + register=True, + isExposedInAnyWorker=True)] + + curr = CGHeaders([], [], [], [], [], defineIncludes, + 'RegisterWorkerBindings', curr) + + # Add include guards. + curr = CGIncludeGuard('RegisterWorkerBindings', curr) + + # Done. + return curr + + @staticmethod + def RegisterWorkerDebuggerBindings(config): + + curr = CGRegisterWorkerDebuggerBindings(config) + + # Wrap all of that in our namespaces. + curr = CGNamespace.build(['mozilla', 'dom'], + CGWrapper(curr, post='\n')) + curr = CGWrapper(curr, post='\n') + + # Add the includes + defineIncludes = [CGHeaders.getDeclarationFilename(desc.interface) + for desc in config.getDescriptors(hasInterfaceObject=True, + register=True, + isExposedInWorkerDebugger=True)] + + curr = CGHeaders([], [], [], [], [], defineIncludes, + 'RegisterWorkerDebuggerBindings', curr) + + # Add include guards. + curr = CGIncludeGuard('RegisterWorkerDebuggerBindings', curr) + + # Done. + return curr + + @staticmethod + def RegisterWorkletBindings(config): + + curr = CGRegisterWorkletBindings(config) + + # Wrap all of that in our namespaces. + curr = CGNamespace.build(['mozilla', 'dom'], + CGWrapper(curr, post='\n')) + curr = CGWrapper(curr, post='\n') + + # Add the includes + defineIncludes = [CGHeaders.getDeclarationFilename(desc.interface) + for desc in config.getDescriptors(hasInterfaceObject=True, + register=True, + isExposedInAnyWorklet=True)] + + curr = CGHeaders([], [], [], [], [], defineIncludes, + 'RegisterWorkletBindings', curr) + + # Add include guards. + curr = CGIncludeGuard('RegisterWorkletBindings', curr) + + # Done. + return curr + + @staticmethod + def ResolveSystemBinding(config): + + curr = CGResolveSystemBinding(config) + + # Wrap all of that in our namespaces. + curr = CGNamespace.build(['mozilla', 'dom'], + CGWrapper(curr, post='\n')) + curr = CGWrapper(curr, post='\n') + + # Add the includes + defineIncludes = [CGHeaders.getDeclarationFilename(desc.interface) + for desc in config.getDescriptors(hasInterfaceObject=True, + register=True, + isExposedInSystemGlobals=True)] + defineIncludes.append("nsThreadUtils.h") # For NS_IsMainThread + defineIncludes.append("js/Id.h") # For jsid + defineIncludes.append("mozilla/dom/BindingUtils.h") # AtomizeAndPinJSString + + curr = CGHeaders([], [], [], [], [], defineIncludes, + 'ResolveSystemBinding', curr) + + # Add include guards. + curr = CGIncludeGuard('ResolveSystemBinding', curr) + + # Done. + return curr + + @staticmethod + def UnionTypes(config): + unionTypes = UnionsForFile(config, None) + (includes, implincludes, declarations, + traverseMethods, unlinkMethods, + unionStructs) = UnionTypes(unionTypes, config) + + unions = CGList(traverseMethods + + unlinkMethods + + [CGUnionStruct(t, config) for t in unionStructs] + + [CGUnionStruct(t, config, True) for t in unionStructs], + "\n") + + includes.add("mozilla/OwningNonNull.h") + includes.add("mozilla/dom/UnionMember.h") + includes.add("mozilla/dom/BindingDeclarations.h") + # BindingUtils.h is only needed for SetToObject. + # If it stops being inlined or stops calling CallerSubsumes + # both this bit and the bit in CGBindingRoot can be removed. + includes.add("mozilla/dom/BindingUtils.h") + implincludes.add("mozilla/dom/PrimitiveConversions.h") + + # Wrap all of that in our namespaces. + curr = CGNamespace.build(['mozilla', 'dom'], unions) + + curr = CGWrapper(curr, post='\n') + + builder = ForwardDeclarationBuilder() + for className, isStruct in declarations: + builder.add(className, isStruct=isStruct) + + curr = CGList([builder.build(), curr], "\n") + + curr = CGHeaders([], [], [], [], includes, implincludes, 'UnionTypes', + curr) + + # Add include guards. + curr = CGIncludeGuard('UnionTypes', curr) + + # Done. + return curr + + @staticmethod + def UnionConversions(config): + unionTypes = [] + for l in config.unionsPerFilename.itervalues(): + unionTypes.extend(l) + unionTypes.sort(key=lambda u: u.name) + headers, unions = UnionConversions(unionTypes, + config) + + # Wrap all of that in our namespaces. + curr = CGNamespace.build(['mozilla', 'dom'], unions) + + curr = CGWrapper(curr, post='\n') + + headers.update(["nsDebug.h", "mozilla/dom/UnionTypes.h"]) + curr = CGHeaders([], [], [], [], headers, [], 'UnionConversions', curr) + + # Add include guards. + curr = CGIncludeGuard('UnionConversions', curr) + + # Done. + return curr + + +# Code generator for simple events +class CGEventGetter(CGNativeMember): + def __init__(self, descriptor, attr): + ea = descriptor.getExtendedAttributes(attr, getter=True) + CGNativeMember.__init__(self, descriptor, attr, + CGSpecializedGetter.makeNativeName(descriptor, + attr), + (attr.type, []), + ea, + resultNotAddRefed=not attr.type.isSequence()) + self.body = self.getMethodBody() + + def getArgs(self, returnType, argList): + if 'infallible' not in self.extendedAttrs: + raise TypeError("Event code generator does not support [Throws]!") + if not self.member.isAttr(): + raise TypeError("Event code generator does not support methods") + if self.member.isStatic(): + raise TypeError("Event code generators does not support static attributes") + return CGNativeMember.getArgs(self, returnType, argList) + + def getMethodBody(self): + type = self.member.type + memberName = CGDictionary.makeMemberName(self.member.identifier.name) + if (type.isPrimitive() and type.tag() in builtinNames) or type.isEnum() or type.isGeckoInterface(): + return "return " + memberName + ";\n" + if type.isDOMString() or type.isByteString() or type.isUSVString(): + return "aRetVal = " + memberName + ";\n" + if type.isSpiderMonkeyInterface() or type.isObject(): + return fill( + """ + if (${memberName}) { + JS::ExposeObjectToActiveJS(${memberName}); + } + aRetVal.set(${memberName}); + return; + """, + memberName=memberName) + if type.isAny(): + return fill( + """ + ${selfName}(aRetVal); + """, + selfName=self.name) + if type.isUnion(): + return "aRetVal = " + memberName + ";\n" + if type.isSequence(): + return "aRetVal = " + memberName + ";\n" + raise TypeError("Event code generator does not support this type!") + + def declare(self, cgClass): + if getattr(self.member, "originatingInterface", + cgClass.descriptor.interface) != cgClass.descriptor.interface: + return "" + return CGNativeMember.declare(self, cgClass) + + def define(self, cgClass): + if getattr(self.member, "originatingInterface", + cgClass.descriptor.interface) != cgClass.descriptor.interface: + return "" + return CGNativeMember.define(self, cgClass) + + +class CGEventSetter(CGNativeMember): + def __init__(self): + raise TypeError("Event code generator does not support setters!") + + +class CGEventMethod(CGNativeMember): + def __init__(self, descriptor, method, signature, isConstructor, breakAfter=True): + self.isInit = False + + CGNativeMember.__init__(self, descriptor, method, + CGSpecializedMethod.makeNativeName(descriptor, + method), + signature, + descriptor.getExtendedAttributes(method), + breakAfter=breakAfter, + variadicIsSequence=True) + self.originalArgs = list(self.args) + + iface = descriptor.interface + allowed = isConstructor + if not allowed and iface.getExtendedAttribute("LegacyEventInit"): + # Allow it, only if it fits the initFooEvent profile exactly + # We could check the arg types but it's not worth the effort. + if (method.identifier.name == "init" + iface.identifier.name and + signature[1][0].type.isDOMString() and + signature[1][1].type.isBoolean() and + signature[1][2].type.isBoolean() and + # -3 on the left to ignore the type, bubbles, and cancelable parameters + # -1 on the right to ignore the .trusted property which bleeds through + # here because it is [Unforgeable]. + len(signature[1]) - 3 == len(filter(lambda x: x.isAttr(), iface.members)) - 1): + allowed = True + self.isInit = True + + if not allowed: + raise TypeError("Event code generator does not support methods!") + + def getArgs(self, returnType, argList): + args = [self.getArg(arg) for arg in argList] + return args + + def getArg(self, arg): + decl, ref = self.getArgType(arg.type, + arg.canHaveMissingValue(), + "Variadic" if arg.variadic else False) + if ref: + decl = CGWrapper(decl, pre="const ", post="&") + + name = arg.identifier.name + name = "a" + name[0].upper() + name[1:] + return Argument(decl.define(), name) + + def declare(self, cgClass): + if self.isInit: + constructorForNativeCaller = "" + else: + self.args = list(self.originalArgs) + self.args.insert(0, Argument("mozilla::dom::EventTarget*", "aOwner")) + constructorForNativeCaller = CGNativeMember.declare(self, cgClass) + + self.args = list(self.originalArgs) + if needCx(None, self.arguments(), [], considerTypes=True, static=True): + self.args.insert(0, Argument("JSContext*", "aCx")) + if not self.isInit: + self.args.insert(0, Argument("const GlobalObject&", "aGlobal")) + self.args.append(Argument('ErrorResult&', 'aRv')) + return constructorForNativeCaller + CGNativeMember.declare(self, cgClass) + + def defineInit(self, cgClass): + iface = self.descriptorProvider.interface + members = "" + while iface.identifier.name != "Event": + i = 3 # Skip the boilerplate args: type, bubble,s cancelable. + for m in iface.members: + if m.isAttr(): + # We need to initialize all the member variables that do + # not come from Event. + if getattr(m, "originatingInterface", + iface).identifier.name == "Event": + continue + name = CGDictionary.makeMemberName(m.identifier.name) + members += "%s = %s;\n" % (name, self.args[i].name) + i += 1 + iface = iface.parent + + self.body = fill( + """ + InitEvent(${typeArg}, ${bubblesArg}, ${cancelableArg}); + ${members} + """, + typeArg=self.args[0].name, + bubblesArg=self.args[1].name, + cancelableArg=self.args[2].name, + members=members) + + return CGNativeMember.define(self, cgClass) + + def define(self, cgClass): + self.args = list(self.originalArgs) + if self.isInit: + return self.defineInit(cgClass) + members = "" + holdJS = "" + iface = self.descriptorProvider.interface + while iface.identifier.name != "Event": + for m in self.descriptorProvider.getDescriptor(iface.identifier.name).interface.members: + if m.isAttr(): + # We initialize all the other member variables in the + # Constructor except those ones coming from the Event. + if getattr(m, "originatingInterface", + cgClass.descriptor.interface).identifier.name == "Event": + continue + name = CGDictionary.makeMemberName(m.identifier.name) + if m.type.isSequence(): + # For sequences we may not be able to do a simple + # assignment because the underlying types may not match. + # For example, the argument can be a + # Sequence<OwningNonNull<SomeInterface>> while our + # member is an nsTArray<RefPtr<SomeInterface>>. So + # use AppendElements, which is actually a template on + # the incoming type on nsTArray and does the right thing + # for this case. + target = name + source = "%s.%s" % (self.args[1].name, name) + sequenceCopy = "e->%s.AppendElements(%s);\n" + if m.type.nullable(): + sequenceCopy = CGIfWrapper( + CGGeneric(sequenceCopy), + "!%s.IsNull()" % source).define() + target += ".SetValue()" + source += ".Value()" + members += sequenceCopy % (target, source) + elif m.type.isSpiderMonkeyInterface(): + srcname = "%s.%s" % (self.args[1].name, name) + if m.type.nullable(): + members += fill( + """ + if (${srcname}.IsNull()) { + e->${varname} = nullptr; + } else { + e->${varname} = ${srcname}.Value().Obj(); + } + """, + varname=name, + srcname=srcname) + else: + members += fill( + """ + e->${varname}.set(${srcname}.Obj()); + """, + varname=name, srcname=srcname) + else: + members += "e->%s = %s.%s;\n" % (name, self.args[1].name, name) + if m.type.isAny() or m.type.isObject() or m.type.isSpiderMonkeyInterface(): + holdJS = "mozilla::HoldJSObjects(e.get());\n" + iface = iface.parent + + self.body = fill( + """ + RefPtr<${nativeType}> e = new ${nativeType}(aOwner); + bool trusted = e->Init(aOwner); + e->InitEvent(${eventType}, ${eventInit}.mBubbles, ${eventInit}.mCancelable); + $*{members} + e->SetTrusted(trusted); + e->SetComposed(${eventInit}.mComposed); + $*{holdJS} + return e.forget(); + """, + nativeType=self.descriptorProvider.nativeType.split('::')[-1], + eventType=self.args[0].name, + eventInit=self.args[1].name, + members=members, + holdJS=holdJS) + + self.args.insert(0, Argument("mozilla::dom::EventTarget*", "aOwner")) + constructorForNativeCaller = CGNativeMember.define(self, cgClass) + "\n" + self.args = list(self.originalArgs) + self.body = fill( + """ + nsCOMPtr<mozilla::dom::EventTarget> owner = do_QueryInterface(aGlobal.GetAsSupports()); + return Constructor(owner, ${arg0}, ${arg1}); + """, + arg0=self.args[0].name, + arg1=self.args[1].name) + if needCx(None, self.arguments(), [], considerTypes=True, static=True): + self.args.insert(0, Argument("JSContext*", "aCx")) + self.args.insert(0, Argument("const GlobalObject&", "aGlobal")) + self.args.append(Argument('ErrorResult&', 'aRv')) + return constructorForNativeCaller + CGNativeMember.define(self, cgClass) + + +class CGEventClass(CGBindingImplClass): + """ + Codegen for the actual Event class implementation for this descriptor + """ + def __init__(self, descriptor): + CGBindingImplClass.__init__(self, descriptor, CGEventMethod, CGEventGetter, CGEventSetter, False, "WrapObjectInternal") + members = [] + extraMethods = [] + for m in descriptor.interface.members: + if m.isAttr(): + if m.type.isAny(): + # Add a getter that doesn't need a JSContext. Note that we + # don't need to do this if our originating interface is not + # the descriptor's interface, because in that case we + # wouldn't generate the getter that _does_ need a JSContext + # either. + extraMethods.append( + ClassMethod( + CGSpecializedGetter.makeNativeName(descriptor, m), + "void", + [Argument("JS::MutableHandle<JS::Value>", + "aRetVal")], + const=True, + body=fill( + """ + JS::ExposeValueToActiveJS(${memberName}); + aRetVal.set(${memberName}); + """, + memberName=CGDictionary.makeMemberName(m.identifier.name)))) + if getattr(m, "originatingInterface", + descriptor.interface) != descriptor.interface: + continue + nativeType = self.getNativeTypeForIDLType(m.type).define() + members.append(ClassMember(CGDictionary.makeMemberName(m.identifier.name), + nativeType, + visibility="private", + body="body")) + + parent = self.descriptor.interface.parent + self.parentType = self.descriptor.getDescriptor(parent.identifier.name).nativeType.split('::')[-1] + baseDeclarations = fill( + """ + public: + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(${nativeType}, ${parentType}) + protected: + virtual ~${nativeType}(); + explicit ${nativeType}(mozilla::dom::EventTarget* aOwner); + + """, + nativeType=self.descriptor.nativeType.split('::')[-1], + parentType=self.parentType) + + className = descriptor.nativeType.split('::')[-1] + asConcreteTypeMethod = ClassMethod("As%s" % className, + "%s*" % className, + [], + virtual=True, + body="return this;\n", + breakAfterReturnDecl=" ", + override=True) + extraMethods.append(asConcreteTypeMethod) + + CGClass.__init__(self, className, + bases=[ClassBase(self.parentType)], + methods=extraMethods+self.methodDecls, + members=members, + extradeclarations=baseDeclarations) + + def getWrapObjectBody(self): + return "return %sBinding::Wrap(aCx, this, aGivenProto);\n" % self.descriptor.name + + def implTraverse(self): + retVal = "" + for m in self.descriptor.interface.members: + # Unroll the type so we pick up sequences of interfaces too. + if m.isAttr() and idlTypeNeedsCycleCollection(m.type): + retVal += (" NS_IMPL_CYCLE_COLLECTION_TRAVERSE(" + + CGDictionary.makeMemberName(m.identifier.name) + + ")\n") + return retVal + + def implUnlink(self): + retVal = "" + for m in self.descriptor.interface.members: + if m.isAttr(): + name = CGDictionary.makeMemberName(m.identifier.name) + # Unroll the type so we pick up sequences of interfaces too. + if idlTypeNeedsCycleCollection(m.type): + retVal += " NS_IMPL_CYCLE_COLLECTION_UNLINK(" + name + ")\n" + elif m.type.isAny(): + retVal += " tmp->" + name + ".setUndefined();\n" + elif m.type.isObject() or m.type.isSpiderMonkeyInterface(): + retVal += " tmp->" + name + " = nullptr;\n" + return retVal + + def implTrace(self): + retVal = "" + for m in self.descriptor.interface.members: + if m.isAttr(): + name = CGDictionary.makeMemberName(m.identifier.name) + if m.type.isAny() or m.type.isObject() or m.type.isSpiderMonkeyInterface(): + retVal += " NS_IMPL_CYCLE_COLLECTION_TRACE_JS_MEMBER_CALLBACK(" + name + ")\n" + elif typeNeedsRooting(m.type): + raise TypeError("Need to implement tracing for event " + "member of type %s" % m.type) + return retVal + + def define(self): + dropJS = "" + for m in self.descriptor.interface.members: + if m.isAttr(): + member = CGDictionary.makeMemberName(m.identifier.name) + if m.type.isAny(): + dropJS += member + " = JS::UndefinedValue();\n" + elif m.type.isObject() or m.type.isSpiderMonkeyInterface(): + dropJS += member + " = nullptr;\n" + if dropJS != "": + dropJS += "mozilla::DropJSObjects(this);\n" + # Just override CGClass and do our own thing + nativeType = self.descriptor.nativeType.split('::')[-1] + ctorParams = ("aOwner, nullptr, nullptr" if self.parentType == "Event" + else "aOwner") + + classImpl = fill( + """ + + NS_IMPL_CYCLE_COLLECTION_CLASS(${nativeType}) + + NS_IMPL_ADDREF_INHERITED(${nativeType}, ${parentType}) + NS_IMPL_RELEASE_INHERITED(${nativeType}, ${parentType}) + + NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(${nativeType}, ${parentType}) + $*{traverse} + NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END + + NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(${nativeType}, ${parentType}) + $*{trace} + NS_IMPL_CYCLE_COLLECTION_TRACE_END + + NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(${nativeType}, ${parentType}) + $*{unlink} + NS_IMPL_CYCLE_COLLECTION_UNLINK_END + + NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(${nativeType}) + NS_INTERFACE_MAP_END_INHERITING(${parentType}) + + ${nativeType}::${nativeType}(mozilla::dom::EventTarget* aOwner) + : ${parentType}(${ctorParams}) + { + } + + ${nativeType}::~${nativeType}() + { + $*{dropJS} + } + + """, + ifaceName=self.descriptor.name, + nativeType=nativeType, + ctorParams=ctorParams, + parentType=self.parentType, + traverse=self.implTraverse(), + unlink=self.implUnlink(), + trace=self.implTrace(), + dropJS=dropJS) + return classImpl + CGBindingImplClass.define(self) + + def getNativeTypeForIDLType(self, type): + if type.isPrimitive() and type.tag() in builtinNames: + nativeType = CGGeneric(builtinNames[type.tag()]) + if type.nullable(): + nativeType = CGTemplatedType("Nullable", nativeType) + elif type.isEnum(): + nativeType = CGGeneric(type.unroll().inner.identifier.name) + if type.nullable(): + nativeType = CGTemplatedType("Nullable", nativeType) + elif type.isDOMString() or type.isUSVString(): + nativeType = CGGeneric("nsString") + elif type.isByteString(): + nativeType = CGGeneric("nsCString") + elif type.isGeckoInterface(): + iface = type.unroll().inner + nativeType = self.descriptor.getDescriptor( + iface.identifier.name).nativeType + # Now trim off unnecessary namespaces + nativeType = nativeType.split("::") + if nativeType[0] == "mozilla": + nativeType.pop(0) + if nativeType[0] == "dom": + nativeType.pop(0) + nativeType = CGWrapper(CGGeneric("::".join(nativeType)), pre="RefPtr<", post=">") + elif type.isAny(): + nativeType = CGGeneric("JS::Heap<JS::Value>") + elif type.isObject() or type.isSpiderMonkeyInterface(): + nativeType = CGGeneric("JS::Heap<JSObject*>") + elif type.isUnion(): + nativeType = CGGeneric(CGUnionStruct.unionTypeDecl(type, True)) + elif type.isSequence(): + if type.nullable(): + innerType = type.inner.inner + else: + innerType = type.inner + if (not innerType.isPrimitive() and not innerType.isEnum() and + not innerType.isDOMString() and not innerType.isByteString() and + not innerType.isGeckoInterface()): + raise TypeError("Don't know how to properly manage GC/CC for " + "event member of type %s" % + type) + nativeType = CGTemplatedType( + "nsTArray", + self.getNativeTypeForIDLType(innerType)) + if type.nullable(): + nativeType = CGTemplatedType("Nullable", nativeType) + else: + raise TypeError("Don't know how to declare event member of type %s" % + type) + return nativeType + + +class CGEventRoot(CGThing): + def __init__(self, config, interfaceName): + descriptor = config.getDescriptor(interfaceName) + + self.root = CGWrapper(CGEventClass(descriptor), + pre="\n", post="\n") + + self.root = CGNamespace.build(["mozilla", "dom"], self.root) + + self.root = CGList([CGClassForwardDeclare("JSContext", isStruct=True), + self.root]) + + parent = descriptor.interface.parent.identifier.name + + # Throw in our #includes + self.root = CGHeaders( + [descriptor], + [], + [], + [], + [ + config.getDescriptor(parent).headerFile, + "mozilla/Attributes.h", + "mozilla/ErrorResult.h", + "mozilla/dom/%sBinding.h" % interfaceName, + 'mozilla/dom/BindingUtils.h', + ], + [ + "%s.h" % interfaceName, + "js/GCAPI.h", + 'mozilla/dom/Nullable.h', + ], + "", self.root, config) + + # And now some include guards + self.root = CGIncludeGuard(interfaceName, self.root) + + self.root = CGWrapper( + self.root, + pre=(AUTOGENERATED_WITH_SOURCE_WARNING_COMMENT % + os.path.basename(descriptor.interface.filename()))) + + self.root = CGWrapper(self.root, pre=dedent(""" + /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ + /* vim:set ts=2 sw=2 sts=2 et cindent: */ + /* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + + """)) + + def declare(self): + return self.root.declare() + + def define(self): + return self.root.define() |