Switch numeric values in tokens from f64/i64 to f32/i32

Author: SimonSapin

src/color.rs

@@ -309,18 +309,18 @@ fn parse_color_function(name: &str, arguments: &mut Parser) -> Result<Color, ()>
         // Either integers or percentages, but all the same type.
         match try!(arguments.next()) {
             Token::Number(ref v) if v.int_value.is_some() => {
-                red = (v.value / 255.) as f32;
+                red = v.value / 255.;
                 try!(arguments.expect_comma());
                 green = try!(arguments.expect_integer()) as f32 / 255.;
                 try!(arguments.expect_comma());
                 blue = try!(arguments.expect_integer()) as f32 / 255.;
             }
             Token::Percentage(ref v) => {
-                red = v.unit_value as f32;
+                red = v.unit_value;
                 try!(arguments.expect_comma());
-                green = try!(arguments.expect_percentage()) as f32;
+                green = try!(arguments.expect_percentage());
                 try!(arguments.expect_comma());
-                blue = try!(arguments.expect_percentage()) as f32;
+                blue = try!(arguments.expect_percentage());
             }
             _ => return Err(())
         };
@@ -333,7 +333,7 @@ fn parse_color_function(name: &str, arguments: &mut Parser) -> Result<Color, ()>
         let lightness = (try!(arguments.expect_percentage())).max(0.).min(1.);
 
         // http://www.w3.org/TR/css3-color/#hsl-color
-        fn hue_to_rgb(m1: f64, m2: f64, mut h: f64) -> f64 {
+        fn hue_to_rgb(m1: f32, m2: f32, mut h: f32) -> f32 {
             if h < 0. { h += 1. }
             if h > 1. { h -= 1. }
 
@@ -345,14 +345,14 @@ fn parse_color_function(name: &str, arguments: &mut Parser) -> Result<Color, ()>
         let m2 = if lightness <= 0.5 { lightness * (saturation + 1.) }
                  else { lightness + saturation - lightness * saturation };
         let m1 = lightness * 2. - m2;
-        red = hue_to_rgb(m1, m2, hue + 1. / 3.) as f32;
-        green = hue_to_rgb(m1, m2, hue) as f32;
-        blue = hue_to_rgb(m1, m2, hue - 1. / 3.) as f32;
+        red = hue_to_rgb(m1, m2, hue + 1. / 3.);
+        green = hue_to_rgb(m1, m2, hue);
+        blue = hue_to_rgb(m1, m2, hue - 1. / 3.);
     }
 
     let alpha = if has_alpha {
         try!(arguments.expect_comma());
-        (try!(arguments.expect_number())).max(0.).min(1.) as f32
+        (try!(arguments.expect_number())).max(0.).min(1.)
     } else {
         1.
     };

src/parser.rs

@@ -495,7 +495,7 @@ impl<'i, 't> Parser<'i, 't> {
 
     /// Parse a <number-token> and return the integer value.
     #[inline]
-    pub fn expect_number(&mut self) -> Result<f64, ()> {
+    pub fn expect_number(&mut self) -> Result<f32, ()> {
         match try!(self.next()) {
             Token::Number(NumericValue { value, .. }) => Ok(value),
             _ => Err(())
@@ -504,7 +504,7 @@ impl<'i, 't> Parser<'i, 't> {
 
     /// Parse a <number-token> that does not have a fractional part, and return the integer value.
     #[inline]
-    pub fn expect_integer(&mut self) -> Result<i64, ()> {
+    pub fn expect_integer(&mut self) -> Result<i32, ()> {
         match try!(self.next()) {
             Token::Number(NumericValue { int_value, .. }) => int_value.ok_or(()),
             _ => Err(())
@@ -514,7 +514,7 @@ impl<'i, 't> Parser<'i, 't> {
     /// Parse a <percentage-token> and return the value.
     /// `0%` and `100%` map to `0.0` and `1.0` (not `100.0`), respectively.
     #[inline]
-    pub fn expect_percentage(&mut self) -> Result<f64, ()> {
+    pub fn expect_percentage(&mut self) -> Result<f32, ()> {
         match try!(self.next()) {
             Token::Percentage(PercentageValue { unit_value, .. }) => Ok(unit_value),
             _ => Err(())

src/tokenizer.rs

@@ -162,10 +162,10 @@ pub enum Token<'a> {
 #[derive(PartialEq, Debug, Copy, Clone)]
 pub struct NumericValue {
     /// The value as a float
-    pub value: f64,
+    pub value: f32,
 
     /// If the origin source did not include a fractional part, the value as an integer.
-    pub int_value: Option<i64>,
+    pub int_value: Option<i32>,
 
     /// Whether the number had a `+` or `-` sign.
     ///
@@ -178,10 +178,10 @@ pub struct NumericValue {
 #[derive(PartialEq, Debug, Copy, Clone)]
 pub struct PercentageValue {
     /// The value as a float, divided by 100 so that the nominal range is 0.0 to 1.0.
-    pub unit_value: f64,
+    pub unit_value: f32,
 
     /// If the origin source did not include a fractional part, the value as an integer. It is **not** divided by 100.
-    pub int_value: Option<i64>,
+    pub int_value: Option<i32>,
 
     /// Whether the number had a `+` or `-` sign.
     pub signed: bool,
@@ -685,8 +685,8 @@ fn consume_numeric<'a>(tokenizer: &mut Tokenizer<'a>) -> Token<'a> {
             repr = &repr[1..]
         }
         // TODO: handle overflow
-        (repr.parse::<f64>().unwrap(), if is_integer {
-            Some(repr.parse::<i64>().unwrap())
+        (repr.parse::<f32>().unwrap(), if is_integer {
+            Some(repr.parse::<i32>().unwrap())
         } else {
             None
         })