Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-06-06 16:45:39 +00:00
Code Issues Projects Releases Packages Wiki Activity

Borrow input to match_ignore_ascii_case!

Browse source 
In cssparser version 0.11, this macro will stop implicitly borrowing its
own input.
This commit is contained in:
Simon Sapin 2017-02-26 10:40:09 +01:00
parent 4fa3e8e82c
commit 0f2d000a23
21 changed files with 62 additions and 61 deletions
Download patch file Download diff file Expand all files Collapse all files

2
components/script/dom/csskeyframesrule.rs
View file

@ -115,7 +115,7 @@ impl CSSKeyframesRuleMethods for CSSKeyframesRule {
// https://github.com/w3c/csswg-drafts/issues/801
// Setting this property to a CSS-wide keyword or `none` will
// throw a Syntax Error.
match_ignore_ascii_case! { value,
match_ignore_ascii_case! { &value,
"initial" => return Err(Error::Syntax),
"inherit" => return Err(Error::Syntax),
"unset" => return Err(Error::Syntax),

2
components/style/gecko/media_queries.rs
View file

@ -165,7 +165,7 @@ impl Resolution {
_ => return Err(()),
};
Ok(match_ignore_ascii_case! { unit,
Ok(match_ignore_ascii_case! { &unit,
"dpi" => Resolution::Dpi(value),
"dppx" => Resolution::Dppx(value),
"dpcm" => Resolution::Dpcm(value),

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

@ -69,7 +69,7 @@ impl TransitionProperty {
/// Parse a transition-property value.
pub fn parse(input: &mut Parser) -> Result<Self, ()> {
match_ignore_ascii_case! { try!(input.expect_ident()),
match_ignore_ascii_case! { &try!(input.expect_ident()),
"all" => Ok(TransitionProperty::All),
% for prop in data.longhands:
% if prop.animatable:

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

@ -68,7 +68,7 @@
/// Parse a display value.
pub fn parse(_context: &ParserContext, input: &mut Parser)
-> Result<SpecifiedValue, ()> {
match_ignore_ascii_case! { try!(input.expect_ident()),
match_ignore_ascii_case! { &try!(input.expect_ident()),
% for value in values:
"${value}" => {
Ok(computed_value::T::${to_rust_ident(value)})
@ -299,7 +299,7 @@ ${helpers.single_keyword("-moz-top-layer", "none top",
input.try(|i| specified::LengthOrPercentage::parse(context, i))
.map(SpecifiedValue::LengthOrPercentage)
.or_else(|_| {
match_ignore_ascii_case! { try!(input.expect_ident()),
match_ignore_ascii_case! { &try!(input.expect_ident()),
% for keyword in vertical_align_keywords:
"${keyword}" => Ok(SpecifiedValue::${to_rust_ident(keyword)}),
% endfor
@ -588,7 +588,7 @@ ${helpers.single_keyword("overflow-x", "visible hidden scroll auto",
impl Parse for SpecifiedValue {
fn parse(_context: &ParserContext, input: &mut ::cssparser::Parser) -> Result<Self, ()> {
if let Ok(function_name) = input.try(|input| input.expect_function()) {
return match_ignore_ascii_case! { function_name,
return match_ignore_ascii_case! { &function_name,
"cubic-bezier" => {
let (mut p1x, mut p1y, mut p2x, mut p2y) = (0.0, 0.0, 0.0, 0.0);
try!(input.parse_nested_block(|input| {
@ -618,7 +618,7 @@ ${helpers.single_keyword("overflow-x", "visible hidden scroll auto",
if input.try(|input| input.expect_comma()).is_ok() {
start_end = try!(match_ignore_ascii_case! {
try!(input.expect_ident()),
&try!(input.expect_ident()),
"start" => Ok(StartEnd::Start),
"end" => Ok(StartEnd::End),
_ => Err(())
@ -1319,7 +1319,7 @@ ${helpers.predefined_type("scroll-snap-coordinate",
Err(_) => break,
};
match_ignore_ascii_case! {
name,
&name,
"matrix" => {
try!(input.parse_nested_block(|input| {
let values = try!(input.parse_comma_separated(|input| {

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

@ -140,7 +140,7 @@
content.push(ContentItem::String(value.into_owned()))
}
Ok(Token::Function(name)) => {
content.push(try!(match_ignore_ascii_case! { name,
content.push(try!(match_ignore_ascii_case! { &name,
"counter" => input.parse_nested_block(|input| {
let name = try!(input.expect_ident()).into_owned();
let style = input.try(|input| {
@ -163,7 +163,7 @@
}));
}
Ok(Token::Ident(ident)) => {
match_ignore_ascii_case! { ident,
match_ignore_ascii_case! { &ident,
"open-quote" => content.push(ContentItem::OpenQuote),
"close-quote" => content.push(ContentItem::CloseQuote),
"no-open-quote" => content.push(ContentItem::NoOpenQuote),

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

@ -339,7 +339,7 @@ ${helpers.predefined_type("clip",
% endif
if let Ok(function_name) = input.try(|input| input.expect_function()) {
filters.push(try!(input.parse_nested_block(|input| {
match_ignore_ascii_case! { function_name,
match_ignore_ascii_case! { &function_name,
"blur" => specified::Length::parse_non_negative(input).map(SpecifiedFilter::Blur),
"brightness" => parse_factor(input).map(SpecifiedFilter::Brightness),
"contrast" => parse_factor(input).map(SpecifiedFilter::Contrast),
@ -445,7 +445,7 @@ pub fn parse_origin(context: &ParserContext, input: &mut Parser) -> Result<Origi
if let Err(_) = input.try(|input| {
let token = try!(input.expect_ident());
match_ignore_ascii_case! {
token,
&token,
"left" => {
if horizontal.is_none() {
horizontal = Some(LengthOrPercentage::Percentage(Percentage(0.0)))

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

@ -63,7 +63,7 @@
}
_ => {}
}
match_ignore_ascii_case! { input,
match_ignore_ascii_case! { &input,
"serif" => return FontFamily::Generic(atom!("serif")),
"sans-serif" => return FontFamily::Generic(atom!("sans-serif")),
"cursive" => return FontFamily::Generic(atom!("cursive")),
@ -85,7 +85,7 @@
// string (as lowercase) in the static atoms table. We don't have an
// API to do that yet though, so we do the simple thing for now.
let mut css_wide_keyword = false;
match_ignore_ascii_case! { first_ident,
match_ignore_ascii_case! { &first_ident,
"serif" => return Ok(FontFamily::Generic(atom!("serif"))),
"sans-serif" => return Ok(FontFamily::Generic(atom!("sans-serif"))),
"cursive" => return Ok(FontFamily::Generic(atom!("cursive"))),
@ -254,7 +254,7 @@ ${helpers.single_keyword("font-variant-caps",
/// normal | bold | bolder | lighter | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900
pub fn parse(_context: &ParserContext, input: &mut Parser) -> Result<SpecifiedValue, ()> {
input.try(|input| {
match_ignore_ascii_case! { try!(input.expect_ident()),
match_ignore_ascii_case! { &try!(input.expect_ident()),
"normal" => Ok(SpecifiedValue::Normal),
"bold" => Ok(SpecifiedValue::Bold),
"bolder" => Ok(SpecifiedValue::Bolder),
@ -557,7 +557,7 @@ ${helpers.single_keyword("font-variant-caps",
pub fn parse(_context: &ParserContext, input: &mut Parser) -> Result<SpecifiedValue, ()> {
let mut result = SpecifiedValue { weight: false, style: false };
match_ignore_ascii_case! {try!(input.expect_ident()),
match_ignore_ascii_case! { &try!(input.expect_ident()),
"none" => Ok(result),
"weight" => {
result.weight = true;

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

@ -196,7 +196,7 @@ ${helpers.predefined_type("marker-end", "UrlOrNone", "Either::Second(None_)",
loop {
let result = input.try(|i| {
match_ignore_ascii_case! { i.expect_ident()?,
match_ignore_ascii_case! { &i.expect_ident()?,
"fill" => Ok(FILL),
"stroke" => Ok(STROKE),
"markers" => Ok(MARKERS),

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

@ -60,7 +60,7 @@
impl Parse for Side {
fn parse(_context: &ParserContext, input: &mut Parser) -> Result<Side, ()> {
if let Ok(ident) = input.try(|input| input.expect_ident()) {
match_ignore_ascii_case! { ident,
match_ignore_ascii_case! { &ident,
"clip" => Ok(Side::Clip),
"ellipsis" => Ok(Side::Ellipsis),
_ => Err(())
@ -179,7 +179,7 @@ ${helpers.single_keyword("unicode-bidi",
while input.try(|input| {
if let Ok(ident) = input.expect_ident() {
match_ignore_ascii_case! { ident,
match_ignore_ascii_case! { &ident,
"underline" => if result.contains(UNDERLINE) { return Err(()) }
else { empty = false; result.insert(UNDERLINE) },
"overline" => if result.contains(OVERLINE) { return Err(()) }

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

@ -455,7 +455,7 @@ impl Parse for CSSWideKeyword {
fn parse(_context: &ParserContext, input: &mut Parser) -> Result<Self, ()> {
let ident = input.expect_ident()?;
input.expect_exhausted()?;
match_ignore_ascii_case! { ident,
match_ignore_ascii_case! { &ident,
"initial" => Ok(CSSWideKeyword::InitialKeyword),
"inherit" => Ok(CSSWideKeyword::InheritKeyword),
"unset" => Ok(CSSWideKeyword::UnsetKeyword),

2
components/style/servo/media_queries.rs
View file

@ -106,7 +106,7 @@ impl Expression {
let name = try!(input.expect_ident());
try!(input.expect_colon());
// TODO: Handle other media features
Ok(Expression(match_ignore_ascii_case! { name,
Ok(Expression(match_ignore_ascii_case! { &name,
"min-width" => {
ExpressionKind::Width(Range::Min(try!(specified::Length::parse_non_negative(input))))
},

2
components/style/supports.rs
View file

@ -47,7 +47,7 @@ impl SupportsCondition {
return Ok(in_parens)
}
Ok(Token::Ident(ident)) => {
match_ignore_ascii_case! { ident,
match_ignore_ascii_case! { &ident,
"and" => ("and", SupportsCondition::And as fn(_) -> _),
"or" => ("or", SupportsCondition::Or as fn(_) -> _),
_ => return Err(())

2
components/style/values/mod.rs
View file

@ -28,7 +28,7 @@ macro_rules! define_numbered_css_keyword_enum {
impl Parse for $name {
#[allow(missing_docs)]
fn parse(_context: &ParserContext, input: &mut ::cssparser::Parser) -> Result<$name, ()> {
match_ignore_ascii_case! { try!(input.expect_ident()),
match_ignore_ascii_case! { &try!(input.expect_ident()),
$( $css => Ok($name::$variant), )+
_ => Err(())
}

18
components/style/values/specified/align.rs
View file

@ -323,7 +323,7 @@ impl Parse for JustifyItems {
// auto | normal | stretch | <baseline-position>
fn parse_auto_normal_stretch_baseline(input: &mut Parser) -> Result<AlignFlags, ()> {
let ident = input.expect_ident()?;
match_ignore_ascii_case! { ident,
match_ignore_ascii_case! { &ident,
"auto" => Ok(ALIGN_AUTO),
"normal" => Ok(ALIGN_NORMAL),
"stretch" => Ok(ALIGN_STRETCH),
@ -335,7 +335,7 @@ fn parse_auto_normal_stretch_baseline(input: &mut Parser) -> Result<AlignFlags,
// normal | stretch | <baseline-position>
fn parse_normal_stretch_baseline(input: &mut Parser) -> Result<AlignFlags, ()> {
let ident = input.expect_ident()?;
match_ignore_ascii_case! { ident,
match_ignore_ascii_case! { &ident,
"normal" => Ok(ALIGN_NORMAL),
"stretch" => Ok(ALIGN_STRETCH),
"baseline" => Ok(ALIGN_BASELINE),
@ -346,7 +346,7 @@ fn parse_normal_stretch_baseline(input: &mut Parser) -> Result<AlignFlags, ()> {
// normal | <baseline-position>
fn parse_normal_or_baseline(input: &mut Parser) -> Result<AlignFlags, ()> {
let ident = input.expect_ident()?;
match_ignore_ascii_case! { ident,
match_ignore_ascii_case! { &ident,
"normal" => Ok(ALIGN_NORMAL),
"baseline" => Ok(ALIGN_BASELINE),
_ => Err(())
@ -356,7 +356,7 @@ fn parse_normal_or_baseline(input: &mut Parser) -> Result<AlignFlags, ()> {
// <content-distribution>
fn parse_content_distribution(input: &mut Parser) -> Result<AlignFlags, ()> {
let ident = input.expect_ident()?;
match_ignore_ascii_case! { ident,
match_ignore_ascii_case! { &ident,
"stretch" => Ok(ALIGN_STRETCH),
"space_between" => Ok(ALIGN_SPACE_BETWEEN),
"space_around" => Ok(ALIGN_SPACE_AROUND),
@ -386,7 +386,7 @@ fn parse_overflow_content_position(input: &mut Parser) -> Result<AlignFlags, ()>
// <content-position>
fn parse_content_position(input: &mut Parser) -> Result<AlignFlags, ()> {
let ident = input.expect_ident()?;
match_ignore_ascii_case! { ident,
match_ignore_ascii_case! { &ident,
"start" => Ok(ALIGN_START),
"end" => Ok(ALIGN_END),
"flex-start" => Ok(ALIGN_FLEX_START),
@ -401,7 +401,7 @@ fn parse_content_position(input: &mut Parser) -> Result<AlignFlags, ()> {
// <overflow-position>
fn parse_overflow_position(input: &mut Parser) -> Result<AlignFlags, ()> {
let ident = input.expect_ident()?;
match_ignore_ascii_case! { ident,
match_ignore_ascii_case! { &ident,
"safe" => Ok(ALIGN_SAFE),
"unsafe" => Ok(ALIGN_UNSAFE),
_ => Err(())
@ -429,7 +429,7 @@ fn parse_overflow_self_position(input: &mut Parser) -> Result<AlignFlags, ()> {
// <self-position>
fn parse_self_position(input: &mut Parser) -> Result<AlignFlags, ()> {
let ident = input.expect_ident()?;
match_ignore_ascii_case! { ident,
match_ignore_ascii_case! { &ident,
"start" => Ok(ALIGN_START),
"end" => Ok(ALIGN_END),
"flex-start" => Ok(ALIGN_FLEX_START),
@ -448,14 +448,14 @@ fn parse_legacy(input: &mut Parser) -> Result<AlignFlags, ()> {
let a = input.expect_ident()?;
let b = input.expect_ident()?;
if a.eq_ignore_ascii_case("legacy") {
match_ignore_ascii_case! { b,
match_ignore_ascii_case! { &b,
"left" => Ok(ALIGN_LEGACY | ALIGN_LEFT),
"right" => Ok(ALIGN_LEGACY | ALIGN_RIGHT),
"center" => Ok(ALIGN_LEGACY | ALIGN_CENTER),
_ => Err(())
}
} else if b.eq_ignore_ascii_case("legacy") {
match_ignore_ascii_case! { a,
match_ignore_ascii_case! { &a,
"left" => Ok(ALIGN_LEGACY | ALIGN_LEFT),
"right" => Ok(ALIGN_LEGACY | ALIGN_RIGHT),
"center" => Ok(ALIGN_LEGACY | ALIGN_CENTER),

18
components/style/values/specified/basic_shape.rs
View file

@ -141,7 +141,7 @@ pub enum BasicShape {
impl Parse for BasicShape {
fn parse(context: &ParserContext, input: &mut Parser) -> Result<BasicShape, ()> {
match_ignore_ascii_case! { try!(input.expect_function()),
match_ignore_ascii_case! { &try!(input.expect_function()),
"inset" => {
Ok(BasicShape::Inset(
try!(input.parse_nested_block(|i| InsetRect::parse_function_arguments(context, i)))))
@ -237,7 +237,7 @@ impl InsetRect {
impl Parse for InsetRect {
fn parse(context: &ParserContext, input: &mut Parser) -> Result<Self, ()> {
match_ignore_ascii_case! { try!(input.expect_function()),
match_ignore_ascii_case! { &try!(input.expect_function()),
"inset" => {
input.parse_nested_block(|i| InsetRect::parse_function_arguments(context, i))
},
@ -413,7 +413,7 @@ impl Circle {
impl Parse for Circle {
fn parse(context: &ParserContext, input: &mut Parser) -> Result<Self, ()> {
match_ignore_ascii_case! { try!(input.expect_function()),
match_ignore_ascii_case! { &try!(input.expect_function()),
"circle" => {
input.parse_nested_block(|i| Circle::parse_function_arguments(context, i))
},
@ -497,7 +497,7 @@ impl Ellipse {
impl Parse for Ellipse {
fn parse(context: &ParserContext, input: &mut Parser) -> Result<Self, ()> {
match_ignore_ascii_case! { try!(input.expect_function()),
match_ignore_ascii_case! { &try!(input.expect_function()),
"ellipse" => {
input.parse_nested_block(|i| Ellipse::parse_function_arguments(context, i))
},
@ -575,7 +575,7 @@ impl Polygon {
impl Parse for Polygon {
fn parse(context: &ParserContext, input: &mut Parser) -> Result<Self, ()> {
match_ignore_ascii_case! { try!(input.expect_function()),
match_ignore_ascii_case! { &try!(input.expect_function()),
"polygon" => {
input.parse_nested_block(|i| Polygon::parse_function_arguments(context, i))
},
@ -664,7 +664,7 @@ impl Default for ShapeRadius {
impl Parse for ShapeRadius {
fn parse(_: &ParserContext, input: &mut Parser) -> Result<Self, ()> {
input.try(|i| LengthOrPercentage::parse_non_negative(i)).map(ShapeRadius::Length).or_else(|_| {
match_ignore_ascii_case! { try!(input.expect_ident()),
match_ignore_ascii_case! { &try!(input.expect_ident()),
"closest-side" => Ok(ShapeRadius::ClosestSide),
"farthest-side" => Ok(ShapeRadius::FarthestSide),
_ => Err(())
@ -832,7 +832,7 @@ impl ComputedValueAsSpecified for FillRule {}
impl Parse for FillRule {
fn parse(_context: &ParserContext, input: &mut Parser) -> Result<FillRule, ()> {
match_ignore_ascii_case! { try!(input.expect_ident()),
match_ignore_ascii_case! { &try!(input.expect_ident()),
"nonzero" => Ok(FillRule::NonZero),
"evenodd" => Ok(FillRule::EvenOdd),
_ => Err(())
@ -871,7 +871,7 @@ impl Parse for GeometryBox {
if let Ok(shape_box) = input.try(|i| ShapeBox::parse(context, i)) {
Ok(GeometryBox::ShapeBox(shape_box))
} else {
match_ignore_ascii_case! { try!(input.expect_ident()),
match_ignore_ascii_case! { &try!(input.expect_ident()),
"fill-box" => Ok(GeometryBox::Fill),
"stroke-box" => Ok(GeometryBox::Stroke),
"view-box" => Ok(GeometryBox::View),
@ -908,7 +908,7 @@ pub enum ShapeBox {
impl Parse for ShapeBox {
fn parse(_context: &ParserContext, input: &mut Parser) -> Result<Self, ()> {
match_ignore_ascii_case! { try!(input.expect_ident()),
match_ignore_ascii_case! { &try!(input.expect_ident()),
"margin-box" => Ok(ShapeBox::Margin),
"border-box" => Ok(ShapeBox::Border),
"padding-box" => Ok(ShapeBox::Padding),

2
components/style/values/specified/image.rs
View file

@ -103,7 +103,7 @@ impl Gradient {
/// Parses a gradient from the given arguments.
pub fn parse_function(context: &ParserContext, input: &mut Parser) -> Result<Gradient, ()> {
let mut repeating = false;
let (gradient_kind, stops) = match_ignore_ascii_case! { try!(input.expect_function()),
let (gradient_kind, stops) = match_ignore_ascii_case! { &try!(input.expect_function()),
"linear-gradient" => {
try!(input.parse_nested_block(|input| {
let kind = try!(GradientKind::parse_linear(context, input));

2
components/style/values/specified/length.rs
View file

@ -1385,7 +1385,7 @@ impl Parse for MaxLength {
input.try(ExtremumLength::parse).map(MaxLength::ExtremumLength)
.or_else(|()| input.try(LengthOrPercentage::parse_non_negative).map(MaxLength::LengthOrPercentage))
.or_else(|()| {
match_ignore_ascii_case! { try!(input.expect_ident()),
match_ignore_ascii_case! { &try!(input.expect_ident()),
"none" =>
Ok(MaxLength::None),
_ => Err(())

8
components/style/values/specified/mod.rs
View file

@ -297,7 +297,7 @@ impl Angle {
#[allow(missing_docs)]
pub fn parse_border_radius(context: &ParserContext, input: &mut Parser) -> Result<BorderRadiusSize, ()> {
input.try(|i| BorderRadiusSize::parse(context, i)).or_else(|_| {
match_ignore_ascii_case! { try!(input.expect_ident()),
match_ignore_ascii_case! { &try!(input.expect_ident()),
"thin" => Ok(BorderRadiusSize::circle(
LengthOrPercentage::Length(NoCalcLength::from_px(1.)))),
"medium" => Ok(BorderRadiusSize::circle(
@ -312,7 +312,7 @@ pub fn parse_border_radius(context: &ParserContext, input: &mut Parser) -> Resul
#[allow(missing_docs)]
pub fn parse_border_width(input: &mut Parser) -> Result<Length, ()> {
input.try(Length::parse_non_negative).or_else(|()| {
match_ignore_ascii_case! { try!(input.expect_ident()),
match_ignore_ascii_case! { &try!(input.expect_ident()),
"thin" => Ok(Length::from_px(1.)),
"medium" => Ok(Length::from_px(3.)),
"thick" => Ok(Length::from_px(5.)),
@ -335,7 +335,7 @@ impl Parse for BorderWidth {
fn parse(_context: &ParserContext, input: &mut Parser) -> Result<BorderWidth, ()> {
match input.try(Length::parse_non_negative) {
Ok(length) => Ok(BorderWidth::Width(length)),
Err(_) => match_ignore_ascii_case! { try!(input.expect_ident()),
Err(_) => match_ignore_ascii_case! { &try!(input.expect_ident()),
"thin" => Ok(BorderWidth::Thin),
"medium" => Ok(BorderWidth::Medium),
"thick" => Ok(BorderWidth::Thick),
@ -714,7 +714,7 @@ pub enum SVGPaintKind {
impl SVGPaintKind {
fn parse_ident(input: &mut Parser) -> Result<Self, ()> {
Ok(match_ignore_ascii_case! { input.expect_ident()?,
Ok(match_ignore_ascii_case! { &input.expect_ident()?,
"none" => SVGPaintKind::None,
"context-fill" => SVGPaintKind::ContextFill,
"context-stroke" => SVGPaintKind::ContextStroke,

22
components/style/values/specified/position.rs
View file

@ -595,17 +595,17 @@ impl Parse for PositionComponent {
.or_else(|()| {
match try!(input.next()) {
Token::Ident(value) => {
match_ignore_ascii_case! { value,
"center" => Ok(PositionComponent::Keyword(Keyword::Center)),
"left" => Ok(PositionComponent::Keyword(Keyword::Left)),
"right" => Ok(PositionComponent::Keyword(Keyword::Right)),
"top" => Ok(PositionComponent::Keyword(Keyword::Top)),
"bottom" => Ok(PositionComponent::Keyword(Keyword::Bottom)),
"x-start" => Ok(PositionComponent::Keyword(Keyword::XStart)),
"x-end" => Ok(PositionComponent::Keyword(Keyword::XEnd)),
"y-start" => Ok(PositionComponent::Keyword(Keyword::YStart)),
"y-end" => Ok(PositionComponent::Keyword(Keyword::YEnd)),
_ => Err(())
match_ignore_ascii_case! { &value,
"center" => Ok(PositionComponent::Keyword(Keyword::Center)),
"left" => Ok(PositionComponent::Keyword(Keyword::Left)),
"right" => Ok(PositionComponent::Keyword(Keyword::Right)),
"top" => Ok(PositionComponent::Keyword(Keyword::Top)),
"bottom" => Ok(PositionComponent::Keyword(Keyword::Bottom)),
"x-start" => Ok(PositionComponent::Keyword(Keyword::XStart)),
"x-end" => Ok(PositionComponent::Keyword(Keyword::XEnd)),
"y-start" => Ok(PositionComponent::Keyword(Keyword::YStart)),
"y-end" => Ok(PositionComponent::Keyword(Keyword::YEnd)),
_ => Err(())
}
},
_ => Err(())

4
components/style_traits/cursor.rs
View file

@ -20,8 +20,8 @@ macro_rules! define_cursor {
impl Cursor {
/// Given a CSS keyword, get the corresponding cursor enum.
pub fn from_css_keyword(keyword: &str) -> Result<Cursor, ()> {
match_ignore_ascii_case! { keyword,
$( concat!($css) => Ok(Cursor::$variant), )+
match_ignore_ascii_case! { &keyword,
$( $css => Ok(Cursor::$variant), )+
_ => Err(())
}
}

3
components/style_traits/values.rs
View file

@ -116,7 +116,8 @@ macro_rules! __define_css_keyword_enum__actual {
impl $name {
/// Parse this property from a CSS input stream.
pub fn parse(input: &mut ::cssparser::Parser) -> Result<$name, ()> {
match_ignore_ascii_case! { try!(input.expect_ident()),
let ident = input.expect_ident()?;
match_ignore_ascii_case! { &ident,
$( $css => Ok($name::$variant), )+
_ => Err(())
}