Revision control
Copy as Markdown
Other Tools
/* 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
use std::mem::MaybeUninit;
/// Expands to a `match` expression with string patterns,
/// matching case-insensitively in the ASCII range.
///
/// The patterns must not contain ASCII upper case letters. (They must be already be lower-cased.)
///
/// # Example
///
/// ```rust
/// # fn main() {} // Make doctest not wrap everything in its own main
/// # fn dummy(function_name: &String) { let _ =
/// cssparser::match_ignore_ascii_case! { &function_name,
/// "rgb" => parse_rgb(..),
/// # #[cfg(not(something))]
/// "rgba" => parse_rgba(..),
/// "hsl" => parse_hsl(..),
/// "hsla" => parse_hsla(..),
/// _ => Err(format!("unknown function: {}", function_name))
/// }
/// # ;}
/// # use std::ops::RangeFull;
/// # fn parse_rgb(_: RangeFull) -> Result<(), String> { Ok(()) }
/// # fn parse_rgba(_: RangeFull) -> Result<(), String> { Ok(()) }
/// # fn parse_hsl(_: RangeFull) -> Result<(), String> { Ok(()) }
/// # fn parse_hsla(_: RangeFull) -> Result<(), String> { Ok(()) }
/// ```
#[macro_export]
macro_rules! match_ignore_ascii_case {
( $input:expr,
$(
$( #[$meta: meta] )*
$( $pattern:literal )|+ $( if $guard: expr )? => $then: expr
),+
$(,_ => $fallback:expr)?
$(,)?
) => {
{
#[inline(always)]
const fn const_usize_max(a: usize, b: usize) -> usize {
if a > b {
a
} else {
b
}
}
const MAX_LENGTH : usize = {
let mut maxlen : usize = 0;
$(
$( #[$meta] )*
// {} is necessary to work around "[E0658]: attributes on expressions are experimental"
{
$( maxlen = const_usize_max(maxlen, $pattern.len()); )+
}
)+
maxlen
};
let mut buffer = [const { core::mem::MaybeUninit::<u8>::uninit() }; MAX_LENGTH];
let input: &str = $input; // Extend lifetime of temporaries
let lowercase = $crate::_cssparser_internal_to_lowercase(&mut buffer, input);
// "A" is a short string that we know is different for every string pattern,
// since we’ve verified that none of them include ASCII upper case letters.
match lowercase.unwrap_or("A") {
$(
$( #[$meta] )*
$( $pattern )|+ $( if $guard )? => $then,
)+
$(_ => $fallback,)?
}
}
};
}
#[cfg(not(feature = "fast_match_color"))]
#[macro_export]
/// Define a function `$name(&str) -> Option<&'static $ValueType>`
///
/// The function finds a match for the input string
/// and returns a reference to the corresponding value.
/// Matching is case-insensitive in the ASCII range.
///
/// ## Example:
///
/// ```rust
/// # fn main() {} // Make doctest not wrap everything in its own main
///
/// fn color_rgb(input: &str) -> Option<(u8, u8, u8)> {
/// cssparser::ascii_case_insensitive_map! {
/// keywords -> (u8, u8, u8) = {
/// "red" => (255, 0, 0),
/// "green" => (0, 255, 0),
/// "blue" => (0, 0, 255),
/// }
/// }
/// keywords::get(input).cloned()
/// }
/// ```
///
/// You can also iterate over the map entries by using `keywords::entries()`.
macro_rules! ascii_case_insensitive_map {
($name: ident -> $ValueType: ty = { $( $key: tt => $value: expr ),+ }) => {
ascii_case_insensitive_map!($name -> $ValueType = { $( $key => $value, )+ })
};
($name: ident -> $ValueType: ty = { $( $key: tt => $value: expr, )+ }) => {
// While the obvious choice for this would be an inner module, it's not possible to
// reference from types from there, see:
//
// So we abuse a struct with static associated functions instead.
#[allow(non_camel_case_types)]
struct $name;
impl $name {
#[allow(dead_code)]
fn entries() -> impl Iterator<Item = (&'static &'static str, &'static $ValueType)> {
[ $((&$key, &$value),)* ].iter().copied()
}
fn get(input: &str) -> Option<&'static $ValueType> {
$crate::match_ignore_ascii_case!(input,
$($key => Some(&$value),)*
_ => None,
)
}
}
}
}
#[cfg(feature = "fast_match_color")]
#[macro_export]
/// Define a function `$name(&str) -> Option<&'static $ValueType>`
///
/// The function finds a match for the input string
/// and returns a reference to the corresponding value.
/// Matching is case-insensitive in the ASCII range.
///
/// ## Example:
///
/// ```rust
/// # fn main() {} // Make doctest not wrap everything in its own main
///
/// fn color_rgb(input: &str) -> Option<(u8, u8, u8)> {
/// cssparser::ascii_case_insensitive_map! {
/// keywords -> (u8, u8, u8) = {
/// "red" => (255, 0, 0),
/// "green" => (0, 255, 0),
/// "blue" => (0, 0, 255),
/// }
/// }
/// keywords::get(input).cloned()
/// }
/// ```
///
/// You can also iterate over the map entries by using `keywords::entries()`.
macro_rules! ascii_case_insensitive_map {
($($any:tt)+) => {
$crate::ascii_case_insensitive_phf_map!($($any)+);
};
}
/// Fast implementation of `ascii_case_insensitive_map!` using a phf map.
/// See `ascii_case_insensitive_map!` above for docs
#[cfg(feature = "fast_match_color")]
#[macro_export]
macro_rules! ascii_case_insensitive_phf_map {
($name: ident -> $ValueType: ty = { $( $key: tt => $value: expr ),+ }) => {
ascii_case_insensitive_phf_map!($name -> $ValueType = { $( $key => $value, )+ })
};
($name: ident -> $ValueType: ty = { $( $key: tt => $value: expr, )+ }) => {
use $crate::_cssparser_internal_phf as phf;
#[inline(always)]
const fn const_usize_max(a: usize, b: usize) -> usize {
if a > b {
a
} else {
b
}
}
const MAX_LENGTH : usize = {
let mut maxlen : usize = 0;
$( maxlen = const_usize_max(maxlen, ($key).len()); )+
maxlen
};
static __MAP: phf::Map<&'static str, $ValueType> = phf::phf_map! {
$(
$key => $value,
)*
};
// While the obvious choice for this would be an inner module, it's not possible to
// reference from types from there, see:
//
// So we abuse a struct with static associated functions instead.
#[allow(non_camel_case_types)]
struct $name;
impl $name {
#[allow(dead_code)]
fn entries() -> impl Iterator<Item = (&'static &'static str, &'static $ValueType)> {
__MAP.entries()
}
fn get(input: &str) -> Option<&'static $ValueType> {
let mut buffer = [const { core::mem::MaybeUninit::<u8>::uninit() }; MAX_LENGTH];
let lowercase = $crate::_cssparser_internal_to_lowercase(&mut buffer, input)?;
__MAP.get(lowercase)
}
}
}
}
/// Implementation detail of match_ignore_ascii_case! and ascii_case_insensitive_phf_map! macros.
///
/// **This function is not part of the public API. It can change or be removed between any versions.**
///
/// If `input` is larger than buffer, return `None`.
/// Otherwise, return `input` ASCII-lowercased, using `buffer` as temporary space if necessary.
#[doc(hidden)]
#[allow(non_snake_case)]
#[inline]
pub fn _cssparser_internal_to_lowercase<'a>(
buffer: &'a mut [MaybeUninit<u8>],
input: &'a str,
) -> Option<&'a str> {
let buffer = buffer.get_mut(..input.len())?;
#[cold]
fn make_ascii_lowercase<'a>(
buffer: &'a mut [MaybeUninit<u8>],
input: &'a str,
first_uppercase: usize,
) -> &'a str {
// This cast doesn't change the pointer's validity
// since `u8` has the same layout as `MaybeUninit<u8>`:
let input_bytes =
unsafe { &*(input.as_bytes() as *const [u8] as *const [MaybeUninit<u8>]) };
buffer.copy_from_slice(input_bytes);
// Same as above re layout, plus these bytes have been initialized:
let buffer = unsafe { &mut *(buffer as *mut [MaybeUninit<u8>] as *mut [u8]) };
buffer[first_uppercase..].make_ascii_lowercase();
// `buffer` was initialized to a copy of `input`
// (which is `&str` so well-formed UTF-8)
// then ASCII-lowercased (which preserves UTF-8 well-formedness):
unsafe { ::std::str::from_utf8_unchecked(buffer) }
}
Some(
match input.bytes().position(|byte| byte.is_ascii_uppercase()) {
Some(first_uppercase) => make_ascii_lowercase(buffer, input, first_uppercase),
// common case: input is already lower-case
None => input,
},
)
}