[librsvg] Adjust to rust-cssparser API changes

[Federico Mena Quintero <federico src gnome org>]

commit 7066c9cd028e9a946dee4963d362cc6bdef33c52
Author: Federico Mena Quintero <federico gnome org>
Date:   Mon Jul 31 12:24:33 2017 -0500

    Adjust to rust-cssparser API changes

 rust/src/color.rs   |    3 ++-
 rust/src/length.rs  |   15 ++++++++-------
 rust/src/opacity.rs |    9 +++++----
 rust/src/parsers.rs |   26 +++++++++++++++-----------
 4 files changed, 30 insertions(+), 23 deletions(-)
---
diff --git a/rust/src/color.rs b/rust/src/color.rs
index 61d6cca..c83bdfd 100644
--- a/rust/src/color.rs
+++ b/rust/src/color.rs
@@ -70,7 +70,8 @@ impl Color {
                 Err (AttributeError::Value ("inherit is not allowed here".to_string ()))
             }
         } else {
-            match cssparser::Color::parse (&mut cssparser::Parser::new (s)) {
+            let mut input = cssparser::ParserInput::new (s);
+            match cssparser::Color::parse (&mut cssparser::Parser::new (&mut input)) {
                 Ok (cssparser::Color::CurrentColor) => {
                     if allow_current_color == AllowCurrentColor::Yes {
                         Ok (Color::CurrentColor)
diff --git a/rust/src/length.rs b/rust/src/length.rs
index 7e27606..62d49c8 100644
--- a/rust/src/length.rs
+++ b/rust/src/length.rs
@@ -1,4 +1,4 @@
-use ::cssparser::{Parser, Token, NumericValue, PercentageValue};
+use ::cssparser::{Parser, ParserInput, Token};
 use ::glib::translate::*;
 use ::libc;
 
@@ -102,24 +102,25 @@ fn make_err () -> AttributeError {
 
 impl RsvgLength {
     pub fn parse (string: &str, dir: LengthDir) -> Result <RsvgLength, AttributeError> {
-        let mut parser = Parser::new (string);
+        let mut input = ParserInput::new (string);
+        let mut parser = Parser::new (&mut input);
 
         let token = parser.next ()
             .map_err (|_| AttributeError::Parse (ParseError::new ("expected number and optional symbol, or 
number and percentage")))?;
 
-        match token {
-            Token::Number (NumericValue { value, .. }) => Ok (RsvgLength { length: value as f64,
+        match *token {
+            Token::Number { value, .. } => Ok (RsvgLength { length: value as f64,
                                                                            unit:   LengthUnit::Default,
                                                                            dir:    dir }),
 
-            Token::Percentage (PercentageValue { unit_value, .. }) => Ok (RsvgLength { length: unit_value as 
f64,
+            Token::Percentage { unit_value, .. } => Ok (RsvgLength { length: unit_value as f64,
                                                                                        unit:   
LengthUnit::Percent,
                                                                                        dir:    dir }),
 
-            Token::Dimension (NumericValue { value, .. }, cow) => {
+            Token::Dimension { value, unit, .. } => {
                 let value = value as f64;
 
-                match cow.as_ref () {
+                match unit.as_ref () {
                     "em" => Ok (RsvgLength { length: value,
                                              unit:   LengthUnit::FontEm,
                                              dir:    dir }),
diff --git a/rust/src/opacity.rs b/rust/src/opacity.rs
index 9672bab..cd9ca8a 100644
--- a/rust/src/opacity.rs
+++ b/rust/src/opacity.rs
@@ -1,7 +1,7 @@
 /// Struct to represent an inheritable opacity property
 /// https://www.w3.org/TR/SVG/masking.html#OpacityProperty
 
-use ::cssparser::{Parser, Token, NumericValue};
+use ::cssparser::{Parser, ParserInput, Token};
 use ::libc;
 
 use std::str::FromStr;
@@ -67,11 +67,12 @@ impl FromStr for Opacity {
     type Err = AttributeError;
 
     fn from_str (s: &str) -> Result<Opacity, AttributeError> {
-        let mut parser = Parser::new (s);
+        let mut input = ParserInput::new (s);
+        let mut parser = Parser::new (&mut input);
 
         let token = parser.next ();
         let result = match token {
-            Ok (Token::Ident (value)) => {
+            Ok (&Token::Ident (value)) => {
                 if value == "inherit" {
                     Ok (Opacity::Inherit)
                 } else {
@@ -79,7 +80,7 @@ impl FromStr for Opacity {
                 }
             },
 
-            Ok (Token::Number (NumericValue { value, .. })) => {
+            Ok (&Token::Number { value, .. }) => {
                 if value < 0.0 {
                     Ok (Opacity::Specified (0.0))
                 } else if value > 1.0 {
diff --git a/rust/src/parsers.rs b/rust/src/parsers.rs
index 5481fd1..a4e38f6 100644
--- a/rust/src/parsers.rs
+++ b/rust/src/parsers.rs
@@ -1,5 +1,5 @@
 use ::libc;
-use ::cssparser::{Parser, Token, BasicParseError, NumericValue};
+use ::cssparser::{Parser, ParserInput, Token, BasicParseError};
 use ::glib::translate::*;
 use ::glib_sys;
 
@@ -34,18 +34,19 @@ impl<'a> From<BasicParseError<'a>> for ParseError {
 // Returns an f64 angle in degrees
 
 pub fn angle_degrees (s: &str) -> Result <f64, ParseError> {
-    let mut parser = Parser::new (s);
+    let mut input = ParserInput::new (s);
+    let mut parser = Parser::new (&mut input);
 
     let token = parser.next ()
         .map_err (|_| ParseError::new ("expected angle"))?;
 
-    match token {
-        Token::Number (NumericValue { value, .. }) => Ok (value as f64),
+    match *token {
+        Token::Number { value, .. } => Ok (value as f64),
 
-        Token::Dimension (NumericValue { value, .. }, cow) => {
+        Token::Dimension { value, unit, .. } => {
             let value = value as f64;
 
-            match cow.as_ref () {
+            match unit.as_ref () {
                 "deg"  => Ok (value),
                 "grad" => Ok (value * 360.0 / 400.0),
                 "rad"  => Ok (value * 180.0 / PI),
@@ -70,14 +71,15 @@ fn optional_comma (parser: &mut Parser) {
 // https://www.w3.org/TR/SVG/types.html#DataTypeNumberOptionalNumber
 
 pub fn number_optional_number (s: &str) -> Result <(f64, f64), ParseError> {
-    let mut parser = Parser::new (s);
+    let mut input = ParserInput::new (s);
+    let mut parser = Parser::new (&mut input);
 
     let x = parser.expect_number ()? as f64;
 
     if !parser.is_exhausted () {
         let position = parser.position ();
 
-        match parser.next ()? {
+        match *parser.next ()? {
             Token::Comma => {},
             _ => parser.reset (position)
         };
@@ -126,7 +128,8 @@ pub extern fn rsvg_css_parse_number_optional_number (s: *const libc::c_char,
 // https://www.w3.org/TR/SVG/shapes.html#PointsBNF
 
 pub fn list_of_points (string: &str) -> Result <Vec<(f64, f64)>, ParseError> {
-    let mut parser = Parser::new (string);
+    let mut input = ParserInput::new (string);
+    let mut parser = Parser::new (&mut input);
 
     let mut v = Vec::new ();
 
@@ -144,7 +147,7 @@ pub fn list_of_points (string: &str) -> Result <Vec<(f64, f64)>, ParseError> {
         }
 
         match parser.next_including_whitespace () {
-            Ok (Token::WhiteSpace(_)) => (),
+            Ok (&Token::WhiteSpace(_)) => (),
             _ => optional_comma (&mut parser)
         }
     }
@@ -173,7 +176,8 @@ pub fn number_list (s: &str, length: ListLength) -> Result <Vec<f64>, NumberList
         ListLength::Maximum (l) => { assert! (l > 0); n = l; }
     }
 
-    let mut parser = Parser::new (s);
+    let mut input = ParserInput::new (s);
+    let mut parser = Parser::new (&mut input);
 
     let mut v = Vec::<f64>::with_capacity (n);