Clamp numbers on overflow when parsing. Fix #35, fix #72.

Author: SimonSapin

src/tests.rs

@@ -409,6 +409,62 @@ fn line_numbers() {
     assert_eq!(input.next_including_whitespace(), Err(()));
 }
 
+#[test]
+fn overflow() {
+    use std::iter::repeat;
+    use std::f32;
+
+    let css = r"
+         2147483646
+         2147483647
+         2147483648
+         10000000000000
+         1000000000000000000000000000000000000000
+         1{309 zeros}
+
+         -2147483647
+         -2147483648
+         -2147483649
+         -10000000000000
+         -1000000000000000000000000000000000000000
+         -1{309 zeros}
+
+         3.30282347e+38
+         3.40282347e+38
+         3.402824e+38
+
+         -3.30282347e+38
+         -3.40282347e+38
+         -3.402824e+38
+
+    ".replace("{309 zeros}", &repeat('0').take(309).collect::<String>());
+    let mut input = Parser::new(&css);
+
+    assert_eq!(input.expect_integer(), Ok(2147483646));
+    assert_eq!(input.expect_integer(), Ok(2147483647));
+    assert_eq!(input.expect_integer(), Ok(2147483647)); // Clamp on overflow
+    assert_eq!(input.expect_integer(), Ok(2147483647));
+    assert_eq!(input.expect_integer(), Ok(2147483647));
+    assert_eq!(input.expect_integer(), Ok(2147483647));
+
+    assert_eq!(input.expect_integer(), Ok(-2147483647));
+    assert_eq!(input.expect_integer(), Ok(-2147483648));
+    assert_eq!(input.expect_integer(), Ok(-2147483648)); // Clamp on overflow
+    assert_eq!(input.expect_integer(), Ok(-2147483648));
+    assert_eq!(input.expect_integer(), Ok(-2147483648));
+    assert_eq!(input.expect_integer(), Ok(-2147483648));
+
+    assert_eq!(input.expect_number(), Ok(3.30282347e+38));
+    assert_eq!(input.expect_number(), Ok(f32::MAX));
+    assert_eq!(input.expect_number(), Ok(f32::INFINITY));
+    assert!(f32::MAX != f32::INFINITY);
+
+    assert_eq!(input.expect_number(), Ok(-3.30282347e+38));
+    assert_eq!(input.expect_number(), Ok(f32::MIN));
+    assert_eq!(input.expect_number(), Ok(f32::NEG_INFINITY));
+    assert!(f32::MIN != f32::NEG_INFINITY);
+}
+
 #[test]
 fn line_delimited() {
     let mut input = Parser::new(" { foo ; bar } baz;,");

src/tokenizer.rs

@@ -7,10 +7,11 @@
 use std::ops::Range;
 use std::cell::Cell;
 use std::char;
-use std::num;
+use std::num::{self, Float};
 use std::ascii::AsciiExt;
 use std::borrow::{Cow, ToOwned};
 use std::borrow::Cow::{Owned, Borrowed};
+use std::i32;
 
 use self::Token::*;
 
@@ -638,32 +639,51 @@ fn consume_name<'a>(tokenizer: &mut Tokenizer<'a>) -> Cow<'a, str> {
 }
 
 
-fn consume_digits(tokenizer: &mut Tokenizer) {
-    while !tokenizer.is_eof() {
-        match tokenizer.next_char() {
-            '0'...'9' => tokenizer.advance(1),
-            _ => break
-        }
-    }
-}
-
-
 fn consume_numeric<'a>(tokenizer: &mut Tokenizer<'a>) -> Token<'a> {
     // Parse [+-]?\d*(\.\d+)?([eE][+-]?\d+)?
     // But this is always called so that there is at least one digit in \d*(\.\d+)?
