nsresult
nsXBLProtoImplProperty::InstallMember(nsIScriptContext* aContext,
nsIContent* aBoundElement,
void* aScriptObject,
void* aTargetClassObject,
const nsCString& aClassStr)
{
NS_PRECONDITION(mIsCompiled,
"Should not be installing an uncompiled property");
JSContext* cx = aContext->GetNativeContext();
nsIDocument *ownerDoc = aBoundElement->GetOwnerDoc();
nsIScriptGlobalObject *sgo;
if (!ownerDoc || !(sgo = ownerDoc->GetScopeObject())) {
return NS_ERROR_UNEXPECTED;
}
JSObject * scriptObject = (JSObject *) aScriptObject;
NS_ASSERTION(scriptObject, "uh-oh, script Object should NOT be null or bad things will happen");
if (!scriptObject)
return NS_ERROR_FAILURE;
JSObject * targetClassObject = (JSObject *) aTargetClassObject;
JSObject * globalObject = sgo->GetGlobalJSObject();
// now we want to reevaluate our property using aContext and the script object for this window...
if ((mJSGetterObject || mJSSetterObject) && targetClassObject) {
JSObject * getter = nsnull;
JSAutoRequest ar(cx);
JSAutoEnterCompartment ac;
if (!ac.enter(cx, globalObject))
return NS_ERROR_UNEXPECTED;
if (mJSGetterObject)
if (!(getter = ::JS_CloneFunctionObject(cx, mJSGetterObject, globalObject)))
return NS_ERROR_OUT_OF_MEMORY;
JSObject * setter = nsnull;
if (mJSSetterObject)
if (!(setter = ::JS_CloneFunctionObject(cx, mJSSetterObject, globalObject)))
return NS_ERROR_OUT_OF_MEMORY;
nsDependentString name(mName);
if (!::JS_DefineUCProperty(cx, targetClassObject,
reinterpret_cast<const jschar*>(mName),
name.Length(), JSVAL_VOID,
JS_DATA_TO_FUNC_PTR(JSPropertyOp, getter),
JS_DATA_TO_FUNC_PTR(JSStrictPropertyOp, setter),
mJSAttributes))
return NS_ERROR_OUT_OF_MEMORY;
}
return NS_OK;
}
static JSBool
ReifyPropertyOps(JSContext *cx, JSObject *obj, jsval idval, jsid interned_id,
const char *name, JSPropertyOp getter, JSPropertyOp setter,
JSObject **getterobjp, JSObject **setterobjp)
{
// Generate both getter and setter and stash them in the prototype.
jsval roots[2] = { JSVAL_NULL, JSVAL_NULL };
JSAutoTempValueRooter tvr(cx, 2, roots);
uintN attrs = JSPROP_SHARED;
JSObject *getterobj;
if(getter)
{
getterobj = GeneratePropertyOp(cx, obj, idval, 0, name, getter);
if(!getterobj)
return JS_FALSE;
roots[0] = OBJECT_TO_JSVAL(getterobj);
attrs |= JSPROP_GETTER;
}
else
getterobj = nsnull;
JSObject *setterobj;
if (setter)
{
setterobj = GeneratePropertyOp(cx, obj, idval, 1, name, setter);
if(!setterobj)
return JS_FALSE;
roots[1] = OBJECT_TO_JSVAL(setterobj);
attrs |= JSPROP_SETTER;
}
else
setterobj = nsnull;
if(getterobjp)
*getterobjp = getterobj;
if(setterobjp)
*setterobjp = setterobj;
return JS_DefinePropertyById(cx, obj, interned_id, JSVAL_VOID,
JS_DATA_TO_FUNC_PTR(JSPropertyOp, getterobj),
JS_DATA_TO_FUNC_PTR(JSPropertyOp, setterobj),
attrs);
}
JSObject *
GlobalObject::initFunctionAndObjectClasses(JSContext *cx)
{
Rooted<GlobalObject*> self(cx, this);
JS_THREADSAFE_ASSERT(cx->compartment != cx->runtime->atomsCompartment);
JS_ASSERT(isNative());
/*
* Calling a function from a cleared global triggers this (yeah, I know).
* Uncomment this once bug 470510 is fixed (if that bug doesn't remove
* isCleared entirely).
*/
// JS_ASSERT(!isCleared());
/* If cx has no global object, make this the global object. */
if (!cx->globalObject)
JS_SetGlobalObject(cx, self);
RootedObject objectProto(cx);
/*
* Create |Object.prototype| first, mirroring CreateBlankProto but for the
* prototype of the created object.
*/
objectProto = NewObjectWithGivenProto(cx, &ObjectClass, NULL, self);
if (!objectProto || !objectProto->setSingletonType(cx))
return NULL;
/*
* The default 'new' type of Object.prototype is required by type inference
* to have unknown properties, to simplify handling of e.g. heterogenous
* objects in JSON and script literals.
*/
if (!objectProto->setNewTypeUnknown(cx))
return NULL;
/* Create |Function.prototype| next so we can create other functions. */
RootedFunction functionProto(cx);
{
JSObject *functionProto_ = NewObjectWithGivenProto(cx, &FunctionClass, objectProto, self);
if (!functionProto_)
return NULL;
functionProto = functionProto_->toFunction();
/*
* Bizarrely, |Function.prototype| must be an interpreted function, so
* give it the guts to be one.
*/
JSObject *proto = js_NewFunction(cx, functionProto,
NULL, 0, JSFUN_INTERPRETED, self, NULL);
if (!proto)
return NULL;
JS_ASSERT(proto == functionProto);
functionProto->flags |= JSFUN_PROTOTYPE;
const char *rawSource = "() {\n}";
size_t sourceLen = strlen(rawSource);
jschar *source = InflateString(cx, rawSource, &sourceLen);
if (!source)
return NULL;
ScriptSource *ss = cx->new_<ScriptSource>();
if (!ss) {
cx->free_(source);
return NULL;
}
ScriptSourceHolder ssh(cx->runtime, ss);
ss->setSource(source, sourceLen);
CompileOptions options(cx);
options.setNoScriptRval(true)
.setVersion(JSVERSION_DEFAULT);
Rooted<JSScript*> script(cx, JSScript::Create(cx,
/* enclosingScope = */ NullPtr(),
/* savedCallerFun = */ false,
options,
/* staticLevel = */ 0,
ss,
0,
ss->length()));
if (!script || !JSScript::fullyInitTrivial(cx, script))
return NULL;
functionProto->initScript(script);
functionProto->getType(cx)->interpretedFunction = functionProto;
script->setFunction(functionProto);
if (!functionProto->setSingletonType(cx))
return NULL;
/*
* The default 'new' type of Function.prototype is required by type
* inference to have unknown properties, to simplify handling of e.g.
* CloneFunctionObject.
*/
if (!functionProto->setNewTypeUnknown(cx))
return NULL;
}
/* Create the Object function now that we have a [[Prototype]] for it. */
RootedFunction objectCtor(cx);
{
JSObject *ctor = NewObjectWithGivenProto(cx, &FunctionClass, functionProto, self);
if (!ctor)
return NULL;
objectCtor = js_NewFunction(cx, ctor, js_Object, 1, JSFUN_CONSTRUCTOR, self,
CLASS_NAME(cx, Object));
if (!objectCtor)
return NULL;
}
/*
* Install |Object| and |Object.prototype| for the benefit of subsequent
* code that looks for them.
*/
self->setObjectClassDetails(objectCtor, objectProto);
/* Create |Function| so it and |Function.prototype| can be installed. */
RootedFunction functionCtor(cx);
{
// Note that ctor is rooted purely for the JS_ASSERT at the end
RootedObject ctor(cx, NewObjectWithGivenProto(cx, &FunctionClass, functionProto, self));
if (!ctor)
return NULL;
functionCtor = js_NewFunction(cx, ctor, Function, 1, JSFUN_CONSTRUCTOR, self,
CLASS_NAME(cx, Function));
if (!functionCtor)
return NULL;
JS_ASSERT(ctor == functionCtor);
}
/*
* Install |Function| and |Function.prototype| so that we can freely create
* functions and objects without special effort.
*/
self->setFunctionClassDetails(functionCtor, functionProto);
/*
* The hard part's done: now go back and add all the properties these
* primordial values have.
*/
if (!LinkConstructorAndPrototype(cx, objectCtor, objectProto) ||
!DefinePropertiesAndBrand(cx, objectProto, NULL, object_methods))
{
return NULL;
}
/*
* Add an Object.prototype.__proto__ accessor property to implement that
* extension (if it's actually enabled). Cache the getter for this
* function so that cross-compartment [[Prototype]]-getting is implemented
* in one place.
*/
Rooted<JSFunction*> getter(cx, js_NewFunction(cx, NULL, ProtoGetter, 0, 0, self, NULL));
if (!getter)
return NULL;
#if JS_HAS_OBJ_PROTO_PROP
Rooted<JSFunction*> setter(cx, js_NewFunction(cx, NULL, ProtoSetter, 0, 0, self, NULL));
if (!setter)
return NULL;
RootedValue undefinedValue(cx, UndefinedValue());
if (!objectProto->defineProperty(cx, cx->runtime->atomState.protoAtom, undefinedValue,
JS_DATA_TO_FUNC_PTR(PropertyOp, getter.get()),
JS_DATA_TO_FUNC_PTR(StrictPropertyOp, setter.get()),
JSPROP_GETTER | JSPROP_SETTER | JSPROP_SHARED))
{
return NULL;
}
#endif /* JS_HAS_OBJ_PROTO_PROP */
self->setProtoGetter(getter);
if (!DefinePropertiesAndBrand(cx, objectCtor, NULL, object_static_methods) ||
!LinkConstructorAndPrototype(cx, functionCtor, functionProto) ||
!DefinePropertiesAndBrand(cx, functionProto, NULL, function_methods) ||
!DefinePropertiesAndBrand(cx, functionCtor, NULL, NULL))
{
return NULL;
}
/* Add the global Function and Object properties now. */
jsid objectId = NameToId(CLASS_NAME(cx, Object));
if (!self->addDataProperty(cx, objectId, JSProto_Object + JSProto_LIMIT * 2, 0))
return NULL;
jsid functionId = NameToId(CLASS_NAME(cx, Function));
if (!self->addDataProperty(cx, functionId, JSProto_Function + JSProto_LIMIT * 2, 0))
return NULL;
/* Heavy lifting done, but lingering tasks remain. */
/* ES5 15.1.2.1. */
RootedId id(cx, NameToId(cx->runtime->atomState.evalAtom));
JSObject *evalobj = js_DefineFunction(cx, self, id, IndirectEval, 1, JSFUN_STUB_GSOPS);
if (!evalobj)
return NULL;
self->setOriginalEval(evalobj);
/* ES5 13.2.3: Construct the unique [[ThrowTypeError]] function object. */
RootedFunction throwTypeError(cx, js_NewFunction(cx, NULL, ThrowTypeError, 0, 0, self, NULL));
if (!throwTypeError)
return NULL;
if (!throwTypeError->preventExtensions(cx))
return NULL;
self->setThrowTypeError(throwTypeError);
RootedObject intrinsicsHolder(cx, JS_NewObject(cx, NULL, NULL, self));
if (!intrinsicsHolder)
return NULL;
self->setIntrinsicsHolder(intrinsicsHolder);
if (!JS_DefineFunctions(cx, intrinsicsHolder, intrinsic_functions))
return NULL;
/*
* The global object should have |Object.prototype| as its [[Prototype]].
* Eventually we'd like to have standard classes be there from the start,
* and thus we would know we were always setting what had previously been a
* null [[Prototype]], but right now some code assumes it can set the
* [[Prototype]] before standard classes have been initialized. For now,
* only set the [[Prototype]] if it hasn't already been set.
*/
if (self->shouldSplicePrototype(cx) && !self->splicePrototype(cx, objectProto))
return NULL;
/*
* Notify any debuggers about the creation of the script for
* |Function.prototype| -- after all initialization, for simplicity.
*/
js_CallNewScriptHook(cx, functionProto->script(), functionProto);
return functionProto;
}
