Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-03 04:30:10 +01:00
Code Issues Projects Releases Packages Wiki Activity

Describe non-callback interface objects with JSClass structures

Browse source 
JS_NewFunction doesn't allow us to set the prototype of the interface objects.
This commit is contained in:
Anthony Ramine 2016-01-04 16:16:34 +01:00
parent 2957a56ad3
commit e1d3e4df2a
2 changed files with 221 additions and 52 deletions
Download patch file Download diff file Expand all files Collapse all files

96
components/script/dom/bindings/codegen/CodegenRust.py
View file

@ -1861,33 +1861,25 @@ static PrototypeClass: JSClass = JSClass {
class CGInterfaceObjectJSClass(CGThing):
def __init__(self, descriptor):
assert descriptor.interface.hasInterfaceObject() and not descriptor.interface.isCallback()
CGThing.__init__(self)
self.descriptor = descriptor
def define(self):
if True:
return ""
ctorname = "0 as *const u8" if not self.descriptor.interface.ctor() else CONSTRUCT_HOOK_NAME
hasinstance = HASINSTANCE_HOOK_NAME
if self.descriptor.interface.ctor():
constructor = CONSTRUCT_HOOK_NAME
else:
constructor = "throwing_constructor"
args = {
"constructor": constructor,
"hasInstance": HASINSTANCE_HOOK_NAME,
"name": self.descriptor.interface.identifier.name,
}
return """\
const InterfaceObjectClass: JSClass = {
%s, 0,
JS_PropertyStub,
JS_PropertyStub,
JS_PropertyStub,
JS_StrictPropertyStub,
JS_EnumerateStub,
JS_ResolveStub,
JS_ConvertStub,
0 as *const u8,
0 as *const u8,
%s,
%s,
%s,
0 as *const u8,
JSCLASS_NO_INTERNAL_MEMBERS
};
""" % (str_to_const_array("Function"), ctorname, hasinstance, ctorname)
static InterfaceObjectClass: NonCallbackInterfaceObjectClass =
NonCallbackInterfaceObjectClass::new(%(constructor)s, %(hasInstance)s,
fun_to_string);
""" % args
class CGList(CGThing):
@ -2420,12 +2412,14 @@ assert!(!rval.ptr.is_null());""" % properties))
else:
properties["constructor"] = "throwing_constructor"
properties["length"] = 0
code.append(CGGeneric("""\
code.append(CGGeneric("""
let interface_proto = RootedObject::new(cx, JS_GetFunctionPrototype(cx, global));
assert!(!interface_proto.ptr.is_null());
create_noncallback_interface_object(cx,
receiver,
%(constructor)s,
interface_proto.handle(),
&InterfaceObjectClass,
%(static_methods)s,
%(static_attrs)s,
%(consts)s,
@ -4693,6 +4687,44 @@ let args = CallArgs::from_vp(vp, argc);
return CGList([preamble, callGenerator])
class CGClassHasInstanceHook(CGAbstractExternMethod):
def __init__(self, descriptor):
args = [Argument('*mut JSContext', 'cx'),
Argument('HandleObject', 'obj'),
Argument('MutableHandleValue', 'value'),
Argument('*mut bool', 'rval')]
assert descriptor.interface.hasInterfaceObject() and not descriptor.interface.isCallback()
CGAbstractExternMethod.__init__(self, descriptor, HASINSTANCE_HOOK_NAME,
'bool', args)
def definition_body(self):
id = "PrototypeList::ID::%s" % self.descriptor.interface.identifier.name
return CGGeneric("""\
match has_instance(cx, obj, value.handle(), %(id)s, %(index)s) {
Ok(result) => {
*rval = result;
true
}
Err(()) => false,
}
""" % {"id": id, "index": self.descriptor.prototypeDepth})
class CGClassFunToStringHook(CGAbstractExternMethod):
"""
A hook to convert functions to strings.
"""
def __init__(self, descriptor):
args = [Argument('*mut JSContext', 'cx'), Argument('HandleObject', '_obj'),
Argument('u32', '_indent')]
CGAbstractExternMethod.__init__(self, descriptor, "fun_to_string", '*mut JSString', args)
def definition_body(self):
name = self.descriptor.interface.identifier.name
string = str_to_const_array("function %s() {\\n [native code]\\n}" % name)
return CGGeneric("JS_NewStringCopyZ(cx, %s as *const _ as *const libc::c_char)" % string)
class CGClassFinalizeHook(CGAbstractClassHook):
"""
A hook for finalize, used to release our native object.
@ -4860,7 +4892,10 @@ class CGDescriptor(CGThing):
cgThings.append(CGClassConstructHook(descriptor))
for ctor in descriptor.interface.namedConstructors:
cgThings.append(CGClassConstructHook(descriptor, ctor))
cgThings.append(CGInterfaceObjectJSClass(descriptor))
if not descriptor.interface.isCallback():
cgThings.append(CGInterfaceObjectJSClass(descriptor))
cgThings.append(CGClassHasInstanceHook(descriptor))
cgThings.append(CGClassFunToStringHook(descriptor))
if not descriptor.interface.isCallback():
cgThings.append(CGPrototypeJSClass(descriptor))
@ -5258,8 +5293,8 @@ class CGBindingRoot(CGThing):
'js::jsapi::{JS_GetObjectPrototype, JS_GetProperty, JS_GetPropertyById}',
'js::jsapi::{JS_GetPropertyDescriptorById, JS_GetReservedSlot, JS_HasProperty}',
'js::jsapi::{JS_HasPropertyById, JS_InitializePropertiesFromCompatibleNativeObject}',
'js::jsapi::{JS_InternString, JS_IsExceptionPending, JS_NewObject}',
'js::jsapi::{JS_NewObjectWithGivenProto, JS_NewObjectWithoutMetadata, JS_SetProperty}',
'js::jsapi::{JS_InternString, JS_IsExceptionPending, JS_NewObject, JS_NewObjectWithGivenProto}',
'js::jsapi::{JS_NewObjectWithoutMetadata, JS_NewStringCopyZ, JS_SetProperty}',
'js::jsapi::{JS_SetPrototype, JS_SetReservedSlot, JS_WrapValue, JSAutoCompartment}',
'js::jsapi::{JSAutoRequest, JSContext, JSClass, JSFreeOp, JSFunctionSpec}',
'js::jsapi::{JSJitGetterCallArgs, JSJitInfo, JSJitMethodCallArgs, JSJitSetterCallArgs}',
@ -5279,8 +5314,9 @@ class CGBindingRoot(CGThing):
'js::rust::{GCMethods, define_methods, define_properties}',
'dom::bindings',
'dom::bindings::global::{GlobalRef, global_root_from_object, global_root_from_reflector}',
'dom::bindings::interface::{create_callback_interface_object, create_interface_prototype_object}',
'dom::bindings::interface::{create_named_constructors, create_noncallback_interface_object}',
'dom::bindings::interface::{NonCallbackInterfaceObjectClass, create_callback_interface_object}',
'dom::bindings::interface::{create_interface_prototype_object, create_named_constructors}',
'dom::bindings::interface::{create_noncallback_interface_object, has_instance}',
'dom::bindings::js::{JS, Root, RootedReference}',
'dom::bindings::js::{OptionalRootedReference}',
'dom::bindings::reflector::{Reflectable}',

177
components/script/dom/bindings/interface.rs
View file

@ -4,17 +4,109 @@
//! Machinery to initialise interface prototype objects and interface objects.
use dom::bindings::codegen::PrototypeList;
use dom::bindings::conversions::get_dom_class;
use dom::bindings::utils::{ConstantSpec, NonNullJSNative, define_constants};
use js::jsapi::{HandleObject, JSClass, JSContext, JSFunctionSpec};
use js::jsapi::{JSObject, JSPropertySpec, JS_DefineProperty1, JS_DefineProperty2};
use js::jsapi::{JS_GetFunctionObject, JS_InternString, JS_LinkConstructorAndPrototype};
use js::jsapi::{JS_NewFunction, JS_NewObject, JS_NewObjectWithUniqueType};
use js::jsapi::{MutableHandleObject, RootedObject, RootedString};
use js::glue::UncheckedUnwrapObject;
use js::jsapi::{Class, ClassExtension, ClassSpec, HandleObject, HandleValue, JSClass};
use js::jsapi::{JSContext, JSFunctionSpec, JSObject, JSPropertySpec, JSString};
use js::jsapi::{JS_DefineProperty1, JS_DefineProperty2, JS_DefineProperty4};
use js::jsapi::{JS_GetFunctionObject, JS_GetPrototype, JS_InternString};
use js::jsapi::{JS_LinkConstructorAndPrototype, JS_NewFunction, JS_NewObject};
use js::jsapi::{JS_NewObjectWithUniqueType, MutableHandleObject, MutableHandleValue};
use js::jsapi::{ObjectOps, RootedObject, RootedString, Value};
use js::rust::{define_methods, define_properties};
use js::{JSFUN_CONSTRUCTOR, JSPROP_PERMANENT, JSPROP_READONLY};
use libc;
use std::ptr;
/// A constructor class hook.
pub type ConstructorClassHook =
unsafe extern "C" fn(cx: *mut JSContext, argc: u32, vp: *mut Value) -> bool;
/// A has_instance class hook.
pub type HasInstanceClassHook =
unsafe extern "C" fn(cx: *mut JSContext,
obj: HandleObject,
vp: MutableHandleValue,
bp: *mut bool)
-> bool;
/// A fun_to_string class hook.
pub type FunToStringHook =
unsafe extern "C" fn(cx: *mut JSContext,
obj: HandleObject,
indent: u32)
-> *mut JSString;
/// The class of a non-callback interface object.
#[derive(Copy, Clone)]
pub struct NonCallbackInterfaceObjectClass {
/// The SpiderMonkey Class structure.
pub class: Class,
}
unsafe impl Sync for NonCallbackInterfaceObjectClass {}
impl NonCallbackInterfaceObjectClass {
/// Create a new `NonCallbackInterfaceObjectClass` structure.
pub const fn new(
constructor: ConstructorClassHook,
has_instance: HasInstanceClassHook,
fun_to_string: FunToStringHook)
-> NonCallbackInterfaceObjectClass {
NonCallbackInterfaceObjectClass {
class: Class {
name: b"Function\0" as *const _ as *const libc::c_char,
flags: 0,
addProperty: None,
delProperty: None,
getProperty: None,
setProperty: None,
enumerate: None,
resolve: None,
convert: None,
finalize: None,
call: Some(constructor),
hasInstance: Some(has_instance),
construct: Some(constructor),
trace: None,
spec: ClassSpec {
createConstructor: None,
createPrototype: None,
constructorFunctions: ptr::null(),
constructorProperties: ptr::null(),
prototypeFunctions: ptr::null(),
prototypeProperties: ptr::null(),
finishInit: None,
flags: 0,
},
ext: ClassExtension {
outerObject: None,
innerObject: None,
isWrappedNative: false,
weakmapKeyDelegateOp: None,
objectMovedOp: None,
},
ops: ObjectOps {
lookupProperty: None,
defineProperty: None,
hasProperty: None,
getProperty: None,
setProperty: None,
getOwnPropertyDescriptor: None,
deleteProperty: None,
watch: None,
unwatch: None,
getElements: None,
enumerate: None,
thisObject: None,
funToString: Some(fun_to_string),
}
},
}
}
}
/// Create and define the interface object of a callback interface.
pub unsafe fn create_callback_interface_object(
cx: *mut JSContext,
@ -45,31 +137,26 @@ pub unsafe fn create_interface_prototype_object(
pub unsafe fn create_noncallback_interface_object(
cx: *mut JSContext,
receiver: HandleObject,
constructor_native: NonNullJSNative,
proto: HandleObject,
class: &'static NonCallbackInterfaceObjectClass,
static_methods: Option<&'static [JSFunctionSpec]>,
static_properties: Option<&'static [JSPropertySpec]>,
constants: &'static [ConstantSpec],
interface_prototype_object: HandleObject,
name: &'static [u8],
length: u32) {
assert!(!interface_prototype_object.ptr.is_null());
let interface_object =
RootedObject::new(cx, create_constructor(cx, constructor_native, length, name));
assert!(!interface_object.ptr.is_null());
if let Some(static_methods) = static_methods {
define_methods(cx, interface_object.handle(), static_methods).unwrap();
}
if let Some(static_properties) = static_properties {
define_properties(cx, interface_object.handle(), static_properties).unwrap();
}
define_constants(cx, interface_object.handle(), constants);
let mut interface_object = RootedObject::new(cx, ptr::null_mut());
create_object(cx,
proto,
&*(class as *const _ as *const JSClass),
static_methods,
static_properties,
constants,
interface_object.handle_mut());
assert!(JS_LinkConstructorAndPrototype(cx, interface_object.handle(),
interface_prototype_object));
define_name(cx, interface_object.handle(), name);
define_length(cx, interface_object.handle(), length);
define_on_global_object(cx, receiver, name, interface_object.handle());
}
@ -99,6 +186,43 @@ pub unsafe fn create_named_constructors(
}
}
/// Return whether a value is an instance of a given prototype.
/// http://heycam.github.io/webidl/#es-interface-hasinstance
pub unsafe fn has_instance(
cx: *mut JSContext,
prototype: HandleObject,
value: HandleValue,
id: PrototypeList::ID,
index: usize)
-> Result<bool, ()> {
if !value.is_object() {
// Step 1.
return Ok(false);
}
let mut value = RootedObject::new(cx, value.to_object());
// Steps 2-3 only concern callback interface objects.
if let Ok(dom_class) = get_dom_class(UncheckedUnwrapObject(value.ptr, /* stopAtOuter = */ 0)) {
if dom_class.interface_chain[index] == id {
// Step 4.
return Ok(true);
}
}
while JS_GetPrototype(cx, value.handle(), value.handle_mut()) {
if value.ptr.is_null() {
// Step 5.2.
return Ok(false);
} else if value.ptr as *const _ == prototype.ptr {
// Step 5.3.
return Ok(true);
}
}
// JS_GetPrototype threw an exception.
Err(())
}
unsafe fn create_constructor(
cx: *mut JSContext,
constructor_native: NonNullJSNative,
@ -152,6 +276,15 @@ unsafe fn define_name(cx: *mut JSContext, obj: HandleObject, name: &'static [u8]
None, None));
}
unsafe fn define_length(cx: *mut JSContext, obj: HandleObject, length: u32) {
assert!(JS_DefineProperty4(cx,
obj,
b"length\0".as_ptr() as *const libc::c_char,
length,
JSPROP_READONLY,
None, None));
}
unsafe fn define_on_global_object(
cx: *mut JSContext,
receiver: HandleObject,