use std::collections::HashSet;
use std::sync::OnceLock;
use super::generated::{FUNCTIONS, PROPERTIES, TYPES};
use super::grammar::Grammar;
#[derive(Debug, PartialEq, Eq)]
pub struct PropertyData {
pub name: &'static str,
pub syntax: Option<&'static str>,
pub initial: Option<&'static str>,
pub inherited: Option<bool>,
pub longhands: &'static [&'static str],
pub alias_of: Option<&'static str>,
pub href: &'static str,
}
pub type Property = PropertyData;
impl PropertyData {
pub fn is_shorthand(&self) -> bool {
!self.longhands.is_empty()
}
pub(crate) fn position(&self) -> Option<usize> {
let at = (self as *const PropertyData as usize).wrapping_sub(PROPERTIES.as_ptr() as usize)
/ std::mem::size_of::<PropertyData>();
match PROPERTIES.get(at) {
Some(p) if std::ptr::eq(p, self) => Some(at),
_ => index(self.name),
}
}
pub(crate) fn keywords(&self) -> &'static Keywords {
static ALL: OnceLock<Vec<OnceLock<Keywords>>> = OnceLock::new();
static NONE: OnceLock<Keywords> = OnceLock::new();
let all = ALL.get_or_init(|| PROPERTIES.iter().map(|_| OnceLock::new()).collect());
let (Some(i), Some(g)) = (self.position(), self.grammar()) else {
return NONE.get_or_init(Keywords::default);
};
all[i].get_or_init(|| keywords_of(g))
}
pub(crate) fn takes_names(&self) -> bool {
static ALL: OnceLock<Vec<OnceLock<bool>>> = OnceLock::new();
let all = ALL.get_or_init(|| PROPERTIES.iter().map(|_| OnceLock::new()).collect());
let (Some(i), Some(g)) = (self.position(), self.grammar()) else {
return true;
};
*all[i].get_or_init(|| names_in(g))
}
pub fn grammar(&self) -> Option<&'static Grammar> {
let grammars = grammars();
let i = self.position()?;
if let Some(g) = &grammars.properties[i] {
return Some(g);
}
let target = property(self.alias_of?)?;
grammars.properties[index(target.name)?].as_ref()
}
}
pub fn property(name: &str) -> Option<&'static Property> {
index(name).map(|i| &PROPERTIES[i])
}
pub fn properties() -> &'static [Property] {
PROPERTIES
}
fn index(name: &str) -> Option<usize> {
let table = by_name();
let mask = table.len() - 1;
let mut slot = fnv_lower(name.as_bytes()) as usize & mask;
loop {
match table[slot] {
0 => return None,
i => {
let i = i as usize - 1;
let found = PROPERTIES[i].name;
if found.len() == name.len() && (found == name || found.eq_ignore_ascii_case(name))
{
return Some(i);
}
}
}
slot = (slot + 1) & mask;
}
}
fn fnv_lower(bytes: &[u8]) -> u32 {
let word = |b: &[u8]| {
let mut w = [0u8; 8];
w[..b.len()].copy_from_slice(b);
u64::from_le_bytes(w) | 0x2020_2020_2020_2020
};
let n = bytes.len();
let (head, tail) = if n >= 8 {
(word(&bytes[..8]), word(&bytes[n - 8..]))
} else {
(word(bytes), 0)
};
let h = (head ^ tail.rotate_left(29) ^ n as u64).wrapping_mul(0x9e37_79b9_7f4a_7c15);
(h >> 32) as u32
}
fn by_name() -> &'static [u16] {
static TABLE: OnceLock<Vec<u16>> = OnceLock::new();
TABLE.get_or_init(|| {
let size = (PROPERTIES.len() * 2).next_power_of_two();
let mut t = vec![0u16; size];
for (i, p) in PROPERTIES.iter().enumerate() {
let mut slot = fnv_lower(p.name.as_bytes()) as usize & (size - 1);
while t[slot] != 0 {
slot = (slot + 1) & (size - 1);
}
t[slot] = i as u16 + 1;
}
t
})
}
#[derive(Default)]
pub(crate) struct Fnv(u64);
impl std::hash::Hasher for Fnv {
fn finish(&self) -> u64 {
self.0
}
fn write(&mut self, bytes: &[u8]) {
let mut h = if self.0 == 0 {
0xcbf2_9ce4_8422_2325
} else {
self.0
};
for b in bytes {
h = (h ^ u64::from(*b)).wrapping_mul(0x100_0000_01b3);
}
self.0 = h;
}
}
pub(crate) type FnvBuild = std::hash::BuildHasherDefault<Fnv>;
pub(crate) type Keywords = HashSet<&'static str, FnvBuild>;
fn keywords_of(g: &'static Grammar) -> Keywords {
let mut out = Keywords::default();
let mut seen: HashSet<*const Grammar> = HashSet::new();
let mut stack = vec![g];
while let Some(g) = stack.pop() {
if !seen.insert(g) {
continue;
}
match g {
Grammar::Keyword(k) => {
out.insert(&**k);
}
Grammar::Type(t) => {
let found = match t.name.strip_suffix("()") {
Some(_) => None,
None => type_grammar(&t.name),
};
stack.extend(found);
}
Grammar::Property(r) => stack.extend(property(&r.name).and_then(|p| p.grammar())),
Grammar::Sequence(v) | Grammar::All(v) | Grammar::Any(v) | Grammar::One(v) => {
stack.extend(v.iter())
}
Grammar::Repeat { item, .. } | Grammar::NonEmpty(item) => stack.push(item),
_ => {}
}
}
out
}
fn names_in(g: &'static Grammar) -> bool {
let mut seen: HashSet<*const Grammar> = HashSet::new();
let mut stack = vec![g];
while let Some(g) = stack.pop() {
if !seen.insert(g) {
continue;
}
match g {
Grammar::Type(t) => {
if t.name.ends_with("()") {
continue;
}
match &*t.name {
"ident"
| "custom-ident"
| "dashed-ident"
| "custom-property-name"
| "color"
| "declaration-value"
| "any-value" => return true,
name => stack.extend(type_grammar(name)),
}
}
Grammar::Property(r) => stack.extend(property(&r.name).and_then(|p| p.grammar())),
Grammar::Sequence(v) | Grammar::All(v) | Grammar::Any(v) | Grammar::One(v) => {
stack.extend(v.iter())
}
Grammar::Repeat { item, .. } | Grammar::NonEmpty(item) => stack.push(item),
_ => {}
}
}
false
}
pub(crate) struct Grammars {
pub properties: Vec<Option<Grammar>>,
pub types: Vec<Option<Grammar>>,
pub functions: Vec<Option<Grammar>>,
}
pub(crate) fn grammars() -> &'static Grammars {
static G: OnceLock<Grammars> = OnceLock::new();
G.get_or_init(|| Grammars {
properties: PROPERTIES
.iter()
.map(|p| p.syntax.and_then(Grammar::parse))
.collect(),
types: TYPES.iter().map(|(_, s)| Grammar::parse(s)).collect(),
functions: FUNCTIONS.iter().map(|(_, s)| Grammar::parse(s)).collect(),
})
}
pub(crate) fn type_grammar(name: &str) -> Option<&'static Grammar> {
let i = TYPES.binary_search_by(|(n, _)| (*n).cmp(name)).ok()?;
grammars().types[i].as_ref()
}
pub(crate) fn function_grammar(name: &str) -> Option<&'static Grammar> {
let i = FUNCTIONS.binary_search_by(|(n, _)| (*n).cmp(name)).ok()?;
grammars().functions[i].as_ref()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_table() {
let longhands: Vec<_> = PROPERTIES
.iter()
.filter(|p| !p.is_shorthand() && p.alias_of.is_none())
.collect();
assert_eq!(PROPERTIES.len(), 822);
assert_eq!(longhands.len(), 597);
assert!(
PROPERTIES
.iter()
.all(|p| p.syntax.is_none() || p.grammar().is_some())
);
let mut prose = Vec::new();
for p in &longhands {
let Some(initial) = p.initial else { continue };
let values = crate::parse_component_values(initial);
if super::super::parse_value(p.name, &values).is_err() {
prose.push(format!("{}: {initial}", p.name));
}
}
assert_eq!(
prose,
[
"all: see individual properties",
"background-tbd: see individual properties",
"fill: black",
"glyph-orientation-vertical: n/a",
"text-spacing-trim: normal",
"voice-family: implementation-dependent",
]
);
}
}