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

Untry style

Browse source
This commit is contained in:
Simon Sapin 2017-06-18 12:40:03 +02:00
parent 4c5f7bfaa3
commit a5bb55790f
45 changed files with 518 additions and 527 deletions
Download patch file Download diff file Expand all files Collapse all files

12
components/style/properties/declaration_block.rs
View file

@ -840,10 +840,10 @@ pub fn append_serialization<'a, W, I, N>(dest: &mut W,
I: Iterator<Item=&'a PropertyDeclaration>,
N: ToCss,
{
try!(handle_first_serialization(dest, is_first_serialization));
handle_first_serialization(dest, is_first_serialization)?;
try!(property_name.to_css(dest));
try!(dest.write_char(':'));
property_name.to_css(dest)?;
dest.write_char(':')?;
// for normal parsed values, add a space between key: and value
match appendable_value {
@ -863,10 +863,10 @@ pub fn append_serialization<'a, W, I, N>(dest: &mut W,
AppendableValue::DeclarationsForShorthand(..) => unreachable!(),
}
try!(append_declaration_value(dest, appendable_value));
append_declaration_value(dest, appendable_value)?;
if importance.important() {
try!(dest.write_str(" !important"));
dest.write_str(" !important")?;
}
dest.write_char(';')
@ -934,7 +934,7 @@ impl<'a, 'b, 'i> DeclarationParser<'i> for PropertyDeclarationParser<'a, 'b> {
fn parse_value<'t>(&mut self, name: CompactCowStr<'i>, input: &mut Parser<'i, 't>)
-> Result<Importance, ParseError<'i>> {
let id = try!(PropertyId::parse(name));
let id = PropertyId::parse(name)?;
input.parse_until_before(Delimiter::Bang, |input| {
PropertyDeclaration::parse_into(self.declarations, id, self.context, input)
.map_err(|e| e.into())

24
components/style/properties/helpers.mako.rs
View file

@ -158,17 +158,17 @@
{
let mut iter = self.0.iter();
if let Some(val) = iter.next() {
try!(val.to_css(dest));
val.to_css(dest)?;
} else {
% if allow_empty:
try!(dest.write_str("none"));
dest.write_str("none")?;
% else:
warn!("Found empty value for property ${name}");
% endif
}
for i in iter {
try!(dest.write_str(", "));
try!(i.to_css(dest));
dest.write_str(", ")?;
i.to_css(dest)?;
}
Ok(())
}
@ -185,17 +185,17 @@
{
let mut iter = self.0.iter();
if let Some(val) = iter.next() {
try!(val.to_css(dest));
val.to_css(dest)?;
} else {
% if allow_empty:
try!(dest.write_str("none"));
dest.write_str("none")?;
% else:
warn!("Found empty value for property ${name}");
% endif
}
for i in iter {
try!(dest.write_str(", "));
try!(i.to_css(dest));
dest.write_str(", ")?;
i.to_css(dest)?;
}
Ok(())
}
@ -462,8 +462,8 @@
let var = input.seen_var_functions();
if specified.is_err() && var {
input.reset(start);
let (first_token_type, css) = try!(
::custom_properties::parse_non_custom_with_var(input));
let (first_token_type, css) =
::custom_properties::parse_non_custom_with_var(input)?;
return Ok(PropertyDeclaration::WithVariables(LonghandId::${property.camel_case},
Arc::new(UnparsedValue {
css: css.into_owned(),
@ -876,8 +876,8 @@
Ok(())
} else if var {
input.reset(start);
let (first_token_type, css) = try!(
::custom_properties::parse_non_custom_with_var(input));
let (first_token_type, css) =
::custom_properties::parse_non_custom_with_var(input)?;
let unparsed = Arc::new(UnparsedValue {
css: css.into_owned(),
first_token_type: first_token_type,

169
components/style/properties/helpers/animated_properties.mako.rs
View file

@ -223,7 +223,7 @@ impl TransitionProperty {
/// Parse a transition-property value.
pub fn parse<'i, 't>(input: &mut Parser<'i, 't>) -> Result<Self, ParseError<'i>> {
let ident = try!(input.expect_ident());
let ident = input.expect_ident()?;
let supported = match_ignore_ascii_case! { &ident,
"all" => Ok(Some(TransitionProperty::All)),
% for prop in data.longhands + data.shorthands_except_all():
@ -986,8 +986,8 @@ impl Animatable for Visibility {
impl<T: Animatable + Copy> Animatable for Size2D<T> {
#[inline]
fn add_weighted(&self, other: &Self, self_portion: f64, other_portion: f64) -> Result<Self, ()> {
let width = try!(self.width.add_weighted(&other.width, self_portion, other_portion));
let height = try!(self.height.add_weighted(&other.height, self_portion, other_portion));
let width = self.width.add_weighted(&other.width, self_portion, other_portion)?;
let height = self.height.add_weighted(&other.height, self_portion, other_portion)?;
Ok(Size2D::new(width, height))
}
@ -996,8 +996,8 @@ impl<T: Animatable + Copy> Animatable for Size2D<T> {
impl<T: Animatable + Copy> Animatable for Point2D<T> {
#[inline]
fn add_weighted(&self, other: &Self, self_portion: f64, other_portion: f64) -> Result<Self, ()> {
let x = try!(self.x.add_weighted(&other.x, self_portion, other_portion));
let y = try!(self.y.add_weighted(&other.y, self_portion, other_portion));
let x = self.x.add_weighted(&other.x, self_portion, other_portion)?;
let y = self.y.add_weighted(&other.y, self_portion, other_portion)?;
Ok(Point2D::new(x, y))
}
@ -1016,8 +1016,8 @@ impl Animatable for BorderCornerRadius {
#[inline]
fn compute_squared_distance(&self, other: &Self) -> Result<f64, ()> {
Ok(try!(self.0.width.compute_squared_distance(&other.0.width)) +
try!(self.0.height.compute_squared_distance(&other.0.height)))
Ok(self.0.width.compute_squared_distance(&other.0.width)? +
self.0.height.compute_squared_distance(&other.0.height)?)
}
}
@ -1487,10 +1487,8 @@ impl<H: Animatable, V: Animatable> Animatable for generic_position::Position<H,
#[inline]
fn add_weighted(&self, other: &Self, self_portion: f64, other_portion: f64) -> Result<Self, ()> {
Ok(generic_position::Position {
horizontal: try!(self.horizontal.add_weighted(&other.horizontal,
self_portion, other_portion)),
vertical: try!(self.vertical.add_weighted(&other.vertical,
self_portion, other_portion)),
horizontal: self.horizontal.add_weighted(&other.horizontal, self_portion, other_portion)?,
vertical: self.vertical.add_weighted(&other.vertical, self_portion, other_portion)?,
})
}
@ -1509,8 +1507,8 @@ impl<H: Animatable, V: Animatable> Animatable for generic_position::Position<H,
#[inline]
fn compute_squared_distance(&self, other: &Self) -> Result<f64, ()> {
Ok(try!(self.horizontal.compute_squared_distance(&other.horizontal)) +
try!(self.vertical.compute_squared_distance(&other.vertical)))
Ok(self.horizontal.compute_squared_distance(&other.horizontal)? +
self.vertical.compute_squared_distance(&other.vertical)?)
}
}
@ -1523,10 +1521,10 @@ impl Animatable for ClipRect {
fn add_weighted(&self, other: &Self, self_portion: f64, other_portion: f64)
-> Result<Self, ()> {
Ok(ClipRect {
top: try!(self.top.add_weighted(&other.top, self_portion, other_portion)),
right: try!(self.right.add_weighted(&other.right, self_portion, other_portion)),
bottom: try!(self.bottom.add_weighted(&other.bottom, self_portion, other_portion)),
left: try!(self.left.add_weighted(&other.left, self_portion, other_portion)),
top: self.top.add_weighted(&other.top, self_portion, other_portion)?,
right: self.right.add_weighted(&other.right, self_portion, other_portion)?,
bottom: self.bottom.add_weighted(&other.bottom, self_portion, other_portion)?,
left: self.left.add_weighted(&other.left, self_portion, other_portion)?,
})
}
@ -1537,10 +1535,12 @@ impl Animatable for ClipRect {
#[inline]
fn compute_squared_distance(&self, other: &Self) -> Result<f64, ()> {
let list = [ try!(self.top.compute_distance(&other.top)),
try!(self.right.compute_distance(&other.right)),
try!(self.bottom.compute_distance(&other.bottom)),
try!(self.left.compute_distance(&other.left)) ];
let list = [
self.top.compute_distance(&other.top)?,
self.right.compute_distance(&other.right)?,
self.bottom.compute_distance(&other.bottom)?,
self.left.compute_distance(&other.left)?
];
Ok(list.iter().fold(0.0f64, |sum, diff| sum + diff * diff))
}
}
@ -1630,9 +1630,9 @@ fn add_weighted_with_initial_val<T: Animatable>(a: &T,
a_portion: f64,
b_portion: f64,
initial_val: &T) -> Result<T, ()> {
let a = try!(a.add_weighted(&initial_val, 1.0, -1.0));
let b = try!(b.add_weighted(&initial_val, 1.0, -1.0));
let result = try!(a.add_weighted(&b, a_portion, b_portion));
let a = a.add_weighted(&initial_val, 1.0, -1.0)?;
let b = b.add_weighted(&initial_val, 1.0, -1.0)?;
let result = a.add_weighted(&b, a_portion, b_portion)?;
result.add_weighted(&initial_val, 1.0, 1.0)
}
@ -1793,12 +1793,12 @@ pub struct MatrixDecomposed2D {
impl Animatable for InnerMatrix2D {
fn add_weighted(&self, other: &Self, self_portion: f64, other_portion: f64) -> Result<Self, ()> {
Ok(InnerMatrix2D {
m11: try!(add_weighted_with_initial_val(&self.m11, &other.m11,
self_portion, other_portion, &1.0)),
m12: try!(self.m12.add_weighted(&other.m12, self_portion, other_portion)),
m21: try!(self.m21.add_weighted(&other.m21, self_portion, other_portion)),
m22: try!(add_weighted_with_initial_val(&self.m22, &other.m22,
self_portion, other_portion, &1.0)),
m11: add_weighted_with_initial_val(&self.m11, &other.m11,
self_portion, other_portion, &1.0)?,
m12: self.m12.add_weighted(&other.m12, self_portion, other_portion)?,
m21: self.m21.add_weighted(&other.m21, self_portion, other_portion)?,
m22: add_weighted_with_initial_val(&self.m22, &other.m22,
self_portion, other_portion, &1.0)?,
})
}
}
@ -1806,8 +1806,8 @@ impl Animatable for InnerMatrix2D {
impl Animatable for Translate2D {
fn add_weighted(&self, other: &Self, self_portion: f64, other_portion: f64) -> Result<Self, ()> {
Ok(Translate2D(
try!(self.0.add_weighted(&other.0, self_portion, other_portion)),
try!(self.1.add_weighted(&other.1, self_portion, other_portion))
self.0.add_weighted(&other.0, self_portion, other_portion)?,
self.1.add_weighted(&other.1, self_portion, other_portion)?,
))
}
}
@ -1815,8 +1815,8 @@ impl Animatable for Translate2D {
impl Animatable for Scale2D {
fn add_weighted(&self, other: &Self, self_portion: f64, other_portion: f64) -> Result<Self, ()> {
Ok(Scale2D(
try!(add_weighted_with_initial_val(&self.0, &other.0, self_portion, other_portion, &1.0)),
try!(add_weighted_with_initial_val(&self.1, &other.1, self_portion, other_portion, &1.0))
add_weighted_with_initial_val(&self.0, &other.0, self_portion, other_portion, &1.0)?,
add_weighted_with_initial_val(&self.1, &other.1, self_portion, other_portion, &1.0)?,
))
}
}
@ -1853,11 +1853,10 @@ impl Animatable for MatrixDecomposed2D {
}
// Interpolate all values.
let translate = try!(self.translate.add_weighted(&other.translate,
self_portion, other_portion));
let scale = try!(scale.add_weighted(&other.scale, self_portion, other_portion));
let angle = try!(angle.add_weighted(&other_angle, self_portion, other_portion));
let matrix = try!(self.matrix.add_weighted(&other.matrix, self_portion, other_portion));
let translate = self.translate.add_weighted(&other.translate, self_portion, other_portion)?;
let scale = scale.add_weighted(&other.scale, self_portion, other_portion)?;
let angle = angle.add_weighted(&other_angle, self_portion, other_portion)?;
let matrix = self.matrix.add_weighted(&other.matrix, self_portion, other_portion)?;
Ok(MatrixDecomposed2D {
translate: translate,
@ -1875,7 +1874,7 @@ impl Animatable for ComputedMatrix {
let decomposed_to = decompose_3d_matrix(*other);
match (decomposed_from, decomposed_to) {
(Ok(from), Ok(to)) => {
let sum = try!(from.add_weighted(&to, self_portion, other_portion));
let sum = from.add_weighted(&to, self_portion, other_portion)?;
Ok(ComputedMatrix::from(sum))
},
_ => {
@ -1886,8 +1885,7 @@ impl Animatable for ComputedMatrix {
} else {
let decomposed_from = MatrixDecomposed2D::from(*self);
let decomposed_to = MatrixDecomposed2D::from(*other);
let sum = try!(decomposed_from.add_weighted(&decomposed_to,
self_portion, other_portion));
let sum = decomposed_from.add_weighted(&decomposed_to, self_portion, other_portion)?;
Ok(ComputedMatrix::from(sum))
}
}
@ -2228,9 +2226,9 @@ fn cross(row1: [f32; 3], row2: [f32; 3]) -> [f32; 3] {
impl Animatable for Translate3D {
fn add_weighted(&self, other: &Self, self_portion: f64, other_portion: f64) -> Result<Self, ()> {
Ok(Translate3D(
try!(self.0.add_weighted(&other.0, self_portion, other_portion)),
try!(self.1.add_weighted(&other.1, self_portion, other_portion)),
try!(self.2.add_weighted(&other.2, self_portion, other_portion))
self.0.add_weighted(&other.0, self_portion, other_portion)?,
self.1.add_weighted(&other.1, self_portion, other_portion)?,
self.2.add_weighted(&other.2, self_portion, other_portion)?,
))
}
}
@ -2238,9 +2236,9 @@ impl Animatable for Translate3D {
impl Animatable for Scale3D {
fn add_weighted(&self, other: &Self, self_portion: f64, other_portion: f64) -> Result<Self, ()> {
Ok(Scale3D(
try!(add_weighted_with_initial_val(&self.0, &other.0, self_portion, other_portion, &1.0)),
try!(add_weighted_with_initial_val(&self.1, &other.1, self_portion, other_portion, &1.0)),
try!(add_weighted_with_initial_val(&self.2, &other.2, self_portion, other_portion, &1.0))
add_weighted_with_initial_val(&self.0, &other.0, self_portion, other_portion, &1.0)?,
add_weighted_with_initial_val(&self.1, &other.1, self_portion, other_portion, &1.0)?,
add_weighted_with_initial_val(&self.2, &other.2, self_portion, other_portion, &1.0)?,
))
}
}
@ -2248,9 +2246,9 @@ impl Animatable for Scale3D {
impl Animatable for Skew {
fn add_weighted(&self, other: &Self, self_portion: f64, other_portion: f64) -> Result<Self, ()> {
Ok(Skew(
try!(self.0.add_weighted(&other.0, self_portion, other_portion)),
try!(self.1.add_weighted(&other.1, self_portion, other_portion)),
try!(self.2.add_weighted(&other.2, self_portion, other_portion))
self.0.add_weighted(&other.0, self_portion, other_portion)?,
self.1.add_weighted(&other.1, self_portion, other_portion)?,
self.2.add_weighted(&other.2, self_portion, other_portion)?,
))
}
}
@ -2258,10 +2256,10 @@ impl Animatable for Skew {
impl Animatable for Perspective {
fn add_weighted(&self, other: &Self, self_portion: f64, other_portion: f64) -> Result<Self, ()> {
Ok(Perspective(
try!(self.0.add_weighted(&other.0, self_portion, other_portion)),
try!(self.1.add_weighted(&other.1, self_portion, other_portion)),
try!(self.2.add_weighted(&other.2, self_portion, other_portion)),
try!(add_weighted_with_initial_val(&self.3, &other.3, self_portion, other_portion, &1.0))
self.0.add_weighted(&other.0, self_portion, other_portion)?,
self.1.add_weighted(&other.1, self_portion, other_portion)?,
self.2.add_weighted(&other.2, self_portion, other_portion)?,
add_weighted_with_initial_val(&self.3, &other.3, self_portion, other_portion, &1.0)?,
))
}
}
@ -2277,12 +2275,10 @@ impl Animatable for MatrixDecomposed3D {
let mut sum = *self;
// Add translate, scale, skew and perspective components.
sum.translate = try!(self.translate.add_weighted(&other.translate,
self_portion, other_portion));
sum.scale = try!(self.scale.add_weighted(&other.scale, self_portion, other_portion));
sum.skew = try!(self.skew.add_weighted(&other.skew, self_portion, other_portion));
sum.perspective = try!(self.perspective.add_weighted(&other.perspective,
self_portion, other_portion));
sum.translate = self.translate.add_weighted(&other.translate, self_portion, other_portion)?;
sum.scale = self.scale.add_weighted(&other.scale, self_portion, other_portion)?;
sum.skew = self.skew.add_weighted(&other.skew, self_portion, other_portion)?;
sum.perspective = self.perspective.add_weighted(&other.perspective, self_portion, other_portion)?;
// Add quaternions using spherical linear interpolation (Slerp).
//
@ -2734,25 +2730,22 @@ impl Animatable for IntermediateRGBA {
#[inline]
fn add_weighted(&self, other: &IntermediateRGBA, self_portion: f64, other_portion: f64)
-> Result<Self, ()> {
let mut alpha = try!(self.alpha.add_weighted(&other.alpha, self_portion, other_portion));
let mut alpha = self.alpha.add_weighted(&other.alpha, self_portion, other_portion)?;
if alpha <= 0. {
// Ideally we should return color value that only alpha component is
// 0, but this is what current gecko does.
Ok(IntermediateRGBA::transparent())
} else {
alpha = alpha.min(1.);
let red = try!((self.red * self.alpha)
.add_weighted(&(other.red * other.alpha),
self_portion, other_portion))
* 1. / alpha;
let green = try!((self.green * self.alpha)
.add_weighted(&(other.green * other.alpha),
self_portion, other_portion))
* 1. / alpha;
let blue = try!((self.blue * self.alpha)
.add_weighted(&(other.blue * other.alpha),
self_portion, other_portion))
* 1. / alpha;
let red = (self.red * self.alpha).add_weighted(
&(other.red * other.alpha), self_portion, other_portion
)? * 1. / alpha;
let green = (self.green * self.alpha).add_weighted(
&(other.green * other.alpha), self_portion, other_portion
)? * 1. / alpha;
let blue = (self.blue * self.alpha).add_weighted(
&(other.blue * other.alpha), self_portion, other_portion
)? * 1. / alpha;
Ok(IntermediateRGBA::new(red, green, blue, alpha))
}
}
@ -3093,13 +3086,11 @@ impl Animatable for IntermediateShadow {
return Err(());
}
let x = try!(self.offset_x.add_weighted(&other.offset_x, self_portion, other_portion));
let y = try!(self.offset_y.add_weighted(&other.offset_y, self_portion, other_portion));
let color = try!(self.color.add_weighted(&other.color, self_portion, other_portion));
let blur = try!(self.blur_radius.add_weighted(&other.blur_radius,
self_portion, other_portion));
let spread = try!(self.spread_radius.add_weighted(&other.spread_radius,
self_portion, other_portion));
let x = self.offset_x.add_weighted(&other.offset_x, self_portion, other_portion)?;
let y = self.offset_y.add_weighted(&other.offset_y, self_portion, other_portion)?;
let color = self.color.add_weighted(&other.color, self_portion, other_portion)?;
let blur = self.blur_radius.add_weighted(&other.blur_radius, self_portion, other_portion)?;
let spread = self.spread_radius.add_weighted(&other.spread_radius, self_portion, other_portion)?;
Ok(IntermediateShadow {
offset_x: x,
@ -3121,11 +3112,12 @@ impl Animatable for IntermediateShadow {
if self.inset != other.inset {
return Err(());
}
let list = [ try!(self.offset_x.compute_distance(&other.offset_x)),
try!(self.offset_y.compute_distance(&other.offset_y)),
try!(self.blur_radius.compute_distance(&other.blur_radius)),
try!(self.color.compute_distance(&other.color)),
try!(self.spread_radius.compute_distance(&other.spread_radius)),
let list = [
self.offset_x.compute_distance(&other.offset_x)?,
self.offset_y.compute_distance(&other.offset_y)?,
self.blur_radius.compute_distance(&other.blur_radius)?,
self.color.compute_distance(&other.color)?,
self.spread_radius.compute_distance(&other.spread_radius)?,
];
Ok(list.iter().fold(0.0f64, |sum, diff| sum + diff * diff))
}
@ -3155,8 +3147,9 @@ impl Animatable for IntermediateShadowList {
for i in 0..max_len {
let shadow = match (self.0.get(i), other.0.get(i)) {
(Some(shadow), Some(other)) =>
try!(shadow.add_weighted(other, self_portion, other_portion)),
(Some(shadow), Some(other)) => {
shadow.add_weighted(other, self_portion, other_portion)?
}
(Some(shadow), None) => {
zero.inset = shadow.inset;
shadow.add_weighted(&zero, self_portion, other_portion).unwrap()

14
components/style/properties/longhand/background.mako.rs
View file

@ -66,10 +66,10 @@ ${helpers.predefined_type("background-image", "ImageLayer",
(RepeatKeyword::Repeat, RepeatKeyword::NoRepeat) => dest.write_str("repeat-x"),
(RepeatKeyword::NoRepeat, RepeatKeyword::Repeat) => dest.write_str("repeat-y"),
(horizontal, vertical) => {
try!(horizontal.to_css(dest));
horizontal.to_css(dest)?;
if horizontal != vertical {
try!(dest.write_str(" "));
try!(vertical.to_css(dest));
dest.write_str(" ")?;
vertical.to_css(dest)?;
}
Ok(())
},
@ -82,10 +82,10 @@ ${helpers.predefined_type("background-image", "ImageLayer",
SpecifiedValue::RepeatX => dest.write_str("repeat-x"),
SpecifiedValue::RepeatY => dest.write_str("repeat-y"),
SpecifiedValue::Other(horizontal, vertical) => {
try!(horizontal.to_css(dest));
horizontal.to_css(dest)?;
if let Some(vertical) = vertical {
try!(dest.write_str(" "));
try!(vertical.to_css(dest));
dest.write_str(" ")?;
vertical.to_css(dest)?;
}
Ok(())
}
@ -138,7 +138,7 @@ ${helpers.predefined_type("background-image", "ImageLayer",
}).or_else(|()| {
let horizontal: Result<_, ParseError> = RepeatKeyword::from_ident(&ident)
.map_err(|()| SelectorParseError::UnexpectedIdent(ident).into());
let horizontal = try!(horizontal);
let horizontal = horizontal?;
let vertical = input.try(RepeatKeyword::parse).ok();
Ok(SpecifiedValue::Other(horizontal, vertical))
})

16
components/style/properties/longhand/border.mako.rs
View file

@ -91,10 +91,10 @@ ${helpers.gecko_keyword_conversion(Keyword('border-style',
let mut first = true;
for ref color in vec {
if !first {
try!(dest.write_str(" "));
dest.write_str(" ")?;
}
first = false;
try!(color.to_css(dest))
color.to_css(dest)?
}
Ok(())
}
@ -110,10 +110,10 @@ ${helpers.gecko_keyword_conversion(Keyword('border-style',
let mut first = true;
for ref color in vec {
if !first {
try!(dest.write_str(" "));
dest.write_str(" ")?;
}
first = false;
try!(color.to_css(dest))
color.to_css(dest)?
}
Ok(())
}
@ -240,10 +240,10 @@ ${helpers.predefined_type("border-image-outset", "LengthOrNumberRect",
impl ToCss for SpecifiedValue {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
try!(self.0.to_css(dest));
self.0.to_css(dest)?;
if let Some(second) = self.1 {
try!(dest.write_str(" "));
try!(second.to_css(dest));
dest.write_str(" ")?;
second.to_css(dest)?;
}
Ok(())
}
@ -274,7 +274,7 @@ ${helpers.predefined_type("border-image-outset", "LengthOrNumberRect",
pub fn parse<'i, 't>(_context: &ParserContext, input: &mut Parser<'i, 't>)
-> Result<SpecifiedValue, ParseError<'i>> {
let first = try!(RepeatKeyword::parse(input));
let first = RepeatKeyword::parse(input)?;
let second = input.try(RepeatKeyword::parse).ok();
Ok(SpecifiedValue(first, second))

172
components/style/properties/longhand/box.mako.rs
View file

@ -567,7 +567,7 @@ ${helpers.predefined_type("animation-timing-function",
return Ok(SpecifiedValue::Infinite)
}
let number = try!(input.expect_number());
let number = input.expect_number()?;
if number < 0.0 {
return Err(StyleParseError::UnspecifiedError.into());
}
@ -936,10 +936,10 @@ ${helpers.predefined_type("scroll-snap-coordinate",
let mut first = true;
for operation in &self.0 {
if !first {
try!(dest.write_str(" "));
dest.write_str(" ")?;
}
first = false;
try!(operation.to_css(dest))
operation.to_css(dest)?
}
Ok(())
}
@ -966,12 +966,12 @@ ${helpers.predefined_type("scroll-snap-coordinate",
let valid_fn = match_ignore_ascii_case! {
&name,
"matrix" => {
try!(input.parse_nested_block(|input| {
input.parse_nested_block(|input| {
// Standard matrix parsing.
if !prefixed {
let values = try!(input.parse_comma_separated(|input| {
let values = input.parse_comma_separated(|input| {
specified::parse_number(context, input)
}));
})?;
if values.len() != 6 {
return Err(StyleParseError::UnspecifiedError.into())
}
@ -1018,13 +1018,13 @@ ${helpers.predefined_type("scroll-snap-coordinate",
f: lengths[1].clone(),
});
Ok(true)
}))
})?
},
"matrix3d" => {
try!(input.parse_nested_block(|input| {
input.parse_nested_block(|input| {
// Standard matrix3d parsing.
if !prefixed {
let values = try!(input.parse_comma_separated(|i| specified::parse_number(context, i)));
let values = input.parse_comma_separated(|i| specified::parse_number(context, i))?;
if values.len() != 16 {
return Err(StyleParseError::UnspecifiedError.into())
}
@ -1073,170 +1073,170 @@ ${helpers.predefined_type("scroll-snap-coordinate",
m44: values[12]
});
Ok(true)
}))
})?
},
"translate" => {
try!(input.parse_nested_block(|input| {
let sx = try!(specified::LengthOrPercentage::parse(context, input));
input.parse_nested_block(|input| {
let sx = specified::LengthOrPercentage::parse(context, input)?;
if input.try(|input| input.expect_comma()).is_ok() {
let sy = try!(specified::LengthOrPercentage::parse(context, input));
let sy = specified::LengthOrPercentage::parse(context, input)?;
result.push(SpecifiedOperation::Translate(sx, Some(sy)));
} else {
result.push(SpecifiedOperation::Translate(sx, None));
}
Ok(true)
}))
})?
},
"translatex" => {
try!(input.parse_nested_block(|input| {
let tx = try!(specified::LengthOrPercentage::parse(context, input));
input.parse_nested_block(|input| {
let tx = specified::LengthOrPercentage::parse(context, input)?;
result.push(SpecifiedOperation::TranslateX(tx));
Ok(true)
}))
})?
},
"translatey" => {
try!(input.parse_nested_block(|input| {
let ty = try!(specified::LengthOrPercentage::parse(context, input));
input.parse_nested_block(|input| {
let ty = specified::LengthOrPercentage::parse(context, input)?;
result.push(SpecifiedOperation::TranslateY(ty));
Ok(true)
}))
})?
},
"translatez" => {
try!(input.parse_nested_block(|input| {
let tz = try!(specified::Length::parse(context, input));
input.parse_nested_block(|input| {
let tz = specified::Length::parse(context, input)?;
result.push(SpecifiedOperation::TranslateZ(tz));
Ok(true)
}))
})?
},
"translate3d" => {
try!(input.parse_nested_block(|input| {
let tx = try!(specified::LengthOrPercentage::parse(context, input));
try!(input.expect_comma());
let ty = try!(specified::LengthOrPercentage::parse(context, input));
try!(input.expect_comma());
let tz = try!(specified::Length::parse(context, input));
input.parse_nested_block(|input| {
let tx = specified::LengthOrPercentage::parse(context, input)?;
input.expect_comma()?;
let ty = specified::LengthOrPercentage::parse(context, input)?;
input.expect_comma()?;
let tz = specified::Length::parse(context, input)?;
result.push(SpecifiedOperation::Translate3D(tx, ty, tz));
Ok(true)
}))
})?
},
"scale" => {
try!(input.parse_nested_block(|input| {
let sx = try!(specified::parse_number(context, input));
input.parse_nested_block(|input| {
let sx = specified::parse_number(context, input)?;
if input.try(|input| input.expect_comma()).is_ok() {
let sy = try!(specified::parse_number(context, input));
let sy = specified::parse_number(context, input)?;
result.push(SpecifiedOperation::Scale(sx, Some(sy)));
} else {
result.push(SpecifiedOperation::Scale(sx, None));
}
Ok(true)
}))
})?
},
"scalex" => {
try!(input.parse_nested_block(|input| {
let sx = try!(specified::parse_number(context, input));
input.parse_nested_block(|input| {
let sx = specified::parse_number(context, input)?;
result.push(SpecifiedOperation::ScaleX(sx));
Ok(true)
}))
})?
},
"scaley" => {
try!(input.parse_nested_block(|input| {
let sy = try!(specified::parse_number(context, input));
input.parse_nested_block(|input| {
let sy = specified::parse_number(context, input)?;
result.push(SpecifiedOperation::ScaleY(sy));
Ok(true)
}))
})?
},
"scalez" => {
try!(input.parse_nested_block(|input| {
let sz = try!(specified::parse_number(context, input));
input.parse_nested_block(|input| {
let sz = specified::parse_number(context, input)?;
result.push(SpecifiedOperation::ScaleZ(sz));
Ok(true)
}))
})?
},
"scale3d" => {
try!(input.parse_nested_block(|input| {
let sx = try!(specified::parse_number(context, input));
try!(input.expect_comma());
let sy = try!(specified::parse_number(context, input));
try!(input.expect_comma());
let sz = try!(specified::parse_number(context, input));
input.parse_nested_block(|input| {
let sx = specified::parse_number(context, input)?;
input.expect_comma()?;
let sy = specified::parse_number(context, input)?;
input.expect_comma()?;
let sz = specified::parse_number(context, input)?;
result.push(SpecifiedOperation::Scale3D(sx, sy, sz));
Ok(true)
}))
})?
},
"rotate" => {
try!(input.parse_nested_block(|input| {
let theta = try!(specified::Angle::parse_with_unitless(context, input));
input.parse_nested_block(|input| {
let theta = specified::Angle::parse_with_unitless(context, input)?;
result.push(SpecifiedOperation::Rotate(theta));
Ok(true)
}))
})?
},
"rotatex" => {
try!(input.parse_nested_block(|input| {
let theta = try!(specified::Angle::parse_with_unitless(context, input));
input.parse_nested_block(|input| {
let theta = specified::Angle::parse_with_unitless(context, input)?;
result.push(SpecifiedOperation::RotateX(theta));
Ok(true)
}))
})?
},
"rotatey" => {
try!(input.parse_nested_block(|input| {
let theta = try!(specified::Angle::parse_with_unitless(context, input));
input.parse_nested_block(|input| {
let theta = specified::Angle::parse_with_unitless(context, input)?;
result.push(SpecifiedOperation::RotateY(theta));
Ok(true)
}))
})?
},
"rotatez" => {
try!(input.parse_nested_block(|input| {
let theta = try!(specified::Angle::parse_with_unitless(context, input));
input.parse_nested_block(|input| {
let theta = specified::Angle::parse_with_unitless(context, input)?;
result.push(SpecifiedOperation::RotateZ(theta));
Ok(true)
}))
})?
},
"rotate3d" => {
try!(input.parse_nested_block(|input| {
let ax = try!(specified::parse_number(context, input));
try!(input.expect_comma());
let ay = try!(specified::parse_number(context, input));
try!(input.expect_comma());
let az = try!(specified::parse_number(context, input));
try!(input.expect_comma());
let theta = try!(specified::Angle::parse_with_unitless(context, input));
input.parse_nested_block(|input| {
let ax = specified::parse_number(context, input)?;
input.expect_comma()?;
let ay = specified::parse_number(context, input)?;
input.expect_comma()?;
let az = specified::parse_number(context, input)?;
input.expect_comma()?;
let theta = specified::Angle::parse_with_unitless(context, input)?;
// TODO(gw): Check the axis can be normalized!!
result.push(SpecifiedOperation::Rotate3D(ax, ay, az, theta));
Ok(true)
}))
})?
},
"skew" => {
try!(input.parse_nested_block(|input| {
let theta_x = try!(specified::Angle::parse_with_unitless(context, input));
input.parse_nested_block(|input| {
let theta_x = specified::Angle::parse_with_unitless(context, input)?;
if input.try(|input| input.expect_comma()).is_ok() {
let theta_y = try!(specified::Angle::parse_with_unitless(context, input));
let theta_y = specified::Angle::parse_with_unitless(context, input)?;
result.push(SpecifiedOperation::Skew(theta_x, Some(theta_y)));
} else {
result.push(SpecifiedOperation::Skew(theta_x, None));
}
Ok(true)
}))
})?
},
"skewx" => {
try!(input.parse_nested_block(|input| {
let theta_x = try!(specified::Angle::parse_with_unitless(context, input));
input.parse_nested_block(|input| {
let theta_x = specified::Angle::parse_with_unitless(context, input)?;
result.push(SpecifiedOperation::SkewX(theta_x));
Ok(true)
}))
})?
},
"skewy" => {
try!(input.parse_nested_block(|input| {
let theta_y = try!(specified::Angle::parse_with_unitless(context, input));
input.parse_nested_block(|input| {
let theta_y = specified::Angle::parse_with_unitless(context, input)?;
result.push(SpecifiedOperation::SkewY(theta_y));
Ok(true)
}))
})?
},
"perspective" => {
try!(input.parse_nested_block(|input| {
let d = try!(specified::Length::parse_non_negative(context, input));
input.parse_nested_block(|input| {
let d = specified::Length::parse_non_negative(context, input)?;
result.push(SpecifiedOperation::Perspective(d));
Ok(true)
}))
})?
},
_ => false
};
@ -1757,10 +1757,10 @@ ${helpers.predefined_type("transform-origin",
($ident:ident => $str:expr) => {
if self.contains($ident) {
if has_any {
try!(dest.write_str(" "));
dest.write_str(" ")?;
}
has_any = true;
try!(dest.write_str($str));
dest.write_str($str)?;
}
}
}

32
components/style/properties/longhand/counters.mako.rs
View file

@ -71,18 +71,18 @@
match *self {
ContentItem::String(ref s) => s.to_css(dest),
ContentItem::Counter(ref s, ref counter_style) => {
try!(dest.write_str("counter("));
try!(cssparser::serialize_identifier(&**s, dest));
try!(dest.write_str(", "));
try!(counter_style.to_css(dest));
dest.write_str("counter(")?;
cssparser::serialize_identifier(&**s, dest)?;
dest.write_str(", ")?;
counter_style.to_css(dest)?;
dest.write_str(")")
}
ContentItem::Counters(ref s, ref separator, ref counter_style) => {
try!(dest.write_str("counters("));
try!(cssparser::serialize_identifier(&**s, dest));
try!(dest.write_str(", "));
dest.write_str("counters(")?;
cssparser::serialize_identifier(&**s, dest)?;
dest.write_str(", ")?;
separator.to_css(dest)?;
try!(dest.write_str(", "));
dest.write_str(", ")?;
counter_style.to_css(dest)?;
dest.write_str(")")
}
@ -121,10 +121,10 @@
% endif
T::Items(ref content) => {
let mut iter = content.iter();
try!(iter.next().unwrap().to_css(dest));
iter.next().unwrap().to_css(dest)?;
for c in iter {
try!(dest.write_str(" "));
try!(c.to_css(dest));
dest.write_str(" ")?;
c.to_css(dest)?;
}
Ok(())
}
@ -186,14 +186,14 @@
Ok(Token::Function(name)) => {
let result = match_ignore_ascii_case! { &name,
"counter" => Some(input.parse_nested_block(|input| {
let name = try!(input.expect_ident()).into_owned();
let name = input.expect_ident()?.into_owned();
let style = parse_counter_style(context, input);
Ok(ContentItem::Counter(name, style))
})),
"counters" => Some(input.parse_nested_block(|input| {
let name = try!(input.expect_ident()).into_owned();
try!(input.expect_comma());
let separator = try!(input.expect_string()).into_owned();
let name = input.expect_ident()?.into_owned();
input.expect_comma()?;
let separator = input.expect_string()?.into_owned();
let style = parse_counter_style(context, input);
Ok(ContentItem::Counters(name, separator, style))
})),
@ -205,7 +205,7 @@
_ => None
};
match result {
Some(result) => content.push(try!(result)),
Some(result) => content.push(result?),
None => return Err(StyleParseError::UnexpectedFunction(name).into())
}
}

72
components/style/properties/longhand/effects.mako.rs
View file

@ -159,14 +159,14 @@ ${helpers.predefined_type("clip",
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
let mut iter = self.filters.iter();
if let Some(filter) = iter.next() {
try!(filter.to_css(dest));
filter.to_css(dest)?;
} else {
try!(dest.write_str("none"));
dest.write_str("none")?;
return Ok(())
}
for filter in iter {
try!(dest.write_str(" "));
try!(filter.to_css(dest));
dest.write_str(" ")?;
filter.to_css(dest)?;
}
Ok(())
}
@ -176,14 +176,14 @@ ${helpers.predefined_type("clip",
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
let mut iter = self.0.iter();
if let Some(filter) = iter.next() {
try!(filter.to_css(dest));
filter.to_css(dest)?;
} else {
try!(dest.write_str("none"));
dest.write_str("none")?;
return Ok(())
}
for filter in iter {
try!(dest.write_str(" "));
try!(filter.to_css(dest));
dest.write_str(" ")?;
filter.to_css(dest)?;
}
Ok(())
}
@ -193,22 +193,22 @@ ${helpers.predefined_type("clip",
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match *self {
computed_value::Filter::Blur(ref value) => {
try!(dest.write_str("blur("));
try!(value.to_css(dest));
try!(dest.write_str(")"));
dest.write_str("blur(")?;
value.to_css(dest)?;
dest.write_str(")")?;
}
computed_value::Filter::Brightness(value) => try!(write!(dest, "brightness({})", value)),
computed_value::Filter::Contrast(value) => try!(write!(dest, "contrast({})", value)),
computed_value::Filter::Grayscale(value) => try!(write!(dest, "grayscale({})", value)),
computed_value::Filter::Brightness(value) => write!(dest, "brightness({})", value)?,
computed_value::Filter::Contrast(value) => write!(dest, "contrast({})", value)?,
computed_value::Filter::Grayscale(value) => write!(dest, "grayscale({})", value)?,
computed_value::Filter::HueRotate(value) => {
try!(dest.write_str("hue-rotate("));
try!(value.to_css(dest));
try!(dest.write_str(")"));
dest.write_str("hue-rotate(")?;
value.to_css(dest)?;
dest.write_str(")")?;
}
computed_value::Filter::Invert(value) => try!(write!(dest, "invert({})", value)),
computed_value::Filter::Opacity(value) => try!(write!(dest, "opacity({})", value)),
computed_value::Filter::Saturate(value) => try!(write!(dest, "saturate({})", value)),
computed_value::Filter::Sepia(value) => try!(write!(dest, "sepia({})", value)),
computed_value::Filter::Invert(value) => write!(dest, "invert({})", value)?,
computed_value::Filter::Opacity(value) => write!(dest, "opacity({})", value)?,
computed_value::Filter::Saturate(value) => write!(dest, "saturate({})", value)?,
computed_value::Filter::Sepia(value) => write!(dest, "sepia({})", value)?,
% if product == "gecko":
computed_value::Filter::DropShadow(shadow) => {
dest.write_str("drop-shadow(")?;
@ -228,22 +228,22 @@ ${helpers.predefined_type("clip",
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
match *self {
SpecifiedFilter::Blur(ref value) => {
try!(dest.write_str("blur("));
try!(value.to_css(dest));
try!(dest.write_str(")"));
dest.write_str("blur(")?;
value.to_css(dest)?;
dest.write_str(")")?;
}
SpecifiedFilter::Brightness(value) => try!(write!(dest, "brightness({})", value)),
SpecifiedFilter::Contrast(value) => try!(write!(dest, "contrast({})", value)),
SpecifiedFilter::Grayscale(value) => try!(write!(dest, "grayscale({})", value)),
SpecifiedFilter::Brightness(value) => write!(dest, "brightness({})", value)?,
SpecifiedFilter::Contrast(value) => write!(dest, "contrast({})", value)?,
SpecifiedFilter::Grayscale(value) => write!(dest, "grayscale({})", value)?,
SpecifiedFilter::HueRotate(value) => {
try!(dest.write_str("hue-rotate("));
try!(value.to_css(dest));
try!(dest.write_str(")"));
dest.write_str("hue-rotate(")?;
value.to_css(dest)?;
dest.write_str(")")?;
}
SpecifiedFilter::Invert(value) => try!(write!(dest, "invert({})", value)),
SpecifiedFilter::Opacity(value) => try!(write!(dest, "opacity({})", value)),
SpecifiedFilter::Saturate(value) => try!(write!(dest, "saturate({})", value)),
SpecifiedFilter::Sepia(value) => try!(write!(dest, "sepia({})", value)),
SpecifiedFilter::Invert(value) => write!(dest, "invert({})", value)?,
SpecifiedFilter::Opacity(value) => write!(dest, "opacity({})", value)?,
SpecifiedFilter::Saturate(value) => write!(dest, "saturate({})", value)?,
SpecifiedFilter::Sepia(value) => write!(dest, "sepia({})", value)?,
% if product == "gecko":
SpecifiedFilter::DropShadow(ref shadow) => {
dest.write_str("drop-shadow(")?;
@ -277,7 +277,7 @@ ${helpers.predefined_type("clip",
} else
% endif
if let Ok(function_name) = input.try(|input| input.expect_function()) {
filters.push(try!(input.parse_nested_block(|input| {
filters.push(input.parse_nested_block(|input| {
match_ignore_ascii_case! { &function_name,
"blur" => specified::Length::parse_non_negative(context, input).map(SpecifiedFilter::Blur),
"brightness" => parse_factor(input).map(SpecifiedFilter::Brightness),
@ -294,7 +294,7 @@ ${helpers.predefined_type("clip",
% endif
_ => Err(StyleParseError::UnexpectedFunction(function_name.clone()).into())
}
})));
})?);
} else if filters.is_empty() {
return Err(StyleParseError::UnspecifiedError.into())
} else {

29
components/style/properties/longhand/font.mako.rs
View file

@ -160,7 +160,7 @@ macro_rules! impl_gecko_keyword_from_trait {
quoted: true,
}))
}
let first_ident = try!(input.expect_ident());
let first_ident = input.expect_ident()?;
// FIXME(bholley): The fast thing to do here would be to look up the
// string (as lowercase) in the static atoms table. We don't have an
@ -271,10 +271,10 @@ macro_rules! impl_gecko_keyword_from_trait {
impl ToCss for T {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
let mut iter = self.0.iter();
try!(iter.next().unwrap().to_css(dest));
iter.next().unwrap().to_css(dest)?;
for family in iter {
try!(dest.write_str(", "));
try!(family.to_css(dest));
dest.write_str(", ")?;
family.to_css(dest)?;
}
Ok(())
}
@ -1125,8 +1125,7 @@ ${helpers.single_keyword_system("font-variant-caps",
-> Result<Self, ()> {
match (*self, *other) {
(T::Number(ref number), T::Number(ref other)) =>
Ok(T::Number(try!(number.add_weighted(other,
self_portion, other_portion)))),
Ok(T::Number(number.add_weighted(other, self_portion, other_portion)?)),
_ => Err(()),
}
}
@ -1161,7 +1160,7 @@ ${helpers.single_keyword_system("font-variant-caps",
return Ok(SpecifiedValue::None);
}
Ok(SpecifiedValue::Number(try!(Number::parse_non_negative(context, input))))
Ok(SpecifiedValue::Number(Number::parse_non_negative(context, input)?))
}
</%helpers:longhand>
@ -1327,10 +1326,10 @@ ${helpers.single_keyword_system("font-kerning",
($ident:ident => $str:expr) => {
if self.intersects($ident) {
if has_any {
try!(dest.write_str(" "));
dest.write_str(" ")?;
}
has_any = true;
try!(dest.write_str($str));
dest.write_str($str)?;
}
}
}
@ -1473,10 +1472,10 @@ macro_rules! exclusive_value {
($ident:ident => $str:expr) => {
if self.intersects($ident) {
if has_any {
try!(dest.write_str(" "));
dest.write_str(" ")?;
}
has_any = true;
try!(dest.write_str($str));
dest.write_str($str)?;
}
}
}
@ -1620,10 +1619,10 @@ macro_rules! exclusive_value {
($ident:ident => $str:expr) => {
if self.intersects($ident) {
if has_any {
try!(dest.write_str(" "));
dest.write_str(" ")?;
}
has_any = true;
try!(dest.write_str($str));
dest.write_str($str)?;
}
}
}
@ -1776,10 +1775,10 @@ macro_rules! exclusive_value {
($ident:ident => $str:expr) => {
if self.intersects($ident) {
if has_any {
try!(dest.write_str(" "));
dest.write_str(" ")?;
}
has_any = true;
try!(dest.write_str($str));
dest.write_str($str)?;
}
}
}

6
components/style/properties/longhand/inherited_box.mako.rs
View file

@ -82,7 +82,7 @@ ${helpers.single_keyword("image-rendering",
impl ToCss for SpecifiedValue {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
if let Some(angle) = self.angle {
try!(angle.to_css(dest));
angle.to_css(dest)?;
if self.flipped {
dest.write_str(" flip")
} else {
@ -163,9 +163,9 @@ ${helpers.single_keyword("image-rendering",
match *self {
computed_value::T::FromImage => dest.write_str("from-image"),
computed_value::T::AngleWithFlipped(angle, flipped) => {
try!(angle.to_css(dest));
angle.to_css(dest)?;
if flipped {
try!(dest.write_str(" flip"));
dest.write_str(" flip")?;
}
Ok(())
},

16
components/style/properties/longhand/inherited_table.mako.rs
View file

@ -44,10 +44,10 @@ ${helpers.single_keyword("caption-side", "top bottom",
fn add_weighted(&self, other: &Self, self_portion: f64, other_portion: f64)
-> Result<Self, ()> {
Ok(T {
horizontal: try!(self.horizontal.add_weighted(&other.horizontal,
self_portion, other_portion)),
vertical: try!(self.vertical.add_weighted(&other.vertical,
self_portion, other_portion)),
horizontal: self.horizontal.add_weighted(&other.horizontal,
self_portion, other_portion)?,
vertical: self.vertical.add_weighted(&other.vertical,
self_portion, other_portion)?,
})
}
@ -58,8 +58,8 @@ ${helpers.single_keyword("caption-side", "top bottom",
#[inline]
fn compute_squared_distance(&self, other: &Self) -> Result<f64, ()> {
Ok(try!(self.horizontal.compute_squared_distance(&other.horizontal)) +
try!(self.vertical.compute_squared_distance(&other.vertical)))
Ok(self.horizontal.compute_squared_distance(&other.horizontal)? +
self.vertical.compute_squared_distance(&other.vertical)?)
}
}
}
@ -83,9 +83,9 @@ ${helpers.single_keyword("caption-side", "top bottom",
fn to_css<W>(&self, dest: &mut W) -> fmt::Result
where W: fmt::Write,
{
try!(self.horizontal.to_css(dest));
self.horizontal.to_css(dest)?;
if let Some(vertical) = self.vertical.as_ref() {
try!(dest.write_str(" "));
dest.write_str(" ")?;
vertical.to_css(dest)?;
}
Ok(())

20
components/style/properties/longhand/inherited_text.mako.rs
View file

@ -470,16 +470,16 @@ ${helpers.predefined_type("word-spacing",
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
if let Some(fill) = self.fill() {
if fill {
try!(dest.write_str("filled"));
dest.write_str("filled")?;
} else {
try!(dest.write_str("open"));
dest.write_str("open")?;
}
}
if let Some(shape) = self.shape() {
if self.fill().is_some() {
try!(dest.write_str(" "));
dest.write_str(" ")?;
}
try!(shape.to_css(dest));
shape.to_css(dest)?;
}
Ok(())
}
@ -487,11 +487,11 @@ ${helpers.predefined_type("word-spacing",
impl ToCss for computed_value::KeywordValue {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
if self.fill {
try!(dest.write_str("filled"));
dest.write_str("filled")?;
} else {
try!(dest.write_str("open"));
dest.write_str("open")?;
}
try!(dest.write_str(" "));
dest.write_str(" ")?;
self.shape.to_css(dest)
}
}
@ -643,11 +643,11 @@ ${helpers.predefined_type("word-spacing",
pub fn parse<'i, 't>(_context: &ParserContext, input: &mut Parser<'i, 't>)
-> Result<SpecifiedValue, ParseError<'i>> {
if let Ok(horizontal) = input.try(|input| HorizontalWritingModeValue::parse(input)) {
let vertical = try!(VerticalWritingModeValue::parse(input));
let vertical = VerticalWritingModeValue::parse(input)?;
Ok(SpecifiedValue(horizontal, vertical))
} else {
let vertical = try!(VerticalWritingModeValue::parse(input));
let horizontal = try!(HorizontalWritingModeValue::parse(input));
let vertical = VerticalWritingModeValue::parse(input)?;
let horizontal = HorizontalWritingModeValue::parse(input)?;
Ok(SpecifiedValue(horizontal, vertical))
}
}

24
components/style/properties/longhand/pointing.mako.rs
View file

@ -52,12 +52,12 @@
#[cfg(feature = "gecko")]
impl ToCss for Image {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
try!(self.url.to_css(dest));
self.url.to_css(dest)?;
if let Some((x, y)) = self.hotspot {
try!(dest.write_str(" "));
try!(x.to_css(dest));
try!(dest.write_str(" "));
try!(y.to_css(dest));
dest.write_str(" ")?;
x.to_css(dest)?;
dest.write_str(" ")?;
y.to_css(dest)?;
}
Ok(())
}
@ -67,8 +67,8 @@
impl ToCss for T {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
for url in &self.images {
try!(url.to_css(dest));
try!(dest.write_str(", "));
url.to_css(dest)?;
dest.write_str(", ")?;
}
self.keyword.to_css(dest)
}
@ -95,7 +95,7 @@
-> Result<computed_value::Keyword, ParseError<'i>> {
use std::ascii::AsciiExt;
use style_traits::cursor::Cursor;
let ident = try!(input.expect_ident());
let ident = input.expect_ident()?;
if ident.eq_ignore_ascii_case("auto") {
Ok(computed_value::Keyword::Auto)
} else {
@ -110,9 +110,9 @@
fn parse_image<'i, 't>(context: &ParserContext, input: &mut Parser<'i, 't>)
-> Result<computed_value::Image, ParseError<'i>> {
Ok(computed_value::Image {
url: try!(SpecifiedUrl::parse(context, input)),
url: SpecifiedUrl::parse(context, input)?,
hotspot: match input.try(|input| input.expect_number()) {
Ok(number) => Some((number, try!(input.expect_number()))),
Ok(number) => Some((number, input.expect_number()?)),
Err(_) => None,
},
})
@ -137,12 +137,12 @@
}
Err(_) => break,
}
try!(input.expect_comma());
input.expect_comma()?;
}
Ok(computed_value::T {
images: images,
keyword: try!(computed_value::Keyword::parse(context, input)),
keyword: computed_value::Keyword::parse(context, input)?,
})
}
</%helpers:longhand>

14
components/style/properties/longhand/text.mako.rs
View file

@ -57,11 +57,11 @@
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
if self.sides_are_logical {
assert!(self.first == Side::Clip);
try!(self.second.to_css(dest));
self.second.to_css(dest)?;
} else {
try!(self.first.to_css(dest));
try!(dest.write_str(" "));
try!(self.second.to_css(dest));
self.first.to_css(dest)?;
dest.write_str(" ")?;
self.second.to_css(dest)?;
}
Ok(())
}
@ -133,10 +133,10 @@
impl ToCss for SpecifiedValue {
fn to_css<W>(&self, dest: &mut W) -> fmt::Result where W: fmt::Write {
try!(self.first.to_css(dest));
self.first.to_css(dest)?;
if let Some(ref second) = self.second {
try!(dest.write_str(" "));
try!(second.to_css(dest));
dest.write_str(" ")?;
second.to_css(dest)?;
}
Ok(())
}

2
components/style/properties/longhand/ui.mako.rs
View file

@ -78,7 +78,7 @@ ${helpers.single_keyword("-moz-window-shadow", "none default menu tooltip sheet"
pub fn parse<'i, 't>(_context: &ParserContext, input: &mut Parser<'i, 't>)
-> Result<SpecifiedValue, ParseError<'i>> {
match try!(input.expect_integer()) {
match input.expect_integer()? {
0 => Ok(computed_value::T(false)),
1 => Ok(computed_value::T(true)),
_ => Err(StyleParseError::UnspecifiedError.into()),

8
components/style/properties/properties.mako.rs
View file

@ -234,8 +234,8 @@ pub mod shorthands {
while let Ok(_) = input.next() {} // Look for var()
if input.seen_var_functions() {
input.reset(start);
let (first_token_type, css) = try!(
::custom_properties::parse_non_custom_with_var(input));
let (first_token_type, css) =
::custom_properties::parse_non_custom_with_var(input)?;
declarations.all_shorthand = AllShorthand::WithVariables(Arc::new(UnparsedValue {
css: css.into_owned(),
first_token_type: first_token_type,
@ -1137,8 +1137,8 @@ impl HasViewportPercentage for PropertyDeclaration {
impl fmt::Debug for PropertyDeclaration {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
try!(self.id().to_css(f));
try!(f.write_str(": "));
self.id().to_css(f)?;
f.write_str(": ")?;
self.to_css(f)
}
}

32
components/style/properties/shorthand/background.mako.rs
View file

@ -39,7 +39,7 @@
% for name in "image position_x position_y repeat size attachment origin clip".split():
let mut background_${name} = background_${name}::SpecifiedValue(Vec::new());
% endfor
try!(input.parse_comma_separated(|input| {
input.parse_comma_separated(|input| {
// background-color can only be in the last element, so if it
// is parsed anywhere before, the value is invalid.
if background_color.is_some() {
@ -62,7 +62,7 @@
// Parse background size, if applicable.
size = input.try(|input| {
try!(input.expect_delim('/'));
input.expect_delim('/')?;
background_size::single_value::parse(context, input)
}).ok();
@ -110,7 +110,7 @@
} else {
Err(StyleParseError::UnspecifiedError.into())
}
}));
})?;
Ok(expanded! {
background_color: background_color.unwrap_or(Color::transparent()),
@ -148,37 +148,37 @@
% endfor
if i != 0 {
try!(write!(dest, ", "));
write!(dest, ", ")?;
}
if i == len - 1 {
try!(self.background_color.to_css(dest));
try!(write!(dest, " "));
self.background_color.to_css(dest)?;
write!(dest, " ")?;
}
try!(image.to_css(dest));
image.to_css(dest)?;
% for name in "repeat attachment".split():
try!(write!(dest, " "));
try!(${name}.to_css(dest));
write!(dest, " ")?;
${name}.to_css(dest)?;
% endfor
try!(write!(dest, " "));
write!(dest, " ")?;
Position {
horizontal: position_x.clone(),
vertical: position_y.clone()
}.to_css(dest)?;
if *size != background_size::single_value::get_initial_specified_value() {
try!(write!(dest, " / "));
try!(size.to_css(dest));
write!(dest, " / ")?;
size.to_css(dest)?;
}
if *origin != Origin::padding_box || *clip != Clip::border_box {
try!(write!(dest, " "));
try!(origin.to_css(dest));
write!(dest, " ")?;
origin.to_css(dest)?;
if *clip != From::from(*origin) {
try!(write!(dest, " "));
try!(clip.to_css(dest));
write!(dest, " ")?;
clip.to_css(dest)?;
}
}
}

12
components/style/properties/shorthand/border.mako.rs
View file

@ -104,7 +104,7 @@ pub fn parse_border<'i, 't>(context: &ParserContext, input: &mut Parser<'i, 't>)
pub fn parse_value<'i, 't>(context: &ParserContext, input: &mut Parser<'i, 't>)
-> Result<Longhands, ParseError<'i>> {
let (color, style, width) = try!(super::parse_border(context, input));
let (color, style, width) = super::parse_border(context, input)?;
Ok(expanded! {
border_${to_rust_ident(side)}_color: color,
border_${to_rust_ident(side)}_style: style,
@ -146,7 +146,7 @@ pub fn parse_border<'i, 't>(context: &ParserContext, input: &mut Parser<'i, 't>)
use properties::longhands::{border_image_outset, border_image_repeat, border_image_slice};
use properties::longhands::{border_image_source, border_image_width};
let (color, style, width) = try!(super::parse_border(context, input));
let (color, style, width) = super::parse_border(context, input)?;
Ok(expanded! {
% for side in PHYSICAL_SIDES:
border_${side}_color: color.clone(),
@ -214,7 +214,7 @@ pub fn parse_border<'i, 't>(context: &ParserContext, input: &mut Parser<'i, 't>)
pub fn parse_value<'i, 't>(context: &ParserContext, input: &mut Parser<'i, 't>)
-> Result<Longhands, ParseError<'i>> {
let radii = try!(BorderRadius::parse(context, input));
let radii = BorderRadius::parse(context, input)?;
Ok(expanded! {
border_top_left_radius: radii.top_left,
border_top_right_radius: radii.top_right,
@ -262,7 +262,7 @@ pub fn parse_border<'i, 't>(context: &ParserContext, input: &mut Parser<'i, 't>)
slice = Some(value);
// Parse border image width and outset, if applicable.
let maybe_width_outset: Result<_, ParseError> = input.try(|input| {
try!(input.expect_delim('/'));
input.expect_delim('/')?;
// Parse border image width, if applicable.
let w = input.try(|input|
@ -270,7 +270,7 @@ pub fn parse_border<'i, 't>(context: &ParserContext, input: &mut Parser<'i, 't>)
// Parse border image outset if applicable.
let o = input.try(|input| {
try!(input.expect_delim('/'));
input.expect_delim('/')?;
border_image_outset::parse(context, input)
}).ok();
if w.is_none() && o.is_none() {
@ -313,7 +313,7 @@ pub fn parse_border<'i, 't>(context: &ParserContext, input: &mut Parser<'i, 't>)
Err(StyleParseError::UnspecifiedError.into())
}
});
try!(result);
result?;
Ok(expanded! {
% for name in "outset repeat slice source width".split():

8
components/style/properties/shorthand/box.mako.rs
View file

@ -135,7 +135,7 @@ macro_rules! try_parse_one {
% endfor
if input.try(|input| input.expect_ident_matching("none")).is_err() {
let results = try!(input.parse_comma_separated(|i| parse_one_transition(context, i)));
let results = input.parse_comma_separated(|i| parse_one_transition(context, i))?;
for result in results {
% for prop in "property duration timing_function delay".split():
${prop}s.push(result.transition_${prop});
@ -257,7 +257,7 @@ macro_rules! try_parse_one {
let mut ${prop}s = vec![];
% endfor
let results = try!(input.parse_comma_separated(|i| parse_one_animation(context, i)));
let results = input.parse_comma_separated(|i| parse_one_animation(context, i))?;
for result in results.into_iter() {
% for prop in props:
${prop}s.push(result.animation_${prop});
@ -289,7 +289,7 @@ macro_rules! try_parse_one {
for i in 0..len {
if i != 0 {
try!(write!(dest, ", "));
write!(dest, ", ")?;
}
% for name in props[1:]:
@ -310,7 +310,7 @@ macro_rules! try_parse_one {
pub fn parse_value<'i, 't>(context: &ParserContext, input: &mut Parser<'i, 't>)
-> Result<Longhands, ParseError<'i>> {
let result = try!(scroll_snap_type_x::parse(context, input));
let result = scroll_snap_type_x::parse(context, input)?;
Ok(expanded! {
scroll_snap_type_x: result,
scroll_snap_type_y: result,

4
components/style/properties/shorthand/font.mako.rs
View file

@ -89,7 +89,7 @@
continue
}
}
size = Some(try!(font_size::parse(context, input)));
size = Some(font_size::parse(context, input)?);
break
}
#[inline]
@ -101,7 +101,7 @@
return Err(StyleParseError::UnspecifiedError.into())
}
let line_height = if input.try(|input| input.expect_delim('/')).is_ok() {
Some(try!(LineHeight::parse(context, input)))
Some(LineHeight::parse(context, input)?)
} else {
None
};

6
components/style/properties/shorthand/mask.mako.rs
View file

@ -41,7 +41,7 @@
let mut mask_${name} = mask_${name}::SpecifiedValue(Vec::new());
% endfor
try!(input.parse_comma_separated(|input| {
input.parse_comma_separated(|input| {
% for name in "image mode position size repeat origin clip composite".split():
let mut ${name} = None;
% endfor
@ -59,7 +59,7 @@
// Parse mask size, if applicable.
size = input.try(|input| {
try!(input.expect_delim('/'));
input.expect_delim('/')?;
mask_size::single_value::parse(context, input)
}).ok();
@ -106,7 +106,7 @@
} else {
Err(StyleParseError::UnspecifiedError.into())
}
}));
})?;
Ok(expanded! {
% for name in "image mode position_x position_y size repeat origin clip composite".split():

2
components/style/properties/shorthand/outline.mako.rs
View file

@ -66,7 +66,7 @@
pub fn parse_value<'i, 't>(context: &ParserContext, input: &mut Parser<'i, 't>)
-> Result<Longhands, ParseError<'i>> {
let radii = try!(BorderRadius::parse(context, input));
let radii = BorderRadius::parse(context, input)?;
Ok(expanded! {
_moz_outline_radius_topleft: radii.top_left,
_moz_outline_radius_topright: radii.top_right,

2
components/style/properties/shorthand/position.mako.rs
View file

@ -50,7 +50,7 @@
fn parse_flexibility<'i, 't>(context: &ParserContext, input: &mut Parser<'i, 't>)
-> Result<(Number, Option<Number>),ParseError<'i>> {
let grow = try!(Number::parse_non_negative(context, input));
let grow = Number::parse_non_negative(context, input)?;
let shrink = input.try(|i| Number::parse_non_negative(context, i)).ok();
Ok((grow, shrink))
}