1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163
/* 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/. */ /// See docs of the `procedural-masquerade` crate. define_invoke_proc_macro!(cssparser_internal__invoke_proc_macro); /// 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 /// #[macro_use] extern crate cssparser; /// /// # fn main() {} // Make doctest not wrap everythig in its own main /// # fn dummy(function_name: &String) { let _ = /// match_ignore_ascii_case! { &function_name, /// "rgb" => parse_rgb(..), /// "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, $( $match_body:tt )* ) => { { cssparser_internal__invoke_proc_macro! { cssparser_internal__assert_ascii_lowercase__max_len!( $( $match_body )* ) } { // MAX_LENGTH is generated by cssparser_internal__assert_ascii_lowercase__max_len cssparser_internal__to_lowercase!($input, MAX_LENGTH => lowercase); // "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") { $( $match_body )* } } } }; } /// Define a function `$name(&str) -> Option<&'static $ValueType>` /// /// The function finds a match for the input string /// in a [`phf` map](https://github.com/sfackler/rust-phf) /// and returns a reference to the corresponding value. /// Matching is case-insensitive in the ASCII range. /// /// ## Example: /// /// ```rust /// #[macro_use] extern crate cssparser; /// /// # fn main() {} // Make doctest not wrap everything in its own main /// /// fn color_rgb(input: &str) -> Option<(u8, u8, u8)> { /// ascii_case_insensitive_phf_map! { /// keyword -> (u8, u8, u8) = { /// "red" => (255, 0, 0), /// "green" => (0, 255, 0), /// "blue" => (0, 0, 255), /// } /// } /// keyword(input).cloned() /// } #[macro_export] macro_rules! ascii_case_insensitive_phf_map { ($name: ident -> $ValueType: ty = { $( $key: expr => $value: expr ),* }) => { ascii_case_insensitive_phf_map!($name -> $ValueType = { $( $key => $value, )* }) }; ($name: ident -> $ValueType: ty = { $( $key: expr => $value: expr, )* }) => { pub fn $name(input: &str) -> Option<&'static $ValueType> { cssparser_internal__invoke_proc_macro! { cssparser_internal__phf_map!( ($ValueType) $( $key ($value) )+ ) } { cssparser_internal__invoke_proc_macro! { cssparser_internal__max_len!( $( $key )+ ) } // MAX_LENGTH is generated by cssparser_internal__max_len cssparser_internal__to_lowercase!(input, MAX_LENGTH => lowercase); lowercase.and_then(|s| MAP.get(s)) } } } } /// Implementation detail of match_ignore_ascii_case! and ascii_case_insensitive_phf_map! macros. /// /// **This macro is not part of the public API. It can change or be removed between any versions.** /// /// Define a local variable named `$output` /// and assign it the result of calling `_internal__to_lowercase` /// with a stack-allocated buffer of length `$BUFFER_SIZE`. #[macro_export] #[doc(hidden)] macro_rules! cssparser_internal__to_lowercase { ($input: expr, $BUFFER_SIZE: expr => $output: ident) => { // mem::uninitialized() is ok because `buffer` is only used in `_internal__to_lowercase`, // which initializes with `copy_from_slice` the part of the buffer it uses, // before it uses it. #[allow(unsafe_code)] let mut buffer: [u8; $BUFFER_SIZE] = unsafe { ::std::mem::uninitialized() }; let input: &str = $input; let $output = $crate::_internal__to_lowercase(&mut buffer, input); } } /// 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 verisons.** /// /// 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)] pub fn _internal__to_lowercase<'a>(buffer: &'a mut [u8], input: &'a str) -> Option<&'a str> { if let Some(buffer) = buffer.get_mut(..input.len()) { if let Some(first_uppercase) = input.bytes().position(|byte| matches!(byte, b'A'...b'Z')) { buffer.copy_from_slice(input.as_bytes()); ::std::ascii::AsciiExt::make_ascii_lowercase(&mut buffer[first_uppercase..]); // `buffer` was initialized to a copy of `input` (which is &str so well-formed UTF-8) // then lowercased (which preserves UTF-8 well-formedness) unsafe { Some(::std::str::from_utf8_unchecked(buffer)) } } else { // Input is already lower-case Some(input) } } else { // Input is longer than buffer, which has the length of the longest expected string: // none of the expected strings would match. None } } #[cfg(feature = "dummy_match_byte")] macro_rules! match_byte { ($value:expr, $($rest:tt)* ) => { match $value { $( $rest )+ } }; }