The Tor Browser / file revision

 # 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

 from WebIDL import BuiltinTypes, IDLBuiltinType, IDLNullValue, IDLSequenceType, IDLType, IDLAttribute, IDLUndefinedValue

 from Configuration import NoSuchDescriptorError, getTypesFromDescriptor, getTypesFromDictionary, getTypesFromCallback, Descriptor

 AUTOGENERATED_WARNING_COMMENT = \

     "/* THIS FILE IS AUTOGENERATED - DO NOT EDIT */\n\n"

 ADDPROPERTY_HOOK_NAME = '_addProperty'

 FINALIZE_HOOK_NAME = '_finalize'

 CONSTRUCT_HOOK_NAME = '_constructor'

 LEGACYCALLER_HOOK_NAME = '_legacycaller'

 HASINSTANCE_HOOK_NAME = '_hasInstance'

 NEWRESOLVE_HOOK_NAME = '_newResolve'

 ENUMERATE_HOOK_NAME = '_enumerate'

 ENUM_ENTRY_VARIABLE_NAME = 'strings'

 INSTANCE_RESERVED_SLOTS = 3

 def memberReservedSlot(member):

     return "(DOM_INSTANCE_RESERVED_SLOTS + %d)" % member.slotIndex

 def toStringBool(arg):

     return str(not not arg).lower()

 def toBindingNamespace(arg):

     return re.sub("((_workers)?$)", "Binding\\1", arg)

 def isTypeCopyConstructible(type):

     # Nullable and sequence stuff doesn't affect copy-constructibility

     type = type.unroll()

     return (type.isPrimitive() or type.isString() or type.isEnum() or

             (type.isUnion() and

              CGUnionStruct.isUnionCopyConstructible(type)) or

             (type.isDictionary() and

              CGDictionary.isDictionaryCopyConstructible(type.inner)) 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 wantsAddProperty(desc):

     return (desc.concrete and

             desc.wrapperCache and

             not (desc.workers and

                  desc.interface.getExtendedAttribute("Global")))

 # 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).

     """

     if s == "":

         return s

     return re.sub(lineStartDetector, indentLevel * " ", s)

 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)

 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.

     """

     # This works by transforming the fill()-template to an equivalent

     # string.Template.

     multiline_substitution_re = re.compile(r"( *)\$\*{(\w+)}(\n)?")

     def replace(match):

         """

         Replaces a line like '  $*{xyz}\n' with '${xyz_n}',

         where n is the indent depth, and add a corresponding entry to args.

         """

         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)

         # Multiline text without a newline at the end is probably a mistake.

         if not (args[name] == "" or args[name].endswith("\n")):

             raise ValueError("Argument %s with value %r is missing a newline" % (name, args[name]))

         # Now replace this whole line of template with the indented equivalent.

         modified_name = name + "_" + str(depth)

         indented_value = indent(args[name], depth)

         if modified_name in args:

             assert args[modified_name] == indented_value

         else:

             args[modified_name] = indented_value

         return "${" + modified_name + "}"

     t = dedent(template)

     assert t.endswith("\n") or "\n" not in t

     t = re.sub(multiline_substitution_re, replace, t)

     t = string.Template(t)

     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 self.descriptor.workers:

             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[];

             """).rstrip()  # BOGUS strip newline from the last line here (!)

     def define(self):

         if self.descriptor.workers:

             return ""

         if self.descriptor.concrete and self.descriptor.proxy:

             resolveOwnProperty = "ResolveOwnProperty"

             enumerateOwnProperties = "EnumerateOwnProperties"

         elif self.descriptor.needsXrayResolveHooks():

             resolveOwnProperty = "ResolveOwnPropertyViaNewresolve"

             enumerateOwnProperties = "EnumerateOwnPropertiesViaGetOwnPropertyNames"

         else:

             resolveOwnProperty = "nullptr"

             enumerateOwnProperties = "nullptr"

         if self.properties.hasNonChromeOnly():

             regular = "&sNativeProperties"

         else:

             regular = "nullptr"

         if self.properties.hasChromeOnly():

             chrome = "&sChromeOnlyNativeProperties"

         else:

             chrome = "nullptr"

         constructorID = "constructors::id::"

         if self.descriptor.interface.hasInterfaceObject():

             constructorID += self.descriptor.name

         else:

             constructorID += "_ID_Count"

         prototypeID = "prototypes::id::"

         if self.descriptor.interface.hasInterfacePrototypeObject():

             prototypeID += self.descriptor.name

         else:

             prototypeID += "_ID_Count"

         parent = self.descriptor.interface.parent

         parentHooks = (toBindingNamespace(parent.identifier.name) + "::sNativePropertyHooks"

                        if parent else 'nullptr')

         return fill(

             """

             const NativePropertyHooks sNativePropertyHooks[] = { {

               ${resolveOwnProperty},

               ${enumerateOwnProperties},

               { ${regular}, ${chrome} },

               ${prototypeID},

               ${constructorID},

               ${parentHooks}

             } };

             """,

             resolveOwnProperty=resolveOwnProperty,

             enumerateOwnProperties=enumerateOwnProperties,

             regular=regular,

             chrome=chrome,

             prototypeID=prototypeID,

             constructorID=constructorID,

             parentHooks=parentHooks)

 def NativePropertyHooks(descriptor):

     return "&sWorkerNativePropertyHooks" if descriptor.workers else "sNativePropertyHooks"

 def DOMClass(descriptor):

     def make_name(d):

         return "%s%s" % (d.interface.identifier.name, '_workers' if d.workers else '')

     protoList = ['prototypes::id::' + make_name(descriptor.getDescriptor(proto)) for proto in descriptor.prototypeChain]

     # Pad out the list to the right length with _ID_Count so we

     # guarantee that all the lists are the same length.  _ID_Count

     # is never the ID of any prototype, so it's safe to use as

     # padding.

     protoList.extend(['prototypes::id::_ID_Count'] * (descriptor.config.maxProtoChainLength - len(protoList)))

     return fill(

         """

         {

           { ${protoChain} },

           IsBaseOf<nsISupports, ${nativeType} >::value,

           ${hooks},

           GetParentObject<${nativeType}>::Get,

           GetProtoObject,

           GetCCParticipant<${nativeType}>::Get()

         }

         """,

         protoChain=', '.join(protoList),

         nativeType=descriptor.nativeType,

         hooks=NativePropertyHooks(descriptor))

 class CGDOMJSClass(CGThing):

     """

     Generate a DOMJSClass for a given descriptor

     """

     def __init__(self, descriptor):

         CGThing.__init__(self)

         self.descriptor = descriptor

     def declare(self):

         return ""

     def define(self):

         traceHook = 'nullptr'

         callHook = LEGACYCALLER_HOOK_NAME if self.descriptor.operations["LegacyCaller"] else 'nullptr'

         slotCount = INSTANCE_RESERVED_SLOTS + self.descriptor.interface.totalMembersInSlots

         classFlags = "JSCLASS_IS_DOMJSCLASS | "

         classExtensionAndObjectOps = """\

 JS_NULL_CLASS_EXT,

 JS_NULL_OBJECT_OPS

 """

         if self.descriptor.interface.getExtendedAttribute("Global"):

             classFlags += "JSCLASS_DOM_GLOBAL | JSCLASS_GLOBAL_FLAGS_WITH_SLOTS(DOM_GLOBAL_SLOTS) | JSCLASS_IMPLEMENTS_BARRIERS"

             traceHook = "JS_GlobalObjectTraceHook"

             if not self.descriptor.workers:

                 classExtensionAndObjectOps = """\

 {

   nsGlobalWindow::OuterObject, /* outerObject */

   nullptr, /* innerObject */

   nullptr, /* iteratorObject */

   false, /* isWrappedNative */

   nullptr /* weakmapKeyDelegateOp */

 },

 {

   nullptr, /* lookupGeneric */

   nullptr, /* lookupProperty */

   nullptr, /* lookupElement */

   nullptr, /* defineGeneric */

   nullptr, /* defineProperty */

   nullptr, /* defineElement */

   nullptr, /* getGeneric  */

   nullptr, /* getProperty */

   nullptr, /* getElement */

   nullptr, /* setGeneric */

   nullptr, /* setProperty */

   nullptr, /* setElement */

   nullptr, /* getGenericAttributes */

   nullptr, /* setGenericAttributes */

   nullptr, /* deleteProperty */

   nullptr, /* deleteElement */

   nullptr, /* watch */

   nullptr, /* unwatch */

   nullptr, /* slice */

   nullptr, /* enumerate */

   JS_ObjectToOuterObject /* thisObject */

 }

 """

         else:

             classFlags += "JSCLASS_HAS_RESERVED_SLOTS(%d)" % slotCount

         if self.descriptor.interface.getExtendedAttribute("NeedNewResolve"):

             newResolveHook = "(JSResolveOp)" + NEWRESOLVE_HOOK_NAME

             classFlags += " | JSCLASS_NEW_RESOLVE"

             enumerateHook = ENUMERATE_HOOK_NAME

         elif self.descriptor.interface.getExtendedAttribute("Global"):

             newResolveHook = "(JSResolveOp) mozilla::dom::ResolveGlobal"

             classFlags += " | JSCLASS_NEW_RESOLVE"

             enumerateHook = "mozilla::dom::EnumerateGlobal"

         else:

             newResolveHook = "JS_ResolveStub"

             enumerateHook = "JS_EnumerateStub"

         return fill(  # BOGUS extra blank line at the top

             """

             static const DOMJSClass Class = {

               { "${name}",

                 ${flags},

                 ${addProperty}, /* addProperty */

                 JS_DeletePropertyStub, /* delProperty */

                 JS_PropertyStub,       /* getProperty */

                 JS_StrictPropertyStub, /* setProperty */

                 ${enumerate}, /* enumerate */

                 ${resolve}, /* resolve */

                 JS_ConvertStub,

                 ${finalize}, /* finalize */

                 ${call}, /* call */

                 nullptr,               /* hasInstance */

                 nullptr,               /* construct */

                 ${trace}, /* trace */

                 JS_NULL_CLASS_SPEC,

                 $*{classExtensionAndObjectOps}

               },

               $*{descriptor}

             };

             """,

             name=self.descriptor.interface.identifier.name,

             flags=classFlags,

             addProperty=ADDPROPERTY_HOOK_NAME if wantsAddProperty(self.descriptor) else 'JS_PropertyStub',

             enumerate=enumerateHook,

             resolve=newResolveHook,

             finalize=FINALIZE_HOOK_NAME,

             call=callHook,

             trace=traceHook,

             classExtensionAndObjectOps=classExtensionAndObjectOps,

             descriptor=DOMClass(self.descriptor))

 class CGDOMProxyJSClass(CGThing):

     """

     Generate a DOMJSClass for a given proxy descriptor

     """

     def __init__(self, descriptor):

         CGThing.__init__(self)

         self.descriptor = descriptor

     def declare(self):

         return ""

     def define(self):

         flags = ["JSCLASS_IS_DOMJSCLASS"]

         # We don't use an IDL annotation for JSCLASS_EMULATES_UNDEFINED because

         # we don't want people ever adding that to any interface other than

         # HTMLAllCollection.  So just hardcode it here.

         if self.descriptor.interface.identifier.name == "HTMLAllCollection":

             flags.append("JSCLASS_EMULATES_UNDEFINED")

         callHook = LEGACYCALLER_HOOK_NAME if self.descriptor.operations["LegacyCaller"] else 'nullptr'

         return fill(  # BOGUS extra blank line at the top

             """

             static const DOMJSClass Class = {

               PROXY_CLASS_DEF("${name}",

                               0, /* extra slots */

                               ${flags},

                               ${call}, /* call */

                               nullptr  /* construct */),

               $*{descriptor}

             };

             """,

             name=self.descriptor.interface.identifier.name,

             flags=" | ".join(flags),

             call=callHook,

             descriptor=DOMClass(self.descriptor))

 def PrototypeIDAndDepth(descriptor):

     prototypeID = "prototypes::id::"

     if descriptor.interface.hasInterfacePrototypeObject():

         prototypeID += descriptor.interface.identifier.name

         if descriptor.workers:

             prototypeID += "_workers"

         depth = "PrototypeTraits<%s>::Depth" % prototypeID

     else:

         prototypeID += "_ID_Count"

         depth = "0"

     return (prototypeID, depth)

 def UseHolderForUnforgeable(descriptor):

     return (descriptor.concrete and

             descriptor.proxy and

             any(m for m in descriptor.interface.members if m.isAttr() and m.isUnforgeable()))

 def CallOnUnforgeableHolder(descriptor, code, isXrayCheck=None,

                             useSharedRoot=False):

     """

     Generate the code to execute the code in "code" on an unforgeable holder if

     needed. code should be a string containing the code to execute. If it

     contains a ${holder} string parameter it will be replaced with the

     unforgeable holder object.

     If isXrayCheck is not None it should be a string that contains a statement

     returning whether proxy is an Xray. If isXrayCheck is None the generated

     code won't try to unwrap Xrays.

     If useSharedRoot is true, we will use an existing

     JS::Rooted<JSObject*> sharedRoot for storing our unforgeable holder instead

     of declaring a new Rooted.

     """

     if isXrayCheck is not None:

         pre = fill(

             """

             // Scope for 'global', 'ac' and 'unforgeableHolder'

             {

               JS::Rooted<JSObject*> global(cx);

               Maybe<JSAutoCompartment> ac;

               if (${isXrayCheck}) {

                 global = js::GetGlobalForObjectCrossCompartment(js::UncheckedUnwrap(proxy));

                 ac.construct(cx, global);

               } else {

                 global = js::GetGlobalForObjectCrossCompartment(proxy);

               }

             """,

             isXrayCheck=isXrayCheck)

     else:

         pre = dedent("""

             // Scope for 'global' and 'unforgeableHolder'

             {

               JSObject* global = js::GetGlobalForObjectCrossCompartment(proxy);

             """)

     if useSharedRoot:

         holderDecl = "JS::Rooted<JSObject*>& unforgeableHolder(sharedRoot);\n"

     else:

         holderDecl = "JS::Rooted<JSObject*> unforgeableHolder(cx);\n"

     code = string.Template(code).substitute({"holder": "unforgeableHolder"})

     return fill(

         """

         $*{pre}

           $*{holderDecl}

           unforgeableHolder = GetUnforgeableHolder(global, prototypes::id::${name});

           $*{code}

         }

         """,

         pre=pre,

         holderDecl=holderDecl,

         name=descriptor.name,

         code=code)

 class CGPrototypeJSClass(CGThing):

     def __init__(self, descriptor, properties):

         CGThing.__init__(self)

         self.descriptor = descriptor

         self.properties = properties

     def declare(self):

         # We're purely for internal consumption

         return ""

     def define(self):

         prototypeID, depth = PrototypeIDAndDepth(self.descriptor)

         slotCount = "DOM_INTERFACE_PROTO_SLOTS_BASE"

         if UseHolderForUnforgeable(self.descriptor):

             slotCount += " + 1 /* slot for the JSObject holding the unforgeable properties */"

         return fill(

             """

             static const DOMIfaceAndProtoJSClass PrototypeClass = {

               {

                 "${name}Prototype",

                 JSCLASS_IS_DOMIFACEANDPROTOJSCLASS | JSCLASS_HAS_RESERVED_SLOTS(${slotCount}),

                 JS_PropertyStub,       /* addProperty */

                 JS_DeletePropertyStub, /* delProperty */

                 JS_PropertyStub,       /* getProperty */

                 JS_StrictPropertyStub, /* setProperty */

                 JS_EnumerateStub,

                 JS_ResolveStub,

                 JS_ConvertStub,

                 nullptr,               /* finalize */

                 nullptr,               /* call */

                 nullptr,               /* hasInstance */

                 nullptr,               /* construct */

                 nullptr,               /* trace */

                 JSCLASS_NO_INTERNAL_MEMBERS

               },

               eInterfacePrototype,

               ${hooks},

               "[object ${name}Prototype]",

               ${prototypeID},

               ${depth}

             };

             """,

             name=self.descriptor.interface.identifier.name,

             slotCount=slotCount,

             hooks=NativePropertyHooks(self.descriptor),

             prototypeID=prototypeID,

             depth=depth)

 def NeedsGeneratedHasInstance(descriptor):

     return descriptor.hasXPConnectImpls or descriptor.interface.isConsequential()

 class CGInterfaceObjectJSClass(CGThing):

     def __init__(self, descriptor, properties):

         CGThing.__init__(self)

         self.descriptor = descriptor

         self.properties = properties

     def declare(self):

         # We're purely for internal consumption

         return ""

     def define(self):

         if self.descriptor.interface.ctor():

             ctorname = CONSTRUCT_HOOK_NAME

         else:

             ctorname = "ThrowingConstructor"

         if NeedsGeneratedHasInstance(self.descriptor):

             hasinstance = HASINSTANCE_HOOK_NAME

         elif self.descriptor.interface.hasInterfacePrototypeObject():

             hasinstance = "InterfaceHasInstance"

         else:

             hasinstance = "nullptr"

         prototypeID, depth = PrototypeIDAndDepth(self.descriptor)

         slotCount = "DOM_INTERFACE_SLOTS_BASE"

         if len(self.descriptor.interface.namedConstructors) > 0:

             slotCount += (" + %i /* slots for the named constructors */" %

                           len(self.descriptor.interface.namedConstructors))

         return fill(  # BOGUS extra newline at the top

             """

             static const DOMIfaceAndProtoJSClass InterfaceObjectClass = {

               {

                 "Function",

                 JSCLASS_IS_DOMIFACEANDPROTOJSCLASS | JSCLASS_HAS_RESERVED_SLOTS(${slotCount}),

                 JS_PropertyStub,       /* addProperty */

                 JS_DeletePropertyStub, /* delProperty */

                 JS_PropertyStub,       /* getProperty */

                 JS_StrictPropertyStub, /* setProperty */

                 JS_EnumerateStub,

                 JS_ResolveStub,

                 JS_ConvertStub,

                 nullptr,               /* finalize */

                 ${ctorname}, /* call */

                 ${hasInstance}, /* hasInstance */

                 ${ctorname}, /* construct */

                 nullptr,               /* trace */

                 JSCLASS_NO_INTERNAL_MEMBERS

               },

               eInterface,

               ${hooks},

               "function ${name}() {\\n    [native code]\\n}",

               ${prototypeID},

               ${depth}

             };

             """,

             slotCount=slotCount,

             ctorname=ctorname,

             hasInstance=hasinstance,

             hooks=NativePropertyHooks(self.descriptor),

             name=self.descriptor.interface.identifier.name,

             prototypeID=prototypeID,

             depth=depth)

 class CGList(CGThing):

     """

     Generate code for a list of GCThings.  Just concatenates them together, with

     an optional joiner string.  "\n" is a common joiner.

     """

     def __init__(self, children, joiner=""):

         CGThing.__init__(self)

         # Make a copy of the kids into a list, because if someone passes in a

         # generator we won't be able to both declare and define ourselves, or

         # define ourselves more than once!

         self.children = list(children)

         self.joiner = joiner

     def append(self, child):

         self.children.append(child)

     def prepend(self, child):

         self.children.insert(0, child)

     def extend(self, kids):

         self.children.extend(kids)

     def join(self, 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

 class CGGeneric(CGThing):

     """

     A class that spits out a fixed string into the codegen.  Can spit out a

     separate string for the declaration too.

     """

     def __init__(self, define="", declare=""):

         self.declareText = declare

         self.defineText = define

     def declare(self):

         return self.declareText

     def define(self):

         return self.defineText

     def deps(self):

         return set()

 class CGIndenter(CGThing):

     """

     A class that takes another CGThing and generates code that indents that

     CGThing by some number of spaces.  The default indent is two spaces.

     """

     def __init__(self, child, indentLevel=2, declareOnly=False):

         assert isinstance(child, CGThing)

         CGThing.__init__(self)

         self.child = child

         self.indentLevel = indentLevel

         self.declareOnly = declareOnly

     def declare(self):

         return indent(self.child.declare(), self.indentLevel)

     def define(self):

         defn = self.child.define()

         if self.declareOnly:

             return defn

         else:

             return indent(defn, self.indentLevel)

 class CGWrapper(CGThing):

     """

     Generic CGThing that wraps other CGThings with pre and post text.

     """

     def __init__(self, child, pre="", post="", declarePre=None,

                  declarePost=None, definePre=None, definePost=None,

                  declareOnly=False, defineOnly=False, reindent=False):

         CGThing.__init__(self)

         self.child = child

         self.declarePre = declarePre or pre

         self.declarePost = declarePost or post

         self.definePre = definePre or pre

         self.definePost = definePost or post

         self.declareOnly = declareOnly

         self.defineOnly = defineOnly

         self.reindent = reindent

     def declare(self):

         if self.defineOnly:

             return ''

         decl = self.child.declare()

         if self.reindent:

             decl = self.reindentString(decl, self.declarePre)

         return self.declarePre + decl + self.declarePost

     def define(self):

         if self.declareOnly:

             return ''

         defn = self.child.define()

         if self.reindent:

             defn = self.reindentString(defn, self.definePre)

         return self.definePre + defn + self.definePost

     @staticmethod

     def reindentString(stringToIndent, widthString):

         # We don't use lineStartDetector because we don't want to

         # insert whitespace at the beginning of our _first_ line.

         # Use the length of the last line of width string, in case

         # it is a multiline string.

         lastLineWidth = len(widthString.splitlines()[-1])

         return stripTrailingWhitespace(

             stringToIndent.replace("\n", "\n" + (" " * lastLineWidth)))

     def deps(self):

         return self.child.deps()

 class CGIfWrapper(CGList):

     def __init__(self, child, condition):

         CGList.__init__(self, [

             CGWrapper(CGGeneric(condition), pre="if (", post=") {\n", reindent=True),

             CGIndenter(child),

             CGGeneric("}\n")

         ])

 class CGIfElseWrapper(CGList):

     def __init__(self, condition, ifTrue, ifFalse):

         CGList.__init__(self, [

             CGWrapper(CGGeneric(condition), pre="if (", post=") {\n", reindent=True),

             CGIndenter(ifTrue),

             CGGeneric("} else {\n"),

             CGIndenter(ifFalse),

             CGGeneric("}\n")

         ])

 class CGElseChain(CGThing):

     """

     Concatenate if statements in an if-else-if-else chain.

     """

     def __init__(self, children):

         self.children = [c for c in children if c is not None]

     def declare(self):

         assert False

     def define(self):

         if not self.children:

             return ""

         s = self.children[0].define()

         assert s.endswith("\n")

         for child in self.children[1:]:

             code = child.define()

             assert code.startswith("if") or code.startswith("{")

             assert code.endswith("\n")

             s = s.rstrip() + " else " + code

         return s

 class CGTemplatedType(CGWrapper):

     def __init__(self, templateName, child, isConst=False, isReference=False):

         const = "const " if isConst else ""

         pre = "%s%s<" % (const, templateName)

         ref = "&" if isReference else ""

         post = ">%s" % ref

         CGWrapper.__init__(self, child, pre=pre, post=post)

 class CGNamespace(CGWrapper):

     def __init__(self, namespace, child, declareOnly=False):

         pre = "namespace %s {\n" % namespace

         post = "} // namespace %s\n" % namespace

         CGWrapper.__init__(self, child, pre=pre, post=post,

                            declareOnly=declareOnly)

     @staticmethod

     def build(namespaces, child, declareOnly=False):

         """

         Static helper method to build multiple wrapped namespaces.

         """

         if not namespaces:

             return CGWrapper(child, declareOnly=declareOnly)

         inner = CGNamespace.build(namespaces[1:], child, declareOnly=declareOnly)

         return CGNamespace(namespaces[0], inner, declareOnly=declareOnly)

 class CGIncludeGuard(CGWrapper):

     """

     Generates include guards for a header.

     """

     def __init__(self, prefix, child):

         """|prefix| is the filename without the extension."""

         define = 'mozilla_dom_%s_h' % prefix

         CGWrapper.__init__(self, child,

                            declarePre='#ifndef %s\n#define %s\n\n' % (define, define),

                            declarePost='\n#endif // %s\n' % define)

 def getRelevantProviders(descriptor, config):

     if descriptor is not None:

         return [descriptor]

     # Do both the non-worker and worker versions

     return [

         config.getDescriptorProvider(False),

         config.getDescriptorProvider(True)

     ]

 def getAllTypes(descriptors, dictionaries, callbacks):

     """

     Generate all the types we're dealing with.  For each type, a tuple

     containing type, descriptor, dictionary is yielded.  The

     descriptor and dictionary can be None if the type does not come

     from a descriptor or dictionary; they will never both be non-None.

     """

     for d in descriptors:

         if d.interface.isExternal():

             continue

         for t in getTypesFromDescriptor(d):

             yield (t, d, None)

     for dictionary in dictionaries:

         for t in getTypesFromDictionary(dictionary):

             yield (t, None, dictionary)

     for callback in callbacks:

         for t in getTypesFromCallback(callback):

             yield (t, None, None)

 class CGHeaders(CGWrapper):

     """

     Generates the appropriate include statements.

     """

     def __init__(self, descriptors, dictionaries, callbacks,

                  callbackDescriptors,

                  declareIncludes, defineIncludes, prefix, child,

                  config=None, jsImplementedDescriptors=[]):

         """

         Builds a set of includes to cover |descriptors|.

         Also includes the files in |declareIncludes| in the header

         file and the files in |defineIncludes| in the .cpp.

         |prefix| contains the basename of the file that we generate include

         statements for.

         """

         # Determine the filenames for which we need headers.

         interfaceDeps = [d.interface for d in descriptors]

         ancestors = []

         for iface in interfaceDeps:

             if iface.parent:

                 # We're going to need our parent's prototype, to use as the

                 # prototype of our prototype object.

                 ancestors.append(iface.parent)

                 # And if we have an interface object, we'll need the nearest

                 # ancestor with an interface object too, so we can use its

                 # interface object as the proto of our interface object.

                 if iface.hasInterfaceObject():

                     parent = iface.parent

                     while parent and not parent.hasInterfaceObject():

                         parent = parent.parent

                     if parent:

                         ancestors.append(parent)

         interfaceDeps.extend(ancestors)

         bindingIncludes = set(self.getDeclarationFilename(d) for d in interfaceDeps)

         # Grab all the implementation declaration files we need.

         implementationIncludes = set(d.headerFile for d in descriptors if d.needsHeaderInclude())

         # Grab the includes for checking hasInstance

         interfacesImplementingSelf = set()

         for d in descriptors:

             interfacesImplementingSelf |= d.interface.interfacesImplementingSelf

         implementationIncludes |= set(self.getDeclarationFilename(i) for i in

                                       interfacesImplementingSelf)

          # Grab the includes for the things that involve XPCOM interfaces

         hasInstanceIncludes = set("nsIDOM" + d.interface.identifier.name + ".h" for d

                                   in descriptors if

                                   NeedsGeneratedHasInstance(d) and

                                   d.interface.hasInterfacePrototypeObject())

         # Now find all the things we'll need as arguments because we

         # need to wrap or unwrap them.

         bindingHeaders = set()

         declareIncludes = set(declareIncludes)

         def addHeadersForType((t, descriptor, dictionary)):

             """

             Add the relevant headers for this type.  We use descriptor and

             dictionary, if passed, to decide what to do with interface types.

             """

             assert not descriptor or not dictionary

             # Dictionaries have members that need to be actually

             # declared, not just forward-declared.

             if dictionary:

                 headerSet = declareIncludes

             else:

                 headerSet = bindingHeaders

             if t.nullable():

                 # Need to make sure that Nullable as a dictionary

                 # member works.

                 headerSet.add("mozilla/dom/Nullable.h")

             unrolled = t.unroll()

             if unrolled.isUnion():

                 # UnionConversions.h includes UnionTypes.h

                 bindingHeaders.add("mozilla/dom/UnionConversions.h")

                 if dictionary:

                     # Our dictionary definition is in the header and

                     # needs the union type.

                     declareIncludes.add("mozilla/dom/UnionTypes.h")

             elif unrolled.isDate():

                 if dictionary or jsImplementedDescriptors:

                     declareIncludes.add("mozilla/dom/Date.h")

                 else:

                     bindingHeaders.add("mozilla/dom/Date.h")

             elif unrolled.isInterface():

                 if unrolled.isSpiderMonkeyInterface():

                     bindingHeaders.add("jsfriendapi.h")

                     headerSet.add("mozilla/dom/TypedArray.h")

                 else:

                     providers = getRelevantProviders(descriptor, config)

                     for p in providers:

                         try:

                             typeDesc = p.getDescriptor(unrolled.inner.identifier.name)

                         except NoSuchDescriptorError:

                             continue

                         # Dictionaries with interface members rely on the

                         # actual class definition of that interface member

                         # being visible in the binding header, because they

                         # store them in nsRefPtr and have inline

                         # constructors/destructors.

                         #

                         # XXXbz maybe dictionaries with interface members

                         # should just have out-of-line constructors and

                         # destructors?

                         headerSet.add(typeDesc.headerFile)

             elif unrolled.isDictionary():

                 headerSet.add(self.getDeclarationFilename(unrolled.inner))

             elif unrolled.isCallback():

                 # Callbacks are both a type and an object

                 headerSet.add(self.getDeclarationFilename(unrolled))

             elif unrolled.isFloat() and not unrolled.isUnrestricted():

                 # Restricted floats are tested for finiteness

                 bindingHeaders.add("mozilla/FloatingPoint.h")

                 bindingHeaders.add("mozilla/dom/PrimitiveConversions.h")

             elif unrolled.isEnum():

                 filename = self.getDeclarationFilename(unrolled.inner)

                 declareIncludes.add(filename)

             elif unrolled.isPrimitive():

                 bindingHeaders.add("mozilla/dom/PrimitiveConversions.h")

             elif unrolled.isMozMap():

                 if dictionary or jsImplementedDescriptors:

                     declareIncludes.add("mozilla/dom/MozMap.h")

                 else:

                     bindingHeaders.add("mozilla/dom/MozMap.h")

                 # Also add headers for the type the MozMap is

                 # parametrized over, if needed.

                 addHeadersForType((t.inner, descriptor, dictionary))

         map(addHeadersForType,

             getAllTypes(descriptors + callbackDescriptors, dictionaries,

                         callbacks))

         # Now make sure we're not trying to include the header from inside itself

         declareIncludes.discard(prefix + ".h")

         # Now for non-callback descriptors make sure we include any

         # headers needed by Func declarations.

         for desc in descriptors:

             if desc.interface.isExternal():

                 continue

             def addHeaderForFunc(func):

                 if func is None:

                     return

                 # Include the right class header, which we can only do

                 # if this is a class member function.

                 if not desc.headerIsDefault:

                     # An explicit header file was provided, assume that we know

                     # what we're doing.

                     return

                 if "::" in func:

                     # Strip out the function name and convert "::" to "/"

                     bindingHeaders.add("/".join(func.split("::")[:-1]) + ".h")

             for m in desc.interface.members:

                 addHeaderForFunc(PropertyDefiner.getStringAttr(m, "Func"))

             # getExtendedAttribute() returns a list, extract the entry.

             funcList = desc.interface.getExtendedAttribute("Func")

             if funcList is not None:

                 addHeaderForFunc(funcList[0])

         for d in dictionaries:

             if d.parent:

                 declareIncludes.add(self.getDeclarationFilename(d.parent))

             bindingHeaders.add(self.getDeclarationFilename(d))

         for c in callbacks:

             bindingHeaders.add(self.getDeclarationFilename(c))

         for c in callbackDescriptors:

             bindingHeaders.add(self.getDeclarationFilename(c.interface))

         if len(callbacks) != 0:

             # We need CallbackFunction to serve as our parent class

             declareIncludes.add("mozilla/dom/CallbackFunction.h")

             # And we need BindingUtils.h so we can wrap "this" objects

             declareIncludes.add("mozilla/dom/BindingUtils.h")

         if len(callbackDescriptors) != 0 or len(jsImplementedDescriptors) != 0:

             # We need CallbackInterface to serve as our parent class

             declareIncludes.add("mozilla/dom/CallbackInterface.h")

             # And we need BindingUtils.h so we can wrap "this" objects

             declareIncludes.add("mozilla/dom/BindingUtils.h")

         # Also need to include the headers for ancestors of

         # JS-implemented interfaces.

         for jsImplemented in jsImplementedDescriptors:

             jsParent = jsImplemented.interface.parent

             if jsParent:

                 parentDesc = jsImplemented.getDescriptor(jsParent.identifier.name)

                 declareIncludes.add(parentDesc.jsImplParentHeader)

         # Let the machinery do its thing.

         def _includeString(includes):

             return ''.join(['#include "%s"\n' % i for i in includes]) + '\n'

         CGWrapper.__init__(self, child,

                            declarePre=_includeString(sorted(declareIncludes)),

                            definePre=_includeString(sorted(set(defineIncludes) |

                                                            bindingIncludes |

                                                            bindingHeaders |

                                                            hasInstanceIncludes |

                                                            implementationIncludes)))

     @staticmethod

     def getDeclarationFilename(decl):

         # Use our local version of the header, not the exported one, so that

         # test bindings, which don't export, will work correctly.

         basename = os.path.basename(decl.filename())

         return basename.replace('.webidl', 'Binding.h')

 def SortedDictValues(d):

     """

     Returns a list of values from the dict sorted by key.

     """

     return [v for k, v in sorted(d.items())]

 def UnionTypes(descriptors, dictionaries, callbacks, config):

     """

     Returns a tuple containing a set of header filenames to include in

     UnionTypes.h, a set of header filenames to include in UnionTypes.cpp, a set

     of tuples containing a type declaration and a boolean if the type is a

     struct for member types of the unions and a CGList containing CGUnionStructs

     for every union.

     """

     # Now find all the things we'll need as arguments and return values because

     # we need to wrap or unwrap them.

     headers = set()

     implheaders = set(["UnionTypes.h"])

     declarations = set()

     unionStructs = dict()

     owningUnionStructs = dict()

     for t, descriptor, dictionary in getAllTypes(descriptors, dictionaries, callbacks):

         # Add info for the given type.  descriptor and dictionary, if present, are

         # used to figure out what to do with interface types.

         assert not descriptor or not dictionary

         t = t.unroll()

         while t.isMozMap():

             t = t.inner.unroll()

         if not t.isUnion():

             continue

         name = str(t)

         if name not in unionStructs:

             providers = getRelevantProviders(descriptor, config)

             # FIXME: Unions are broken in workers.  See bug 809899.

             unionStructs[name] = CGUnionStruct(t, providers[0])

             owningUnionStructs[name] = CGUnionStruct(t, providers[0],

                                                      ownsMembers=True)

             def addHeadersForType(f):

                 if f.nullable():

                     headers.add("mozilla/dom/Nullable.h")

                 f = f.unroll()

                 if f.isInterface():

                     if f.isSpiderMonkeyInterface():

                         headers.add("jsfriendapi.h")

                         headers.add("mozilla/dom/TypedArray.h")

                     else:

                         for p in providers:

                             try:

                                 typeDesc = p.getDescriptor(f.inner.identifier.name)

                             except NoSuchDescriptorError:

                                 continue

                             if typeDesc.interface.isCallback():

                                 # Callback interfaces always use strong refs, so

                                 # we need to include the right header to be able

                                 # to Release() in our inlined code.

                                 headers.add(typeDesc.headerFile)

                             else:

                                 declarations.add((typeDesc.nativeType, False))

                                 implheaders.add(typeDesc.headerFile)

                 elif f.isDictionary():

                     # For a dictionary, we need to see its declaration in

                     # UnionTypes.h so we have its sizeof and know how big to

                     # make our union.

                     headers.add(CGHeaders.getDeclarationFilename(f.inner))

                     # And if it needs rooting, we need RootedDictionary too

                     if typeNeedsRooting(f):

                         headers.add("mozilla/dom/RootedDictionary.h")

                 elif f.isEnum():

                     # Need to see the actual definition of the enum,

                     # unfortunately.

                     headers.add(CGHeaders.getDeclarationFilename(f.inner))

                 elif f.isCallback():

                     # Callbacks always use strong refs, so we need to include

                     # the right header to be able to Release() in our inlined

                     # code.

                     headers.add(CGHeaders.getDeclarationFilename(f))

                 elif f.isMozMap():

                     headers.add("mozilla/dom/MozMap.h")

                     # And add headers for the type we're parametrized over

                     addHeadersForType(f.inner)

             for f in t.flatMemberTypes:

                 assert not f.nullable()

                 addHeadersForType(f)

     return (headers, implheaders, declarations,

             CGList(SortedDictValues(unionStructs) +

                    SortedDictValues(owningUnionStructs),

                    "\n"))

 def UnionConversions(descriptors, dictionaries, callbacks, config):

     """

     Returns a CGThing to declare all union argument conversion helper structs.

     """

     # Now find all the things we'll need as arguments because we

     # need to unwrap them.

     headers = set()

     unionConversions = dict()

     for t, descriptor, dictionary in getAllTypes(descriptors, dictionaries, callbacks):

         # Add info for the given type.  descriptor and dictionary, if passed, are

         # used to figure out what to do with interface types.

         assert not descriptor or not dictionary

         t = t.unroll()

         if not t.isUnion():

             continue

         name = str(t)

         if name not in unionConversions:

             providers = getRelevantProviders(descriptor, config)

             unionConversions[name] = CGUnionConversionStruct(t, providers[0])

             def addHeadersForType(f, providers):

                 f = f.unroll()

                 if f.isInterface():

                     if f.isSpiderMonkeyInterface():

                         headers.add("jsfriendapi.h")

                         headers.add("mozilla/dom/TypedArray.h")

                     elif f.inner.isExternal():

                         providers = getRelevantProviders(descriptor, config)

                         for p in providers:

                             try:

                                 typeDesc = p.getDescriptor(f.inner.identifier.name)

                             except NoSuchDescriptorError:

                                 continue

                             headers.add(typeDesc.headerFile)

                     else:

                         headers.add(CGHeaders.getDeclarationFilename(f.inner))

                     # Check for whether we have a possibly-XPConnect-implemented

                     # interface.  If we do, the right descriptor will come from

                     # providers[0], because that would be the non-worker

                     # descriptor provider, if we have one at all.

                     if (f.isGeckoInterface() and

                         providers[0].getDescriptor(f.inner.identifier.name).hasXPConnectImpls):

                         headers.add("nsDOMQS.h")

                 elif f.isDictionary():

                     headers.add(CGHeaders.getDeclarationFilename(f.inner))

                 elif f.isPrimitive():

                     headers.add("mozilla/dom/PrimitiveConversions.h")

                 elif f.isMozMap():

                     headers.add("mozilla/dom/MozMap.h")

                     # And the internal type of the MozMap

                     addHeadersForType(f.inner, providers)

             for f in t.flatMemberTypes:

                 addHeadersForType(f, providers)

     return (headers,

             CGWrapper(CGList(SortedDictValues(unionConversions), "\n"),

                       post="\n\n"))

 class Argument():

     """

     A class for outputting the type and name of an argument

     """

     def __init__(self, argType, name, default=None):

         self.argType = argType

         self.name = name

         self.default = default

     def declare(self):

         string = self.argType + ' ' + self.name

         if self.default is not None:

             string += " = " + self.default

         return string

     def define(self):

         return self.argType + ' ' + self.name

 class CGAbstractMethod(CGThing):

     """

     An abstract class for generating code for a method.  Subclasses

     should override definition_body to create the actual code.

     descriptor is the descriptor for the interface the method is associated with

     name is the name of the method as a string

     returnType is the IDLType of the return value

     args is a list of Argument objects

     inline should be True to generate an inline method, whose body is

     part of the declaration.

     alwaysInline should be True to generate an inline method annotated with

     MOZ_ALWAYS_INLINE.

     static should be True to generate a static method, which only has

     a definition.

     If templateArgs is not None it should be a list of strings containing

     template arguments, and the function will be templatized using those

     arguments.

     """

     def __init__(self, descriptor, name, returnType, args, inline=False, alwaysInline=False, static=False, templateArgs=None):

         CGThing.__init__(self)

         self.descriptor = descriptor

         self.name = name

         self.returnType = returnType

         self.args = args

         self.inline = inline

         self.alwaysInline = alwaysInline

         self.static = static

         self.templateArgs = templateArgs

     def _argstring(self, declare):

         return ', '.join([a.declare() if declare else a.define() for a in self.args])

     def _template(self):

         if self.templateArgs is None:

             return ''

         return 'template <%s>\n' % ', '.join(self.templateArgs)

     def _decorators(self):

         decorators = []

         if self.alwaysInline:

             decorators.append('MOZ_ALWAYS_INLINE')

         elif self.inline:

             decorators.append('inline')

         if self.static:

             decorators.append('static')

         decorators.append(self.returnType)

         maybeNewline = " " if self.inline else "\n"

         return ' '.join(decorators) + maybeNewline

     def declare(self):

         if self.inline:

             return self._define(True)

         return "%s%s%s(%s);\n" % (self._template(), self._decorators(), self.name, self._argstring(True))

     def _define(self, fromDeclare=False):

         return self.definition_prologue(fromDeclare) + 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 ("\n"  # BOGUS extra blank line at start of function

                 "  %s* self = UnwrapDOMObject<%s>(obj);\n" %

                 (self.descriptor.nativeType, self.descriptor.nativeType))

     def definition_body(self):

         return self.definition_body_prologue() + self.generate_code()

     def generate_code(self):

         assert False  # Override me!

 class CGGetJSClassMethod(CGAbstractMethod):

     def __init__(self, descriptor):

         CGAbstractMethod.__init__(self, descriptor, 'GetJSClass', 'const JSClass*',

                                   [])

     def definition_body(self):

         return "  return Class.ToJSClass();\n"

 class CGAddPropertyHook(CGAbstractClassHook):

     """

     A hook for addProperty, used to preserve our wrapper from GC.

     """

     def __init__(self, descriptor):

         args = [Argument('JSContext*', 'cx'),

                 Argument('JS::Handle<JSObject*>', 'obj'),

                 Argument('JS::Handle<jsid>', 'id'),

                 Argument('JS::MutableHandle<JS::Value>', 'vp')]

         CGAbstractClassHook.__init__(self, descriptor, ADDPROPERTY_HOOK_NAME,

                                      'bool', args)

     def generate_code(self):

         assert self.descriptor.wrapperCache

         return indent(dedent("""

             // We don't want to preserve if we don't have a wrapper.

             if (self->GetWrapperPreserveColor()) {

               PreserveWrapper(self);

             }

             return true;

             """))

 def DeferredFinalizeSmartPtr(descriptor):

     if descriptor.nativeOwnership == 'owned':

         smartPtr = 'nsAutoPtr'

     else:

         smartPtr = 'nsRefPtr'

     return smartPtr

 def finalizeHook(descriptor, hookName, freeOp):

     finalize = "JSBindingFinalized<%s>::Finalized(self);\n" % descriptor.nativeType

     if descriptor.wrapperCache:

         finalize += "ClearWrapper(self, self);\n"

     if descriptor.interface.getExtendedAttribute('OverrideBuiltins'):

         finalize += "self->mExpandoAndGeneration.expando = JS::UndefinedValue();\n"

     if descriptor.interface.getExtendedAttribute("Global"):

         finalize += "mozilla::dom::FinalizeGlobal(CastToJSFreeOp(%s), obj);\n" % freeOp

     finalize += ("AddForDeferredFinalization<%s, %s >(self);\n" %

                  (descriptor.nativeType, DeferredFinalizeSmartPtr(descriptor)))

     return CGIfWrapper(CGGeneric(finalize), "self")

 class CGClassFinalizeHook(CGAbstractClassHook):

     """

     A hook for finalize, used to release our native object.

     """

     def __init__(self, descriptor):

         args = [Argument('js::FreeOp*', 'fop'), Argument('JSObject*', 'obj')]

         CGAbstractClassHook.__init__(self, descriptor, FINALIZE_HOOK_NAME,

                                      'void', args)

     def generate_code(self):

         return indent(finalizeHook(self.descriptor, self.name, self.args[0].name).define())

 class CGClassConstructor(CGAbstractStaticMethod):

     """

     JS-visible constructor for our objects

     """

     def __init__(self, descriptor, ctor, name=CONSTRUCT_HOOK_NAME):

         args = [Argument('JSContext*', 'cx'),

                 Argument('unsigned', 'argc'),

                 Argument('JS::Value*', 'vp')]

         CGAbstractStaticMethod.__init__(self, descriptor, name, 'bool', args)

         self._ctor = ctor

     def define(self):

         if not self._ctor:

             return ""

         return CGAbstractStaticMethod.define(self)

     def definition_body(self):

         return self.generate_code()

     def generate_code(self):

         # [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(  # BOGUS extra blank line at beginning of function body

             """

             JS::CallArgs args = JS::CallArgsFromVp(argc, vp);

             JS::Rooted<JSObject*> obj(cx, &args.callee());

             $*{chromeOnlyCheck}

             bool mayInvoke = args.isConstructing();

             #ifdef RELEASE_BUILD

             mayInvoke = mayInvoke || nsContentUtils::ThreadsafeIsCallerChrome();

             #endif // RELEASE_BUILD

             if (!mayInvoke) {

               // XXXbz wish I could get the name from the callee instead of

               // Adding more relocations

               return ThrowConstructorWithoutNew(cx, "${ctorName}");

             }

             """,

             chromeOnlyCheck=chromeOnlyCheck,

             ctorName=ctorName)

         name = self._ctor.identifier.name

         nativeName = MakeNativeName(self.descriptor.binaryNames.get(name, name))

         callGenerator = CGMethodCall(nativeName, True, self.descriptor,

                                      self._ctor, isConstructor=True,

                                      constructorName=ctorName)

         return indent(preamble) + callGenerator.define()

 # Encapsulate the constructor in a helper method to share genConstructorBody with CGJSImplMethod.

 class CGConstructNavigatorObjectHelper(CGAbstractStaticMethod):

     """

     Construct a new JS-implemented WebIDL DOM object, for use on navigator.

     """

     def __init__(self, descriptor):

         name = "ConstructNavigatorObjectHelper"

         args = [Argument('JSContext*', 'cx'),

                 Argument('GlobalObject&', 'global'),

                 Argument('ErrorResult&', 'aRv')]

         rtype = 'already_AddRefed<%s>' % descriptor.name

         CGAbstractStaticMethod.__init__(self, descriptor, name, rtype, args)

     def definition_body(self):

         return indent(genConstructorBody(self.descriptor))

 class CGConstructNavigatorObject(CGAbstractMethod):

     """

     Wrap a JS-implemented WebIDL object into a JS value, for use on navigator.

     """

     def __init__(self, descriptor):

         name = 'ConstructNavigatorObject'

         args = [Argument('JSContext*', 'aCx'), Argument('JS::Handle<JSObject*>', 'aObj')]

         CGAbstractMethod.__init__(self, descriptor, name, 'JSObject*', args)

     def definition_body(self):

         if not self.descriptor.interface.isJSImplemented():

             raise TypeError("Only JS-implemented classes are currently supported "

                             "on navigator. See bug 856820.")

         return indent(fill(

             """

             GlobalObject global(aCx, aObj);

             if (global.Failed()) {

               return nullptr;

             }

             ErrorResult rv;

             JS::Rooted<JS::Value> v(aCx);

             {  // Scope to make sure |result| goes out of scope while |v| is rooted

               nsRefPtr<mozilla::dom::${descriptorName}> result = ConstructNavigatorObjectHelper(aCx, global, rv);

               rv.WouldReportJSException();

               if (rv.Failed()) {

                 ThrowMethodFailedWithDetails(aCx, rv, "${descriptorName}", "navigatorConstructor");

                 return nullptr;

               }

               if (!WrapNewBindingObject(aCx, result, &v)) {

                 //XXX Assertion disabled for now, see bug 991271.

                 MOZ_ASSERT(true || JS_IsExceptionPending(aCx));

                 return nullptr;

               }

             }

             return &v.toObject();

             """,

             descriptorName=self.descriptor.name))

 class CGClassConstructHookHolder(CGGeneric):

     def __init__(self, descriptor):

         if descriptor.interface.ctor():

             constructHook = CONSTRUCT_HOOK_NAME

         else:

             constructHook = "ThrowingConstructor"

         CGGeneric.__init__(self, fill(

             """

             static const JSNativeHolder ${CONSTRUCT_HOOK_NAME}_holder = {

               ${constructHook},

               ${hooks}

             };

             """,

             CONSTRUCT_HOOK_NAME=CONSTRUCT_HOOK_NAME,

             constructHook=constructHook,

             hooks=NativePropertyHooks(descriptor)))

 def NamedConstructorName(m):

     return '_' + m.identifier.name

 class CGNamedConstructors(CGThing):

     def __init__(self, descriptor):

         self.descriptor = descriptor

         CGThing.__init__(self)

     def declare(self):

         return ""

     def define(self):

         if len(self.descriptor.interface.namedConstructors) == 0:

             return ""

         constructorID = "constructors::id::"

         if self.descriptor.interface.hasInterfaceObject():

             constructorID += self.descriptor.name

         else:

             constructorID += "_ID_Count"

         namedConstructors = ""

         for n in self.descriptor.interface.namedConstructors:

             namedConstructors += (

                 "{ \"%s\", { %s, &sNamedConstructorNativePropertyHooks }, %i },\n" %

                 (n.identifier.name, NamedConstructorName(n), methodLength(n)))

         return fill(

             """

             const NativePropertyHooks sNamedConstructorNativePropertyHooks = {

                 nullptr,

                 nullptr,

                 { nullptr, nullptr },

                 prototypes::id::${name},

                 ${constructorID},

                 nullptr

             };

             static const NamedConstructor namedConstructors[] = {

               $*{namedConstructors}

               { nullptr, { nullptr, nullptr }, 0 }

             };

             """,

             name=self.descriptor.name,

             constructorID=constructorID,

             namedConstructors=namedConstructors)

 class CGClassHasInstanceHook(CGAbstractStaticMethod):

     def __init__(self, descriptor):

         args = [Argument('JSContext*', 'cx'),

                 Argument('JS::Handle<JSObject*>', 'obj'),

                 Argument('JS::MutableHandle<JS::Value>', 'vp'),

                 Argument('bool*', 'bp')]

         CGAbstractStaticMethod.__init__(self, descriptor, HASINSTANCE_HOOK_NAME,

                                         'bool', args)

     def define(self):

         if not NeedsGeneratedHasInstance(self.descriptor):

             return ""

         return CGAbstractStaticMethod.define(self)

     def definition_body(self):

         return self.generate_code()

     def generate_code(self):

         # BOGUS extra blank line at start of function

         header = dedent("""

             if (!vp.isObject()) {

               *bp = false;

               return true;

             }

             JS::Rooted<JSObject*> instance(cx, &vp.toObject());

             """)

         if self.descriptor.interface.hasInterfacePrototypeObject():

             return indent(

                 header +

                 fill(

                     """

                     static_assert(IsBaseOf<nsISupports, ${nativeType}>::value,

                                   "HasInstance only works for nsISupports-based classes.");

                     bool ok = InterfaceHasInstance(cx, obj, instance, bp);

                     if (!ok || *bp) {

                       return ok;

                     }

                     // FIXME Limit this to chrome by checking xpc::AccessCheck::isChrome(obj).

                     nsISupports* native =

                       nsContentUtils::XPConnect()->GetNativeOfWrapper(cx,

                                                                       js::UncheckedUnwrap(instance));

                     nsCOMPtr<nsIDOM${name}> qiResult = do_QueryInterface(native);

                     *bp = !!qiResult;

                     return true;

                     """,  # BOGUS extra blank line at end of function

                     nativeType=self.descriptor.nativeType,

                     name=self.descriptor.interface.identifier.name))

         hasInstanceCode = dedent("""

             const DOMClass* domClass = GetDOMClass(js::UncheckedUnwrap(instance));

             *bp = false;

             if (!domClass) {

               // Not a DOM object, so certainly not an instance of this interface

               return true;

             }

             """)

         if self.descriptor.interface.identifier.name == "ChromeWindow":

             setBp = "*bp = UnwrapDOMObject<nsGlobalWindow>(js::UncheckedUnwrap(instance))->IsChromeWindow()"

         else:

             setBp = "*bp = true"

         # Sort interaces implementing self by name so we get stable output.

         for iface in sorted(self.descriptor.interface.interfacesImplementingSelf,

                             key=lambda iface: iface.identifier.name):

             hasInstanceCode += fill(

                 """

                 if (domClass->mInterfaceChain[PrototypeTraits<prototypes::id::${name}>::Depth] == prototypes::id::${name}) {

                   ${setBp};

                   return true;

                 }

                 """,

                 name=iface.identifier.name,

                 setBp=setBp)

         hasInstanceCode += "return true;\n"

         return indent(header + hasInstanceCode)

 def isChromeOnly(m):

     return m.getExtendedAttribute("ChromeOnly")

 def getAvailableInTestFunc(obj):

     availableIn = obj.getExtendedAttribute("AvailableIn")

     if availableIn is None:

         return None

     assert isinstance(availableIn, list) and len(availableIn) == 1

     if availableIn[0] == "PrivilegedApps":

         return "IsInPrivilegedApp"

     if availableIn[0] == "CertifiedApps":

         return "IsInCertifiedApp"

     raise TypeError("Unknown AvailableIn value '%s'" % availableIn[0])

 class MemberCondition:

     """

     An object representing the condition for a member to actually be

     exposed.  Any of pref, func, and available can be None.  If not

     None, they should be strings that have the pref name (for "pref")

     or function name (for "func" and "available").

     """

     def __init__(self, pref, func, available=None):

         assert pref is None or isinstance(pref, str)

         assert func is None or isinstance(func, str)

         assert available is None or isinstance(available, str)

         self.pref = pref

         def toFuncPtr(val):

             if val is None:

                 return "nullptr"

             return "&" + val

         self.func = toFuncPtr(func)

         self.available = toFuncPtr(available)

     def __eq__(self, other):

         return (self.pref == other.pref and self.func == other.func and

                 self.available == other.available)

     def __ne__(self, other):

         return not self.__eq__(other)

 class PropertyDefiner:

     """

     A common superclass for defining things on prototype objects.

     Subclasses should implement generateArray to generate the actual arrays of

     things we're defining.  They should also set self.chrome to the list of

     things only exposed to chrome and self.regular to the list of things exposed

     to both chrome and web pages.

     """

     def __init__(self, descriptor, name):

         self.descriptor = descriptor

         self.name = name

         # self.prefCacheData will store an array of (prefname, bool*)

         # pairs for our bool var caches.  generateArray will fill it

         # in as needed.

         self.prefCacheData = []

     def hasChromeOnly(self):

         return len(self.chrome) > 0

     def hasNonChromeOnly(self):

         return len(self.regular) > 0

     def variableName(self, chrome):

         if chrome:

             if self.hasChromeOnly():

                 return "sChrome" + self.name

         else:

             if self.hasNonChromeOnly():

                 return "s" + self.name

         return "nullptr"

     def usedForXrays(self):

         # No Xrays in workers.

         return not self.descriptor.workers

     def __str__(self):

         # We only need to generate id arrays for things that will end

         # up used via ResolveProperty or EnumerateProperties.

         str = self.generateArray(self.regular, self.variableName(False),

                                  self.usedForXrays())

         if self.hasChromeOnly():

             str += self.generateArray(self.chrome, self.variableName(True),

                                       self.usedForXrays())

         return str

     @staticmethod

     def getStringAttr(member, name):

         attr = member.getExtendedAttribute(name)

         if attr is None:

             return None

         # It's a list of strings

         assert len(attr) == 1

         assert attr[0] is not None

         return attr[0]

     @staticmethod

     def getControllingCondition(interfaceMember):

         return MemberCondition(PropertyDefiner.getStringAttr(interfaceMember,

                                                              "Pref"),

                                PropertyDefiner.getStringAttr(interfaceMember,

                                                              "Func"),

                                getAvailableInTestFunc(interfaceMember))

     def generatePrefableArray(self, array, name, specTemplate, specTerminator,

                               specType, getCondition, getDataTuple, doIdArrays):

         """

         This method generates our various arrays.

         array is an array of interface members as passed to generateArray

         name is the name as passed to generateArray

         specTemplate is a template for each entry of the spec array

         specTerminator is a terminator for the spec array (inserted every time

           our controlling pref changes and at the end of the array)

         specType is the actual typename of our spec

         getCondition is a callback function that takes an array entry and

           returns the corresponding MemberCondition.

         getDataTuple is a callback function that takes an array entry and

           returns a tuple suitable for substitution into specTemplate.

         """

         # We want to generate a single list of specs, but with specTerminator

         # inserted at every point where the pref name controlling the member

         # changes.  That will make sure the order of the properties as exposed

         # on the interface and interface prototype objects does not change when

         # pref control is added to members while still allowing us to define all

         # the members in the smallest number of JSAPI calls.

         assert len(array) != 0

         lastCondition = getCondition(array[0])  # So we won't put a specTerminator

                                                 # at the very front of the list.

         specs = []

         prefableSpecs = []

         prefableTemplate = '  { true, %s, %s, &%s[%d] }'

         prefCacheTemplate = '&%s[%d].enabled'

         def switchToCondition(props, condition):

             # Remember the info about where our pref-controlled

             # booleans live.

             if condition.pref is not None:

                 props.prefCacheData.append(

                     (condition.pref,

                      prefCacheTemplate % (name, len(prefableSpecs))))

             # Set up pointers to the new sets of specs inside prefableSpecs

             prefableSpecs.append(prefableTemplate %

                                  (condition.func,

                                   condition.available,

                                   name + "_specs", len(specs)))

         switchToCondition(self, lastCondition)

         for member in array:

             curCondition = getCondition(member)

             if lastCondition != curCondition:

                 # Terminate previous list

                 specs.append(specTerminator)

                 # And switch to our new pref

                 switchToCondition(self, curCondition)

                 lastCondition = curCondition

             # And the actual spec

             specs.append(specTemplate % getDataTuple(member))

         specs.append(specTerminator)

         prefableSpecs.append("  { false, nullptr }")

         specType = "const " + specType

         arrays = fill(

             """

             static ${specType} ${name}_specs[] = {

             ${specs}

             };

             // Can't be const because the pref-enabled boolean needs to be writable

             static Prefable<${specType}> ${name}[] = {

             ${prefableSpecs}

             };

             """,

             specType=specType,

             name=name,

             specs=',\n'.join(specs),

             prefableSpecs=',\n'.join(prefableSpecs))

         if doIdArrays:

             arrays += "static jsid %s_ids[%i];\n\n" % (name, len(specs))

         return arrays

 # The length of a method is the minimum of the lengths of the

 # argument lists of all its overloads.

 def overloadLength(arguments):

     i = len(arguments)

     while i > 0 and arguments[i - 1].optional:

         i -= 1

     return i

 def methodLength(method):

     signatures = method.signatures()

     return min(overloadLength(arguments) for retType, arguments in signatures)

 class MethodDefiner(PropertyDefiner):

     """

     A class for defining methods on a prototype object.

     """

     def __init__(self, descriptor, name, static):

         PropertyDefiner.__init__(self, descriptor, name)

         # FIXME https://bugzilla.mozilla.org/show_bug.cgi?id=772822

         #       We should be able to check for special operations without an

         #       identifier. For now we check if the name starts with __

         # Ignore non-static methods for interfaces without a proto object

         if descriptor.interface.hasInterfacePrototypeObject() or static:

             methods = [m for m in descriptor.interface.members if

                        m.isMethod() and m.isStatic() == static and

                        not m.isIdentifierLess()]

         else:

             methods = []

         self.chrome = []

         self.regular = []

         for m in methods:

             if m.identifier.name == 'queryInterface':

                 if self.descriptor.workers:

                     continue

                 if m.isStatic():

                     raise TypeError("Legacy queryInterface member shouldn't be static")

                 signatures = m.signatures()

                 def argTypeIsIID(arg):

                     return arg.type.inner.isExternal() and arg.type.inner.identifier.name == 'IID'

                 if len(signatures) > 1 or len(signatures[0][1]) > 1 or not argTypeIsIID(signatures[0][1][0]):

                     raise TypeError("There should be only one queryInterface method with 1 argument of type IID")

                 # Make sure to not stick QueryInterface on abstract interfaces that

                 # have hasXPConnectImpls (like EventTarget).  So only put it on

                 # interfaces that are concrete and all of whose ancestors are abstract.

                 def allAncestorsAbstract(iface):

                     if not iface.parent:

                         return True

                     desc = self.descriptor.getDescriptor(iface.parent.identifier.name)

                     if desc.concrete:

                         return False

                     return allAncestorsAbstract(iface.parent)

                 if (not self.descriptor.interface.hasInterfacePrototypeObject() or

                     not self.descriptor.concrete or

                     not allAncestorsAbstract(self.descriptor.interface)):

                     raise TypeError("QueryInterface is only supported on "

                                     "interfaces that are concrete and all "

                                     "of whose ancestors are abstract: " +

                                     self.descriptor.name)

                 condition = "WantsQueryInterface<%s>::Enabled" % descriptor.nativeType

                 self.regular.append({

                     "name": 'QueryInterface',

                     "methodInfo": False,

                     "length": 1,

                     "flags": "0",

                     "condition": MemberCondition(None, condition)

                 })

                 continue

             method = {

                 "name": m.identifier.name,

                 "methodInfo": not m.isStatic(),

                 "length": methodLength(m),

                 "flags": "JSPROP_ENUMERATE",

                 "condition": PropertyDefiner.getControllingCondition(m),

                 "allowCrossOriginThis": m.getExtendedAttribute("CrossOriginCallable"),

                 "returnsPromise": m.returnsPromise()

             }

             if isChromeOnly(m):

                 self.chrome.append(method)

             else:

                 self.regular.append(method)

         # FIXME Check for an existing iterator on the interface first.

         if any(m.isGetter() and m.isIndexed() for m in methods):

             self.regular.append({

                 "name": "@@iterator",

                 "methodInfo": False,

                 "selfHostedName": "ArrayValues",

                 "length": 0,

                 "flags": "JSPROP_ENUMERATE",

                 "condition": MemberCondition(None, None)

             })

         if not static:

             stringifier = descriptor.operations['Stringifier']

             if stringifier:

                 toStringDesc = {

                     "name": "toString",

                     "nativeName": stringifier.identifier.name,

                     "length": 0,

                     "flags": "JSPROP_ENUMERATE",

                     "condition": PropertyDefiner.getControllingCondition(stringifier)

                 }

                 if isChromeOnly(stringifier):

                     self.chrome.append(toStringDesc)

                 else:

                     self.regular.append(toStringDesc)

             jsonifier = descriptor.operations['Jsonifier']

             if jsonifier:

                 toJSONDesc = {

                     "name": "toJSON",

                     "nativeName": jsonifier.identifier.name,

                     "length": 0,

                     "flags": "JSPROP_ENUMERATE",

                     "condition": PropertyDefiner.getControllingCondition(jsonifier)

                 }

                 if isChromeOnly(jsonifier):

                     self.chrome.append(toJSONDesc)

                 else:

                     self.regular.append(toJSONDesc)

         elif (descriptor.interface.isJSImplemented() and

               descriptor.interface.hasInterfaceObject()):

             self.chrome.append({

                 "name": '_create',

                 "nativeName": ("%s::_Create" % descriptor.name),

                 "methodInfo": False,

                 "length": 2,

                 "flags": "0",

                 "condition": MemberCondition(None, None)

             })

         if static:

             if not descriptor.interface.hasInterfaceObject():

                 # static methods go on the interface object

                 assert not self.hasChromeOnly() and not self.hasNonChromeOnly()

         else:

             if not descriptor.interface.hasInterfacePrototypeObject():

                 # non-static methods go on the interface prototype object

                 assert not self.hasChromeOnly() and not self.hasNonChromeOnly()

     def generateArray(self, array, name, doIdArrays):

         if len(array) == 0:

             return ""

         def condition(m):

             return m["condition"]

         def specData(m):

             if "selfHostedName" in m:

                 selfHostedName = '"%s"' % m["selfHostedName"]

                 assert not m.get("methodInfo", True)

                 accessor = "nullptr"

                 jitinfo = "nullptr"

             else:

                 selfHostedName = "nullptr"

                 accessor = m.get("nativeName", m["name"])

                 if m.get("methodInfo", True):

                     # Cast this in case the methodInfo is a

                     # JSTypedMethodJitInfo.

                     jitinfo = ("reinterpret_cast<const JSJitInfo*>(&%s_methodinfo)" % accessor)

                     if m.get("allowCrossOriginThis", False):

                         if m.get("returnsPromise", False):

                             raise TypeError("%s returns a Promise but should "

                                             "be allowed cross-origin?" %

                                             accessor)

                         accessor = "genericCrossOriginMethod"

                     elif self.descriptor.needsSpecialGenericOps():

                         if m.get("returnsPromise", False):

                             raise TypeError("%s returns a Promise but needs "

                                             "special generic ops?" %

                                             accessor)

                         accessor = "genericMethod"

                     elif m.get("returnsPromise", False):

                         accessor = "GenericPromiseReturningBindingMethod"

                     else:

                         accessor = "GenericBindingMethod"

                 else:

                     if m.get("returnsPromise", False):

                         jitinfo = "&%s_methodinfo" % accessor

                         accessor = "StaticMethodPromiseWrapper"

                     else:

                         jitinfo = "nullptr"

             return (m["name"], accessor, jitinfo, m["length"], m["flags"], selfHostedName)

         return self.generatePrefableArray(

             array, name,

             '  JS_FNSPEC("%s", %s, %s, %s, %s, %s)',

             '  JS_FS_END',

             'JSFunctionSpec',

             condition, specData, doIdArrays)

 class AttrDefiner(PropertyDefiner):

     def __init__(self, descriptor, name, static, unforgeable=False):

         assert not (static and unforgeable)

         PropertyDefiner.__init__(self, descriptor, name)

         self.name = name

         # Ignore non-static attributes for interfaces without a proto object

         if descriptor.interface.hasInterfacePrototypeObject() or static:

             attributes = [m for m in descriptor.interface.members if

                           m.isAttr() and m.isStatic() == static and

                           m.isUnforgeable() == unforgeable]

         else:

             attributes = []

         self.chrome = [m for m in attributes if isChromeOnly(m)]

         self.regular = [m for m in attributes if not isChromeOnly(m)]

         self.static = static

         self.unforgeable = unforgeable

         if static:

             if not descriptor.interface.hasInterfaceObject():

                 # static attributes go on the interface object

                 assert not self.hasChromeOnly() and not self.hasNonChromeOnly()

         else:

             if not descriptor.interface.hasInterfacePrototypeObject():

                 # non-static attributes go on the interface prototype object

                 assert not self.hasChromeOnly() and not self.hasNonChromeOnly()

     def generateArray(self, array, name, doIdArrays):

         if len(array) == 0:

             return ""

         def flags(attr):

             unforgeable = " | JSPROP_PERMANENT" if self.unforgeable else ""

             return ("JSPROP_SHARED | JSPROP_ENUMERATE | JSPROP_NATIVE_ACCESSORS" +

                     unforgeable)

         def getter(attr):

             if self.static:

                 accessor = 'get_' + attr.identifier.name

                 jitinfo = "nullptr"

             else:

                 if attr.hasLenientThis():

                     accessor = "genericLenientGetter"

                 elif attr.getExtendedAttribute("CrossOriginReadable"):

                     accessor = "genericCrossOriginGetter"

                 elif self.descriptor.needsSpecialGenericOps():

                     accessor = "genericGetter"

                 else:

                     accessor = "GenericBindingGetter"

                 jitinfo = "&%s_getterinfo" % attr.identifier.name

             return "{ { JS_CAST_NATIVE_TO(%s, JSPropertyOp), %s } }" % \

                    (accessor, jitinfo)

         def setter(attr):

             if (attr.readonly and

                 attr.getExtendedAttribute("PutForwards") is None and

                 attr.getExtendedAttribute("Replaceable") is None):

                 return "JSOP_NULLWRAPPER"

             if self.static:

                 accessor = 'set_' + attr.identifier.name

                 jitinfo = "nullptr"

             else:

                 if attr.hasLenientThis():

                     accessor = "genericLenientSetter"

                 elif attr.getExtendedAttribute("CrossOriginWritable"):

                     accessor = "genericCrossOriginSetter"

                 elif self.descriptor.needsSpecialGenericOps():

                     accessor = "genericSetter"

                 else:

                     accessor = "GenericBindingSetter"

                 jitinfo = "&%s_setterinfo" % attr.identifier.name

             return "{ { JS_CAST_NATIVE_TO(%s, JSStrictPropertyOp), %s } }" % \

                    (accessor, jitinfo)

         def specData(attr):

             return (attr.identifier.name, flags(attr), getter(attr),

                     setter(attr))

         return self.generatePrefableArray(

             array, name,

             '  { "%s", %s, %s, %s}',

             '  JS_PS_END',

             'JSPropertySpec',

             PropertyDefiner.getControllingCondition, specData, doIdArrays)

 class ConstDefiner(PropertyDefiner):

     """

     A class for definining constants on the interface object

     """

     def __init__(self, descriptor, name):

         PropertyDefiner.__init__(self, descriptor, name)

         self.name = name

         constants = [m for m in descriptor.interface.members if m.isConst()]

         self.chrome = [m for m in constants if isChromeOnly(m)]

         self.regular = [m for m in constants if not isChromeOnly(m)]

     def generateArray(self, array, name, doIdArrays):

         if len(array) == 0:

             return ""

         def specData(const):

             return (const.identifier.name,

                     convertConstIDLValueToJSVal(const.value))

         return self.generatePrefableArray(

             array, name,

             '  { "%s", %s }',

             '  { 0, JS::UndefinedValue() }',

             'ConstantSpec',

             PropertyDefiner.getControllingCondition, specData, doIdArrays)

 class PropertyArrays():

     def __init__(self, descriptor):

         self.staticMethods = MethodDefiner(descriptor, "StaticMethods",

                                            static=True)

         self.staticAttrs = AttrDefiner(descriptor, "StaticAttributes",

                                        static=True)

         self.methods = MethodDefiner(descriptor, "Methods", static=False)

         self.attrs = AttrDefiner(descriptor, "Attributes", static=False)

         self.unforgeableAttrs = AttrDefiner(descriptor, "UnforgeableAttributes",

                                             static=False, unforgeable=True)

         self.consts = ConstDefiner(descriptor, "Constants")

     @staticmethod

     def arrayNames():

         return ["staticMethods", "staticAttrs", "methods", "attrs",

                 "unforgeableAttrs", "consts"]

     def hasChromeOnly(self):

         return any(getattr(self, a).hasChromeOnly() for a in self.arrayNames())

     def hasNonChromeOnly(self):

         return any(getattr(self, a).hasNonChromeOnly() for a in self.arrayNames())

     def __str__(self):

         define = ""

         for array in self.arrayNames():

             define += str(getattr(self, array))

         return define

 class CGNativeProperties(CGList):

     def __init__(self, descriptor, properties):

         def generateNativeProperties(name, chrome):

             def check(p):

                 return p.hasChromeOnly() if chrome else p.hasNonChromeOnly()

             nativeProps = []

             for array in properties.arrayNames():

                 propertyArray = getattr(properties, array)

                 if check(propertyArray):

                     if propertyArray.usedForXrays():

                         ids = "%(name)s_ids"

                     else:

                         ids = "nullptr"

                     props = "%(name)s, " + ids + ", %(name)s_specs"

                     props = (props % {'name': propertyArray.variableName(chrome)})

                 else:

                     props = "nullptr, nullptr, nullptr"

                 nativeProps.append(CGGeneric(props))

             return CGWrapper(CGIndenter(CGList(nativeProps, ",\n")),

                              pre="static const NativeProperties %s = {\n" % name,

                              post="\n};\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):

         # BOGUSly strip off a newline

         return CGList.define(self).rstrip()

 class CGCreateInterfaceObjectsMethod(CGAbstractMethod):

     """

     Generate the CreateInterfaceObjects method for an interface descriptor.

     properties should be a PropertyArrays instance.

     """

     def __init__(self, descriptor, properties):

         args = [Argument('JSContext*', 'aCx'),

                 Argument('JS::Handle<JSObject*>', 'aGlobal'),

                 Argument('ProtoAndIfaceCache&', 'aProtoAndIfaceCache'),

                 Argument('bool', 'aDefineOnGlobal')]

         CGAbstractMethod.__init__(self, descriptor, 'CreateInterfaceObjects', 'void', args)

         self.properties = properties

     def definition_body(self):

         if len(self.descriptor.prototypeChain) == 1:

             parentProtoType = "Rooted"

             if self.descriptor.interface.getExtendedAttribute("ArrayClass"):

                 getParentProto = "aCx, JS_GetArrayPrototype(aCx, aGlobal)"

             else:

                 getParentProto = "aCx, JS_GetObjectPrototype(aCx, aGlobal)"

         else:

             parentProtoName = self.descriptor.prototypeChain[-2]

             parentDesc = self.descriptor.getDescriptor(parentProtoName)

             if parentDesc.workers:

                 parentProtoName += '_workers'

             getParentProto = ("%s::GetProtoObject(aCx, aGlobal)" %

                               toBindingNamespace(parentProtoName))

             parentProtoType = "Handle"

         parentWithInterfaceObject = self.descriptor.interface.parent

         while (parentWithInterfaceObject and

                not parentWithInterfaceObject.hasInterfaceObject()):

             parentWithInterfaceObject = parentWithInterfaceObject.parent

         if parentWithInterfaceObject:

             parentIfaceName = parentWithInterfaceObject.identifier.name

             parentDesc = self.descriptor.getDescriptor(parentIfaceName)

             if parentDesc.workers:

                 parentIfaceName += "_workers"

             getConstructorProto = ("%s::GetConstructorObject(aCx, aGlobal)" %

                                    toBindingNamespace(parentIfaceName))

             constructorProtoType = "Handle"

         else:

             getConstructorProto = "aCx, JS_GetFunctionPrototype(aCx, aGlobal)"

             constructorProtoType = "Rooted"

         needInterfaceObject = self.descriptor.interface.hasInterfaceObject()

         needInterfacePrototypeObject = self.descriptor.interface.hasInterfacePrototypeObject()

         # if we don't need to create anything, why are we generating this?

         assert needInterfaceObject or needInterfacePrototypeObject

         idsToInit = []

         # There is no need to init any IDs in workers, because worker bindings

         # don't have Xrays.

         if not self.descriptor.workers:

             for var in self.properties.arrayNames():

                 props = getattr(self.properties, var)

                 # We only have non-chrome ids to init if we have no chrome ids.

                 if props.hasChromeOnly():

                     idsToInit.append(props.variableName(True))

                 if props.hasNonChromeOnly():

                     idsToInit.append(props.variableName(False))

         if len(idsToInit) > 0:

             initIdCalls = ["!InitIds(aCx, %s, %s_ids)" % (varname, varname)

                            for varname in idsToInit]

             idsInitedFlag = CGGeneric("static bool sIdsInited = false;\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) {\n"

                                        "  sPrefCachesInited = true;\n"),

                                   post="}\n")

         else:

             prefCache = None

         if UseHolderForUnforgeable(self.descriptor):

             createUnforgeableHolder = CGGeneric(dedent("""

                 JS::Rooted<JSObject*> unforgeableHolder(aCx,

                   JS_NewObjectWithGivenProto(aCx, nullptr, JS::NullPtr(), JS::NullPtr()));

                 if (!unforgeableHolder) {

                   return;

                 }

                 """))

             defineUnforgeables = InitUnforgeablePropertiesOnObject(self.descriptor,

                                                                    "unforgeableHolder",

                                                                    self.properties)

             createUnforgeableHolder = CGList(

                 [createUnforgeableHolder, defineUnforgeables])

         else:

             createUnforgeableHolder = None

         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)

         if (needInterfaceObject and

             self.descriptor.needsConstructHookHolder()):

             constructHookHolder = "&" + CONSTRUCT_HOOK_NAME + "_holder"

         else:

             constructHookHolder = "nullptr"

         if self.descriptor.interface.ctor():

             constructArgs = methodLength(self.descriptor.interface.ctor())

         else:

             constructArgs = 0

         if len(self.descriptor.interface.namedConstructors) > 0:

             namedConstructors = "namedConstructors"

         else:

             namedConstructors = "nullptr"

         if needInterfacePrototypeObject:

             protoClass = "&PrototypeClass.mBase"

             protoCache = "&aProtoAndIfaceCache.EntrySlotOrCreate(prototypes::id::%s)" % self.descriptor.name

         else:

             protoClass = "nullptr"

             protoCache = "nullptr"

         if needInterfaceObject:

             interfaceClass = "&InterfaceObjectClass.mBase"

             interfaceCache = "&aProtoAndIfaceCache.EntrySlotOrCreate(constructors::id::%s)" % self.descriptor.name

         else:

             # We don't have slots to store the named constructors.

             assert len(self.descriptor.interface.namedConstructors) == 0

             interfaceClass = "nullptr"

             interfaceCache = "nullptr"

         if self.descriptor.concrete:

             domClass = "&Class.mClass"

         else:

             domClass = "nullptr"

         if self.properties.hasNonChromeOnly():

             properties = "&sNativeProperties"

         else:

             properties = "nullptr"

         if self.properties.hasChromeOnly():

             accessCheck = "nsContentUtils::ThreadsafeIsCallerChrome()"

             chromeProperties = accessCheck + " ? &sChromeOnlyNativeProperties : nullptr"

         else:

             chromeProperties = "nullptr"

         call = fill(

             """

             dom::CreateInterfaceObjects(aCx, aGlobal, parentProto,

                                         ${protoClass}, ${protoCache},

                                         constructorProto, ${interfaceClass}, ${constructHookHolder}, ${constructArgs}, ${namedConstructors},

                                         ${interfaceCache},

                                         ${domClass},

                                         ${properties},

                                         ${chromeProperties},

                                         ${name}, aDefineOnGlobal);

             """,

             protoClass=protoClass,

             protoCache=protoCache,

             interfaceClass=interfaceClass,

             constructHookHolder=constructHookHolder,

             constructArgs=constructArgs,

             namedConstructors=namedConstructors,

             interfaceCache=interfaceCache,

             domClass=domClass,

             properties=properties,

             chromeProperties=chromeProperties,

             name='"' + self.descriptor.interface.identifier.name + '"' if needInterfaceObject else "nullptr")

         if UseHolderForUnforgeable(self.descriptor):

             assert needInterfacePrototypeObject

             setUnforgeableHolder = CGGeneric(fill(

                 """

                 JSObject* proto = aProtoAndIfaceCache.EntrySlotOrCreate(prototypes::id::${name});

                 if (proto) {

                   js::SetReservedSlot(proto, DOM_INTERFACE_PROTO_SLOTS_BASE,

                                       JS::ObjectValue(*unforgeableHolder));

                 }

                 """,

                 name=self.descriptor.name))

         else:

             setUnforgeableHolder = None

         functionBody = CGList(

             [CGGeneric(getParentProto), CGGeneric(getConstructorProto), initIds,

              prefCache, createUnforgeableHolder, CGGeneric(call), setUnforgeableHolder],

             "\n")

         return CGIndenter(functionBody).define()

 class CGGetPerInterfaceObject(CGAbstractMethod):

     """

     A method for getting a per-interface object (a prototype object or interface

     constructor object).

     """

     def __init__(self, descriptor, name, idPrefix="", extraArgs=[]):

         args = [Argument('JSContext*', 'aCx'),

                 Argument('JS::Handle<JSObject*>', 'aGlobal')] + extraArgs

         CGAbstractMethod.__init__(self, descriptor, name,

                                   'JS::Handle<JSObject*>', args)

         self.id = idPrefix + "id::" + self.descriptor.name

     def definition_body(self):

         # BOGUS extra blank line at the beginning of the code below

         # BOGUS - should be a blank line between an if-block and following comment below

         return indent(fill(

             """

             /* Make sure our global is sane.  Hopefully we can remove this sometime */

             if (!(js::GetObjectClass(aGlobal)->flags & JSCLASS_DOM_GLOBAL)) {

               return JS::NullPtr();

             }

             /* Check to see whether the interface objects are already installed */

             ProtoAndIfaceCache& protoAndIfaceCache = *GetProtoAndIfaceCache(aGlobal);

             if (!protoAndIfaceCache.EntrySlotIfExists(${id})) {

               CreateInterfaceObjects(aCx, aGlobal, protoAndIfaceCache, aDefineOnGlobal);

             }

             /*

              * The object might _still_ be null, but that's OK.

              *

              * Calling fromMarkedLocation() is safe because protoAndIfaceCache is

              * traced by TraceProtoAndIfaceCache() and its contents are never

              * changed after they have been set.

              */

             return JS::Handle<JSObject*>::fromMarkedLocation(protoAndIfaceCache.EntrySlotMustExist(${id}).address());

             """,

             id=self.id))

 class CGGetProtoObjectMethod(CGGetPerInterfaceObject):

     """

     A method for getting the interface prototype object.

     """

     def __init__(self, descriptor):

         CGGetPerInterfaceObject.__init__(self, descriptor, "GetProtoObject",

                                          "prototypes::")

     def definition_body(self):

         # BOGUS extra blank line at start of method

         return indent(dedent("""

             /* Get the interface prototype object for this class.  This will create the

                object as needed. */

             bool aDefineOnGlobal = true;

             """)) + CGGetPerInterfaceObject.definition_body(self)

 class CGGetConstructorObjectMethod(CGGetPerInterfaceObject):

     """

     A method for getting the interface constructor object.

     """

     def __init__(self, descriptor):

         CGGetPerInterfaceObject.__init__(

             self, descriptor, "GetConstructorObject",

             "constructors::",

             extraArgs=[Argument("bool", "aDefineOnGlobal", "true")])

     def definition_body(self):

         # BOGUS extra blank line at start of method

         return indent(dedent("""

             /* Get the interface object for this class.  This will create the object as

                needed. */

             """)) + CGGetPerInterfaceObject.definition_body(self)

 class CGDefineDOMInterfaceMethod(CGAbstractMethod):

     """

     A method for resolve hooks to try to lazily define the interface object for

     a given interface.

     """

     def __init__(self, descriptor):

         args = [Argument('JSContext*', 'aCx'),

                 Argument('JS::Handle<JSObject*>', 'aGlobal'),

                 Argument('JS::Handle<jsid>', 'id'),

                 Argument('bool', 'aDefineOnGlobal')]

         CGAbstractMethod.__init__(self, descriptor, 'DefineDOMInterface', 'JSObject*', args)

     def declare(self):

         if self.descriptor.workers:

             return ''

         return CGAbstractMethod.declare(self)