-    let start_pos = tokenizer.position();
-    let mut is_integer = true;
-    let has_sign = matches!(tokenizer.next_char(), '-' | '+');
+
+    // Do all the math in f64 so that large numbers overflow to +/-inf
+    // and i32::{MIN, MAX} are within range.
+
+    let (has_sign, sign) = match tokenizer.next_char() {
+        '-' => (true, -1.),
+        '+' => (true, 1.),
+        _ => (false, 1.),
+    };
     if has_sign {
         tokenizer.advance(1);
     }
-    consume_digits(tokenizer);
+
+    let mut integral_part: f64 = 0.;
+    while let Some(digit) = tokenizer.next_char().to_digit(10) {
+        integral_part = integral_part * 10. + digit as f64;
+        tokenizer.advance(1);
+        if tokenizer.is_eof() {
+            break
+        }
+    }
+
+    let mut is_integer = true;
+
+    let mut fractional_part: f64 = 0.;
     if tokenizer.has_at_least(1) && tokenizer.next_char() == '.'
             && matches!(tokenizer.char_at(1), '0'...'9') {
         is_integer = false;
-        tokenizer.advance(2);  // '.' and first digit
-        consume_digits(tokenizer);
+        tokenizer.advance(1);  // '.' and first digit
+        let mut divisor = 10.;
+        while let Some(digit) = tokenizer.next_char().to_digit(10) {
+            fractional_part += digit as f64 / divisor;
+            divisor *= 10.;
+            tokenizer.advance(1);
+            if tokenizer.is_eof() {
+                break
+            }
+        }
     }
+
+    let mut value = sign * (integral_part + fractional_part);
+
     if (
         tokenizer.has_at_least(1)
         && matches!(tokenizer.next_char(), 'e' | 'E')
@@ -675,37 +695,57 @@ fn consume_numeric<'a>(tokenizer: &mut Tokenizer<'a>) -> Token<'a> {
         && matches!(tokenizer.char_at(2), '0'...'9')
     ) {
         is_integer = false;
-        tokenizer.advance(2);  // 'e' or 'E', and sign or first digit
-        consume_digits(tokenizer);
-    }
-    let (value, int_value) = {
-        let mut repr = tokenizer.slice_from(start_pos);
-        // Remove any + sign as int::parse() does not parse them.
-        if repr.starts_with("+") {
-            repr = &repr[1..]
+        tokenizer.advance(1);
+        let (has_sign, sign) = match tokenizer.next_char() {
+            '-' => (true, -1.),
+            '+' => (true, 1.),
+            _ => (false, 1.),
+        };
+        if has_sign {
+            tokenizer.advance(1);
+        }
+        let mut exponent: f64 = 0.;
+        while let Some(digit) = tokenizer.next_char().to_digit(10) {
+            exponent = exponent * 10. + digit as f64;
+            tokenizer.advance(1);
+            if tokenizer.is_eof() {
+                break
+            }
         }
-        // TODO: handle overflow
-        (repr.parse::<f32>().unwrap(), if is_integer {
-            Some(repr.parse::<i32>().unwrap())
+        value *= Float::powf(10., sign * exponent);
+    }
+
+    let int_value = if is_integer {
+        Some(if value >= i32::MAX as f64 {
+            i32::MAX
+        } else if value <= i32::MIN as f64 {
+            i32::MIN
         } else {
-            None
+            value as i32
         })
+    } else {
+        None
     };
+
     if !tokenizer.is_eof() && tokenizer.next_char() == '%' {
         tokenizer.advance(1);
         return Percentage(PercentageValue {
-            unit_value: value / 100.,
+            unit_value: value as f32 / 100.,
             int_value: int_value,
             has_sign: has_sign,
         })
     }
     let value = NumericValue {
-        value: value,
+        value: value as f32,
         int_value: int_value,
         has_sign: has_sign,
     };
-    if is_ident_start(tokenizer) { Dimension(value, consume_name(tokenizer)) }
-    else { Number(value) }
+    if is_ident_start(tokenizer) {
+        Dimension(value, consume_name(tokenizer))
+    }
+    else {
+        Number(value)
+    }
 }