Method build

regex/src/exec.rs:290–365

Build an executor that can run a regular expression.

(self)

    /// Build an executor that can run a regular expression.
    pub fn build(self) -> Result<Exec, Error> {
        // Special case when we have no patterns to compile.
        // This can happen when compiling a regex set.
        if self.options.pats.is_empty() {
            let ro = Arc::new(ExecReadOnly {
                res: vec![],
                nfa: Program::new(),
                dfa: Program::new(),
                dfa_reverse: Program::new(),
                suffixes: LiteralSearcher::empty(),
                ac: None,
                match_type: MatchType::Nothing,
            });
            return Ok(Exec { ro: ro, cache: CachedThreadLocal::new() });
        }
        let parsed = self.parse()?;
        let mut nfa =
            Compiler::new()
                     .size_limit(self.options.size_limit)
                     .bytes(self.bytes || parsed.bytes)
                     .only_utf8(self.only_utf8)
                     .compile(&parsed.exprs)?;
        let mut dfa =
            Compiler::new()
                     .size_limit(self.options.size_limit)
                     .dfa(true)
                     .only_utf8(self.only_utf8)
                     .compile(&parsed.exprs)?;
        let mut dfa_reverse =
            Compiler::new()
                     .size_limit(self.options.size_limit)
                     .dfa(true)
                     .only_utf8(self.only_utf8)
                     .reverse(true)
                     .compile(&parsed.exprs)?;

        let prefixes = parsed.prefixes.unambiguous_prefixes();
        let suffixes = parsed.suffixes.unambiguous_suffixes();
        nfa.prefixes = LiteralSearcher::prefixes(prefixes);
        dfa.prefixes = nfa.prefixes.clone();
        dfa.dfa_size_limit = self.options.dfa_size_limit;
        dfa_reverse.dfa_size_limit = self.options.dfa_size_limit;

        let mut ac = None;
        if parsed.exprs.len() == 1 {
            if let Some(lits) = alternation_literals(&parsed.exprs[0]) {
                // If we have a small number of literals, then let Teddy
                // handle things (see literal/mod.rs).
                if lits.len() > 32 {
                    let fsm = AhoCorasickBuilder::new()
                        .match_kind(MatchKind::LeftmostFirst)
                        .auto_configure(&lits)
                        // We always want this to reduce size, regardless of
                        // what auto-configure does.
                        .byte_classes(true)
                        .build_with_size::<u32, _, _>(&lits)
                        .expect("AC automaton too big");
                    ac = Some(fsm);