mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
3058 lines
119 KiB
Python
3058 lines
119 KiB
Python
# This Source Code Form is subject to the terms of the Mozilla Public
|
|
# License, v. 2.0. If a copy of the MPL was not distributed with this file,
|
|
# You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
|
|
# Common codegen classes.
|
|
|
|
import os
|
|
import string
|
|
|
|
from WebIDL import *
|
|
|
|
AUTOGENERATED_WARNING_COMMENT = \
|
|
"/* THIS FILE IS AUTOGENERATED - DO NOT EDIT */\n\n"
|
|
ADDPROPERTY_HOOK_NAME = '_AddProperty'
|
|
FINALIZE_HOOK_NAME = '_Finalize'
|
|
TRACE_HOOK_NAME = '_Trace'
|
|
CONSTRUCT_HOOK_NAME = '_Construct'
|
|
HASINSTANCE_HOOK_NAME = '_HasInstance'
|
|
|
|
def replaceFileIfChanged(filename, newContents):
|
|
"""
|
|
Read a copy of the old file, so that we don't touch it if it hasn't changed.
|
|
Returns True if the file was updated, false otherwise.
|
|
"""
|
|
oldFileContents = ""
|
|
try:
|
|
oldFile = open(filename, 'rb')
|
|
oldFileContents = ''.join(oldFile.readlines())
|
|
oldFile.close()
|
|
except:
|
|
pass
|
|
|
|
if newContents == oldFileContents:
|
|
return False
|
|
|
|
f = open(filename, 'wb')
|
|
f.write(newContents)
|
|
f.close()
|
|
|
|
def toStringBool(arg):
|
|
return str(not not arg).lower()
|
|
|
|
def toBindingNamespace(arg):
|
|
return re.sub("((_workers)?$)", "Binding\\1", arg);
|
|
|
|
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!
|
|
|
|
class CGNativePropertyHooks(CGThing):
|
|
"""
|
|
Generate a NativePropertyHooks for a given descriptor
|
|
"""
|
|
def __init__(self, descriptor):
|
|
CGThing.__init__(self)
|
|
self.descriptor = descriptor
|
|
def declare(self):
|
|
return " extern const NativePropertyHooks NativeHooks;\n"
|
|
def define(self):
|
|
parent = self.descriptor.interface.parent
|
|
parentHooks = ("&" + toBindingNamespace(parent.identifier.name) + "::NativeHooks"
|
|
if parent else 'NULL')
|
|
return """
|
|
const NativePropertyHooks NativeHooks = { ResolveProperty, EnumerateProperties, %s };
|
|
""" % parentHooks
|
|
|
|
class CGDOMJSClass(CGThing):
|
|
"""
|
|
Generate a DOMJSClass for a given descriptor
|
|
"""
|
|
def __init__(self, descriptor):
|
|
CGThing.__init__(self)
|
|
self.descriptor = descriptor
|
|
def declare(self):
|
|
return " extern DOMJSClass Class;\n"
|
|
def define(self):
|
|
traceHook = TRACE_HOOK_NAME if self.descriptor.customTrace else 'NULL'
|
|
protoList = ['prototypes::id::' + proto for proto in self.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.
|
|
while len(protoList) < self.descriptor.config.maxProtoChainLength:
|
|
protoList.append('prototypes::id::_ID_Count')
|
|
prototypeChainString = ', '.join(protoList)
|
|
return """
|
|
DOMJSClass Class = {
|
|
{ "%s",
|
|
JSCLASS_IS_DOMJSCLASS | JSCLASS_HAS_RESERVED_SLOTS(1),
|
|
%s, /* addProperty */
|
|
JS_PropertyStub, /* delProperty */
|
|
JS_PropertyStub, /* getProperty */
|
|
JS_StrictPropertyStub, /* setProperty */
|
|
JS_EnumerateStub,
|
|
JS_ResolveStub,
|
|
JS_ConvertStub,
|
|
%s, /* finalize */
|
|
NULL, /* checkAccess */
|
|
NULL, /* call */
|
|
NULL, /* construct */
|
|
NULL, /* hasInstance */
|
|
%s, /* trace */
|
|
JSCLASS_NO_INTERNAL_MEMBERS
|
|
},
|
|
{ %s },
|
|
-1, %s, DOM_OBJECT_SLOT,
|
|
&NativeHooks
|
|
};
|
|
""" % (self.descriptor.interface.identifier.name,
|
|
ADDPROPERTY_HOOK_NAME if self.descriptor.concrete and not self.descriptor.workers else 'JS_PropertyStub',
|
|
FINALIZE_HOOK_NAME, traceHook, prototypeChainString,
|
|
str(self.descriptor.nativeIsISupports).lower())
|
|
|
|
class CGPrototypeJSClass(CGThing):
|
|
def __init__(self, descriptor):
|
|
CGThing.__init__(self)
|
|
self.descriptor = descriptor
|
|
def declare(self):
|
|
# We're purely for internal consumption
|
|
return ""
|
|
def define(self):
|
|
return """
|
|
static JSClass PrototypeClass = {
|
|
"%s Prototype", 0,
|
|
JS_PropertyStub, /* addProperty */
|
|
JS_PropertyStub, /* delProperty */
|
|
JS_PropertyStub, /* getProperty */
|
|
JS_StrictPropertyStub, /* setProperty */
|
|
JS_EnumerateStub,
|
|
JS_ResolveStub,
|
|
JS_ConvertStub,
|
|
NULL, /* finalize */
|
|
NULL, /* checkAccess */
|
|
NULL, /* call */
|
|
NULL, /* construct */
|
|
NULL, /* hasInstance */
|
|
NULL, /* trace */
|
|
JSCLASS_NO_INTERNAL_MEMBERS
|
|
};
|
|
""" % (self.descriptor.interface.identifier.name)
|
|
|
|
class CGInterfaceObjectJSClass(CGThing):
|
|
def __init__(self, descriptor):
|
|
CGThing.__init__(self)
|
|
self.descriptor = descriptor
|
|
def declare(self):
|
|
# We're purely for internal consumption
|
|
return ""
|
|
def define(self):
|
|
if not self.descriptor.hasInstanceInterface:
|
|
return ""
|
|
ctorname = "NULL" if not self.descriptor.interface.ctor() else CONSTRUCT_HOOK_NAME
|
|
hasinstance = HASINSTANCE_HOOK_NAME
|
|
return """
|
|
static JSClass InterfaceObjectClass = {
|
|
"Function", 0,
|
|
JS_PropertyStub, /* addProperty */
|
|
JS_PropertyStub, /* delProperty */
|
|
JS_PropertyStub, /* getProperty */
|
|
JS_StrictPropertyStub, /* setProperty */
|
|
JS_EnumerateStub,
|
|
JS_ResolveStub,
|
|
JS_ConvertStub,
|
|
NULL, /* finalize */
|
|
NULL, /* checkAccess */
|
|
%s, /* call */
|
|
%s, /* construct */
|
|
%s, /* hasInstance */
|
|
NULL, /* trace */
|
|
JSCLASS_NO_INTERNAL_MEMBERS
|
|
};
|
|
""" % (ctorname, ctorname, hasinstance)
|
|
|
|
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)
|
|
self.children = children
|
|
self.joiner = joiner
|
|
def append(self, child):
|
|
self.children.append(child)
|
|
def prepend(self, child):
|
|
self.children.insert(0, child)
|
|
def declare(self):
|
|
return self.joiner.join([child.declare() for child in self.children
|
|
if child is not None])
|
|
def define(self):
|
|
return self.joiner.join([child.define() for child in self.children
|
|
if child is not None])
|
|
|
|
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
|
|
|
|
# We'll want to insert the indent at the beginnings of lines, but we
|
|
# don't want to indent empty lines. So only indent lines that have a
|
|
# non-newline character on them.
|
|
lineStartDetector = re.compile("^(?=[^\n#])", re.MULTILINE)
|
|
class CGIndenter(CGThing):
|
|
"""
|
|
A class that takes another CGThing and generates code that indents that
|
|
CGThing by some number of spaces. The default indent is two spaces.
|
|
"""
|
|
def __init__(self, child, indentLevel=2):
|
|
CGThing.__init__(self)
|
|
self.child = child
|
|
self.indent = " " * indentLevel
|
|
def declare(self):
|
|
decl = self.child.declare()
|
|
if decl is not "":
|
|
return re.sub(lineStartDetector, self.indent, decl)
|
|
else:
|
|
return ""
|
|
def define(self):
|
|
defn = self.child.define()
|
|
if defn is not "":
|
|
return re.sub(lineStartDetector, self.indent, defn)
|
|
else:
|
|
return ""
|
|
|
|
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:
|
|
# We don't use lineStartDetector because we don't want to
|
|
# insert whitespace at the beginning of our _first_ line.
|
|
decl = stripTrailingWhitespace(
|
|
decl.replace("\n", "\n" + (" " * len(self.declarePre))))
|
|
return self.declarePre + decl + self.declarePost
|
|
def define(self):
|
|
if self.declareOnly:
|
|
return ''
|
|
defn = self.child.define()
|
|
if self.reindent:
|
|
# We don't use lineStartDetector because we don't want to
|
|
# insert whitespace at the beginning of our _first_ line.
|
|
defn = stripTrailingWhitespace(
|
|
defn.replace("\n", "\n" + (" " * len(self.definePre))))
|
|
return self.definePre + defn + self.definePost
|
|
|
|
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 child
|
|
return CGNamespace(namespaces[0], CGNamespace.build(namespaces[1:],
|
|
child),
|
|
declareOnly=declareOnly)
|
|
|
|
class CGIncludeGuard(CGWrapper):
|
|
"""
|
|
Generates include guards for a header.
|
|
"""
|
|
def __init__(self, prefix, child):
|
|
"""|prefix| is the filename without the extension."""
|
|
define = 'mozilla_dom_%s_h__' % prefix
|
|
CGWrapper.__init__(self, child,
|
|
declarePre='#ifndef %s\n#define %s\n\n' % (define, define),
|
|
declarePost='\n#endif // %s\n' % define)
|
|
|
|
class CGHeaders(CGWrapper):
|
|
"""
|
|
Generates the appropriate include statements.
|
|
"""
|
|
def __init__(self, descriptors, declareIncludes, defineIncludes, child):
|
|
"""
|
|
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.
|
|
"""
|
|
|
|
# Determine the filenames for which we need headers.
|
|
interfaceDeps = [d.interface for d in descriptors]
|
|
ancestors = []
|
|
for iface in interfaceDeps:
|
|
while iface.parent:
|
|
ancestors.append(iface.parent)
|
|
iface = iface.parent
|
|
interfaceDeps.extend(ancestors)
|
|
bindingIncludes = set(self.getInterfaceFilename(d) for d in interfaceDeps)
|
|
|
|
# Grab all the implementation declaration files we need.
|
|
implementationIncludes = set(d.headerFile for d in descriptors)
|
|
|
|
# Now find all the things we'll need as arguments because we
|
|
# need to wrap or unwrap them.
|
|
bindingHeaders = set()
|
|
for d in descriptors:
|
|
members = [m for m in d.interface.members]
|
|
signatures = [s for m in members if m.isMethod() for s in m.signatures()]
|
|
types = []
|
|
for s in signatures:
|
|
assert len(s) == 2
|
|
(returnType, arguments) = s
|
|
types.append(returnType)
|
|
types.extend([a.type for a in arguments])
|
|
|
|
attrs = [a for a in members if a.isAttr()]
|
|
types.extend([a.type for a in attrs])
|
|
|
|
for t in types:
|
|
if t.unroll().isInterface():
|
|
if t.unroll().isArrayBuffer():
|
|
bindingHeaders.add("jsfriendapi.h")
|
|
else:
|
|
typeDesc = d.getDescriptor(t.unroll().inner.identifier.name)
|
|
if typeDesc is not None:
|
|
implementationIncludes.add(typeDesc.headerFile)
|
|
bindingHeaders.add(self.getInterfaceFilename(typeDesc.interface))
|
|
|
|
# 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(declareIncludes),
|
|
definePre=_includeString(sorted(set(defineIncludes) |
|
|
bindingIncludes |
|
|
bindingHeaders |
|
|
implementationIncludes)))
|
|
@staticmethod
|
|
def getInterfaceFilename(interface):
|
|
basename = os.path.basename(interface.filename())
|
|
return 'mozilla/dom/' + \
|
|
basename.replace('.webidl', 'Binding.h')
|
|
|
|
class Argument():
|
|
"""
|
|
A class for outputting the type and name of an argument
|
|
"""
|
|
def __init__(self, argType, name):
|
|
self.argType = argType
|
|
self.name = name
|
|
def __str__(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.
|
|
|
|
static should be True to generate a static method, which only has
|
|
a definition.
|
|
"""
|
|
def __init__(self, descriptor, name, returnType, args, inline=False, static=False):
|
|
CGThing.__init__(self)
|
|
self.descriptor = descriptor
|
|
self.name = name
|
|
self.returnType = returnType
|
|
self.args = args
|
|
self.inline = inline
|
|
self.static = static
|
|
def _argstring(self):
|
|
return ', '.join([str(a) for a in self.args])
|
|
def _decorators(self):
|
|
decorators = []
|
|
if self.inline:
|
|
decorators.append('inline')
|
|
if self.static:
|
|
decorators.append('static')
|
|
decorators.append(self.returnType)
|
|
return ' '.join(decorators)
|
|
def declare(self):
|
|
if self.inline:
|
|
return self._define()
|
|
return "\n %s %s(%s);\n" % (self._decorators(), self.name, self._argstring())
|
|
def _define(self):
|
|
return self.definition_prologue() + "\n" + self.definition_body() + self.definition_epilogue()
|
|
def define(self):
|
|
return "" if self.inline else self._define()
|
|
def definition_prologue(self):
|
|
maybeNewline = " " if self.inline else "\n"
|
|
return "\n%s%s%s(%s)\n{" % (self._decorators(), maybeNewline,
|
|
self.name, self._argstring())
|
|
def definition_epilogue(self):
|
|
return "\n}\n"
|
|
def definition_body(self):
|
|
assert(False) # Override me!
|
|
|
|
class CGAbstractStaticMethod(CGAbstractMethod):
|
|
"""
|
|
Abstract base class for codegen of implementation-only (no
|
|
declaration) static methods.
|
|
"""
|
|
def __init__(self, descriptor, name, returnType, args):
|
|
CGAbstractMethod.__init__(self, descriptor, name, returnType, args,
|
|
inline=False, static=True)
|
|
def declare(self):
|
|
# We only have implementation
|
|
return ""
|
|
|
|
class CGAbstractClassHook(CGAbstractStaticMethod):
|
|
"""
|
|
Meant for implementing JSClass hooks, like Finalize or Trace. Does very raw
|
|
'this' unwrapping as it assumes that the unwrapped type is always known.
|
|
"""
|
|
def __init__(self, descriptor, name, returnType, args):
|
|
CGAbstractStaticMethod.__init__(self, descriptor, name, returnType,
|
|
args)
|
|
|
|
def definition_body_prologue(self):
|
|
return """
|
|
MOZ_ASSERT(js::GetObjectJSClass(obj) == Class.ToJSClass());
|
|
%s* self = UnwrapDOMObject<%s>(obj, Class.ToJSClass());
|
|
""" % (self.descriptor.nativeType, self.descriptor.nativeType)
|
|
|
|
def definition_body(self):
|
|
return self.definition_body_prologue() + self.generate_code()
|
|
|
|
def generate_code(self):
|
|
# Override me
|
|
assert(False)
|
|
|
|
class CGAddPropertyHook(CGAbstractClassHook):
|
|
"""
|
|
A hook for addProperty, used to preserve our wrapper from GC.
|
|
"""
|
|
def __init__(self, descriptor):
|
|
args = [Argument('JSContext*', 'cx'), Argument('JSObject*', 'obj'),
|
|
Argument('jsid', 'id'), Argument('jsval*', 'vp')]
|
|
CGAbstractClassHook.__init__(self, descriptor, ADDPROPERTY_HOOK_NAME,
|
|
'JSBool', args)
|
|
|
|
def generate_code(self):
|
|
return """
|
|
JSCompartment* compartment = js::GetObjectCompartment(obj);
|
|
xpc::CompartmentPrivate* priv =
|
|
static_cast<xpc::CompartmentPrivate*>(JS_GetCompartmentPrivate(compartment));
|
|
if (!priv->RegisterDOMExpandoObject(obj)) {
|
|
return false;
|
|
}
|
|
self->SetPreservingWrapper(true);
|
|
return true;"""
|
|
|
|
class CGClassFinalizeHook(CGAbstractClassHook):
|
|
"""
|
|
A hook for finalize, used to release our native object.
|
|
"""
|
|
def __init__(self, descriptor):
|
|
args = [Argument('JSFreeOp*', 'fop'), Argument('JSObject*', 'obj')]
|
|
CGAbstractClassHook.__init__(self, descriptor, FINALIZE_HOOK_NAME,
|
|
'void', args)
|
|
|
|
def generate_code(self):
|
|
if self.descriptor.customFinalize:
|
|
return """ if (self) {
|
|
self->%s(%s);
|
|
}""" % (self.name, self.args[0].name)
|
|
if self.descriptor.workers:
|
|
release = "self->Release();"
|
|
else:
|
|
assert self.descriptor.nativeIsISupports
|
|
release = """
|
|
XPCJSRuntime *rt = nsXPConnect::GetRuntimeInstance();
|
|
if (rt) {
|
|
rt->DeferredRelease(NativeToSupports(self));
|
|
} else {
|
|
NS_RELEASE(self);
|
|
}"""
|
|
return """
|
|
self->ClearWrapper();
|
|
%s""" % (release)
|
|
|
|
class CGClassTraceHook(CGAbstractClassHook):
|
|
"""
|
|
A hook to trace through our native object; used for GC and CC
|
|
"""
|
|
def __init__(self, descriptor):
|
|
args = [Argument('JSTracer*', 'trc'), Argument('JSObject*', 'obj')]
|
|
CGAbstractClassHook.__init__(self, descriptor, TRACE_HOOK_NAME, 'void',
|
|
args)
|
|
|
|
def generate_code(self):
|
|
return """ if (self) {
|
|
self->%s(%s);
|
|
}""" % (self.name, self.args[0].name)
|
|
|
|
class CGClassConstructHook(CGAbstractStaticMethod):
|
|
"""
|
|
JS-visible constructor for our objects
|
|
"""
|
|
def __init__(self, descriptor):
|
|
args = [Argument('JSContext*', 'cx'), Argument('unsigned', 'argc'), Argument('JS::Value*', 'vp')]
|
|
CGAbstractStaticMethod.__init__(self, descriptor, CONSTRUCT_HOOK_NAME,
|
|
'JSBool', args)
|
|
self._ctor = self.descriptor.interface.ctor()
|
|
|
|
def define(self):
|
|
if not self._ctor:
|
|
return ""
|
|
return CGAbstractStaticMethod.define(self)
|
|
|
|
def definition_body(self):
|
|
return self.generate_code()
|
|
|
|
def generate_code(self):
|
|
preamble = """
|
|
JSObject* obj = JS_GetGlobalForObject(cx, JSVAL_TO_OBJECT(JS_CALLEE(cx, vp)));
|
|
"""
|
|
preArgs = ""
|
|
if self.descriptor.workers:
|
|
preArgs = "cx, obj, "
|
|
else:
|
|
preamble += """
|
|
nsISupports* global;
|
|
xpc_qsSelfRef globalRef;
|
|
{
|
|
nsresult rv;
|
|
JS::Value val = OBJECT_TO_JSVAL(obj);
|
|
rv = xpc_qsUnwrapArg<nsISupports>(cx, val, &global, &globalRef.ptr, &val);
|
|
if (NS_FAILED(rv)) {
|
|
return Throw<true>(cx, NS_ERROR_XPC_BAD_CONVERT_JS);
|
|
}
|
|
}
|
|
"""
|
|
preArgs = "global, "
|
|
|
|
name = "_" + self._ctor.identifier.name
|
|
nativeName = "_" + MakeNativeName(self._ctor.identifier.name)
|
|
nativeName = self.descriptor.binaryNames.get(name, nativeName)
|
|
callGenerator = CGMethodCall(preArgs, nativeName, True,
|
|
self.descriptor, self._ctor, {})
|
|
return preamble + callGenerator.define();
|
|
|
|
class CGClassHasInstanceHook(CGAbstractStaticMethod):
|
|
def __init__(self, descriptor):
|
|
args = [Argument('JSContext*', 'cx'), Argument('JSObject*', 'obj'),
|
|
Argument('const jsval*', 'v'), Argument('JSBool*', 'bp')]
|
|
CGAbstractStaticMethod.__init__(self, descriptor, HASINSTANCE_HOOK_NAME,
|
|
'JSBool', args)
|
|
|
|
def define(self):
|
|
if not self.descriptor.hasInstanceInterface:
|
|
return ""
|
|
return CGAbstractStaticMethod.define(self)
|
|
|
|
def definition_body(self):
|
|
return self.generate_code()
|
|
|
|
def generate_code(self):
|
|
return """ if (!v->isObject()) {
|
|
*bp = false;
|
|
return true;
|
|
}
|
|
|
|
jsval protov;
|
|
if (!JS_GetProperty(cx, obj, "prototype", &protov))
|
|
return false;
|
|
if (!protov.isObject()) {
|
|
JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_BAD_PROTOTYPE,
|
|
"%s");
|
|
return false;
|
|
}
|
|
obj = &protov.toObject();
|
|
|
|
JSObject* instance = &v->toObject();
|
|
JSObject* proto = JS_GetPrototype(instance);
|
|
while (proto) {
|
|
if (proto == obj) {
|
|
*bp = true;
|
|
return true;
|
|
}
|
|
proto = JS_GetPrototype(proto);
|
|
}
|
|
|
|
nsISupports* native =
|
|
nsContentUtils::XPConnect()->GetNativeOfWrapper(cx, instance);
|
|
nsCOMPtr<%s> qiResult = do_QueryInterface(native);
|
|
*bp = !!qiResult;
|
|
return true;
|
|
""" % (self.descriptor.name, self.descriptor.hasInstanceInterface)
|
|
|
|
def isChromeOnly(m):
|
|
return m.getExtendedAttribute("ChromeOnly")
|
|
|
|
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 exposed to chrome and self.regular to the list of things exposed to
|
|
web pages. self.chrome must be a superset of self.regular but also include
|
|
all the ChromeOnly stuff.
|
|
"""
|
|
def __init__(self, descriptor, name):
|
|
self.descriptor = descriptor
|
|
self.name = name
|
|
def hasChromeOnly(self):
|
|
return len(self.chrome) > len(self.regular)
|
|
def hasNonChromeOnly(self):
|
|
return len(self.regular) > 0
|
|
def variableName(self, chrome):
|
|
if chrome and self.hasChromeOnly():
|
|
return "sChrome" + self.name
|
|
if self.hasNonChromeOnly():
|
|
return "s" + self.name
|
|
return "NULL"
|
|
def __str__(self):
|
|
str = self.generateArray(self.regular, self.variableName(False))
|
|
if self.hasChromeOnly():
|
|
str += self.generateArray(self.chrome, self.variableName(True))
|
|
return str
|
|
|
|
# The length of a method is the maximum of the lengths of the
|
|
# argument lists of all its overloads.
|
|
def methodLength(method):
|
|
signatures = method.signatures()
|
|
return max([len(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)
|
|
|
|
methods = [m for m in descriptor.interface.members if
|
|
m.isMethod() and m.isStatic() == static]
|
|
self.chrome = [{"name": m.identifier.name,
|
|
"length": methodLength(m),
|
|
"flags": "JSPROP_ENUMERATE"} for m in methods]
|
|
self.regular = [{"name": m.identifier.name,
|
|
"length": methodLength(m),
|
|
"flags": "JSPROP_ENUMERATE"}
|
|
for m in methods if not isChromeOnly(m)]
|
|
if not descriptor.interface.parent and not static and not descriptor.workers:
|
|
self.chrome.append({"name": 'QueryInterface',
|
|
"length": 1,
|
|
"flags": "0"})
|
|
self.regular.append({"name": 'QueryInterface',
|
|
"length": 1,
|
|
"flags": "0"})
|
|
|
|
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()
|
|
|
|
@staticmethod
|
|
def generateArray(array, name):
|
|
if len(array) == 0:
|
|
return ""
|
|
|
|
funcdecls = [' JS_FN("%s", %s, %s, %s)' %
|
|
(m["name"], m["name"], m["length"], m["flags"])
|
|
for m in array]
|
|
# And add our JS_FS_END
|
|
funcdecls.append(' JS_FS_END')
|
|
|
|
return ("static JSFunctionSpec %s[] = {\n" +
|
|
',\n'.join(funcdecls) + "\n" +
|
|
"};\n\n" +
|
|
"static jsid %s_ids[%i] = { JSID_VOID };\n\n") % (name, name, len(array))
|
|
|
|
class AttrDefiner(PropertyDefiner):
|
|
def __init__(self, descriptor, name):
|
|
PropertyDefiner.__init__(self, descriptor, name)
|
|
self.name = name
|
|
self.chrome = [m for m in descriptor.interface.members if m.isAttr()]
|
|
self.regular = [m for m in self.chrome if not isChromeOnly(m)]
|
|
|
|
@staticmethod
|
|
def generateArray(array, name):
|
|
if len(array) == 0:
|
|
return ""
|
|
|
|
def flags(attr):
|
|
flags = "JSPROP_SHARED | JSPROP_ENUMERATE"
|
|
if generateNativeAccessors:
|
|
flags = "JSPROP_NATIVE_ACCESSORS | " + flags
|
|
elif attr.readonly:
|
|
return "JSPROP_READONLY | " + flags
|
|
return flags
|
|
|
|
def getter(attr):
|
|
return "get_" + attr.identifier.name
|
|
|
|
def setter(attr):
|
|
if attr.readonly:
|
|
return "NULL"
|
|
return "set_" + attr.identifier.name
|
|
|
|
attrdecls = [' { "%s", 0, %s, (JSPropertyOp)%s, (JSStrictPropertyOp)%s }' %
|
|
(attr.identifier.name, flags(attr), getter(attr),
|
|
setter(attr)) for attr in array]
|
|
attrdecls.append(' { 0, 0, 0, 0, 0 }')
|
|
|
|
return ("static JSPropertySpec %s[] = {\n" +
|
|
',\n'.join(attrdecls) + "\n" +
|
|
"};\n\n" +
|
|
"static jsid %s_ids[%i] = { JSID_VOID };\n\n") % (name, name, len(array))
|
|
|
|
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
|
|
self.chrome = [m for m in descriptor.interface.members if m.isConst()]
|
|
self.regular = [m for m in self.chrome if not isChromeOnly(m)]
|
|
|
|
@staticmethod
|
|
def generateArray(array, name):
|
|
if len(array) == 0:
|
|
return ""
|
|
|
|
constdecls = [' { "%s", %s }' %
|
|
(const.identifier.name,
|
|
convertConstIDLValueToJSVal(const.value))
|
|
for const in array]
|
|
constdecls.append(' { 0, JSVAL_VOID }')
|
|
|
|
return ("static ConstantSpec %s[] = {\n" +
|
|
',\n'.join(constdecls) + "\n" +
|
|
"};\n\n" +
|
|
"static jsid %s_ids[%i] = { JSID_VOID };\n\n") % (name, name, len(array))
|
|
|
|
class PropertyArrays():
|
|
def __init__(self, descriptor):
|
|
self.staticMethods = MethodDefiner(descriptor, "StaticMethods", True)
|
|
self.methods = MethodDefiner(descriptor, "Methods", False)
|
|
self.attrs = AttrDefiner(descriptor, "Attributes")
|
|
self.consts = ConstDefiner(descriptor, "Constants")
|
|
|
|
@staticmethod
|
|
def arrayNames():
|
|
return [ "staticMethods", "methods", "attrs", "consts" ]
|
|
|
|
def hasChromeOnly(self):
|
|
return reduce(lambda b, a: b or getattr(self, a).hasChromeOnly(),
|
|
self.arrayNames(), False)
|
|
def variableNames(self, chrome):
|
|
names = {}
|
|
for array in self.arrayNames():
|
|
names[array] = getattr(self, array).variableName(chrome)
|
|
return names
|
|
def __str__(self):
|
|
define = ""
|
|
for array in self.arrayNames():
|
|
define += str(getattr(self, array))
|
|
return define
|
|
|
|
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('JSObject*', 'aGlobal'),
|
|
Argument('JSObject*', 'aReceiver')]
|
|
CGAbstractMethod.__init__(self, descriptor, 'CreateInterfaceObjects', 'JSObject*', args)
|
|
self.properties = properties
|
|
def definition_body(self):
|
|
protoChain = self.descriptor.prototypeChain
|
|
if len(protoChain) == 1:
|
|
getParentProto = "JS_GetObjectPrototype(aCx, aGlobal)"
|
|
else:
|
|
parentProtoName = self.descriptor.prototypeChain[-2]
|
|
getParentProto = ("%s::GetProtoObject(aCx, aGlobal, aReceiver)" %
|
|
toBindingNamespace(parentProtoName))
|
|
|
|
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 = []
|
|
for var in self.properties.arrayNames():
|
|
props = getattr(self.properties, var)
|
|
if props.hasNonChromeOnly():
|
|
idsToInit.append(props.variableName(False))
|
|
if props.hasChromeOnly() and not self.descriptor.workers:
|
|
idsToInit.append(props.variableName(True))
|
|
if len(idsToInit) > 0:
|
|
initIds = CGList(
|
|
[CGGeneric("!InitIds(aCx, %s, %s_ids)" % (varname, varname)) for
|
|
varname in idsToInit], ' ||\n')
|
|
if len(idsToInit) > 1:
|
|
initIds = CGWrapper(initIds, pre="(", post=")", reindent=True)
|
|
initIds = CGList(
|
|
[CGGeneric("%s_ids[0] == JSID_VOID &&" % idsToInit[0]), initIds],
|
|
"\n")
|
|
initIds = CGWrapper(initIds, pre="if (", post=") {", reindent=True)
|
|
initIds = CGList(
|
|
[initIds,
|
|
CGGeneric((" %s_ids[0] = JSID_VOID;\n"
|
|
" return NULL;") % idsToInit[0]),
|
|
CGGeneric("}")],
|
|
"\n")
|
|
else:
|
|
initIds = None
|
|
|
|
getParentProto = ("JSObject* parentProto = %s;\n"
|
|
"if (!parentProto) {\n"
|
|
" return NULL;\n"
|
|
"}") % getParentProto
|
|
|
|
needInterfaceObjectClass = (needInterfaceObject and
|
|
self.descriptor.hasInstanceInterface)
|
|
needConstructor = (needInterfaceObject and
|
|
not self.descriptor.hasInstanceInterface)
|
|
if self.descriptor.interface.ctor():
|
|
constructHook = CONSTRUCT_HOOK_NAME
|
|
constructArgs = methodLength(self.descriptor.interface.ctor())
|
|
else:
|
|
constructHook = "ThrowingConstructorWorkers" if self.descriptor.workers else "ThrowingConstructor"
|
|
constructArgs = 0
|
|
|
|
call = CGGeneric(("return dom::CreateInterfaceObjects(aCx, aGlobal, aReceiver, parentProto,\n"
|
|
" %s, %s, %s, %d,\n"
|
|
" %%(methods)s, %%(attrs)s, %%(consts)s, %%(staticMethods)s,\n"
|
|
" %s);") % (
|
|
"&PrototypeClass" if needInterfacePrototypeObject else "NULL",
|
|
"&InterfaceObjectClass" if needInterfaceObjectClass else "NULL",
|
|
constructHook if needConstructor else "NULL",
|
|
constructArgs,
|
|
'"' + self.descriptor.interface.identifier.name + '"' if needInterfaceObject else "NULL"))
|
|
|
|
if self.properties.hasChromeOnly():
|
|
if self.descriptor.workers:
|
|
accessCheck = "mozilla::dom::workers::GetWorkerPrivateFromContext(aCx)->IsChromeWorker()"
|
|
else:
|
|
accessCheck = "xpc::AccessCheck::isChrome(js::GetObjectCompartment(aGlobal))"
|
|
accessCheck = "if (" + accessCheck + ") {\n"
|
|
chrome = CGWrapper(CGGeneric((CGIndenter(call).define() % self.properties.variableNames(True))),
|
|
pre=accessCheck, post="\n}")
|
|
else:
|
|
chrome = None
|
|
|
|
functionBody = CGList(
|
|
[CGGeneric(getParentProto), initIds, chrome,
|
|
CGGeneric(call.define() % self.properties.variableNames(False))],
|
|
"\n\n")
|
|
return CGIndenter(functionBody).define()
|
|
|
|
class CGGetPerInterfaceObject(CGAbstractMethod):
|
|
"""
|
|
A method for getting a per-interface object (a prototype object or interface
|
|
constructor object).
|
|
"""
|
|
def __init__(self, descriptor, name, idPrefix=""):
|
|
args = [Argument('JSContext*', 'aCx'), Argument('JSObject*', 'aGlobal'),
|
|
Argument('JSObject*', 'aReceiver')]
|
|
CGAbstractMethod.__init__(self, descriptor, name,
|
|
'JSObject*', args, inline=True)
|
|
self.id = idPrefix + "id::" + self.descriptor.name
|
|
def definition_body(self):
|
|
return """
|
|
|
|
/* aGlobal and aReceiver are usually the same, but they can be different
|
|
too. For example a sandbox often has an xray wrapper for a window as the
|
|
prototype of the sandbox's global. In that case aReceiver is the xray
|
|
wrapper and aGlobal is the sandbox's global.
|
|
*/
|
|
|
|
/* Make sure our global is sane. Hopefully we can remove this sometime */
|
|
if (!(js::GetObjectClass(aGlobal)->flags & JSCLASS_DOM_GLOBAL)) {
|
|
return NULL;
|
|
}
|
|
/* Check to see whether the interface objects are already installed */
|
|
JSObject** protoOrIfaceArray = GetProtoOrIfaceArray(aGlobal);
|
|
JSObject* cachedObject = protoOrIfaceArray[%s];
|
|
if (!cachedObject) {
|
|
protoOrIfaceArray[%s] = cachedObject = CreateInterfaceObjects(aCx, aGlobal, aReceiver);
|
|
}
|
|
|
|
/* cachedObject might _still_ be null, but that's OK */
|
|
return cachedObject;""" % (self.id, self.id)
|
|
|
|
class CGGetProtoObjectMethod(CGGetPerInterfaceObject):
|
|
"""
|
|
A method for getting the interface prototype object.
|
|
"""
|
|
def __init__(self, descriptor):
|
|
CGGetPerInterfaceObject.__init__(self, descriptor, "GetProtoObject",
|
|
"prototypes::")
|
|
def definition_body(self):
|
|
return """
|
|
/* Get the interface prototype object for this class. This will create the
|
|
object as needed. */""" + 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::")
|
|
def definition_body(self):
|
|
return """
|
|
/* Get the interface object for this class. This will create the object as
|
|
needed. */""" + CGGetPerInterfaceObject.definition_body(self)
|
|
|
|
def CheckPref(descriptor, globalName, varName, retval, wrapperCache = None):
|
|
"""
|
|
Check whether bindings should be enabled for this descriptor. If not, set
|
|
varName to false and return retval.
|
|
"""
|
|
if not descriptor.prefable:
|
|
return ""
|
|
if wrapperCache:
|
|
wrapperCache = " %s->ClearIsDOMBinding();\n" % (wrapperCache)
|
|
else:
|
|
wrapperCache = ""
|
|
return """
|
|
{
|
|
XPCWrappedNativeScope* scope =
|
|
XPCWrappedNativeScope::FindInJSObjectScope(aCx, %s);
|
|
if (!scope) {
|
|
return %s;
|
|
}
|
|
|
|
if (!scope->ExperimentalBindingsEnabled()) {
|
|
%s %s = false;
|
|
return %s;
|
|
}
|
|
}
|
|
""" % (globalName, retval, wrapperCache, varName, retval)
|
|
|
|
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('JSObject*', 'aReceiver'),
|
|
Argument('bool*', 'aEnabled')]
|
|
CGAbstractMethod.__init__(self, descriptor, 'DefineDOMInterface', 'bool', args)
|
|
|
|
def declare(self):
|
|
if self.descriptor.workers:
|
|
return ''
|
|
return CGAbstractMethod.declare(self)
|
|
|
|
def define(self):
|
|
if self.descriptor.workers:
|
|
return ''
|
|
return CGAbstractMethod.define(self)
|
|
|
|
def definition_body(self):
|
|
if self.descriptor.interface.hasInterfacePrototypeObject():
|
|
# We depend on GetProtoObject defining an interface constructor
|
|
# object as needed.
|
|
getter = "GetProtoObject"
|
|
else:
|
|
getter = "GetConstructorObject"
|
|
|
|
return (" JSObject* global = JS_GetGlobalForObject(aCx, aReceiver);\n" +
|
|
CheckPref(self.descriptor, "global", "*aEnabled", "false") +
|
|
"""
|
|
*aEnabled = true;
|
|
return !!%s(aCx, global, aReceiver);""" % (getter))
|
|
|
|
class CGNativeToSupportsMethod(CGAbstractStaticMethod):
|
|
"""
|
|
A method to cast our native to an nsISupports. We do it by casting up the
|
|
interface chain in hopes of getting to something that singly-inherits from
|
|
nsISupports.
|
|
"""
|
|
def __init__(self, descriptor):
|
|
args = [Argument(descriptor.nativeType + '*', 'aNative')]
|
|
CGAbstractStaticMethod.__init__(self, descriptor, 'NativeToSupports', 'nsISupports*', args)
|
|
|
|
def definition_body(self):
|
|
cur = CGGeneric("aNative")
|
|
for proto in reversed(self.descriptor.prototypeChain[:-1]):
|
|
d = self.descriptor.getDescriptor(proto)
|
|
cast = "static_cast<%s*>(\n" % d.nativeType;
|
|
cur = CGWrapper(CGIndenter(cur), pre=cast, post=")")
|
|
return CGIndenter(CGWrapper(cur, pre="return ", post=";")).define();
|
|
|
|
class CGWrapMethod(CGAbstractMethod):
|
|
def __init__(self, descriptor):
|
|
# XXX can we wrap if we don't have an interface prototype object?
|
|
assert descriptor.interface.hasInterfacePrototypeObject()
|
|
args = [Argument('JSContext*', 'aCx'), Argument('JSObject*', 'aScope'),
|
|
Argument(descriptor.nativeType + '*', 'aObject'),
|
|
Argument('bool*', 'aTriedToWrap')]
|
|
CGAbstractMethod.__init__(self, descriptor, 'Wrap', 'JSObject*', args)
|
|
|
|
def definition_body(self):
|
|
if self.descriptor.workers:
|
|
return """
|
|
*aTriedToWrap = true;
|
|
return aObject->GetJSObject();"""
|
|
|
|
return """
|
|
*aTriedToWrap = true;
|
|
|
|
JSObject* parent = WrapNativeParent(aCx, aScope, aObject->GetParentObject());
|
|
if (!parent) {
|
|
return NULL;
|
|
}
|
|
|
|
JSAutoEnterCompartment ac;
|
|
if (js::GetGlobalForObjectCrossCompartment(parent) != aScope) {
|
|
if (!ac.enter(aCx, parent)) {
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
JSObject* global = JS_GetGlobalForObject(aCx, parent);
|
|
%s
|
|
JSObject* proto = GetProtoObject(aCx, global, global);
|
|
if (!proto) {
|
|
return NULL;
|
|
}
|
|
|
|
JSObject* obj = JS_NewObject(aCx, &Class.mBase, proto, parent);
|
|
if (!obj) {
|
|
return NULL;
|
|
}
|
|
|
|
js::SetReservedSlot(obj, DOM_OBJECT_SLOT, PRIVATE_TO_JSVAL(aObject));
|
|
NS_ADDREF(aObject);
|
|
|
|
aObject->SetWrapper(obj);
|
|
|
|
return obj;""" % (CheckPref(self.descriptor, "global", "*aTriedToWrap", "NULL", "aObject"))
|
|
|
|
builtinNames = {
|
|
IDLType.Tags.bool: 'bool',
|
|
IDLType.Tags.int8: 'int8_t',
|
|
IDLType.Tags.int16: 'int16_t',
|
|
IDLType.Tags.int32: 'int32_t',
|
|
IDLType.Tags.int64: 'int64_t',
|
|
IDLType.Tags.uint8: 'uint8_t',
|
|
IDLType.Tags.uint16: 'uint16_t',
|
|
IDLType.Tags.uint32: 'uint32_t',
|
|
IDLType.Tags.uint64: 'uint64_t',
|
|
IDLType.Tags.float: 'float',
|
|
IDLType.Tags.double: 'double'
|
|
}
|
|
|
|
class CastableObjectUnwrapper():
|
|
"""
|
|
A class for unwrapping an object named by the "source" argument
|
|
based on the passed-in descriptor and storing it in a variable
|
|
called by the name in the "target" argument.
|
|
|
|
codeOnFailure is the code to run if unwrapping fails.
|
|
"""
|
|
def __init__(self, descriptor, source, target, codeOnFailure):
|
|
assert descriptor.castable
|
|
self.substitution = { "type" : descriptor.nativeType,
|
|
"protoID" : "prototypes::id::" + descriptor.name,
|
|
"source" : source,
|
|
"target" : target,
|
|
"codeOnFailure" : codeOnFailure }
|
|
|
|
def __str__(self):
|
|
return string.Template(
|
|
""" {
|
|
nsresult rv = UnwrapObject<${protoID}>(cx, ${source}, &${target});
|
|
if (NS_FAILED(rv)) {
|
|
${codeOnFailure}
|
|
}
|
|
}""").substitute(self.substitution)
|
|
|
|
class FailureFatalCastableObjectUnwrapper(CastableObjectUnwrapper):
|
|
"""
|
|
As CastableObjectUnwrapper, but defaulting to throwing if unwrapping fails
|
|
"""
|
|
def __init__(self, descriptor, source, target):
|
|
CastableObjectUnwrapper.__init__(self, descriptor, source, target,
|
|
"return Throw<%s>(cx, rv);" %
|
|
toStringBool(not descriptor.workers))
|
|
|
|
class CallbackObjectUnwrapper:
|
|
"""
|
|
A class for unwrapping objects implemented in JS.
|
|
|
|
|source| is the JSObject we want to use in native code.
|
|
|target| is an nsCOMPtr of the appropriate type in which we store the result.
|
|
"""
|
|
def __init__(self, descriptor, source, target, codeOnFailure=None):
|
|
if codeOnFailure is None:
|
|
codeOnFailure = ("return Throw<%s>(cx, rv);" %
|
|
toStringBool(not descriptor.workers))
|
|
self.descriptor = descriptor
|
|
self.substitution = { "nativeType" : descriptor.nativeType,
|
|
"source" : source,
|
|
"target" : target,
|
|
"codeOnFailure" : codeOnFailure }
|
|
|
|
def __str__(self):
|
|
if self.descriptor.workers:
|
|
return string.Template("""
|
|
${target} = ${source};""").substitute(self.substitution)
|
|
|
|
return string.Template("""
|
|
nsresult rv;
|
|
XPCCallContext ccx(JS_CALLER, cx);
|
|
if (!ccx.IsValid()) {
|
|
rv = NS_ERROR_XPC_BAD_CONVERT_JS;
|
|
${codeOnFailure}
|
|
}
|
|
|
|
const nsIID& iid = NS_GET_IID(${nativeType});
|
|
nsRefPtr<nsXPCWrappedJS> wrappedJS;
|
|
rv = nsXPCWrappedJS::GetNewOrUsed(ccx, ${source}, iid,
|
|
NULL, getter_AddRefs(wrappedJS));
|
|
if (NS_FAILED(rv) || !wrappedJS) {
|
|
${codeOnFailure}
|
|
}
|
|
|
|
${target} = do_QueryObject(wrappedJS.get());
|
|
if (!${target}) {
|
|
${codeOnFailure}
|
|
}""").substitute(self.substitution)
|
|
|
|
def getArgumentConversionTemplate(type, descriptor):
|
|
if type.isSequence() or type.isArray():
|
|
raise TypeError("Can't handle sequence or array arguments yet")
|
|
|
|
if descriptor is not None:
|
|
assert(type.isInterface())
|
|
# This is an interface that we implement as a concrete class
|
|
# or an XPCOM interface.
|
|
argIsPointer = type.nullable() or type.unroll().inner.isExternal()
|
|
if argIsPointer:
|
|
nameSuffix = ""
|
|
else:
|
|
nameSuffix = "_ptr"
|
|
|
|
# If we're going to QI, we want an nsCOMPtr. But note that XPConnect
|
|
# unwrapping may or may not QI, and we don't know whether it will. So
|
|
# we use a raw pointer for the isExternal() case, and if a ref is needed
|
|
# it'll be handled by the xpc_qsSelfRef we put on the stack later.
|
|
if descriptor.castable or type.unroll().inner.isExternal() or descriptor.workers:
|
|
declType = " ${typeName}*"
|
|
else:
|
|
declType = " nsCOMPtr<${typeName}>"
|
|
template = declType + " ${name}%s;\n" % nameSuffix
|
|
|
|
# We have to be very careful here to put anything that might need to
|
|
# hold references across the C++ call in |template| and not
|
|
# |templateBody|, since things in |templateBody| will go out of scope
|
|
# before the call happens.
|
|
templateBody = " if (${argVal}.isObject()) {"
|
|
if descriptor.castable:
|
|
templateBody += str(FailureFatalCastableObjectUnwrapper(
|
|
descriptor,
|
|
"&${argVal}.toObject()",
|
|
"${name}"+nameSuffix)).replace("\n", "\n ") + "\n"
|
|
elif descriptor.interface.isCallback():
|
|
templateBody += str(CallbackObjectUnwrapper(
|
|
descriptor,
|
|
"&${argVal}.toObject()",
|
|
"${name}"+nameSuffix)) + "\n"
|
|
elif descriptor.workers:
|
|
templateBody += """
|
|
${name}%s = &${argVal}.toObject();
|
|
MOZ_ASSERT(${name}%s);
|
|
""" % (nameSuffix, nameSuffix)
|
|
else:
|
|
template += " xpc_qsSelfRef tmpRef_${name};\n"
|
|
template += " jsval tmpVal_${name} = ${argVal};\n"
|
|
templateBody += """
|
|
${typeName}* tmp;
|
|
if (NS_FAILED(xpc_qsUnwrapArg<${typeName}>(cx, ${argVal}, &tmp, &tmpRef_${name}.ptr,
|
|
&tmpVal_${name}))) {
|
|
return Throw<%s>(cx, NS_ERROR_XPC_BAD_CONVERT_JS);
|
|
}
|
|
MOZ_ASSERT(tmp);
|
|
${name}%s = tmp;
|
|
""" % (toStringBool(not descriptor.workers), nameSuffix)
|
|
|
|
if type.nullable():
|
|
templateBody += (
|
|
" } else if (${argVal}.isNullOrUndefined()) {\n"
|
|
" ${name}%s = NULL;\n" % nameSuffix)
|
|
|
|
templateBody += (
|
|
" } else {\n"
|
|
" return Throw<%s>(cx, NS_ERROR_XPC_BAD_CONVERT_JS);\n"
|
|
" }\n" % toStringBool(not descriptor.workers))
|
|
|
|
template += templateBody
|
|
|
|
if not argIsPointer:
|
|
template += " ${typeName} &${name} = *${name}_ptr;\n"
|
|
|
|
return template
|
|
|
|
if type.isArrayBuffer():
|
|
template = (
|
|
" JSObject* ${name};\n"
|
|
" if (${argVal}.isObject() && JS_IsArrayBufferObject(&${argVal}.toObject(), cx)) {\n"
|
|
" ${name} = &${argVal}.toObject();\n"
|
|
" }")
|
|
if type.nullable():
|
|
template += (
|
|
" else if (${argVal}.isNullOrUndefined()) {\n"
|
|
" ${name} = NULL;\n"
|
|
" }")
|
|
|
|
template += (
|
|
# XXXbz We don't know whether we're on workers, so play it safe
|
|
" else {\n"
|
|
" return Throw<false>(cx, NS_ERROR_XPC_BAD_CONVERT_JS);\n"
|
|
" }")
|
|
|
|
return template
|
|
|
|
if type.isInterface():
|
|
raise TypeError("Interface type with no descriptor: " + type)
|
|
|
|
if type.isString():
|
|
# XXXbz Need to figure out string behavior based on extended args? Also, how to
|
|
# detect them?
|
|
|
|
# For nullable strings that are not otherwise annotated, null
|
|
# and undefined become null strings.
|
|
if type.nullable():
|
|
nullBehavior = "eNull"
|
|
undefinedBehavior = "eNull"
|
|
else:
|
|
nullBehavior = "eStringify"
|
|
undefinedBehavior = "eStringify"
|
|
|
|
return (
|
|
" const xpc_qsDOMString ${name}(cx, ${argVal}, ${argPtr},\n"
|
|
" xpc_qsDOMString::%s,\n"
|
|
" xpc_qsDOMString::%s);\n"
|
|
" if (!${name}.IsValid()) {\n"
|
|
" return false;\n"
|
|
" }\n" % (nullBehavior, undefinedBehavior))
|
|
|
|
if type.isEnum():
|
|
if type.nullable():
|
|
raise TypeError("We don't support nullable enumerated arguments "
|
|
"yet")
|
|
enum = type.inner.identifier.name
|
|
return (
|
|
" %(enumtype)s ${name};\n"
|
|
" {\n"
|
|
" bool ok;\n"
|
|
" ${name} = static_cast<%(enumtype)s>(FindEnumStringIndex(cx, ${argVal}, %(values)s, &ok));\n"
|
|
" if (!ok) {\n"
|
|
" return false;\n"
|
|
" }\n"
|
|
" }" % { "enumtype" : enum,
|
|
"values" : enum + "Values::strings" })
|
|
|
|
if type.isCallback():
|
|
# XXXbz we're going to assume that callback types are always
|
|
# nullable and always have [TreatNonCallableAsNull] for now.
|
|
return (
|
|
" JSObject* ${name};\n"
|
|
" if (${argVal}.isObject() && JS_ObjectIsCallable(cx, &${argVal}.toObject())) {\n"
|
|
" ${name} = &${argVal}.toObject();\n"
|
|
" } else {\n"
|
|
" ${name} = NULL;\n"
|
|
" }\n")
|
|
|
|
if type.isAny():
|
|
return " JS::Value ${name} = ${argVal};\n"
|
|
|
|
if not type.isPrimitive():
|
|
raise TypeError("Need conversion for argument type '%s'" % type)
|
|
|
|
tag = type.tag()
|
|
replacements = dict()
|
|
if type.nullable():
|
|
replacements["declareArg"] = (
|
|
" Nullable<${typeName}> ${name};\n"
|
|
" if (${argVal}.isNullOrUndefined()) {\n"
|
|
" ${name}.SetNull();\n"
|
|
" } else"
|
|
)
|
|
replacements["finalValueSetter"] = "${name}.SetValue"
|
|
else:
|
|
replacements["declareArg"] = " ${typeName} ${name};\n"
|
|
replacements["finalValueSetter"] = "${name} = "
|
|
|
|
replacements["intermediateCast"] = ""
|
|
|
|
if tag == IDLType.Tags.bool:
|
|
replacements["jstype"] = "JSBool"
|
|
replacements["converter"] = "JS_ValueToBoolean"
|
|
elif tag in [IDLType.Tags.int8, IDLType.Tags.uint8, IDLType.Tags.int16,
|
|
IDLType.Tags.uint16, IDLType.Tags.int32, IDLType.Tags.uint32]:
|
|
# XXXbz need to add support for [EnforceRange] and [Clamp]
|
|
# The output of JS_ValueToECMAInt32 is determined as follows:
|
|
# 1) The value is converted to a double
|
|
# 2) Anything that's not a finite double returns 0
|
|
# 3) The double is rounded towards zero to the nearest integer
|
|
# 4) The resulting integer is reduced mod 2^32. The output of this
|
|
# operation is an integer in the range [0, 2^32).
|
|
# 5) If the resulting number is >= 2^31, 2^32 is subtracted from it.
|
|
#
|
|
# The result of all this is a number in the range [-2^31, 2^31)
|
|
#
|
|
# WebIDL conversions for the 8-bit, 16-bit, and 32-bit integer types
|
|
# are defined in the same way, except that step 4 uses reduction mod
|
|
# 2^8 and 2^16 for the 8-bit and 16-bit types respectively, and step 5
|
|
# is only done for the signed types.
|
|
#
|
|
# C/C++ define integer conversion semantics to unsigned types as taking
|
|
# your input integer mod (1 + largest value representable in the
|
|
# unsigned type). Since 2^32 is zero mod 2^8, 2^16, and 2^32,
|
|
# converting to the unsigned int of the relevant width will correctly
|
|
# perform step 4; in particular, the 2^32 possibly subtracted in step 5
|
|
# will become 0.
|
|
#
|
|
# Once we have step 4 done, we're just going to assume 2s-complement
|
|
# representation and cast directly to the type we really want.
|
|
#
|
|
# So we can cast directly for all unsigned types and for int32_t; for
|
|
# the smaller-width signed types we need to cast through the
|
|
# corresponding unsigned type.
|
|
replacements["jstype"] = "int32_t"
|
|
replacements["converter"] = "JS::ToInt32"
|
|
if tag is IDLType.Tags.int8:
|
|
replacements["intermediateCast"] = "(uint8_t)"
|
|
elif tag is IDLType.Tags.int16:
|
|
replacements["intermediateCast"] = "(uint16_t)"
|
|
else:
|
|
replacements["intermediateCast"] = ""
|
|
elif tag is IDLType.Tags.int64:
|
|
# XXXbz this may not match what WebIDL says to do in terms of reducing
|
|
# mod 2^64. Should we check?
|
|
replacements["jstype"] = "int64_t"
|
|
replacements["converter"] = "xpc::ValueToInt64"
|
|
elif tag is IDLType.Tags.uint64:
|
|
# XXXbz this may not match what WebIDL says to do in terms of reducing
|
|
# mod 2^64. Should we check?
|
|
replacements["jstype"] = "uint64_t"
|
|
replacements["converter"] = "xpc::ValueToUint64"
|
|
elif tag in [IDLType.Tags.float, IDLType.Tags.double]:
|
|
replacements["jstype"] = "double"
|
|
replacements["converter"] = "JS::ToNumber"
|
|
else:
|
|
raise TypeError("Unknown primitive type '%s'" % type);
|
|
|
|
# We substitute the %(name)s things here. Our caller will
|
|
# substitute the ${name} things.
|
|
return (" %(jstype)s ${name}_jstype;\n"
|
|
"%(declareArg)s" # No leading whitespace or newline here, on purpose
|
|
" if (%(converter)s(cx, ${argVal}, &${name}_jstype)) {\n"
|
|
" %(finalValueSetter)s((${typeName})%(intermediateCast)s${name}_jstype);\n"
|
|
" } else {\n"
|
|
" return false;\n"
|
|
" }\n" % replacements)
|
|
|
|
def convertConstIDLValueToJSVal(value):
|
|
if isinstance(value, IDLNullValue):
|
|
return "JSVAL_NULL"
|
|
tag = value.type.tag()
|
|
if tag in [IDLType.Tags.int8, IDLType.Tags.uint8, IDLType.Tags.int16,
|
|
IDLType.Tags.uint16, IDLType.Tags.int32]:
|
|
return "INT_TO_JSVAL(%s)" % (value.value)
|
|
if tag == IDLType.Tags.uint32:
|
|
return "UINT_TO_JSVAL(%s)" % (value.value)
|
|
if tag in [IDLType.Tags.int64, IDLType.Tags.uint64]:
|
|
return "DOUBLE_TO_JSVAL(%s)" % (value.value)
|
|
if tag == IDLType.Tags.bool:
|
|
return "JSVAL_TRUE" if value.value else "JSVAL_FALSE"
|
|
if tag in [IDLType.Tags.float, IDLType.Tags.double]:
|
|
return "DOUBLE_TO_JSVAL(%s)" % (value.value)
|
|
raise TypeError("Const value of unhandled type: " + value.type)
|
|
|
|
def convertIDLDefaultValueToJSVal(value):
|
|
if value.type:
|
|
tag = value.type.tag()
|
|
if tag == IDLType.Tags.domstring:
|
|
assert False # Not implemented!
|
|
return convertConstIDLValueToJSVal(value)
|
|
|
|
unindenter = re.compile("^ ", re.MULTILINE)
|
|
class CGArgumentConverter(CGThing):
|
|
"""
|
|
A class that takes an IDL argument object, its index in the
|
|
argument list, and the argv and argc strings and generates code to
|
|
unwrap the argument to the right native type.
|
|
"""
|
|
def __init__(self, argument, index, argv, argc, descriptorProvider):
|
|
CGThing.__init__(self)
|
|
self.argument = argument
|
|
# XXXbz should optional jsval args get JSVAL_VOID? What about
|
|
# others?
|
|
self.replacementVariables = {
|
|
"index" : index,
|
|
"argc" : argc,
|
|
"argv" : argv,
|
|
"defaultValue" : "JSVAL_VOID",
|
|
"name" : "arg%d" % index
|
|
}
|
|
if argument.optional:
|
|
if argument.defaultValue:
|
|
self.replacementVariables["defaultValue"] = convertIDLDefaultValueToJSVal(argument.defaultValue)
|
|
self.replacementVariables["argVal"] = string.Template(
|
|
"(${index} < ${argc} ? ${argv}[${index}] : ${defaultValue})"
|
|
).substitute(self.replacementVariables)
|
|
self.replacementVariables["argPtr"] = string.Template(
|
|
"(${index} < ${argc} ? &${argv}[${index}] : NULL)"
|
|
).substitute(self.replacementVariables)
|
|
else:
|
|
self.replacementVariables["argVal"] = string.Template(
|
|
"${argv}[${index}]"
|
|
).substitute(self.replacementVariables)
|
|
self.replacementVariables["argPtr"] = (
|
|
"&" + self.replacementVariables["argVal"])
|
|
self.descriptor = None
|
|
if argument.type.isPrimitive():
|
|
self.replacementVariables["typeName"] = builtinNames[argument.type.tag()]
|
|
elif argument.type.isInterface() and not argument.type.isArrayBuffer():
|
|
descriptor = descriptorProvider.getDescriptor(
|
|
argument.type.unroll().inner.identifier.name)
|
|
self.descriptor = descriptor
|
|
self.replacementVariables["typeName"] = descriptor.nativeType
|
|
|
|
def define(self):
|
|
return string.Template(
|
|
re.sub(unindenter,
|
|
"",
|
|
getArgumentConversionTemplate(self.argument.type,
|
|
self.descriptor))
|
|
).substitute(self.replacementVariables)
|
|
|
|
def getWrapTemplateForTypeImpl(type, result, descriptorProvider,
|
|
resultAlreadyAddRefed):
|
|
if type is None or type.isVoid():
|
|
return """
|
|
${jsvalRef} = JSVAL_VOID;
|
|
return true;"""
|
|
|
|
if type.isSequence() or type.isArray():
|
|
raise TypeError("Can't handle sequence or array return values yet")
|
|
|
|
if type.isInterface() and not type.isArrayBuffer():
|
|
descriptor = descriptorProvider.getDescriptor(type.unroll().inner.identifier.name)
|
|
wrappingCode = ("""
|
|
if (!%s) {
|
|
${jsvalRef} = JSVAL_NULL;
|
|
return true;
|
|
}""" % result) if type.nullable() else ""
|
|
if descriptor.castable and not type.unroll().inner.isExternal():
|
|
wrappingCode += """
|
|
if (WrapNewBindingObject(cx, obj, %s, ${jsvalPtr})) {
|
|
return true;
|
|
}""" % result
|
|
# We don't support prefable stuff in workers.
|
|
assert(not descriptor.prefable or not descriptor.workers)
|
|
if not descriptor.prefable:
|
|
# Non-prefable bindings can only fail to wrap as a new-binding object
|
|
# if they already threw an exception. Same thing for
|
|
# non-prefable bindings.
|
|
wrappingCode += """
|
|
MOZ_ASSERT(JS_IsExceptionPending(cx));
|
|
return false;"""
|
|
else:
|
|
# Try old-style wrapping for bindings which might be preffed off.
|
|
wrappingCode += """
|
|
return HandleNewBindingWrappingFailure(cx, obj, %s, ${jsvalPtr});""" % result
|
|
else:
|
|
if descriptor.notflattened:
|
|
getIID = "&NS_GET_IID(%s), " % descriptor.nativeType
|
|
else:
|
|
getIID = ""
|
|
wrappingCode += """
|
|
return WrapObject(cx, obj, %s, %s${jsvalPtr});""" % (result, getIID)
|
|
return wrappingCode
|
|
|
|
if type.isString():
|
|
if type.nullable():
|
|
return """
|
|
return xpc::StringToJsval(cx, %s, ${jsvalPtr});""" % result
|
|
else:
|
|
return """
|
|
return xpc::NonVoidStringToJsval(cx, %s, ${jsvalPtr});""" % result
|
|
|
|
if type.isEnum():
|
|
if type.nullable():
|
|
raise TypeError("We don't support nullable enumerated return types "
|
|
"yet")
|
|
return """
|
|
MOZ_ASSERT(uint32_t(%(result)s) < ArrayLength(%(strings)s));
|
|
JSString* result_str = JS_NewStringCopyN(cx, %(strings)s[uint32_t(%(result)s)].value, %(strings)s[uint32_t(%(result)s)].length);
|
|
if (!result_str) {
|
|
return false;
|
|
}
|
|
${jsvalRef} = JS::StringValue(result_str);
|
|
return true;""" % { "result" : result,
|
|
"strings" : type.inner.identifier.name + "Values::strings" }
|
|
|
|
if type.isCallback() and not type.isInterface():
|
|
# XXXbz we're going to assume that callback types are always
|
|
# nullable and always have [TreatNonCallableAsNull] for now.
|
|
# See comments in WrapNewBindingObject explaining why we need
|
|
# to wrap here.
|
|
return """
|
|
${jsvalRef} = JS::ObjectOrNullValue(%s);
|
|
return JS_WrapValue(cx, ${jsvalPtr});""" % result
|
|
|
|
if type.tag() == IDLType.Tags.any:
|
|
# See comments in WrapNewBindingObject explaining why we need
|
|
# to wrap here.
|
|
return """
|
|
${jsvalRef} = %s;\n
|
|
return JS_WrapValue(cx, ${jsvalPtr});""" % result
|
|
|
|
if not type.isPrimitive():
|
|
raise TypeError("Need to learn to wrap %s" % type)
|
|
|
|
if type.nullable():
|
|
return """
|
|
if (%s.IsNull()) {
|
|
${jsvalRef} = JSVAL_NULL;
|
|
return true;
|
|
}
|
|
%s""" % (result, getWrapTemplateForTypeImpl(type.inner, "%s.Value()" % result,
|
|
descriptorProvider,
|
|
resultAlreadyAddRefed))
|
|
|
|
tag = type.tag()
|
|
|
|
if tag in [IDLType.Tags.int8, IDLType.Tags.uint8, IDLType.Tags.int16,
|
|
IDLType.Tags.uint16, IDLType.Tags.int32]:
|
|
return """
|
|
${jsvalRef} = INT_TO_JSVAL(int32_t(%s));
|
|
return true;""" % result
|
|
|
|
elif tag in [IDLType.Tags.int64, IDLType.Tags.uint64, IDLType.Tags.float,
|
|
IDLType.Tags.double]:
|
|
# XXXbz will cast to double do the "even significand" thing that webidl
|
|
# calls for for 64-bit ints? Do we care?
|
|
return """
|
|
return JS_NewNumberValue(cx, double(%s), ${jsvalPtr});""" % result
|
|
|
|
elif tag == IDLType.Tags.uint32:
|
|
return """
|
|
${jsvalRef} = UINT_TO_JSVAL(%s);
|
|
return true;""" % result
|
|
|
|
elif tag == IDLType.Tags.bool:
|
|
return """
|
|
${jsvalRef} = BOOLEAN_TO_JSVAL(%s);
|
|
return true;""" % result
|
|
|
|
else:
|
|
raise TypeError("Need to learn to wrap primitive: %s" % type)
|
|
|
|
def getWrapTemplateForType(type, descriptorProvider, resultAlreadyAddRefed):
|
|
return getWrapTemplateForTypeImpl(type, "result", descriptorProvider,
|
|
resultAlreadyAddRefed)
|
|
|
|
class CGCallGenerator(CGThing):
|
|
"""
|
|
A class to generate an actual call to a C++ object. Assumes that the C++
|
|
object is stored in a variable named "self".
|
|
"""
|
|
def __init__(self, errorReport, argCount, argsPre, returnType,
|
|
resultAlreadyAddRefed, descriptorProvider, nativeMethodName, static):
|
|
CGThing.__init__(self)
|
|
|
|
isFallible = errorReport is not None
|
|
|
|
args = CGList([CGGeneric("arg" + str(i)) for i in range(argCount)], ", ")
|
|
resultOutParam = returnType is not None and returnType.isString()
|
|
# Return values that go in outparams go here
|
|
if resultOutParam:
|
|
args.append(CGGeneric("result"))
|
|
if isFallible:
|
|
args.append(CGGeneric("rv"))
|
|
|
|
if returnType is None or returnType.isVoid():
|
|
# Nothing to declare
|
|
result = None
|
|
elif returnType.isPrimitive() and returnType.tag() in builtinNames:
|
|
result = CGGeneric(builtinNames[returnType.tag()])
|
|
if returnType.nullable():
|
|
result = CGWrapper(result, pre="Nullable<", post=">")
|
|
elif returnType.isString():
|
|
result = CGGeneric("nsString")
|
|
elif returnType.isEnum():
|
|
if returnType.nullable():
|
|
raise TypeError("We don't support nullable enum return values")
|
|
result = CGGeneric(returnType.inner.identifier.name)
|
|
elif returnType.isInterface() and not returnType.isArrayBuffer():
|
|
result = CGGeneric(descriptorProvider.getDescriptor(
|
|
returnType.unroll().inner.identifier.name).nativeType)
|
|
if resultAlreadyAddRefed:
|
|
result = CGWrapper(result, pre="nsRefPtr<", post=">")
|
|
else:
|
|
result = CGWrapper(result, post="*")
|
|
elif returnType.isCallback():
|
|
# XXXbz we're going to assume that callback types are always
|
|
# nullable for now.
|
|
result = CGGeneric("JSObject*")
|
|
elif returnType.tag() is IDLType.Tags.any:
|
|
result = CGGeneric("JS::Value")
|
|
else:
|
|
raise TypeError("Don't know how to declare return value for %s" %
|
|
returnType)
|
|
|
|
# Build up our actual call
|
|
self.cgRoot = CGList([], "\n")
|
|
|
|
call = CGGeneric(nativeMethodName)
|
|
if static:
|
|
call = CGWrapper(call, pre="%s::" % (descriptorProvider.getDescriptor(
|
|
returnType.unroll().inner.identifier.name).nativeType))
|
|
else:
|
|
call = CGWrapper(call, pre="self->")
|
|
call = CGList([call, CGWrapper(args, pre="(" + argsPre, post=");")])
|
|
if result is not None:
|
|
result = CGWrapper(result, post=" result;")
|
|
self.cgRoot.prepend(result)
|
|
if not resultOutParam:
|
|
call = CGWrapper(call, pre="result = ")
|
|
|
|
call = CGWrapper(call)
|
|
self.cgRoot.append(call)
|
|
|
|
if isFallible:
|
|
self.cgRoot.prepend(CGGeneric("nsresult rv = NS_OK;"))
|
|
self.cgRoot.append(CGGeneric("if (NS_FAILED(rv)) {"))
|
|
self.cgRoot.append(CGIndenter(CGGeneric(errorReport)))
|
|
self.cgRoot.append(CGGeneric("}"))
|
|
|
|
def define(self):
|
|
return self.cgRoot.define()
|
|
|
|
class CGPerSignatureCall(CGThing):
|
|
"""
|
|
This class handles the guts of generating code for a particular
|
|
call signature. A call signature consists of four things:
|
|
|
|
1) A return type, which can be None to indicate that there is no
|
|
actual return value (e.g. this is an attribute setter) or an
|
|
IDLType if there's an IDL type involved (including |void|).
|
|
2) An argument list, which is allowed to be empty.
|
|
3) A name of a native method to call.
|
|
4) Whether or not this method is static.
|
|
|
|
We also need to know whether this is a method or a getter/setter
|
|
to do error reporting correctly.
|
|
|
|
The idlNode parameter can be either a method or an attr. We can query
|
|
|idlNode.identifier| in both cases, so we can be agnostic between the two.
|
|
"""
|
|
# XXXbz For now each entry in the argument list is either an
|
|
# IDLArgument or a FakeArgument, but longer-term we may want to
|
|
# have ways of flagging things like JSContext* or optional_argc in
|
|
# there.
|
|
|
|
def __init__(self, returnType, argsPre, arguments, nativeMethodName, static,
|
|
descriptor, idlNode, extendedAttributes, argConversionStartsAt=0):
|
|
CGThing.__init__(self)
|
|
self.returnType = returnType
|
|
self.descriptor = descriptor
|
|
self.idlNode = idlNode
|
|
self.extendedAttributes = extendedAttributes
|
|
# Default to already_AddRefed on the main thread, raw pointer in workers
|
|
self.resultAlreadyAddRefed = not descriptor.workers and not 'resultNotAddRefed' in self.extendedAttributes
|
|
self.argsPre = "cx, " if 'implicitJSContext' in self.extendedAttributes else ""
|
|
self.argsPre += argsPre
|
|
self.argCount = len(arguments)
|
|
if self.argCount > argConversionStartsAt:
|
|
# Insert our argv in there
|
|
cgThings = [CGGeneric(self.getArgvDecl())]
|
|
else:
|
|
cgThings = []
|
|
cgThings.extend([CGArgumentConverter(arguments[i], i, self.getArgv(),
|
|
self.getArgc(), self.descriptor) for
|
|
i in range(argConversionStartsAt, self.argCount)])
|
|
|
|
cgThings.append(CGCallGenerator(
|
|
self.getErrorReport() if self.isFallible() else None,
|
|
self.argCount, self.argsPre, returnType,
|
|
self.resultAlreadyAddRefed, descriptor, nativeMethodName,
|
|
static))
|
|
self.cgRoot = CGList(cgThings, "\n")
|
|
|
|
def getArgv(self):
|
|
return "argv" if self.argCount > 0 else ""
|
|
def getArgvDecl(self):
|
|
return "\nJS::Value* argv = JS_ARGV(cx, vp);\n"
|
|
def getArgc(self):
|
|
return "argc"
|
|
|
|
def isFallible(self):
|
|
return not 'infallible' in self.extendedAttributes
|
|
|
|
def wrap_return_value(self):
|
|
resultTemplateValues = {'jsvalRef': '*vp', 'jsvalPtr': 'vp'}
|
|
return string.Template(
|
|
re.sub(unindenter,
|
|
"",
|
|
getWrapTemplateForType(self.returnType, self.descriptor,
|
|
self.resultAlreadyAddRefed))
|
|
).substitute(resultTemplateValues)
|
|
|
|
def getErrorReport(self):
|
|
return 'return ThrowMethodFailedWithDetails<%s>(cx, rv, "%s", "%s");'\
|
|
% (toStringBool(not self.descriptor.workers),
|
|
self.descriptor.interface.identifier.name,
|
|
self.idlNode.identifier.name)
|
|
|
|
def define(self):
|
|
return (self.cgRoot.define() + self.wrap_return_value())
|
|
|
|
class CGSwitch(CGList):
|
|
"""
|
|
A class to generate code for a switch statement.
|
|
|
|
Takes three constructor arguments: an expression, a list of cases,
|
|
and an optional default.
|
|
|
|
Each case is a CGCase. The default is a CGThing for the body of
|
|
the default case, if any.
|
|
"""
|
|
def __init__(self, expression, cases, default=None):
|
|
CGList.__init__(self, [CGIndenter(c) for c in cases], "\n")
|
|
self.prepend(CGWrapper(CGGeneric(expression),
|
|
pre="switch (", post=") {"));
|
|
if default is not None:
|
|
self.append(
|
|
CGIndenter(
|
|
CGWrapper(
|
|
CGIndenter(default),
|
|
pre="default: {\n",
|
|
post="\n break;\n}"
|
|
)
|
|
)
|
|
)
|
|
|
|
self.append(CGGeneric("}"))
|
|
|
|
class CGCase(CGList):
|
|
"""
|
|
A class to generate code for a case statement.
|
|
|
|
Takes three constructor arguments: an expression, a CGThing for
|
|
the body (allowed to be None if there is no body), and an optional
|
|
argument (defaulting to False) for whether to fall through.
|
|
"""
|
|
def __init__(self, expression, body, fallThrough=False):
|
|
CGList.__init__(self, [], "\n")
|
|
self.append(CGWrapper(CGGeneric(expression), pre="case ", post=": {"))
|
|
bodyList = CGList([body], "\n")
|
|
if fallThrough:
|
|
bodyList.append(CGGeneric("/* Fall through */"))
|
|
else:
|
|
bodyList.append(CGGeneric("break;"))
|
|
self.append(CGIndenter(bodyList));
|
|
self.append(CGGeneric("}"))
|
|
|
|
class CGMethodCall(CGThing):
|
|
"""
|
|
A class to generate selection of a method signature from a set of
|
|
signatures and generation of a call to that signature.
|
|
"""
|
|
def __init__(self, argsPre, nativeMethodName, static, descriptor, method,
|
|
extendedAttributes):
|
|
CGThing.__init__(self)
|
|
|
|
def requiredArgCount(signature):
|
|
arguments = signature[1]
|
|
if len(arguments) == 0:
|
|
return 0
|
|
requiredArgs = len(arguments)
|
|
while requiredArgs and arguments[requiredArgs-1].optional:
|
|
requiredArgs -= 1
|
|
return requiredArgs
|
|
|
|
def maxSigLength(signatures):
|
|
return max([len(s[1]) for s in signatures])
|
|
|
|
def signaturesForArgCount(i, signatures):
|
|
return filter(
|
|
lambda s: len(s[1]) == i or (len(s[1]) > i and
|
|
s[1][i].optional),
|
|
signatures)
|
|
|
|
def findDistinguishingIndex(argCount, signatures):
|
|
def isValidDistinguishingIndex(idx, signatures):
|
|
for firstSigIndex in range(0, len(signatures)):
|
|
for secondSigIndex in range(0, firstSigIndex):
|
|
firstType = signatures[firstSigIndex][1][idx].type
|
|
secondType = signatures[secondSigIndex][1][idx].type
|
|
if not firstType.isDistinguishableFrom(secondType):
|
|
return False
|
|
return True
|
|
for idx in range(0, argCount):
|
|
if isValidDistinguishingIndex(idx, signatures):
|
|
return idx
|
|
return -1
|
|
|
|
def getPerSignatureCall(signature, argConversionStartsAt=0):
|
|
return CGPerSignatureCall(signature[0], argsPre, signature[1],
|
|
nativeMethodName, static, descriptor,
|
|
method, extendedAttributes,
|
|
argConversionStartsAt)
|
|
|
|
|
|
signatures = method.signatures()
|
|
if len(signatures) == 1:
|
|
# Special case: we can just do a per-signature method call
|
|
# here for our one signature and not worry about switching
|
|
# on anything.
|
|
signature = signatures[0]
|
|
self.cgRoot = CGList([ CGIndenter(getPerSignatureCall(signature)) ])
|
|
requiredArgs = requiredArgCount(signature)
|
|
if requiredArgs > 0:
|
|
self.cgRoot.prepend(
|
|
CGWrapper(
|
|
CGIndenter(
|
|
CGGeneric(
|
|
"if (argc < %d) {\n"
|
|
" return Throw<%s>(cx, NS_ERROR_XPC_NOT_ENOUGH_ARGS);\n"
|
|
"}" % (requiredArgs,
|
|
toStringBool(not descriptor.workers)))
|
|
),
|
|
pre="\n", post="\n")
|
|
)
|
|
return
|
|
|
|
# Need to find the right overload
|
|
maxSigArgs = maxSigLength(signatures)
|
|
allowedArgCounts = [ i for i in range(0, maxSigArgs+1)
|
|
if len(signaturesForArgCount(i, signatures)) != 0 ]
|
|
|
|
argCountCases = []
|
|
for argCount in allowedArgCounts:
|
|
possibleSignatures = signaturesForArgCount(argCount, signatures)
|
|
if len(possibleSignatures) == 1:
|
|
# easy case!
|
|
signature = possibleSignatures[0]
|
|
|
|
# (possibly) important optimization: if signature[1] has >
|
|
# argCount arguments and signature[1][argCount] is optional and
|
|
# there is only one signature for argCount+1, then the
|
|
# signature for argCount+1 is just ourselves and we can fall
|
|
# through.
|
|
if (len(signature[1]) > argCount and
|
|
signature[1][argCount].optional and
|
|
(argCount+1) in allowedArgCounts and
|
|
len(signaturesForArgCount(argCount+1, signatures)) == 1):
|
|
argCountCases.append(
|
|
CGCase(str(argCount), None, True))
|
|
else:
|
|
argCountCases.append(
|
|
CGCase(str(argCount), getPerSignatureCall(signature)))
|
|
continue
|
|
|
|
distinguishingIndex = findDistinguishingIndex(argCount,
|
|
possibleSignatures)
|
|
if distinguishingIndex == -1:
|
|
raise TypeError(("Signatures with %s arguments for " +
|
|
descriptor.interface.identifier.name + "." +
|
|
method.identifier.name +
|
|
" are not distinguishable") % argCount)
|
|
|
|
for idx in range(0, distinguishingIndex):
|
|
firstSigType = possibleSignatures[0][1][idx].type
|
|
for sigIdx in range(1, len(possibleSignatures)):
|
|
if possibleSignatures[sigIdx][1][idx].type != firstSigType:
|
|
raise TypeError(("Signatures with %d arguments for " +
|
|
descriptor.interface.identifier.name +
|
|
"." + method.identifier.name +
|
|
" have different types at index %d" +
|
|
" which is before distinguishing" +
|
|
" index %d") % (argCount,
|
|
idx,
|
|
distinguishingIndex))
|
|
|
|
# Convert all our arguments up to the distinguishing index.
|
|
# Doesn't matter which of the possible signatures we use, since
|
|
# they all have the same types up to that point; just use
|
|
# possibleSignatures[0]
|
|
caseBody = [CGGeneric("JS::Value* argv_start = JS_ARGV(cx, vp);")]
|
|
caseBody.extend([ CGArgumentConverter(possibleSignatures[0][1][i],
|
|
i, "argv_start", "argc",
|
|
descriptor) for i in
|
|
range(0, distinguishingIndex) ])
|
|
|
|
# Select the right overload from our set.
|
|
distinguishingArg = "argv_start[%d]" % distinguishingIndex
|
|
|
|
def pickFirstSignature(condition, filterLambda):
|
|
sigs = filter(filterLambda, possibleSignatures)
|
|
assert len(sigs) < 2
|
|
if len(sigs) > 0:
|
|
if condition is None:
|
|
caseBody.append(
|
|
getPerSignatureCall(sigs[0], distinguishingIndex))
|
|
else:
|
|
caseBody.append(CGGeneric("if (" + condition + ") {"))
|
|
caseBody.append(CGIndenter(
|
|
getPerSignatureCall(sigs[0], distinguishingIndex)))
|
|
caseBody.append(CGGeneric("}"))
|
|
return True
|
|
return False
|
|
|
|
# First check for null or undefined
|
|
pickFirstSignature("%s.isNullOrUndefined()" % distinguishingArg,
|
|
lambda s: s[1][distinguishingIndex].type.nullable())
|
|
|
|
# Now check for distinguishingArg being a platform object.
|
|
# We can actually check separately for array buffers and
|
|
# other things.
|
|
# XXXbz Do we need to worry about security
|
|
# wrappers around the array buffer?
|
|
pickFirstSignature("%s.isObject() && JS_IsArrayBufferObject(&%s.toObject(), cx)" %
|
|
(distinguishingArg, distinguishingArg),
|
|
lambda s: (s[1][distinguishingIndex].type.isArrayBuffer() or
|
|
s[1][distinguishingIndex].type.isObject()))
|
|
|
|
interfacesSigs = [
|
|
s for s in possibleSignatures
|
|
if (s[1][distinguishingIndex].type.isObject() or
|
|
(s[1][distinguishingIndex].type.isInterface() and
|
|
not s[1][distinguishingIndex].type.isArrayBuffer() and
|
|
not s[1][distinguishingIndex].type.isCallback())) ]
|
|
# There might be more than one of these; we need to check
|
|
# which ones we unwrap to.
|
|
|
|
if len(interfacesSigs) > 0:
|
|
caseBody.append(CGGeneric("if (%s.isObject() &&\n"
|
|
" IsPlatformObject(cx, &%s.toObject())) {" %
|
|
(distinguishingArg, distinguishingArg)))
|
|
for sig in interfacesSigs:
|
|
caseBody.append(CGIndenter(CGGeneric("do {")));
|
|
type = sig[1][distinguishingIndex].type
|
|
|
|
# XXXbz this duplicates some argument-unwrapping code!
|
|
interfaceDesc = descriptor.getDescriptor(
|
|
type.unroll().inner.identifier.name)
|
|
argIsPointer = (type.nullable() or
|
|
type.unroll().inner.isExternal())
|
|
if argIsPointer:
|
|
nameSuffix = ""
|
|
else:
|
|
nameSuffix = "_ptr"
|
|
if (interfaceDesc.castable or
|
|
type.unroll().inner.isExternal() or
|
|
interfaceDesc.workers):
|
|
declType = " ${typeName}*"
|
|
else:
|
|
declType = " nsCOMPtr<${typeName}>"
|
|
template = declType + " ${name}%s;\n" % nameSuffix
|
|
if interfaceDesc.castable:
|
|
template += str(CastableObjectUnwrapper(
|
|
interfaceDesc,
|
|
"&${argVal}.toObject()",
|
|
"${name}"+nameSuffix,
|
|
"break;")) + "\n"
|
|
elif interfaceDesc.workers:
|
|
template += """
|
|
${name}%s = &${argVal}.toObject();
|
|
MOZ_ASSERT(${name}%s);
|
|
""" % (nameSuffix, nameSuffix)
|
|
else:
|
|
template += " xpc_qsSelfRef tmpRef_${name};\n"
|
|
template += " jsval tmpVal_${name} = ${argVal};\n"
|
|
template += """
|
|
${typeName}* tmp;
|
|
if (NS_FAILED(xpc_qsUnwrapArg<${typeName}>(cx, ${argVal}, &tmp, &tmpRef_${name}.ptr,
|
|
&tmpVal_${name}))) {
|
|
break;
|
|
}
|
|
MOZ_ASSERT(tmp);
|
|
${name}%s = tmp;
|
|
""" % nameSuffix
|
|
|
|
if not argIsPointer:
|
|
template += " ${typeName} &${name} = *${name}_ptr;\n"
|
|
|
|
testCode = string.Template(template).substitute(
|
|
{
|
|
"typeName": interfaceDesc.nativeType,
|
|
"name" : "arg%d" % distinguishingIndex,
|
|
"argVal" : distinguishingArg
|
|
}
|
|
)
|
|
caseBody.append(CGIndenter(CGGeneric(testCode)));
|
|
# If we got this far, we know we unwrapped to the right
|
|
# interface, so just do the call. Start conversion with
|
|
# distinguishingIndex + 1, since we already converted
|
|
# distinguishingIndex.
|
|
caseBody.append(CGIndenter(CGIndenter(
|
|
getPerSignatureCall(sig, distinguishingIndex + 1))))
|
|
caseBody.append(CGIndenter(CGGeneric("} while (0);")))
|
|
|
|
caseBody.append(CGGeneric("}"))
|
|
|
|
# XXXbz Now we're supposed to check for distinguishingArg being
|
|
# an array or a platform object that supports indexed
|
|
# properties... skip that last for now. It's a bit of a pain.
|
|
pickFirstSignature("%s.isObject() && IsArrayLike(cx, &%s.toObject()" %
|
|
(distinguishingArg, distinguishingArg),
|
|
lambda s:
|
|
(s[1][distinguishingIndex].type.isArray() or
|
|
s[1][distinguishingIndex].type.isSequence() or
|
|
s[1][distinguishingIndex].type.isObject()))
|
|
|
|
# Check for Date objects
|
|
# XXXbz Do we need to worry about security wrappers around the Date?
|
|
pickFirstSignature("%s.isObject() && JS_ObjectIsDate(cx, &%s.toObject())" %
|
|
(distinguishingArg, distinguishingArg),
|
|
lambda s: (s[1][distinguishingIndex].type.isDate() or
|
|
s[1][distinguishingIndex].type.isObject()))
|
|
|
|
# Check for vanilla JS objects
|
|
# XXXbz Do we need to worry about security wrappers?
|
|
pickFirstSignature("%s.isObject() && !IsPlatformObject(cx, &%s.toObject())" %
|
|
(distinguishingArg, distinguishingArg),
|
|
lambda s: (s[1][distinguishingIndex].type.isCallback() or
|
|
s[1][distinguishingIndex].type.isDictionary() or
|
|
s[1][distinguishingIndex].type.isObject()))
|
|
|
|
# The remaining cases are mutually exclusive. The
|
|
# pickFirstSignature calls are what change caseBody
|
|
# Check for strings or enums
|
|
if pickFirstSignature(None,
|
|
lambda s: (s[1][distinguishingIndex].type.isString() or
|
|
s[1][distinguishingIndex].type.isEnum())):
|
|
pass
|
|
# Check for primitives
|
|
elif pickFirstSignature(None,
|
|
lambda s: s[1][distinguishingIndex].type.isPrimitive()):
|
|
pass
|
|
# Check for "any"
|
|
elif pickFirstSignature(None,
|
|
lambda s: s[1][distinguishingIndex].type.isAny()):
|
|
pass
|
|
else:
|
|
# Just throw; we have no idea what we're supposed to
|
|
# do with this.
|
|
caseBody.append(CGGeneric("return Throw<%s>(cx, NS_ERROR_XPC_BAD_CONVERT_JS);" %
|
|
toStringBool(not descriptor.workers)))
|
|
|
|
argCountCases.append(CGCase(str(argCount),
|
|
CGList(caseBody, "\n")))
|
|
|
|
overloadCGThings = []
|
|
overloadCGThings.append(
|
|
CGGeneric("unsigned argcount = NS_MIN(argc, %du);" %
|
|
maxSigArgs))
|
|
overloadCGThings.append(
|
|
CGSwitch("argcount",
|
|
argCountCases,
|
|
CGGeneric("return Throw<%s>(cx, NS_ERROR_XPC_NOT_ENOUGH_ARGS);" %
|
|
toStringBool(not descriptor.workers))))
|
|
overloadCGThings.append(
|
|
CGGeneric('MOZ_NOT_REACHED("We have an always-returning default case");\n'
|
|
'return false;'))
|
|
self.cgRoot = CGWrapper(CGIndenter(CGList(overloadCGThings, "\n")),
|
|
pre="\n")
|
|
|
|
def define(self):
|
|
return self.cgRoot.define()
|
|
|
|
class CGGetterSetterCall(CGPerSignatureCall):
|
|
"""
|
|
A class to generate a native object getter or setter call for a
|
|
particular IDL getter or setter.
|
|
"""
|
|
def __init__(self, returnType, arguments, nativeMethodName, descriptor,
|
|
attr, extendedAttributes):
|
|
CGPerSignatureCall.__init__(self, returnType, "", arguments,
|
|
nativeMethodName, False, descriptor, attr,
|
|
extendedAttributes)
|
|
def getArgv(self):
|
|
if generateNativeAccessors:
|
|
return CGPerSignatureCall.getArgv(self)
|
|
return "vp"
|
|
|
|
class CGGetterCall(CGGetterSetterCall):
|
|
"""
|
|
A class to generate a native object getter call for a particular IDL
|
|
getter.
|
|
"""
|
|
def __init__(self, returnType, nativeMethodName, descriptor, attr,
|
|
extendedAttributes):
|
|
CGGetterSetterCall.__init__(self, returnType, [], nativeMethodName,
|
|
descriptor, attr, extendedAttributes)
|
|
def getArgc(self):
|
|
if generateNativeAccessors:
|
|
return CGGetterSetterCall.getArgc()
|
|
return "0"
|
|
def getArgvDecl(self):
|
|
if generateNativeAccessors:
|
|
return CGPerSignatureCall.getArgvDecl(self)
|
|
# We just get our stuff from vp
|
|
return ""
|
|
|
|
class FakeArgument():
|
|
def __init__(self, type):
|
|
self.type = type
|
|
self.optional = False
|
|
|
|
class CGSetterCall(CGGetterSetterCall):
|
|
"""
|
|
A class to generate a native object setter call for a particular IDL
|
|
setter.
|
|
"""
|
|
def __init__(self, argType, nativeMethodName, descriptor, attr,
|
|
extendedAttributes):
|
|
CGGetterSetterCall.__init__(self, None, [FakeArgument(argType)],
|
|
nativeMethodName, descriptor, attr,
|
|
extendedAttributes)
|
|
def wrap_return_value(self):
|
|
if generateNativeAccessors:
|
|
return CGGetterSetterCall.wrap_return_value(self)
|
|
# We have no return value
|
|
return "\nreturn true;"
|
|
def getArgc(self):
|
|
if generateNativeAccessors:
|
|
return CGGetterSetterCall.getArgc(self)
|
|
return "1"
|
|
def getArgvDecl(self):
|
|
if generateNativeAccessors:
|
|
return (CGPerSignatureCall.getArgvDecl(self) +
|
|
"jsval undef = JS::UndefinedValue();\n"
|
|
"if (argc == 0) {\n"
|
|
" argv = &undef;\n"
|
|
" argc = 1;\n"
|
|
"}")
|
|
# We just get our stuff from vp
|
|
return ""
|
|
|
|
class CGAbstractBindingMethod(CGAbstractStaticMethod):
|
|
"""
|
|
Common class to generate the JSNatives for all our methods, getters, and
|
|
setters. This will generate the function declaration and unwrap the
|
|
|this| object. Subclasses are expected to override the generate_code
|
|
function to do the rest of the work. This function should return a
|
|
CGThing which is already properly indented.
|
|
"""
|
|
def __init__(self, descriptor, name, args, extendedAttributes):
|
|
self.extendedAttributes = extendedAttributes
|
|
CGAbstractStaticMethod.__init__(self, descriptor, name, "JSBool", args)
|
|
|
|
def definition_body(self):
|
|
unwrapThis = CGGeneric(
|
|
str(FailureFatalCastableObjectUnwrapper(self.descriptor, "obj", "self")))
|
|
return CGList([ self.getThis(), unwrapThis,
|
|
self.generate_code() ], "\n").define()
|
|
|
|
def getThis(self):
|
|
return CGIndenter(
|
|
CGGeneric("JSObject* obj = JS_THIS_OBJECT(cx, vp);\n"
|
|
"if (!obj) {\n"
|
|
" return false;\n"
|
|
"}\n"
|
|
"\n"
|
|
"%s* self;" % self.descriptor.nativeType))
|
|
|
|
def generate_code(self):
|
|
assert(False) # Override me
|
|
|
|
def MakeNativeName(name):
|
|
return name[0].upper() + name[1:]
|
|
|
|
class CGNativeMethod(CGAbstractBindingMethod):
|
|
"""
|
|
A class for generating the C++ code for an IDL method..
|
|
"""
|
|
def __init__(self, descriptor, method):
|
|
self.method = method
|
|
baseName = method.identifier.name
|
|
args = [Argument('JSContext*', 'cx'), Argument('unsigned', 'argc'),
|
|
Argument('JS::Value*', 'vp')]
|
|
CGAbstractBindingMethod.__init__(self, descriptor, baseName, args,
|
|
descriptor.getExtendedAttributes(method))
|
|
def generate_code(self):
|
|
name = self.method.identifier.name
|
|
nativeName = self.descriptor.binaryNames.get(name, MakeNativeName(name))
|
|
return CGMethodCall("", nativeName, self.method.isStatic(),
|
|
self.descriptor, self.method,
|
|
self.extendedAttributes)
|
|
|
|
class CGNativeGetter(CGAbstractBindingMethod):
|
|
"""
|
|
A class for generating the C++ code for an IDL attribute getter.
|
|
"""
|
|
def __init__(self, descriptor, attr):
|
|
self.attr = attr
|
|
name = 'get_' + attr.identifier.name
|
|
if generateNativeAccessors:
|
|
args = [Argument('JSContext*', 'cx'), Argument('unsigned', 'argc'),
|
|
Argument('JS::Value*', 'vp')]
|
|
else:
|
|
args = [Argument('JSContext*', 'cx'), Argument('JSObject*', 'obj'),
|
|
Argument('jsid', 'id'), Argument('JS::Value*', 'vp')]
|
|
CGAbstractBindingMethod.__init__(self, descriptor, name, args,
|
|
descriptor.getExtendedAttributes(self.attr, getter=True))
|
|
|
|
def getThis(self):
|
|
if generateNativeAccessors:
|
|
return CGAbstractBindingMethod.getThis(self)
|
|
return CGIndenter(
|
|
CGGeneric("%s* self;" % self.descriptor.nativeType))
|
|
|
|
def generate_code(self):
|
|
|
|
nativeMethodName = "Get" + MakeNativeName(self.attr.identifier.name)
|
|
return CGIndenter(CGGetterCall(self.attr.type, nativeMethodName, self.descriptor,
|
|
self.attr, self.extendedAttributes))
|
|
|
|
class CGNativeSetter(CGAbstractBindingMethod):
|
|
"""
|
|
A class for generating the C++ code for an IDL attribute setter.
|
|
"""
|
|
def __init__(self, descriptor, attr):
|
|
self.attr = attr
|
|
baseName = attr.identifier.name
|
|
name = 'set_' + attr.identifier.name
|
|
if generateNativeAccessors:
|
|
args = [Argument('JSContext*', 'cx'), Argument('unsigned', 'argc'),
|
|
Argument('JS::Value*', 'vp')]
|
|
else:
|
|
args = [Argument('JSContext*', 'cx'), Argument('JSObject*', 'obj'),
|
|
Argument('jsid', 'id'), Argument('JSBool', 'strict'),
|
|
Argument('JS::Value*', 'vp')]
|
|
CGAbstractBindingMethod.__init__(self, descriptor, name, args,
|
|
descriptor.getExtendedAttributes(self.attr, setter=True))
|
|
|
|
def getThis(self):
|
|
if generateNativeAccessors:
|
|
return CGAbstractBindingMethod.getThis(self)
|
|
return CGIndenter(
|
|
CGGeneric("%s* self;" % self.descriptor.nativeType))
|
|
|
|
def generate_code(self):
|
|
nativeMethodName = "Set" + MakeNativeName(self.attr.identifier.name)
|
|
return CGIndenter(CGSetterCall(self.attr.type, nativeMethodName, self.descriptor,
|
|
self.attr, self.extendedAttributes))
|
|
|
|
def getEnumValueName(value):
|
|
# Some enum values can be empty strings. Others might have weird
|
|
# characters in them. Deal with the former by returning "_empty",
|
|
# deal with possible name collisions from that by throwing if the
|
|
# enum value is actually "_empty", and throw on any value
|
|
# containing chars other than [a-z] or '-' for now. Replace '-' with '_'.
|
|
value = value.replace('-', '_')
|
|
if value == "_empty":
|
|
raise SyntaxError('"_empty" is not an IDL enum value we support yet')
|
|
if value == "":
|
|
return "_empty"
|
|
if not re.match("^[a-z_]+$", value):
|
|
raise SyntaxError('Enum value "' + value + '" contains characters '
|
|
'outside [a-z_]')
|
|
return value
|
|
|
|
class CGEnum(CGThing):
|
|
def __init__(self, enum):
|
|
CGThing.__init__(self)
|
|
self.enum = enum
|
|
|
|
def declare(self):
|
|
return """
|
|
enum valuelist {
|
|
%s
|
|
};
|
|
|
|
extern const EnumEntry strings[%d];
|
|
""" % (",\n ".join(map(getEnumValueName, self.enum.values())),
|
|
len(self.enum.values()) + 1)
|
|
|
|
def define(self):
|
|
return """
|
|
const EnumEntry strings[%d] = {
|
|
%s,
|
|
{ NULL, 0 }
|
|
};
|
|
""" % (len(self.enum.values()) + 1,
|
|
",\n ".join(['{"' + val + '", ' + str(len(val)) + '}' for val in self.enum.values()]))
|
|
|
|
class ClassItem:
|
|
""" Use with CGClass """
|
|
def __init__(self, name, visibility):
|
|
self.name = name
|
|
self.visibility = visibility
|
|
def declare(self, cgClass):
|
|
assert False
|
|
def define(self, cgClass):
|
|
assert False
|
|
|
|
class ClassBase(ClassItem):
|
|
def __init__(self, name, visibility='public'):
|
|
ClassItem.__init__(self, name, visibility)
|
|
def declare(self, cgClass):
|
|
return '%s %s' % (self.visibility, self.name)
|
|
def define(self, cgClass):
|
|
# Only in the header
|
|
return ''
|
|
|
|
class ClassMethod(ClassItem):
|
|
def __init__(self, name, returnType, args, inline=False, static=False,
|
|
virtual=False, const=False, bodyInHeader=False,
|
|
templateArgs=None, visibility='public', body=None):
|
|
self.returnType = returnType
|
|
self.args = args
|
|
self.inline = inline or bodyInHeader
|
|
self.static = static
|
|
self.virtual = virtual
|
|
self.const = const
|
|
self.bodyInHeader = bodyInHeader
|
|
self.templateArgs = templateArgs
|
|
self.body = body
|
|
ClassItem.__init__(self, name, visibility)
|
|
|
|
def getDecorators(self, declaring):
|
|
decorators = []
|
|
if self.inline:
|
|
decorators.append('inline')
|
|
if declaring:
|
|
if self.static:
|
|
decorators.append('static')
|
|
if self.virtual:
|
|
decorators.append('virtual')
|
|
if decorators:
|
|
return ' '.join(decorators) + ' '
|
|
return ''
|
|
|
|
def getBody(self):
|
|
# Override me or pass a string to constructor
|
|
assert self.body is not None
|
|
return self.body
|
|
|
|
def declare(self, cgClass):
|
|
templateClause = 'template <%s>\n' % ', '.join(self.templateArgs) \
|
|
if self.bodyInHeader and self.templateArgs else ''
|
|
args = ', '.join([str(a) for a in self.args])
|
|
if self.bodyInHeader:
|
|
body = ' ' + self.getBody();
|
|
body = body.replace('\n', '\n ').rstrip(' ')
|
|
body = '\n{\n' + body + '\n}'
|
|
else:
|
|
body = ';'
|
|
|
|
return string.Template("""${templateClause}${decorators}${returnType}
|
|
${name}(${args})${const}${body}
|
|
""").substitute({ 'templateClause': templateClause,
|
|
'decorators': self.getDecorators(True),
|
|
'returnType': self.returnType,
|
|
'name': self.name,
|
|
'const': ' const' if self.const else '',
|
|
'args': args,
|
|
'body': body })
|
|
|
|
def define(self, cgClass):
|
|
if self.bodyInHeader:
|
|
return ''
|
|
|
|
templateArgs = cgClass.templateArgs
|
|
if templateArgs:
|
|
if cgClass.templateSpecialization:
|
|
templateArgs = \
|
|
templateArgs[len(cgClass.templateSpecialization):]
|
|
|
|
if templateArgs:
|
|
templateClause = \
|
|
'template <%s>\n' % ', '.join([str(a) for a in templateArgs])
|
|
else:
|
|
templateClause = ''
|
|
|
|
args = ', '.join([str(a) for a in self.args])
|
|
|
|
body = ' ' + self.getBody()
|
|
body = body.replace('\n', '\n ').rstrip(' ')
|
|
|
|
return string.Template("""${templateClause}${decorators}${returnType}
|
|
${className}::${name}(${args})${const}
|
|
{
|
|
${body}
|
|
}\n
|
|
""").substitute({ 'templateClause': templateClause,
|
|
'decorators': self.getDecorators(False),
|
|
'returnType': self.returnType,
|
|
'className': cgClass.getNameString(),
|
|
'name': self.name,
|
|
'args': args,
|
|
'const': ' const' if self.const else '',
|
|
'body': body })
|
|
|
|
class ClassMember(ClassItem):
|
|
def __init__(self, name, type, visibility="private", static=False,
|
|
body=None):
|
|
self.type = type;
|
|
self.static = static
|
|
self.body = body
|
|
ClassItem.__init__(self, name, visibility)
|
|
|
|
def getBody(self):
|
|
assert self.body is not None
|
|
return self.body
|
|
|
|
def declare(self, cgClass):
|
|
return '%s%s %s;\n' % ('static ' if self.static else '', self.type,
|
|
self.name)
|
|
|
|
def define(self, cgClass):
|
|
if not self.static:
|
|
return ''
|
|
return '%s %s::%s = %s;\n' % (self.type, cgClass.getNameString(),
|
|
self.name, self.getBody())
|
|
|
|
class ClassTypedef(ClassItem):
|
|
def __init__(self, name, type, visibility="public"):
|
|
self.type = type
|
|
ClassItem.__init__(self, name, visibility)
|
|
|
|
def declare(self, cgClass):
|
|
return 'typedef %s %s;\n' % (self.type, self.name)
|
|
|
|
def define(self, cgClass):
|
|
# Only goes in the header
|
|
return ''
|
|
|
|
class ClassEnum(ClassItem):
|
|
def __init__(self, name, entries, values=None, visibility="public"):
|
|
self.entries = entries
|
|
self.values = values
|
|
ClassItem.__init__(self, name, visibility)
|
|
|
|
def declare(self, cgClass):
|
|
entries = []
|
|
for i in range(0, len(self.entries)):
|
|
if i >= len(self.values):
|
|
entry = '%s' % self.entries[i]
|
|
else:
|
|
entry = '%s = %s' % (self.entries[i], self.values[i])
|
|
entries.append(entry)
|
|
name = '' if not self.name else ' ' + self.name
|
|
return 'enum%s\n{\n %s\n};\n' % (name, ',\n '.join(entries))
|
|
|
|
def define(self, cgClass):
|
|
# Only goes in the header
|
|
return ''
|
|
|
|
class CGClass(CGThing):
|
|
def __init__(self, name, bases=[], members=[], methods=[], typedefs = [],
|
|
enums=[], templateArgs=[], templateSpecialization=[],
|
|
isStruct=False, indent=''):
|
|
CGThing.__init__(self)
|
|
self.name = name
|
|
self.bases = bases
|
|
self.members = members
|
|
self.methods = methods
|
|
self.typedefs = typedefs
|
|
self.enums = enums
|
|
self.templateArgs = templateArgs
|
|
self.templateSpecialization = templateSpecialization
|
|
self.isStruct = isStruct
|
|
self.indent = indent
|
|
self.defaultVisibility ='public' if isStruct else 'private'
|
|
|
|
def getNameString(self):
|
|
className = self.name
|
|
if self.templateSpecialization:
|
|
className = className + \
|
|
'<%s>' % ', '.join([str(a) for a
|
|
in self.templateSpecialization])
|
|
return className
|
|
|
|
def declare(self):
|
|
result = ''
|
|
if self.templateArgs:
|
|
templateArgs = [str(a) for a in self.templateArgs]
|
|
templateArgs = templateArgs[len(self.templateSpecialization):]
|
|
result = result + self.indent + 'template <%s>\n' \
|
|
% ','.join([str(a) for a in templateArgs])
|
|
|
|
type = 'struct' if self.isStruct else 'class'
|
|
|
|
if self.templateSpecialization:
|
|
specialization = \
|
|
'<%s>' % ', '.join([str(a) for a in self.templateSpecialization])
|
|
else:
|
|
specialization = ''
|
|
|
|
result = result + '%s%s %s%s' \
|
|
% (self.indent, type, self.name, specialization)
|
|
|
|
if self.bases:
|
|
result = result + ' : %s' % ', '.join([d.declare(self) for d in self.bases])
|
|
|
|
result = result + '\n%s{\n' % self.indent
|
|
|
|
def declareMembers(cgClass, memberList, defaultVisibility, itemCount,
|
|
separator=''):
|
|
members = { 'private': [], 'protected': [], 'public': [] }
|
|
|
|
for member in memberList:
|
|
members[member.visibility].append(member)
|
|
|
|
|
|
if defaultVisibility == 'public':
|
|
order = [ 'public', 'protected', 'private' ]
|
|
else:
|
|
order = [ 'private', 'protected', 'public' ]
|
|
|
|
result = ''
|
|
|
|
lastVisibility = defaultVisibility
|
|
for visibility in order:
|
|
list = members[visibility]
|
|
if list:
|
|
if visibility != lastVisibility:
|
|
if itemCount:
|
|
result = result + '\n'
|
|
result = result + visibility + ':\n'
|
|
itemCount = 0
|
|
for member in list:
|
|
if itemCount == 0:
|
|
result = result + ' '
|
|
else:
|
|
result = result + separator + ' '
|
|
declaration = member.declare(cgClass)
|
|
declaration = declaration.replace('\n', '\n ')
|
|
declaration = declaration.rstrip(' ')
|
|
result = result + declaration
|
|
itemCount = itemCount + 1
|
|
lastVisibility = visibility
|
|
return (result, lastVisibility, itemCount)
|
|
|
|
order = [(self.enums, ''), (self.typedefs, ''), (self.members, ''),
|
|
(self.methods, '\n')]
|
|
|
|
lastVisibility = self.defaultVisibility
|
|
itemCount = 0
|
|
for (memberList, separator) in order:
|
|
(memberString, lastVisibility, itemCount) = \
|
|
declareMembers(self, memberList, lastVisibility, itemCount,
|
|
separator)
|
|
if self.indent:
|
|
memberString = self.indent + memberString
|
|
memberString = memberString.replace('\n', '\n' + self.indent)
|
|
memberString = memberString.rstrip(' ')
|
|
result = result + memberString
|
|
|
|
result = result + self.indent + '};\n\n'
|
|
return result
|
|
|
|
def define(self):
|
|
def defineMembers(cgClass, memberList, itemCount, separator=''):
|
|
result = ''
|
|
for member in memberList:
|
|
if itemCount != 0:
|
|
result = result + separator
|
|
result = result + member.define(cgClass)
|
|
itemCount = itemCount + 1
|
|
return (result, itemCount)
|
|
|
|
order = [(self.members, '\n'), (self.methods, '\n')]
|
|
|
|
result = ''
|
|
itemCount = 0
|
|
for (memberList, separator) in order:
|
|
(memberString, itemCount) = defineMembers(self, memberList,
|
|
itemCount, separator)
|
|
result = result + memberString
|
|
return result
|
|
|
|
class CGResolveProperty(CGAbstractMethod):
|
|
def __init__(self, descriptor, properties):
|
|
args = [Argument('JSContext*', 'cx'), Argument('JSObject*', 'wrapper'),
|
|
Argument('jsid', 'id'), Argument('bool', 'set'),
|
|
Argument('JSPropertyDescriptor*', 'desc')]
|
|
CGAbstractMethod.__init__(self, descriptor, "ResolveProperty", "bool", args)
|
|
self.properties = properties
|
|
def definition_body(self):
|
|
str = ""
|
|
|
|
varNames = self.properties.variableNames(True)
|
|
|
|
methods = self.properties.methods
|
|
if methods.hasNonChromeOnly() or methods.hasChromeOnly():
|
|
str += """ for (size_t i = 0; i < ArrayLength(%(methods)s_ids); ++i) {
|
|
if (id == %(methods)s_ids[i]) {
|
|
JSFunction *fun = JS_NewFunctionById(cx, %(methods)s[i].call, %(methods)s[i].nargs, 0, wrapper, id);
|
|
if (!fun)
|
|
return false;
|
|
JSObject *funobj = JS_GetFunctionObject(fun);
|
|
desc->value.setObject(*funobj);
|
|
desc->attrs = %(methods)s[i].flags;
|
|
desc->obj = wrapper;
|
|
desc->setter = nsnull;
|
|
desc->getter = nsnull;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
""" % varNames
|
|
|
|
attrs = self.properties.attrs
|
|
if attrs.hasNonChromeOnly() or attrs.hasChromeOnly():
|
|
str += """ for (size_t i = 0; i < ArrayLength(%(attrs)s_ids); ++i) {
|
|
if (id == %(attrs)s_ids[i]) {
|
|
desc->attrs = %(attrs)s[i].flags;
|
|
desc->obj = wrapper;
|
|
desc->setter = %(attrs)s[i].setter;
|
|
desc->getter = %(attrs)s[i].getter;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
""" % varNames
|
|
|
|
return str + " return true;"
|
|
|
|
class CGEnumerateProperties(CGAbstractMethod):
|
|
def __init__(self, descriptor, properties):
|
|
args = [Argument('JS::AutoIdVector&', 'props')]
|
|
CGAbstractMethod.__init__(self, descriptor, "EnumerateProperties", "bool", args)
|
|
self.properties = properties
|
|
def definition_body(self):
|
|
str = ""
|
|
|
|
varNames = self.properties.variableNames(True)
|
|
|
|
methods = self.properties.methods
|
|
if methods.hasNonChromeOnly() or methods.hasChromeOnly():
|
|
str += """ for (size_t i = 0; i < sizeof(%(methods)s_ids); ++i) {
|
|
if ((%(methods)s[i].flags & JSPROP_ENUMERATE) &&
|
|
!props.append(%(methods)s_ids[i])) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
""" % varNames
|
|
|
|
attrs = self.properties.attrs
|
|
if attrs.hasNonChromeOnly() or attrs.hasChromeOnly():
|
|
str += """ for (size_t i = 0; i < sizeof(%(attrs)s_ids); ++i) {
|
|
if ((%(attrs)s[i].flags & JSPROP_ENUMERATE) &&
|
|
!props.append(%(attrs)s_ids[i])) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
""" % varNames
|
|
|
|
return str + " return true;"
|
|
|
|
class CGPrototypeTraitsClass(CGClass):
|
|
def __init__(self, descriptor, indent=''):
|
|
templateArgs = [Argument('prototypes::ID', 'PrototypeID')]
|
|
templateSpecialization = ['prototypes::id::' + descriptor.name]
|
|
enums = [ClassEnum('', ['Depth'],
|
|
[descriptor.interface.inheritanceDepth()])]
|
|
typedefs = [ClassTypedef('NativeType', descriptor.nativeType)]
|
|
CGClass.__init__(self, 'PrototypeTraits', indent=indent,
|
|
templateArgs=templateArgs,
|
|
templateSpecialization=templateSpecialization,
|
|
enums=enums, typedefs=typedefs, isStruct=True)
|
|
|
|
class CGPrototypeIDMapClass(CGClass):
|
|
def __init__(self, descriptor, indent=''):
|
|
templateArgs = [Argument('class', 'ConcreteClass')]
|
|
templateSpecialization = [descriptor.nativeType]
|
|
enums = [ClassEnum('', ['PrototypeID'],
|
|
['prototypes::id::' + descriptor.name])]
|
|
CGClass.__init__(self, 'PrototypeIDMap', indent=indent,
|
|
templateArgs=templateArgs,
|
|
templateSpecialization=templateSpecialization,
|
|
enums=enums, isStruct=True)
|
|
|
|
class CGClassForwardDeclare(CGThing):
|
|
def __init__(self, name, isStruct=False):
|
|
CGThing.__init__(self)
|
|
self.name = name
|
|
self.isStruct = isStruct
|
|
def declare(self):
|
|
type = 'struct' if self.isStruct else 'class'
|
|
return '%s %s;\n' % (type, self.name)
|
|
def define(self):
|
|
# Header only
|
|
return ''
|
|
|
|
def stripTrailingWhitespace(text):
|
|
lines = text.splitlines()
|
|
for i in range(len(lines)):
|
|
lines[i] = lines[i].rstrip()
|
|
return '\n'.join(lines)
|
|
|
|
class CGDescriptor(CGThing):
|
|
def __init__(self, descriptor):
|
|
CGThing.__init__(self)
|
|
|
|
assert not descriptor.concrete or descriptor.interface.hasInterfacePrototypeObject()
|
|
|
|
cgThings = []
|
|
if descriptor.interface.hasInterfacePrototypeObject():
|
|
cgThings.extend([CGNativeMethod(descriptor, m) for m in
|
|
descriptor.interface.members if
|
|
m.isMethod() and not m.isStatic()])
|
|
cgThings.extend([CGNativeGetter(descriptor, a) for a in
|
|
descriptor.interface.members if a.isAttr()])
|
|
cgThings.extend([CGNativeSetter(descriptor, a) for a in
|
|
descriptor.interface.members if
|
|
a.isAttr() and not a.readonly])
|
|
|
|
if descriptor.concrete:
|
|
if not descriptor.workers:
|
|
cgThings.append(CGAddPropertyHook(descriptor))
|
|
|
|
# Always have a finalize hook, regardless of whether the class wants a
|
|
# custom hook.
|
|
if descriptor.nativeIsISupports:
|
|
cgThings.append(CGNativeToSupportsMethod(descriptor))
|
|
cgThings.append(CGClassFinalizeHook(descriptor))
|
|
|
|
# Only generate a trace hook if the class wants a custom hook.
|
|
if (descriptor.customTrace):
|
|
cgThings.append(CGClassTraceHook(descriptor))
|
|
|
|
if descriptor.concrete or descriptor.interface.hasInterfacePrototypeObject():
|
|
cgThings.append(CGNativePropertyHooks(descriptor))
|
|
if descriptor.concrete:
|
|
cgThings.append(CGDOMJSClass(descriptor))
|
|
|
|
if descriptor.interface.hasInterfaceObject():
|
|
cgThings.append(CGClassConstructHook(descriptor))
|
|
cgThings.append(CGClassHasInstanceHook(descriptor))
|
|
cgThings.append(CGInterfaceObjectJSClass(descriptor))
|
|
|
|
if descriptor.interface.hasInterfacePrototypeObject():
|
|
cgThings.append(CGPrototypeJSClass(descriptor))
|
|
|
|
properties = PropertyArrays(descriptor)
|
|
cgThings.append(CGGeneric(define=str(properties)))
|
|
cgThings.append(CGCreateInterfaceObjectsMethod(descriptor, properties))
|
|
if descriptor.interface.hasInterfacePrototypeObject():
|
|
cgThings.append(CGIndenter(CGGetProtoObjectMethod(descriptor)))
|
|
else:
|
|
cgThings.append(CGIndenter(CGGetConstructorObjectMethod(descriptor)))
|
|
|
|
if descriptor.concrete or descriptor.interface.hasInterfacePrototypeObject():
|
|
cgThings.append(CGResolveProperty(descriptor, properties))
|
|
cgThings.append(CGEnumerateProperties(descriptor, properties))
|
|
|
|
if descriptor.interface.hasInterfaceObject():
|
|
cgThings.append(CGDefineDOMInterfaceMethod(descriptor))
|
|
|
|
if descriptor.concrete:
|
|
cgThings.append(CGWrapMethod(descriptor))
|
|
|
|
cgThings = CGList(cgThings)
|
|
cgThings = CGWrapper(cgThings, post='\n')
|
|
self.cgRoot = CGWrapper(CGNamespace(toBindingNamespace(descriptor.name),
|
|
cgThings),
|
|
post='\n')
|
|
|
|
def declare(self):
|
|
return self.cgRoot.declare()
|
|
def define(self):
|
|
return self.cgRoot.define()
|
|
|
|
class CGNamespacedEnum(CGThing):
|
|
def __init__(self, namespace, enumName, names, values, comment=""):
|
|
|
|
if not values:
|
|
values = []
|
|
|
|
# Account for explicit enum values.
|
|
entries = []
|
|
for i in range(0, len(names)):
|
|
if len(values) > i and values[i] is not None:
|
|
entry = "%s = %s" % (names[i], values[i])
|
|
else:
|
|
entry = names[i]
|
|
entries.append(entry)
|
|
|
|
# Append a Count.
|
|
entries.append('_' + enumName + '_Count')
|
|
|
|
# Indent.
|
|
entries = [' ' + e for e in entries]
|
|
|
|
# Build the enum body.
|
|
enumstr = comment + 'enum %s\n{\n%s\n};\n' % (enumName, ',\n'.join(entries))
|
|
curr = CGGeneric(declare=enumstr)
|
|
|
|
# Add some whitespace padding.
|
|
curr = CGWrapper(curr, pre='\n',post='\n')
|
|
|
|
# Add the namespace.
|
|
curr = CGNamespace(namespace, curr)
|
|
|
|
# Add the typedef
|
|
typedef = '\ntypedef %s::%s %s;\n\n' % (namespace, enumName, enumName)
|
|
curr = CGList([curr, CGGeneric(declare=typedef)])
|
|
|
|
# Save the result.
|
|
self.node = curr
|
|
|
|
def declare(self):
|
|
return self.node.declare()
|
|
def define(self):
|
|
assert False # Only for headers.
|
|
|
|
class CGRegisterProtos(CGAbstractMethod):
|
|
def __init__(self, config):
|
|
CGAbstractMethod.__init__(self, None, 'Register', 'void',
|
|
[Argument('nsScriptNameSpaceManager*', 'aNameSpaceManager')])
|
|
self.config = config
|
|
|
|
def _defineMacro(self):
|
|
return """
|
|
#define REGISTER_PROTO(_dom_class) \\
|
|
aNameSpaceManager->RegisterDefineDOMInterface(NS_LITERAL_STRING(#_dom_class), _dom_class##Binding::DefineDOMInterface);\n\n"""
|
|
def _undefineMacro(self):
|
|
return "\n#undef REGISTER_PROTO"
|
|
def _registerProtos(self):
|
|
lines = ["REGISTER_PROTO(%s);" % desc.name
|
|
for desc in self.config.getDescriptors(hasInterfaceObject=True,
|
|
isExternal=False,
|
|
workers=False)]
|
|
return '\n'.join(lines) + '\n'
|
|
def definition_body(self):
|
|
return self._defineMacro() + self._registerProtos() + self._undefineMacro()
|
|
|
|
class CGBindingRoot(CGThing):
|
|
"""
|
|
Root codegen class for binding generation. Instantiate the class, and call
|
|
declare or define to generate header or cpp code (respectively).
|
|
"""
|
|
def __init__(self, config, prefix, webIDLFile):
|
|
descriptors = config.getDescriptors(webIDLFile=webIDLFile,
|
|
hasInterfaceOrInterfacePrototypeObject=True)
|
|
|
|
forwardDeclares = [CGClassForwardDeclare('XPCWrappedNativeScope')]
|
|
|
|
for x in descriptors:
|
|
nativeType = x.nativeType
|
|
components = x.nativeType.split('::')
|
|
declare = CGClassForwardDeclare(components[-1])
|
|
if len(components) > 1:
|
|
declare = CGNamespace.build(components[:-1],
|
|
CGWrapper(declare, declarePre='\n',
|
|
declarePost='\n'),
|
|
declareOnly=True)
|
|
forwardDeclares.append(CGWrapper(declare, declarePost='\n'))
|
|
|
|
forwardDeclares = CGList(forwardDeclares)
|
|
|
|
descriptorsWithPrototype = filter(lambda d: d.interface.hasInterfacePrototypeObject(),
|
|
descriptors)
|
|
traitsClasses = [CGPrototypeTraitsClass(d) for d in descriptorsWithPrototype]
|
|
|
|
# We must have a 1:1 mapping here, skip for prototypes that have more
|
|
# than one concrete class implementation.
|
|
traitsClasses.extend([CGPrototypeIDMapClass(d) for d in descriptorsWithPrototype
|
|
if d.uniqueImplementation])
|
|
|
|
# Wrap all of that in our namespaces.
|
|
if len(traitsClasses) > 0:
|
|
traitsClasses = CGNamespace.build(['mozilla', 'dom'],
|
|
CGWrapper(CGList(traitsClasses),
|
|
declarePre='\n'),
|
|
declareOnly=True)
|
|
traitsClasses = CGWrapper(traitsClasses, declarePost='\n')
|
|
else:
|
|
traitsClasses = None
|
|
|
|
# Do codegen for all the descriptors and enums.
|
|
def makeEnum(e):
|
|
return CGNamespace.build([e.identifier.name + "Values"],
|
|
CGEnum(e))
|
|
def makeEnumTypedef(e):
|
|
return CGGeneric(declare=("typedef %sValues::valuelist %s;\n" %
|
|
(e.identifier.name, e.identifier.name)))
|
|
cgthings = [ fun(e) for e in config.getEnums(webIDLFile)
|
|
for fun in [makeEnum, makeEnumTypedef] ]
|
|
cgthings.extend([CGDescriptor(x) for x in descriptors])
|
|
curr = CGList(cgthings, "\n")
|
|
|
|
# Wrap all of that in our namespaces.
|
|
curr = CGNamespace.build(['mozilla', 'dom'],
|
|
CGWrapper(curr, pre="\n"))
|
|
|
|
curr = CGList([forwardDeclares,
|
|
CGWrapper(CGGeneric("using namespace mozilla::dom;"),
|
|
defineOnly=True),
|
|
traitsClasses, curr],
|
|
"\n")
|
|
|
|
# Add header includes.
|
|
curr = CGHeaders(descriptors,
|
|
['mozilla/dom/BindingUtils.h',
|
|
'mozilla/dom/DOMJSClass.h'],
|
|
['mozilla/dom/Nullable.h',
|
|
'XPCQuickStubs.h',
|
|
'AccessCheck.h',
|
|
'WorkerPrivate.h',
|
|
'nsContentUtils.h'],
|
|
curr)
|
|
|
|
# Add include guards.
|
|
curr = CGIncludeGuard(prefix, curr)
|
|
|
|
# Add the auto-generated comment.
|
|
curr = CGWrapper(curr, pre=AUTOGENERATED_WARNING_COMMENT)
|
|
|
|
# Store the final result.
|
|
self.root = curr
|
|
|
|
def declare(self):
|
|
return stripTrailingWhitespace(self.root.declare())
|
|
def define(self):
|
|
return stripTrailingWhitespace(self.root.define())
|
|
|
|
|
|
class GlobalGenRoots():
|
|
"""
|
|
Roots for global codegen.
|
|
|
|
To generate code, call the method associated with the target, and then
|
|
call the appropriate define/declare method.
|
|
"""
|
|
|
|
@staticmethod
|
|
def PrototypeList(config):
|
|
|
|
# Prototype ID enum.
|
|
protos = [d.name for d in config.getDescriptors(hasInterfacePrototypeObject=True)]
|
|
idEnum = CGNamespacedEnum('id', 'ID', protos, [0])
|
|
idEnum = CGList([idEnum])
|
|
idEnum.append(CGGeneric(declare="const unsigned MaxProtoChainLength = " +
|
|
str(config.maxProtoChainLength) + ";\n\n"))
|
|
|
|
# Wrap all of that in our namespaces.
|
|
idEnum = CGNamespace.build(['mozilla', 'dom', 'prototypes'],
|
|
CGWrapper(idEnum, pre='\n'))
|
|
idEnum = CGWrapper(idEnum, post='\n')
|
|
|
|
curr = CGList([idEnum])
|
|
|
|
# Constructor ID enum.
|
|
constructors = [d.name for d in config.getDescriptors(hasInterfaceObject=True,
|
|
hasInterfacePrototypeObject=False)]
|
|
idEnum = CGNamespacedEnum('id', 'ID', constructors, [0])
|
|
|
|
# Wrap all of that in our namespaces.
|
|
idEnum = CGNamespace.build(['mozilla', 'dom', 'constructors'],
|
|
CGWrapper(idEnum, pre='\n'))
|
|
idEnum = CGWrapper(idEnum, post='\n')
|
|
|
|
curr.append(idEnum)
|
|
|
|
traitsDecl = CGGeneric(declare="""
|
|
template <prototypes::ID PrototypeID>
|
|
struct PrototypeTraits;
|
|
|
|
template <class ConcreteClass>
|
|
struct PrototypeIDMap;
|
|
""")
|
|
|
|
traitsDecl = CGNamespace.build(['mozilla', 'dom'],
|
|
CGWrapper(traitsDecl, post='\n'))
|
|
|
|
curr.append(traitsDecl)
|
|
|
|
# Add include guards.
|
|
curr = CGIncludeGuard('PrototypeList', curr)
|
|
|
|
# Add the auto-generated comment.
|
|
curr = CGWrapper(curr, pre=AUTOGENERATED_WARNING_COMMENT)
|
|
|
|
# Done.
|
|
return curr
|
|
|
|
@staticmethod
|
|
def RegisterBindings(config):
|
|
|
|
# TODO - Generate the methods we want
|
|
curr = CGRegisterProtos(config)
|
|
|
|
# Wrap all of that in our namespaces.
|
|
curr = CGNamespace.build(['mozilla', 'dom'],
|
|
CGWrapper(curr, post='\n'))
|
|
curr = CGWrapper(curr, post='\n')
|
|
|
|
# Add the includes
|
|
defineIncludes = [CGHeaders.getInterfaceFilename(desc.interface)
|
|
for desc in config.getDescriptors(hasInterfaceObject=True,
|
|
workers=False)]
|
|
defineIncludes.append('nsScriptNameSpaceManager.h')
|
|
curr = CGHeaders([], [], defineIncludes, curr)
|
|
|
|
# Add include guards.
|
|
curr = CGIncludeGuard('RegisterBindings', curr)
|
|
|
|
# Done.
|
|
return curr
|