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 // https://github.com/w3c/csswg-drafts/issues/801
// Setting this property to a CSS-wide keyword or `none` will // Setting this property to a CSS-wide keyword or `none` will
// throw a Syntax Error. // throw a Syntax Error.
match_ignore_ascii_case! { value, match_ignore_ascii_case! { &value,
"initial" => return Err(Error::Syntax), "initial" => return Err(Error::Syntax),
"inherit" => return Err(Error::Syntax), "inherit" => return Err(Error::Syntax),
"unset" => 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(()), _ => return Err(()),
}; };
Ok(match_ignore_ascii_case! { unit, Ok(match_ignore_ascii_case! { &unit,
"dpi" => Resolution::Dpi(value), "dpi" => Resolution::Dpi(value),
"dppx" => Resolution::Dppx(value), "dppx" => Resolution::Dppx(value),
"dpcm" => Resolution::Dpcm(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. /// Parse a transition-property value.
pub fn parse(input: &mut Parser) -> Result<Self, ()> { 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), "all" => Ok(TransitionProperty::All),
% for prop in data.longhands: % for prop in data.longhands:
% if prop.animatable: % if prop.animatable:

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

@ -68,7 +68,7 @@
/// Parse a display value. /// Parse a display value.
pub fn parse(_context: &ParserContext, input: &mut Parser) pub fn parse(_context: &ParserContext, input: &mut Parser)
-> Result<SpecifiedValue, ()> { -> Result<SpecifiedValue, ()> {
match_ignore_ascii_case! { try!(input.expect_ident()), match_ignore_ascii_case! { &try!(input.expect_ident()),
% for value in values: % for value in values:
"${value}" => { "${value}" => {
Ok(computed_value::T::${to_rust_ident(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)) input.try(|i| specified::LengthOrPercentage::parse(context, i))
.map(SpecifiedValue::LengthOrPercentage) .map(SpecifiedValue::LengthOrPercentage)
.or_else(|_| { .or_else(|_| {
match_ignore_ascii_case! { try!(input.expect_ident()), match_ignore_ascii_case! { &try!(input.expect_ident()),
% for keyword in vertical_align_keywords: % for keyword in vertical_align_keywords:
"${keyword}" => Ok(SpecifiedValue::${to_rust_ident(keyword)}), "${keyword}" => Ok(SpecifiedValue::${to_rust_ident(keyword)}),
% endfor % endfor
@ -588,7 +588,7 @@ ${helpers.single_keyword("overflow-x", "visible hidden scroll auto",
impl Parse for SpecifiedValue { impl Parse for SpecifiedValue {
fn parse(_context: &ParserContext, input: &mut ::cssparser::Parser) -> Result<Self, ()> { fn parse(_context: &ParserContext, input: &mut ::cssparser::Parser) -> Result<Self, ()> {
if let Ok(function_name) = input.try(|input| input.expect_function()) { 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" => { "cubic-bezier" => {
let (mut p1x, mut p1y, mut p2x, mut p2y) = (0.0, 0.0, 0.0, 0.0); let (mut p1x, mut p1y, mut p2x, mut p2y) = (0.0, 0.0, 0.0, 0.0);
try!(input.parse_nested_block(|input| { 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() { if input.try(|input| input.expect_comma()).is_ok() {
start_end = try!(match_ignore_ascii_case! { start_end = try!(match_ignore_ascii_case! {
try!(input.expect_ident()), &try!(input.expect_ident()),
"start" => Ok(StartEnd::Start), "start" => Ok(StartEnd::Start),
"end" => Ok(StartEnd::End), "end" => Ok(StartEnd::End),
_ => Err(()) _ => Err(())
@ -1319,7 +1319,7 @@ ${helpers.predefined_type("scroll-snap-coordinate",
Err(_) => break, Err(_) => break,
}; };
match_ignore_ascii_case! { match_ignore_ascii_case! {
name, &name,
"matrix" => { "matrix" => {
try!(input.parse_nested_block(|input| { try!(input.parse_nested_block(|input| {
let values = try!(input.parse_comma_separated(|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())) content.push(ContentItem::String(value.into_owned()))
} }
Ok(Token::Function(name)) => { 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| { "counter" => input.parse_nested_block(|input| {
let name = try!(input.expect_ident()).into_owned(); let name = try!(input.expect_ident()).into_owned();
let style = input.try(|input| { let style = input.try(|input| {
@ -163,7 +163,7 @@
})); }));
} }
Ok(Token::Ident(ident)) => { Ok(Token::Ident(ident)) => {
match_ignore_ascii_case! { ident, match_ignore_ascii_case! { &ident,
"open-quote" => content.push(ContentItem::OpenQuote), "open-quote" => content.push(ContentItem::OpenQuote),
"close-quote" => content.push(ContentItem::CloseQuote), "close-quote" => content.push(ContentItem::CloseQuote),
"no-open-quote" => content.push(ContentItem::NoOpenQuote), "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 % endif
if let Ok(function_name) = input.try(|input| input.expect_function()) { if let Ok(function_name) = input.try(|input| input.expect_function()) {
filters.push(try!(input.parse_nested_block(|input| { 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), "blur" => specified::Length::parse_non_negative(input).map(SpecifiedFilter::Blur),
"brightness" => parse_factor(input).map(SpecifiedFilter::Brightness), "brightness" => parse_factor(input).map(SpecifiedFilter::Brightness),
"contrast" => parse_factor(input).map(SpecifiedFilter::Contrast), "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| { if let Err(_) = input.try(|input| {
let token = try!(input.expect_ident()); let token = try!(input.expect_ident());
match_ignore_ascii_case! { match_ignore_ascii_case! {
token, &token,
"left" => { "left" => {
if horizontal.is_none() { if horizontal.is_none() {
horizontal = Some(LengthOrPercentage::Percentage(Percentage(0.0))) 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")), "serif" => return FontFamily::Generic(atom!("serif")),
"sans-serif" => return FontFamily::Generic(atom!("sans-serif")), "sans-serif" => return FontFamily::Generic(atom!("sans-serif")),
"cursive" => return FontFamily::Generic(atom!("cursive")), "cursive" => return FontFamily::Generic(atom!("cursive")),
@ -85,7 +85,7 @@
// string (as lowercase) in the static atoms table. We don't have an // 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. // API to do that yet though, so we do the simple thing for now.
let mut css_wide_keyword = false; 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"))), "serif" => return Ok(FontFamily::Generic(atom!("serif"))),
"sans-serif" => return Ok(FontFamily::Generic(atom!("sans-serif"))), "sans-serif" => return Ok(FontFamily::Generic(atom!("sans-serif"))),
"cursive" => return Ok(FontFamily::Generic(atom!("cursive"))), "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 /// normal | bold | bolder | lighter | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900
pub fn parse(_context: &ParserContext, input: &mut Parser) -> Result<SpecifiedValue, ()> { pub fn parse(_context: &ParserContext, input: &mut Parser) -> Result<SpecifiedValue, ()> {
input.try(|input| { input.try(|input| {
match_ignore_ascii_case! { try!(input.expect_ident()), match_ignore_ascii_case! { &try!(input.expect_ident()),
"normal" => Ok(SpecifiedValue::Normal), "normal" => Ok(SpecifiedValue::Normal),
"bold" => Ok(SpecifiedValue::Bold), "bold" => Ok(SpecifiedValue::Bold),
"bolder" => Ok(SpecifiedValue::Bolder), "bolder" => Ok(SpecifiedValue::Bolder),
@ -557,7 +557,7 @@ ${helpers.single_keyword("font-variant-caps",
pub fn parse(_context: &ParserContext, input: &mut Parser) -> Result<SpecifiedValue, ()> { pub fn parse(_context: &ParserContext, input: &mut Parser) -> Result<SpecifiedValue, ()> {
let mut result = SpecifiedValue { weight: false, style: false }; 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), "none" => Ok(result),
"weight" => { "weight" => {
result.weight = true; 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 { loop {
let result = input.try(|i| { let result = input.try(|i| {
match_ignore_ascii_case! { i.expect_ident()?, match_ignore_ascii_case! { &i.expect_ident()?,
"fill" => Ok(FILL), "fill" => Ok(FILL),
"stroke" => Ok(STROKE), "stroke" => Ok(STROKE),
"markers" => Ok(MARKERS), "markers" => Ok(MARKERS),

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

@ -60,7 +60,7 @@
impl Parse for Side { impl Parse for Side {
fn parse(_context: &ParserContext, input: &mut Parser) -> Result<Side, ()> { fn parse(_context: &ParserContext, input: &mut Parser) -> Result<Side, ()> {
if let Ok(ident) = input.try(|input| input.expect_ident()) { if let Ok(ident) = input.try(|input| input.expect_ident()) {
match_ignore_ascii_case! { ident, match_ignore_ascii_case! { &ident,
"clip" => Ok(Side::Clip), "clip" => Ok(Side::Clip),
"ellipsis" => Ok(Side::Ellipsis), "ellipsis" => Ok(Side::Ellipsis),
_ => Err(()) _ => Err(())
@ -179,7 +179,7 @@ ${helpers.single_keyword("unicode-bidi",
while input.try(|input| { while input.try(|input| {
if let Ok(ident) = input.expect_ident() { if let Ok(ident) = input.expect_ident() {
match_ignore_ascii_case! { ident, match_ignore_ascii_case! { &ident,
"underline" => if result.contains(UNDERLINE) { return Err(()) } "underline" => if result.contains(UNDERLINE) { return Err(()) }
else { empty = false; result.insert(UNDERLINE) }, else { empty = false; result.insert(UNDERLINE) },
"overline" => if result.contains(OVERLINE) { return Err(()) } "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, ()> { fn parse(_context: &ParserContext, input: &mut Parser) -> Result<Self, ()> {
let ident = input.expect_ident()?; let ident = input.expect_ident()?;
input.expect_exhausted()?; input.expect_exhausted()?;
match_ignore_ascii_case! { ident, match_ignore_ascii_case! { &ident,
"initial" => Ok(CSSWideKeyword::InitialKeyword), "initial" => Ok(CSSWideKeyword::InitialKeyword),
"inherit" => Ok(CSSWideKeyword::InheritKeyword), "inherit" => Ok(CSSWideKeyword::InheritKeyword),
"unset" => Ok(CSSWideKeyword::UnsetKeyword), "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()); let name = try!(input.expect_ident());
try!(input.expect_colon()); try!(input.expect_colon());
// TODO: Handle other media features // TODO: Handle other media features
Ok(Expression(match_ignore_ascii_case! { name, Ok(Expression(match_ignore_ascii_case! { &name,
"min-width" => { "min-width" => {
ExpressionKind::Width(Range::Min(try!(specified::Length::parse_non_negative(input)))) 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) return Ok(in_parens)
} }
Ok(Token::Ident(ident)) => { Ok(Token::Ident(ident)) => {
match_ignore_ascii_case! { ident, match_ignore_ascii_case! { &ident,
"and" => ("and", SupportsCondition::And as fn(_) -> _), "and" => ("and", SupportsCondition::And as fn(_) -> _),
"or" => ("or", SupportsCondition::Or as fn(_) -> _), "or" => ("or", SupportsCondition::Or as fn(_) -> _),
_ => return Err(()) _ => 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 { impl Parse for $name {
#[allow(missing_docs)] #[allow(missing_docs)]
fn parse(_context: &ParserContext, input: &mut ::cssparser::Parser) -> Result<$name, ()> { 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), )+ $( $css => Ok($name::$variant), )+
_ => Err(()) _ => Err(())
} }

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

@ -323,7 +323,7 @@ impl Parse for JustifyItems {
// auto | normal | stretch | <baseline-position> // auto | normal | stretch | <baseline-position>
fn parse_auto_normal_stretch_baseline(input: &mut Parser) -> Result<AlignFlags, ()> { fn parse_auto_normal_stretch_baseline(input: &mut Parser) -> Result<AlignFlags, ()> {
let ident = input.expect_ident()?; let ident = input.expect_ident()?;
match_ignore_ascii_case! { ident, match_ignore_ascii_case! { &ident,
"auto" => Ok(ALIGN_AUTO), "auto" => Ok(ALIGN_AUTO),
"normal" => Ok(ALIGN_NORMAL), "normal" => Ok(ALIGN_NORMAL),
"stretch" => Ok(ALIGN_STRETCH), "stretch" => Ok(ALIGN_STRETCH),
@ -335,7 +335,7 @@ fn parse_auto_normal_stretch_baseline(input: &mut Parser) -> Result<AlignFlags,
// normal | stretch | <baseline-position> // normal | stretch | <baseline-position>
fn parse_normal_stretch_baseline(input: &mut Parser) -> Result<AlignFlags, ()> { fn parse_normal_stretch_baseline(input: &mut Parser) -> Result<AlignFlags, ()> {
let ident = input.expect_ident()?; let ident = input.expect_ident()?;
match_ignore_ascii_case! { ident, match_ignore_ascii_case! { &ident,
"normal" => Ok(ALIGN_NORMAL), "normal" => Ok(ALIGN_NORMAL),
"stretch" => Ok(ALIGN_STRETCH), "stretch" => Ok(ALIGN_STRETCH),
"baseline" => Ok(ALIGN_BASELINE), "baseline" => Ok(ALIGN_BASELINE),
@ -346,7 +346,7 @@ fn parse_normal_stretch_baseline(input: &mut Parser) -> Result<AlignFlags, ()> {
// normal | <baseline-position> // normal | <baseline-position>
fn parse_normal_or_baseline(input: &mut Parser) -> Result<AlignFlags, ()> { fn parse_normal_or_baseline(input: &mut Parser) -> Result<AlignFlags, ()> {
let ident = input.expect_ident()?; let ident = input.expect_ident()?;
match_ignore_ascii_case! { ident, match_ignore_ascii_case! { &ident,
"normal" => Ok(ALIGN_NORMAL), "normal" => Ok(ALIGN_NORMAL),
"baseline" => Ok(ALIGN_BASELINE), "baseline" => Ok(ALIGN_BASELINE),
_ => Err(()) _ => Err(())
@ -356,7 +356,7 @@ fn parse_normal_or_baseline(input: &mut Parser) -> Result<AlignFlags, ()> {
// <content-distribution> // <content-distribution>
fn parse_content_distribution(input: &mut Parser) -> Result<AlignFlags, ()> { fn parse_content_distribution(input: &mut Parser) -> Result<AlignFlags, ()> {
let ident = input.expect_ident()?; let ident = input.expect_ident()?;
match_ignore_ascii_case! { ident, match_ignore_ascii_case! { &ident,
"stretch" => Ok(ALIGN_STRETCH), "stretch" => Ok(ALIGN_STRETCH),
"space_between" => Ok(ALIGN_SPACE_BETWEEN), "space_between" => Ok(ALIGN_SPACE_BETWEEN),
"space_around" => Ok(ALIGN_SPACE_AROUND), "space_around" => Ok(ALIGN_SPACE_AROUND),
@ -386,7 +386,7 @@ fn parse_overflow_content_position(input: &mut Parser) -> Result<AlignFlags, ()>
// <content-position> // <content-position>
fn parse_content_position(input: &mut Parser) -> Result<AlignFlags, ()> { fn parse_content_position(input: &mut Parser) -> Result<AlignFlags, ()> {
let ident = input.expect_ident()?; let ident = input.expect_ident()?;
match_ignore_ascii_case! { ident, match_ignore_ascii_case! { &ident,
"start" => Ok(ALIGN_START), "start" => Ok(ALIGN_START),
"end" => Ok(ALIGN_END), "end" => Ok(ALIGN_END),
"flex-start" => Ok(ALIGN_FLEX_START), "flex-start" => Ok(ALIGN_FLEX_START),
@ -401,7 +401,7 @@ fn parse_content_position(input: &mut Parser) -> Result<AlignFlags, ()> {
// <overflow-position> // <overflow-position>
fn parse_overflow_position(input: &mut Parser) -> Result<AlignFlags, ()> { fn parse_overflow_position(input: &mut Parser) -> Result<AlignFlags, ()> {
let ident = input.expect_ident()?; let ident = input.expect_ident()?;
match_ignore_ascii_case! { ident, match_ignore_ascii_case! { &ident,
"safe" => Ok(ALIGN_SAFE), "safe" => Ok(ALIGN_SAFE),
"unsafe" => Ok(ALIGN_UNSAFE), "unsafe" => Ok(ALIGN_UNSAFE),
_ => Err(()) _ => Err(())
@ -429,7 +429,7 @@ fn parse_overflow_self_position(input: &mut Parser) -> Result<AlignFlags, ()> {
// <self-position> // <self-position>
fn parse_self_position(input: &mut Parser) -> Result<AlignFlags, ()> { fn parse_self_position(input: &mut Parser) -> Result<AlignFlags, ()> {
let ident = input.expect_ident()?; let ident = input.expect_ident()?;
match_ignore_ascii_case! { ident, match_ignore_ascii_case! { &ident,
"start" => Ok(ALIGN_START), "start" => Ok(ALIGN_START),
"end" => Ok(ALIGN_END), "end" => Ok(ALIGN_END),
"flex-start" => Ok(ALIGN_FLEX_START), "flex-start" => Ok(ALIGN_FLEX_START),
@ -448,14 +448,14 @@ fn parse_legacy(input: &mut Parser) -> Result<AlignFlags, ()> {
let a = input.expect_ident()?; let a = input.expect_ident()?;
let b = input.expect_ident()?; let b = input.expect_ident()?;
if a.eq_ignore_ascii_case("legacy") { if a.eq_ignore_ascii_case("legacy") {
match_ignore_ascii_case! { b, match_ignore_ascii_case! { &b,
"left" => Ok(ALIGN_LEGACY | ALIGN_LEFT), "left" => Ok(ALIGN_LEGACY | ALIGN_LEFT),
"right" => Ok(ALIGN_LEGACY | ALIGN_RIGHT), "right" => Ok(ALIGN_LEGACY | ALIGN_RIGHT),
"center" => Ok(ALIGN_LEGACY | ALIGN_CENTER), "center" => Ok(ALIGN_LEGACY | ALIGN_CENTER),
_ => Err(()) _ => Err(())
} }
} else if b.eq_ignore_ascii_case("legacy") { } else if b.eq_ignore_ascii_case("legacy") {
match_ignore_ascii_case! { a, match_ignore_ascii_case! { &a,
"left" => Ok(ALIGN_LEGACY | ALIGN_LEFT), "left" => Ok(ALIGN_LEGACY | ALIGN_LEFT),
"right" => Ok(ALIGN_LEGACY | ALIGN_RIGHT), "right" => Ok(ALIGN_LEGACY | ALIGN_RIGHT),
"center" => Ok(ALIGN_LEGACY | ALIGN_CENTER), "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 { impl Parse for BasicShape {
fn parse(context: &ParserContext, input: &mut Parser) -> Result<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" => { "inset" => {
Ok(BasicShape::Inset( Ok(BasicShape::Inset(
try!(input.parse_nested_block(|i| InsetRect::parse_function_arguments(context, i))))) try!(input.parse_nested_block(|i| InsetRect::parse_function_arguments(context, i)))))
@ -237,7 +237,7 @@ impl InsetRect {
impl Parse for InsetRect { impl Parse for InsetRect {
fn parse(context: &ParserContext, input: &mut Parser) -> Result<Self, ()> { 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" => { "inset" => {
input.parse_nested_block(|i| InsetRect::parse_function_arguments(context, i)) input.parse_nested_block(|i| InsetRect::parse_function_arguments(context, i))
}, },
@ -413,7 +413,7 @@ impl Circle {
impl Parse for Circle { impl Parse for Circle {
fn parse(context: &ParserContext, input: &mut Parser) -> Result<Self, ()> { 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" => { "circle" => {
input.parse_nested_block(|i| Circle::parse_function_arguments(context, i)) input.parse_nested_block(|i| Circle::parse_function_arguments(context, i))
}, },
@ -497,7 +497,7 @@ impl Ellipse {
impl Parse for Ellipse { impl Parse for Ellipse {
fn parse(context: &ParserContext, input: &mut Parser) -> Result<Self, ()> { 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" => { "ellipse" => {
input.parse_nested_block(|i| Ellipse::parse_function_arguments(context, i)) input.parse_nested_block(|i| Ellipse::parse_function_arguments(context, i))
}, },
@ -575,7 +575,7 @@ impl Polygon {
impl Parse for Polygon { impl Parse for Polygon {
fn parse(context: &ParserContext, input: &mut Parser) -> Result<Self, ()> { 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" => { "polygon" => {
input.parse_nested_block(|i| Polygon::parse_function_arguments(context, i)) input.parse_nested_block(|i| Polygon::parse_function_arguments(context, i))
}, },
@ -664,7 +664,7 @@ impl Default for ShapeRadius {
impl Parse for ShapeRadius { impl Parse for ShapeRadius {
fn parse(_: &ParserContext, input: &mut Parser) -> Result<Self, ()> { fn parse(_: &ParserContext, input: &mut Parser) -> Result<Self, ()> {
input.try(|i| LengthOrPercentage::parse_non_negative(i)).map(ShapeRadius::Length).or_else(|_| { 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), "closest-side" => Ok(ShapeRadius::ClosestSide),
"farthest-side" => Ok(ShapeRadius::FarthestSide), "farthest-side" => Ok(ShapeRadius::FarthestSide),
_ => Err(()) _ => Err(())
@ -832,7 +832,7 @@ impl ComputedValueAsSpecified for FillRule {}
impl Parse for FillRule { impl Parse for FillRule {
fn parse(_context: &ParserContext, input: &mut Parser) -> Result<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), "nonzero" => Ok(FillRule::NonZero),
"evenodd" => Ok(FillRule::EvenOdd), "evenodd" => Ok(FillRule::EvenOdd),
_ => Err(()) _ => Err(())
@ -871,7 +871,7 @@ impl Parse for GeometryBox {
if let Ok(shape_box) = input.try(|i| ShapeBox::parse(context, i)) { if let Ok(shape_box) = input.try(|i| ShapeBox::parse(context, i)) {
Ok(GeometryBox::ShapeBox(shape_box)) Ok(GeometryBox::ShapeBox(shape_box))
} else { } else {
match_ignore_ascii_case! { try!(input.expect_ident()), match_ignore_ascii_case! { &try!(input.expect_ident()),
"fill-box" => Ok(GeometryBox::Fill), "fill-box" => Ok(GeometryBox::Fill),
"stroke-box" => Ok(GeometryBox::Stroke), "stroke-box" => Ok(GeometryBox::Stroke),
"view-box" => Ok(GeometryBox::View), "view-box" => Ok(GeometryBox::View),
@ -908,7 +908,7 @@ pub enum ShapeBox {
impl Parse for ShapeBox { impl Parse for ShapeBox {
fn parse(_context: &ParserContext, input: &mut Parser) -> Result<Self, ()> { 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), "margin-box" => Ok(ShapeBox::Margin),
"border-box" => Ok(ShapeBox::Border), "border-box" => Ok(ShapeBox::Border),
"padding-box" => Ok(ShapeBox::Padding), "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. /// Parses a gradient from the given arguments.
pub fn parse_function(context: &ParserContext, input: &mut Parser) -> Result<Gradient, ()> { pub fn parse_function(context: &ParserContext, input: &mut Parser) -> Result<Gradient, ()> {
let mut repeating = false; 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" => { "linear-gradient" => {
try!(input.parse_nested_block(|input| { try!(input.parse_nested_block(|input| {
let kind = try!(GradientKind::parse_linear(context, 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) input.try(ExtremumLength::parse).map(MaxLength::ExtremumLength)
.or_else(|()| input.try(LengthOrPercentage::parse_non_negative).map(MaxLength::LengthOrPercentage)) .or_else(|()| input.try(LengthOrPercentage::parse_non_negative).map(MaxLength::LengthOrPercentage))
.or_else(|()| { .or_else(|()| {
match_ignore_ascii_case! { try!(input.expect_ident()), match_ignore_ascii_case! { &try!(input.expect_ident()),
"none" => "none" =>
Ok(MaxLength::None), Ok(MaxLength::None),
_ => Err(()) _ => Err(())

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

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

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

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

4
components/style_traits/cursor.rs
View file

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

3
components/style_traits/values.rs
View file

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