Merge branch 'master' into overflow

Author: SimonSapin

Cargo.toml

@@ -14,6 +14,7 @@ license = "MPL-2.0"
 
 [dev-dependencies]
 rustc-serialize = "0.3"
+tempdir = "0.3"
 
 
 [dependencies]

src/color.rs

@@ -4,7 +4,6 @@
 
 use std::ascii::AsciiExt;
 use std::fmt;
-use std::num::Float;
 
 use text_writer::{self, TextWriter};
 

src/css-parsing-tests/component_value_list.json

@@ -380,22 +380,23 @@
     ["unicode-range", 1048576, 2097151], "?"
 ],
 
-"u+1-2 U+100000-2 U+1000000-2 U+10-200000", [
-    ["unicode-range", 1, 2], " ",
+"u+20-3F U+100000-2 U+1000000-2 U+10-200000", [
+    ["unicode-range", 32, 63], " ",
     ["unicode-range", 1048576, 2], " ",
     ["unicode-range", 1048576, 1048576], ["number", "0", 0, "integer"],
         ["number", "-2", -2, "integer"], " ",
     ["unicode-range", 16, 2097152]
 ],
 
-"ù+12 Ü+12 u +12 U+ 12 U+12 - 20 U+1?2 U+1?-50", [
+"ù+12 Ü+12 u +12 U+ 12 U+12 - 20 U+1?2 U+1?-50 U+1- 2", [
     ["ident", "ù"], ["number", "+12", 12, "integer"], " ",
     ["ident", "Ü"], ["number", "+12", 12, "integer"], " ",
     ["ident", "u"], " ", ["number", "+12", 12, "integer"], " ",
     ["ident", "U"], "+", " ", ["number", "12", 12, "integer"], " ",
     ["unicode-range", 18, 18], " ", "-", " ", ["number", "20", 20, "integer"], " ",
     ["unicode-range", 16, 31], ["number", "2", 2, "integer"], " ",
-    ["unicode-range", 16, 31], ["number", "-50", -50, "integer"]
+    ["unicode-range", 16, 31], ["number", "-50", -50, "integer"], " ",
+    ["unicode-range", 1, 1], "-", " ", ["number", "2", 2, "integer"]
 ],
 
 "~=|=^=$=*=||<!------> |/**/| ~/**/=", [

src/from_bytes.rs

@@ -35,7 +35,7 @@ pub fn decode_stylesheet_bytes(css: &[u8], protocol_encoding_label: Option<&str>
     if css.starts_with("@charset \"".as_bytes()) {
         // 10 is "@charset \"".len()
         // 100 is arbitrary so that no encoding label is more than 100-10 bytes.
-        match css[10..cmp::min(css.len(), 100)].position_elem(&('"' as u8)) {
+        match css[10..cmp::min(css.len(), 100)].iter().position(|&b| b == b'"') {
             None => (),
             Some(label_length)
             => if css[10 + label_length..].starts_with("\";".as_bytes()) {

src/lib.rs

@@ -5,8 +5,6 @@
 #![crate_name = "cssparser"]
 #![crate_type = "rlib"]
 
-#![feature(core, collections)]
-#![cfg_attr(test, feature(test, old_io, old_path))]
 #![deny(missing_docs)]
 
 /*!
@@ -68,8 +66,8 @@ fn parse_border_spacing(_context: &ParserContext, input: &mut Parser)
 extern crate encoding;
 extern crate text_writer;
 #[macro_use] extern crate matches;
-#[cfg(test)] extern crate test;
-#[cfg(test)] extern crate "rustc-serialize" as serialize;
+#[cfg(test)] extern crate tempdir;
+#[cfg(test)] extern crate rustc_serialize;
 
 pub use tokenizer::{Token, NumericValue, PercentageValue, SourceLocation};
 pub use rules_and_declarations::{parse_important};
@@ -99,7 +97,7 @@ match_ignore_ascii_case! { string,
 }
 ```
 
-The macro also calls `.as_slice()` on the value,
+The macro also takes a slice of the value,
 so that a `String` or `CowString` could be passed directly instead of a `&str`.
 
 Note that because of `macro_rules` ambiguity resolutions quirks,
@@ -111,7 +109,7 @@ macro_rules! match_ignore_ascii_case {
     ( $value: expr, $( $string: expr => $result: expr ),+ _ => $fallback: expr ) => {
         {
             use std::ascii::AsciiExt;
-            match $value.as_slice() {
+            match &$value[..] {
                 $(
                     s if s.eq_ignore_ascii_case($string) => $result,
                 )+

src/parser.rs

@@ -290,6 +290,11 @@ impl<'i, 't> Parser<'i, 't> {
     }
 
     /// Same as `Parser::next`, but does not skip whitespace or comment tokens.
+    ///
+    /// **Note**: This should only be used in contexts like a CSS pre-processor
+    /// where comments are preserved.
+    /// When parsing higher-level values, per the CSS Syntax specification,
+    /// comments should always be ignored between tokens.
     pub fn next_including_whitespace_and_comments(&mut self) -> Result<Token<'i>, ()> {
         if let Some(block_type) = self.at_start_of.take() {
             consume_until_end_of_block(block_type, &mut *self.tokenizer);
@@ -373,6 +378,9 @@ impl<'i, 't> Parser<'i, 't> {
                 stop_before: closing_delimiter,
             };
             result = nested_parser.parse_entirely(parse);
+            if let Some(block_type) = nested_parser.at_start_of {
+                consume_until_end_of_block(block_type, &mut *nested_parser.tokenizer);
+            }
         }
         consume_until_end_of_block(block_type, &mut *self.tokenizer);
         result
@@ -437,6 +445,15 @@ impl<'i, 't> Parser<'i, 't> {
         result
     }
 
+    /// Parse a <whitespace-token> and return its value.
+    #[inline]
+    pub fn expect_whitespace(&mut self) -> Result<&'i str, ()> {
+        match try!(self.next_including_whitespace()) {
+            Token::WhiteSpace(value) => Ok(value),
+            _ => Err(())
+        }
+    }
+
     /// Parse a <ident-token> and return the unescaped value.
     #[inline]
     pub fn expect_ident(&mut self) -> Result<Cow<'i, str>, ()> {
@@ -611,6 +628,27 @@ impl<'i, 't> Parser<'i, 't> {
             _ => Err(())
         }
     }
+
+    /// Parse the input until exhaustion and check that it contains no “error” token.
+    ///
+    /// See `Token::is_parse_error`. This also checks nested blocks and functions recursively.
+    #[inline]
+    pub fn expect_no_error_token(&mut self) -> Result<(), ()> {
+        loop {
+            match self.next_including_whitespace_and_comments() {
+                Ok(Token::Function(_)) | Ok(Token::ParenthesisBlock) |
+                Ok(Token::SquareBracketBlock) | Ok(Token::CurlyBracketBlock) => {
+                    try!(self.parse_nested_block(|input| input.expect_no_error_token()))
+                }
+                Ok(token) => {
+                    if token.is_parse_error() {
+                        return Err(())
+                    }
+                }
+                Err(()) => return Ok(())
+            }
+        }
+    }
 }
 
 

src/serializer.rs

@@ -4,7 +4,6 @@
 
 use std::fmt;
 use std::cmp;
-use std::num::{Float, Int};
 
 use text_writer::{self, TextWriter};
 
@@ -49,11 +48,11 @@ pub trait ToCss {
 fn write_numeric<W>(value: NumericValue, dest: &mut W) -> text_writer::Result
 where W: TextWriter {
     // `value.value >= 0` is true for negative 0.
-    if value.has_sign && value.value.is_positive() {
+    if value.has_sign && value.value.is_sign_positive() {
         try!(dest.write_str("+"));
     }
 
-    if value.value == 0.0 && value.value.is_negative() {
+    if value.value == 0.0 && value.value.is_sign_negative() {
         // Negative zero. Work around #20596.
         try!(dest.write_str("-0"))
     } else {
@@ -120,11 +119,13 @@ impl<'a> ToCss for Token<'a> {
             Token::UnicodeRange(start, end) => {
                 try!(dest.write_str("U+"));
                 let bits = cmp::min(start.trailing_zeros(), (!end).trailing_zeros());
-                if bits >= 4 && start >> bits == end >> bits {
-                    let question_marks = bits / 4;
-                    let common = start >> question_marks * 4;
-                    if common != 0 {
-                        try!(write!(dest, "{:X}", common));
+                let question_marks = bits / 4;
+                let bits = question_marks * 4;
+                let truncated_start = start >> bits;
+                let truncated_end = end >> bits;
+                if truncated_start == truncated_end {
+                    if truncated_start != 0 {
+                        try!(write!(dest, "{:X}", truncated_start));
                     }
                     for _ in (0..question_marks) {
                         try!(dest.write_str("?"));