Struct TopLevelRuleParser 

pub struct TopLevelRuleParser<'a, 'i> {
    pub shared_lock: &'a SharedRwLock,
    pub loader: Option<&'a dyn StylesheetLoader>,
    pub context: ParserContext<'a>,
    pub state: State,
    pub dom_error: Option<RulesMutateError>,
    pub insert_rule_context: Option<InsertRuleContext<'a>>,
    pub allow_import_rules: AllowImportRules,
    pub wants_first_declaration_block: bool,
    pub first_declaration_block: PropertyDeclarationBlock,
    pub declaration_parser_state: DeclarationParserState<'i>,
    pub error_reporting_state: Vec<SelectorList<SelectorImpl>>,
    pub rules: Vec<CssRule>,
}

The parser for the top-level rules in a stylesheet.

Fields

shared_lock: &'a SharedRwLock

A reference to the lock we need to use to create rules.

loader: Option<&'a dyn StylesheetLoader>

A reference to a stylesheet loader if applicable, for @import rules.

context: ParserContext<'a>

The top-level parser context.

state: State

The current state of the parser.

dom_error: Option<RulesMutateError>

Whether we have tried to parse was invalid due to being in the wrong place (e.g. an @import rule was found while in the Body state). Reset to false when take_had_hierarchy_error is called.

insert_rule_context: Option<InsertRuleContext<'a>>

The info we need insert a rule in a list.

allow_import_rules: AllowImportRules

Whether @import rules will be allowed.

wants_first_declaration_block: bool

Whether to keep declarations into first_declaration_block, rather than turning it into a nested declarations rule.

first_declaration_block: PropertyDeclarationBlock

The first declaration block, only relevant when wants_first_declaration_block is true.

declaration_parser_state: DeclarationParserState<'i>

Parser state for declaration blocks in either nested rules or style rules.

error_reporting_state: Vec<SelectorList<SelectorImpl>>

State we keep around only for error reporting purposes. Right now that contains just the selectors stack for nesting, if any.

TODO(emilio): This isn’t populated properly for insertRule() but…

rules: Vec<CssRule>

The rules we’ve parsed so far.

Implementations

impl<'a, 'i> TopLevelRuleParser<'a, 'i>

fn nested(&mut self) -> &mut NestedRuleParser<'a, 'i>

pub fn state(&self) -> State

Returns the current state of the parser.

pub fn can_parse_declarations(&self) -> bool

If we’re in a nested state, this returns whether declarations can be parsed. See RuleBodyItemParser::parse_declarations().

fn in_style_rule(&self) -> bool

fn in_page_rule(&self) -> bool

fn in_specified_rule(&self, bits: u32) -> bool

fn in_style_or_page_rule(&self) -> bool

fn check_state(&mut self, new_state: State) -> bool

Checks whether we can parse a rule that would transition us to new_state.

This is usually a simple branch, but we may need more bookkeeping if doing insertRule from CSSOM.

Trait Implementations

impl<'a, 'i> AtRuleParser<'i> for TopLevelRuleParser<'a, 'i>

type Prelude = AtRulePrelude

The intermediate representation of prelude of an at-rule.

type AtRule = SourcePosition

The finished representation of an at-rule.

type Error = StyleParseErrorKind<'i>

The error type that is included in the ParseError value that can be returned.

fn parse_prelude<'t>( &mut self, name: CowRcStr<'i>, input: &mut Parser<'i, 't>, ) -> Result<AtRulePrelude, ParseError<'i>>

Parse the prelude of an at-rule with the given name.

fn parse_block<'t>( &mut self, prelude: AtRulePrelude, start: &ParserState, input: &mut Parser<'i, 't>, ) -> Result<Self::AtRule, ParseError<'i>>

Parse the content of a { /* ... */ } block for the body of the at-rule.

fn rule_without_block( &mut self, prelude: AtRulePrelude, start: &ParserState, ) -> Result<Self::AtRule, ()>

End an at-rule which doesn’t have block. Return the finished representation of the at-rule.

impl<'a, 'i> QualifiedRuleParser<'i> for TopLevelRuleParser<'a, 'i>

type Prelude = SelectorList<SelectorImpl>

The intermediate representation of a qualified rule prelude.

type QualifiedRule = SourcePosition

The finished representation of a qualified rule.

type Error = StyleParseErrorKind<'i>

The error type that is included in the ParseError value that can be returned.

fn parse_prelude<'t>( &mut self, input: &mut Parser<'i, 't>, ) -> Result<Self::Prelude, ParseError<'i>>

Parse the prelude of a qualified rule. For style rules, this is as Selector list.

fn parse_block<'t>( &mut self, prelude: Self::Prelude, start: &ParserState, input: &mut Parser<'i, 't>, ) -> Result<Self::QualifiedRule, ParseError<'i>>

Parse the content of a { /* ... */ } block for the body of the qualified rule.