145 lines
4.9 KiB
Rust
145 lines
4.9 KiB
Rust
/* This Source Code Form is subject to the terms of the Mozilla Public
|
||
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
||
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
||
|
||
use super::{BasicParseError, Parser, ParserInput, Token};
|
||
|
||
/// Parse the *An+B* notation, as found in the `:nth-child()` selector.
|
||
/// The input is typically the arguments of a function,
|
||
/// in which case the caller needs to check if the arguments’ parser is exhausted.
|
||
/// Return `Ok((A, B))`, or an `Err(..)` for a syntax error.
|
||
pub fn parse_nth<'i>(input: &mut Parser<'i, '_>) -> Result<(i32, i32), BasicParseError<'i>> {
|
||
match *input.next()? {
|
||
Token::Number {
|
||
int_value: Some(b), ..
|
||
} => Ok((0, b)),
|
||
Token::Dimension {
|
||
int_value: Some(a),
|
||
ref unit,
|
||
..
|
||
} => {
|
||
match_ignore_ascii_case! {
|
||
unit,
|
||
"n" => Ok(parse_b(input, a)?),
|
||
"n-" => Ok(parse_signless_b(input, a, -1)?),
|
||
_ => match parse_n_dash_digits(unit) {
|
||
Ok(b) => Ok((a, b)),
|
||
Err(()) => {
|
||
let unit = unit.clone();
|
||
Err(input.new_basic_unexpected_token_error(Token::Ident(unit)))
|
||
}
|
||
}
|
||
}
|
||
}
|
||
Token::Ident(ref value) => {
|
||
match_ignore_ascii_case! { value,
|
||
"even" => Ok((2, 0)),
|
||
"odd" => Ok((2, 1)),
|
||
"n" => Ok(parse_b(input, 1)?),
|
||
"-n" => Ok(parse_b(input, -1)?),
|
||
"n-" => Ok(parse_signless_b(input, 1, -1)?),
|
||
"-n-" => Ok(parse_signless_b(input, -1, -1)?),
|
||
_ => {
|
||
let (slice, a) = if let Some(stripped) = value.strip_prefix('-') {
|
||
(stripped, -1)
|
||
} else {
|
||
(&**value, 1)
|
||
};
|
||
match parse_n_dash_digits(slice) {
|
||
Ok(b) => Ok((a, b)),
|
||
Err(()) => {
|
||
let value = value.clone();
|
||
Err(input.new_basic_unexpected_token_error(Token::Ident(value)))
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
Token::Delim('+') => match *input.next_including_whitespace()? {
|
||
Token::Ident(ref value) => {
|
||
match_ignore_ascii_case! { value,
|
||
"n" => parse_b(input, 1),
|
||
"n-" => parse_signless_b(input, 1, -1),
|
||
_ => match parse_n_dash_digits(value) {
|
||
Ok(b) => Ok((1, b)),
|
||
Err(()) => {
|
||
let value = value.clone();
|
||
Err(input.new_basic_unexpected_token_error(Token::Ident(value)))
|
||
}
|
||
}
|
||
}
|
||
}
|
||
ref token => {
|
||
let token = token.clone();
|
||
Err(input.new_basic_unexpected_token_error(token))
|
||
}
|
||
},
|
||
ref token => {
|
||
let token = token.clone();
|
||
Err(input.new_basic_unexpected_token_error(token))
|
||
}
|
||
}
|
||
}
|
||
|
||
fn parse_b<'i>(input: &mut Parser<'i, '_>, a: i32) -> Result<(i32, i32), BasicParseError<'i>> {
|
||
let start = input.state();
|
||
match input.next() {
|
||
Ok(&Token::Delim('+')) => parse_signless_b(input, a, 1),
|
||
Ok(&Token::Delim('-')) => parse_signless_b(input, a, -1),
|
||
Ok(&Token::Number {
|
||
has_sign: true,
|
||
int_value: Some(b),
|
||
..
|
||
}) => Ok((a, b)),
|
||
_ => {
|
||
input.reset(&start);
|
||
Ok((a, 0))
|
||
}
|
||
}
|
||
}
|
||
|
||
fn parse_signless_b<'i>(
|
||
input: &mut Parser<'i, '_>,
|
||
a: i32,
|
||
b_sign: i32,
|
||
) -> Result<(i32, i32), BasicParseError<'i>> {
|
||
// FIXME: remove .clone() when lifetimes are non-lexical.
|
||
match input.next()?.clone() {
|
||
Token::Number {
|
||
has_sign: false,
|
||
int_value: Some(b),
|
||
..
|
||
} => Ok((a, b_sign * b)),
|
||
token => Err(input.new_basic_unexpected_token_error(token)),
|
||
}
|
||
}
|
||
|
||
fn parse_n_dash_digits(string: &str) -> Result<i32, ()> {
|
||
let bytes = string.as_bytes();
|
||
if bytes.len() >= 3
|
||
&& bytes[..2].eq_ignore_ascii_case(b"n-")
|
||
&& bytes[2..].iter().all(|&c| c.is_ascii_digit())
|
||
{
|
||
Ok(parse_number_saturate(&string[1..]).unwrap()) // Include the minus sign
|
||
} else {
|
||
Err(())
|
||
}
|
||
}
|
||
|
||
fn parse_number_saturate(string: &str) -> Result<i32, ()> {
|
||
let mut input = ParserInput::new(string);
|
||
let mut parser = Parser::new(&mut input);
|
||
let int = if let Ok(&Token::Number {
|
||
int_value: Some(int),
|
||
..
|
||
}) = parser.next_including_whitespace_and_comments()
|
||
{
|
||
int
|
||
} else {
|
||
return Err(());
|
||
};
|
||
if !parser.is_exhausted() {
|
||
return Err(());
|
||
}
|
||
Ok(int)
|
||
}
|