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

Implement USVString.

Browse source
This commit is contained in:
Ms2ger 2015-03-13 16:51:22 +01:00
parent 4157a2b02b
commit bbbdb98897
5 changed files with 93 additions and 2 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -717,6 +717,32 @@ def getJSToNativeConversionInfo(type, descriptorProvider, failureCode=None,
return handleOptional(conversionCode, CGGeneric(declType), default)
if type.isUSVString():
assert not isEnforceRange and not isClamp
conversionCode = (
"match FromJSValConvertible::from_jsval(cx, ${val}, ()) {\n"
" Ok(strval) => strval,\n"
" Err(_) => { %s },\n"
"}" % exceptionCode)
if defaultValue is None:
default = None
elif isinstance(defaultValue, IDLNullValue):
assert type.nullable()
default = "None"
else:
assert defaultValue.type.tag() in (IDLType.Tags.domstring, IDLType.Tags.usvstring)
default = 'USVString("%s".to_owned())' % defaultValue.value
if type.nullable():
default = "Some(%s)" % default
declType = "USVString"
if type.nullable():
declType = "Option<%s>" % declType
return handleOptional(conversionCode, CGGeneric(declType), default)
if type.isByteString():
assert not isEnforceRange and not isClamp
@ -1086,6 +1112,11 @@ def getRetvalDeclarationForType(returnType, descriptorProvider):
if returnType.nullable():
result = CGWrapper(result, pre="Option<", post=">")
return result
if returnType.isUSVString():
result = CGGeneric("USVString")
if returnType.nullable():
result = CGWrapper(result, pre="Option<", post=">")
return result
if returnType.isByteString():
result = CGGeneric("ByteString")
if returnType.nullable():
@ -4647,6 +4678,7 @@ class CGBindingRoot(CGThing):
'dom::bindings::proxyhandler::{fill_property_descriptor, get_expando_object}',
'dom::bindings::proxyhandler::{get_property_descriptor}',
'dom::bindings::str::ByteString',
'dom::bindings::str::USVString',
'libc',
'util::str::DOMString',
'std::borrow::ToOwned',

28
components/script/dom/bindings/conversions.rs
View file

@ -19,6 +19,7 @@
//! | float | `f32` |
//! | double | `f64` |
//! | DOMString | `DOMString` |
//! | USVString | `USVString` |
//! | ByteString | `ByteString` |
//! | object | `*mut JSObject` |
//! | interface types | `JSRef<T>` | `Temporary<T>` |
@ -31,7 +32,7 @@
use dom::bindings::codegen::PrototypeList;
use dom::bindings::js::{JSRef, Root, Unrooted};
use dom::bindings::str::ByteString;
use dom::bindings::str::{ByteString, USVString};
use dom::bindings::utils::{Reflectable, Reflector, DOMClass};
use util::str::DOMString;
@ -339,6 +340,31 @@ impl FromJSValConvertible for DOMString {
}
}
impl ToJSValConvertible for USVString {
fn to_jsval(&self, cx: *mut JSContext) -> JSVal {
self.0.to_jsval(cx)
}
}
impl FromJSValConvertible for USVString {
type Config = ();
fn from_jsval(cx: *mut JSContext, value: JSVal, _: ())
-> Result<USVString, ()> {
let jsstr = unsafe { JS_ValueToString(cx, value) };
if jsstr.is_null() {
debug!("JS_ValueToString failed");
Err(())
} else {
unsafe {
let mut length = 0;
let chars = JS_GetStringCharsAndLength(cx, jsstr, &mut length);
let char_vec = slice::from_raw_parts(chars, length as usize);
Ok(USVString(String::from_utf16_lossy(char_vec)))
}
}
}
}
impl ToJSValConvertible for ByteString {
fn to_jsval(&self, cx: *mut JSContext) -> JSVal {
unsafe {

4
components/script/dom/bindings/str.rs
View file

@ -157,3 +157,7 @@ impl FromStr for ByteString {
Ok(ByteString::new(s.to_owned().into_bytes()))
}
}
/// A string that is constructed from a UCS-2 buffer by replacing invalid code
/// points with the replacement character.
pub struct USVString(pub String);

16
components/script/dom/testbinding.rs
View file

@ -14,7 +14,7 @@ use dom::bindings::codegen::UnionTypes::HTMLElementOrLong;
use dom::bindings::codegen::UnionTypes::HTMLElementOrLong::eLong;
use dom::bindings::global::GlobalField;
use dom::bindings::js::{JSRef, Temporary};
use dom::bindings::str::ByteString;
use dom::bindings::str::{ByteString, USVString};
use dom::bindings::utils::{Reflector, Reflectable};
use dom::blob::Blob;
use util::str::DOMString;
@ -55,6 +55,8 @@ impl<'a> TestBindingMethods for JSRef<'a, TestBinding> {
fn SetDoubleAttribute(self, _: f64) {}
fn StringAttribute(self) -> DOMString { "".to_owned() }
fn SetStringAttribute(self, _: DOMString) {}
fn UsvstringAttribute(self) -> USVString { USVString("".to_owned()) }
fn SetUsvstringAttribute(self, _: USVString) {}
fn ByteStringAttribute(self) -> ByteString { ByteString::new(vec!()) }
fn SetByteStringAttribute(self, _: ByteString) {}
fn EnumAttribute(self) -> TestEnum { _empty }
@ -98,6 +100,8 @@ impl<'a> TestBindingMethods for JSRef<'a, TestBinding> {
fn SetByteStringAttributeNullable(self, _: Option<ByteString>) {}
fn GetStringAttributeNullable(self) -> Option<DOMString> { Some("".to_owned()) }
fn SetStringAttributeNullable(self, _: Option<DOMString>) {}
fn GetUsvstringAttributeNullable(self) -> Option<USVString> { Some(USVString("".to_owned())) }
fn SetUsvstringAttributeNullable(self, _: Option<USVString>) {}
fn SetBinaryRenamedAttribute(self, _: DOMString) {}
fn BinaryRenamedAttribute(self) -> DOMString { "".to_owned() }
fn GetEnumAttributeNullable(self) -> Option<TestEnum> { Some(_empty) }
@ -124,6 +128,7 @@ impl<'a> TestBindingMethods for JSRef<'a, TestBinding> {
fn ReceiveFloat(self) -> f32 { 0. }
fn ReceiveDouble(self) -> f64 { 0. }
fn ReceiveString(self) -> DOMString { "".to_owned() }
fn ReceiveUsvstring(self) -> USVString { USVString("".to_owned()) }
fn ReceiveByteString(self) -> ByteString { ByteString::new(vec!()) }
fn ReceiveEnum(self) -> TestEnum { _empty }
fn ReceiveInterface(self) -> Temporary<Blob> {
@ -146,6 +151,7 @@ impl<'a> TestBindingMethods for JSRef<'a, TestBinding> {
fn ReceiveNullableFloat(self) -> Option<f32> { Some(0.) }
fn ReceiveNullableDouble(self) -> Option<f64> { Some(0.) }
fn ReceiveNullableString(self) -> Option<DOMString> { Some("".to_owned()) }
fn ReceiveNullableUsvstring(self) -> Option<USVString> { Some(USVString("".to_owned())) }
fn ReceiveNullableByteString(self) -> Option<ByteString> { Some(ByteString::new(vec!())) }
fn ReceiveNullableEnum(self) -> Option<TestEnum> { Some(_empty) }
fn ReceiveNullableInterface(self) -> Option<Temporary<Blob>> {
@ -167,6 +173,7 @@ impl<'a> TestBindingMethods for JSRef<'a, TestBinding> {
fn PassFloat(self, _: f32) {}
fn PassDouble(self, _: f64) {}
fn PassString(self, _: DOMString) {}
fn PassUsvstring(self, _: USVString) {}
fn PassByteString(self, _: ByteString) {}
fn PassEnum(self, _: TestEnum) {}
fn PassInterface(self, _: JSRef<Blob>) {}
@ -189,6 +196,7 @@ impl<'a> TestBindingMethods for JSRef<'a, TestBinding> {
fn PassNullableFloat(self, _: Option<f32>) {}
fn PassNullableDouble(self, _: Option<f64>) {}
fn PassNullableString(self, _: Option<DOMString>) {}
fn PassNullableUsvstring(self, _: Option<USVString>) {}
fn PassNullableByteString(self, _: Option<ByteString>) {}
// fn PassNullableEnum(self, _: Option<TestEnum>) {}
fn PassNullableInterface(self, _: Option<JSRef<Blob>>) {}
@ -209,6 +217,7 @@ impl<'a> TestBindingMethods for JSRef<'a, TestBinding> {
fn PassOptionalFloat(self, _: Option<f32>) {}
fn PassOptionalDouble(self, _: Option<f64>) {}
fn PassOptionalString(self, _: Option<DOMString>) {}
fn PassOptionalUsvstring(self, _: Option<USVString>) {}
fn PassOptionalByteString(self, _: Option<ByteString>) {}
fn PassOptionalEnum(self, _: Option<TestEnum>) {}
fn PassOptionalInterface(self, _: Option<JSRef<Blob>>) {}
@ -230,6 +239,7 @@ impl<'a> TestBindingMethods for JSRef<'a, TestBinding> {
fn PassOptionalNullableFloat(self, _: Option<Option<f32>>) {}
fn PassOptionalNullableDouble(self, _: Option<Option<f64>>) {}
fn PassOptionalNullableString(self, _: Option<Option<DOMString>>) {}
fn PassOptionalNullableUsvstring(self, _: Option<Option<USVString>>) {}
fn PassOptionalNullableByteString(self, _: Option<Option<ByteString>>) {}
// fn PassOptionalNullableEnum(self, _: Option<Option<TestEnum>>) {}
fn PassOptionalNullableInterface(self, _: Option<Option<JSRef<Blob>>>) {}
@ -248,6 +258,7 @@ impl<'a> TestBindingMethods for JSRef<'a, TestBinding> {
fn PassOptionalLongLongWithDefault(self, _: i64) {}
fn PassOptionalUnsignedLongLongWithDefault(self, _: u64) {}
fn PassOptionalStringWithDefault(self, _: DOMString) {}
fn PassOptionalUsvstringWithDefault(self, _: USVString) {}
fn PassOptionalEnumWithDefault(self, _: TestEnum) {}
fn PassOptionalNullableBooleanWithDefault(self, _: Option<bool>) {}
@ -262,6 +273,7 @@ impl<'a> TestBindingMethods for JSRef<'a, TestBinding> {
// fn PassOptionalNullableFloatWithDefault(self, _: Option<f32>) {}
// fn PassOptionalNullableDoubleWithDefault(self, _: Option<f64>) {}
fn PassOptionalNullableStringWithDefault(self, _: Option<DOMString>) {}
fn PassOptionalNullableUsvstringWithDefault(self, _: Option<USVString>) {}
fn PassOptionalNullableByteStringWithDefault(self, _: Option<ByteString>) {}
// fn PassOptionalNullableEnumWithDefault(self, _: Option<TestEnum>) {}
fn PassOptionalNullableInterfaceWithDefault(self, _: Option<JSRef<Blob>>) {}
@ -283,6 +295,7 @@ impl<'a> TestBindingMethods for JSRef<'a, TestBinding> {
// fn PassOptionalNullableFloatWithNonNullDefault(self, _: Option<f32>) {}
// fn PassOptionalNullableDoubleWithNonNullDefault(self, _: Option<f64>) {}
fn PassOptionalNullableStringWithNonNullDefault(self, _: Option<DOMString>) {}
fn PassOptionalNullableUsvstringWithNonNullDefault(self, _: Option<USVString>) {}
// fn PassOptionalNullableEnumWithNonNullDefault(self, _: Option<TestEnum>) {}
fn PassVariadicBoolean(self, _: Vec<bool>) {}
@ -297,6 +310,7 @@ impl<'a> TestBindingMethods for JSRef<'a, TestBinding> {
fn PassVariadicFloat(self, _: Vec<f32>) {}
fn PassVariadicDouble(self, _: Vec<f64>) {}
fn PassVariadicString(self, _: Vec<DOMString>) {}
fn PassVariadicUsvstring(self, _: Vec<USVString>) {}
fn PassVariadicByteString(self, _: Vec<ByteString>) {}
fn PassVariadicEnum(self, _: Vec<TestEnum>) {}
// fn PassVariadicInterface(self, _: Vec<JSRef<Blob>>) {}

15
components/script/dom/webidls/TestBinding.webidl
View file

@ -17,6 +17,7 @@ dictionary TestDictionary {
float floatValue;
double doubleValue;
DOMString stringValue;
USVString usvstringValue;
TestEnum enumValue;
Blob interfaceValue;
any anyValue;
@ -35,6 +36,7 @@ dictionary TestDictionaryDefaults {
// float floatValue = 7.0;
// double doubleValue = 7.0;
DOMString stringValue = "foo";
USVString usvstringValue = "foo";
TestEnum enumValue = "bar";
any anyValue = null;
@ -50,6 +52,7 @@ dictionary TestDictionaryDefaults {
// float? nullableFloatValue = 7.0;
// double? nullableDoubleValue = 7.0;
DOMString? nullableStringValue = "foo";
USVString? nullableUsvstringValue = "foo";
// TestEnum? nullableEnumValue = "bar";
};
@ -66,6 +69,7 @@ interface TestBinding {
attribute float floatAttribute;
attribute double doubleAttribute;
attribute DOMString stringAttribute;
attribute USVString usvstringAttribute;
attribute ByteString byteStringAttribute;
attribute TestEnum enumAttribute;
attribute Blob interfaceAttribute;
@ -86,6 +90,7 @@ interface TestBinding {
attribute float? floatAttributeNullable;
attribute double? doubleAttributeNullable;
attribute DOMString? stringAttributeNullable;
attribute USVString? usvstringAttributeNullable;
attribute ByteString? byteStringAttributeNullable;
readonly attribute TestEnum? enumAttributeNullable;
attribute Blob? interfaceAttributeNullable;
@ -107,6 +112,7 @@ interface TestBinding {
float receiveFloat();
double receiveDouble();
DOMString receiveString();
USVString receiveUsvstring();
ByteString receiveByteString();
TestEnum receiveEnum();
Blob receiveInterface();
@ -126,6 +132,7 @@ interface TestBinding {
float? receiveNullableFloat();
double? receiveNullableDouble();
DOMString? receiveNullableString();
USVString? receiveNullableUsvstring();
ByteString? receiveNullableByteString();
TestEnum? receiveNullableEnum();
Blob? receiveNullableInterface();
@ -144,6 +151,7 @@ interface TestBinding {
void passFloat(float arg);
void passDouble(double arg);
void passString(DOMString arg);
void passUsvstring(USVString arg);
void passByteString(ByteString arg);
void passEnum(TestEnum arg);
void passInterface(Blob arg);
@ -166,6 +174,7 @@ interface TestBinding {
void passNullableFloat(float? arg);
void passNullableDouble(double? arg);
void passNullableString(DOMString? arg);
void passNullableUsvstring(USVString? arg);
void passNullableByteString(ByteString? arg);
// void passNullableEnum(TestEnum? arg);
void passNullableInterface(Blob? arg);
@ -186,6 +195,7 @@ interface TestBinding {
void passOptionalFloat(optional float arg);
void passOptionalDouble(optional double arg);
void passOptionalString(optional DOMString arg);
void passOptionalUsvstring(optional USVString arg);
void passOptionalByteString(optional ByteString arg);
void passOptionalEnum(optional TestEnum arg);
void passOptionalInterface(optional Blob arg);
@ -207,6 +217,7 @@ interface TestBinding {
void passOptionalNullableFloat(optional float? arg);
void passOptionalNullableDouble(optional double? arg);
void passOptionalNullableString(optional DOMString? arg);
void passOptionalNullableUsvstring(optional USVString? arg);
void passOptionalNullableByteString(optional ByteString? arg);
// void passOptionalNullableEnum(optional TestEnum? arg);
void passOptionalNullableInterface(optional Blob? arg);
@ -225,6 +236,7 @@ interface TestBinding {
void passOptionalLongLongWithDefault(optional long long arg = -12);
void passOptionalUnsignedLongLongWithDefault(optional unsigned long long arg = 17);
void passOptionalStringWithDefault(optional DOMString arg = "x");
void passOptionalUsvstringWithDefault(optional USVString arg = "x");
void passOptionalEnumWithDefault(optional TestEnum arg = "foo");
// void passOptionalUnionWithDefault(optional (HTMLElement or long) arg = 9);
// void passOptionalUnion2WithDefault(optional(Event or DOMString)? data = "foo");
@ -239,6 +251,7 @@ interface TestBinding {
void passOptionalNullableLongLongWithDefault(optional long long? arg = null);
void passOptionalNullableUnsignedLongLongWithDefault(optional unsigned long long? arg = null);
void passOptionalNullableStringWithDefault(optional DOMString? arg = null);
void passOptionalNullableUsvstringWithDefault(optional USVString? arg = null);
void passOptionalNullableByteStringWithDefault(optional ByteString? arg = null);
// void passOptionalNullableEnumWithDefault(optional TestEnum? arg = null);
void passOptionalNullableInterfaceWithDefault(optional Blob? arg = null);
@ -260,6 +273,7 @@ interface TestBinding {
// void passOptionalNullableFloatWithNonNullDefault(optional float? arg = 0.0);
// void passOptionalNullableDoubleWithNonNullDefault(optional double? arg = 0.0);
void passOptionalNullableStringWithNonNullDefault(optional DOMString? arg = "x");
void passOptionalNullableUsvstringWithNonNullDefault(optional USVString? arg = "x");
// void passOptionalNullableEnumWithNonNullDefault(optional TestEnum? arg = "foo");
// void passOptionalNullableUnionWithNonNullDefault(optional (HTMLElement or long)? arg = 7);
// void passOptionalNullableUnion2WithNonNullDefault(optional (Event or DOMString)? data = "foo");
@ -276,6 +290,7 @@ interface TestBinding {
void passVariadicFloat(float... args);
void passVariadicDouble(double... args);
void passVariadicString(DOMString... args);
void passVariadicUsvstring(USVString... args);
void passVariadicByteString(ByteString... args);
void passVariadicEnum(TestEnum... args);
// void passVariadicInterface(Blob... args);