tiny.css.match

1/// The sheet side tables a compound test reads.2pub const Context = struct {3    classes: []const u32,4    nths: []const selector.nth.Nth,5};

1/// The tree interface the matcher runs against. `ui` and `browser` fill it2/// over their own node storage, which is how one matcher serves both.3///4/// `parent` and `previous` return the node's own index when it has no parent5/// or no preceding sibling. `sibling_index` packs the one based index in the6/// low sixteen bits and the sibling count in the high sixteen, because7/// `:nth-last-child` needs the count and the call returns one word.8///9/// `classes` writes at most `capacity` atoms and returns how many the element10/// has. Reporting more than `capacity` is a programmer error and is asserted.11pub const Element = extern struct {12    context: ?*anyopaque,13    parent: *const fn (?*anyopaque, u32) callconv(.c) u32,14    previous: *const fn (?*anyopaque, u32) callconv(.c) u32,15    kind: *const fn (?*anyopaque, u32) callconv(.c) u16,16    role: *const fn (?*anyopaque, u32) callconv(.c) u16,17    identifier: *const fn (?*anyopaque, u32) callconv(.c) u32,18    classes: *const fn (?*anyopaque, u32, [*]u32, u32) callconv(.c) u32,19    pseudo: *const fn (?*anyopaque, u32) callconv(.c) u32,20    sibling_index: *const fn (?*anyopaque, u32, bool) callconv(.c) u32,21};

1/// One selector that matched an element, carried to the cascade.2pub const Match = struct {3    rule: u32,4    selector: u32,5    specificity: Specificity,6    order: u32,7};

1/// Whether one compound matches one node.2pub fn matchCompound(3    context: Context,4    compound: Compound,5    element: Element,6    node: u32,7) bool {8    if (compound.flags & selector.unmatchable != 0) return false;9    if (compound.kind != 0 and element.kind(element.context, node) != compound.kind) return false;10    if (compound.role != 0 and element.role(element.context, node) != compound.role) return false;11    if (compound.id != 0 and element.identifier(element.context, node) != compound.id) return false;12    if (compound.pseudo != 0) {13        const state = element.pseudo(element.context, node);14        if (state & compound.pseudo != compound.pseudo) return false;15    }16    if (compound.class_count > 0 and !matchClasses(context, compound, element, node)) return false;17    if (compound.nth != 0 and !matchNth(context, compound.nth, element, node)) return false;18    return true;19}

1/// Whether `item` matches `node`. The rightmost compound is tested first, then2/// the chain walks leftwards with backtracking at the two loose combinators.3pub fn matches(context: Context, item: Selector, element: Element, node: u32) bool {4    std.debug.assert(item.compounds.len > 0);5    std.debug.assert(item.compounds.len <= max_compounds);6    std.debug.assert(item.combinators.len + 1 == item.compounds.len);7    if (!matchCompound(context, item.rightmost(), element, node)) return false;8    return matchChain(context, item, element, node);9}

1/// The most compounds one selector may carry.2pub const max_compounds: usize = 32;

1/// The deepest ancestor chain a combinator walk crosses. It is the depth bound2/// the layout solver already declares, so a descendant match is bounded work.3pub const max_depth: u32 = 64;

1/// Packs a one based sibling index and a sibling count into one word.2pub fn packSibling(index: u32, count: u32) u32 {3    std.debug.assert(index <= 0xFFFF);4    std.debug.assert(count <= 0xFFFF);5    return (count << 16) | index;6}

1/// The sibling count inside a packed sibling word.2pub fn siblingCount(word: u32) u32 {3    return word >> 16;4}

1/// The one based sibling index inside a packed sibling word.2pub fn siblingIndex(word: u32) u32 {3    return word & 0xFFFF;4}

1//! Selector matching over an element interface, plus the rule bucket index.2//!3//! The matcher is parameterized by `Element`, a vtable a consumer fills over4//! its own node storage, so `ui` and `browser` share one implementation and5//! `css` imports neither.6//!7//! Matching runs right to left. The rightmost compound is tested first, and the8//! chain then walks leftwards with backtracking at the descendant and9//! subsequent sibling combinators, bounded by `max_depth`.1011const engine = @import("engine.zig");1213pub const Context = engine.Context;14pub const Element = engine.Element;15pub const Match = engine.Match;16pub const matchCompound = engine.matchCompound;17pub const matches = engine.matches;18pub const max_compounds = engine.max_compounds;19pub const max_depth = engine.max_depth;20pub const max_element_classes = engine.max_element_classes;21pub const packSibling = engine.packSibling;22pub const siblingCount = engine.siblingCount;23pub const siblingIndex = engine.siblingIndex;

1pub const match = @import("match/root.zig");