dfajit 0.1.0

JIT compilation of DFA transition tables to native x86_64 jump tables
Documentation 
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

use dfajit::{JitDfa, Match};
use dfajit::table::TransitionTable;
use dfajit::error::Error;

#[test]
fn test_empty_dfa() {
    let table = TransitionTable::new(0, 256).unwrap();
    let result = JitDfa::compile(&table);
    assert!(matches!(result, Err(Error::EmptyDfa)));
}

#[test]
fn test_dfa_exceeds_states() {
    let mut table = TransitionTable::new(5000, 256).unwrap();
    let result = JitDfa::compile(&table);
    assert!(result.is_ok()); // Note: currently large DFA falls back to interpreted mode, does not error
}

#[test]
fn test_dfa_from_patterns_empty() {
    let patterns: Vec<&[u8]> = vec![];
    let result = JitDfa::from_patterns(&patterns);
    assert!(matches!(result, Err(Error::EmptyDfa)));
}

#[test]
fn test_dfa_from_patterns_single() {
    let patterns: Vec<&[u8]> = vec![b"abc"];
    let dfa = JitDfa::from_patterns(&patterns).unwrap();
    
    let mut matches = vec![Match::from_parts(0, 0, 0); 10];
    let count = dfa.scan(b"xabcx", &mut matches);
    assert_eq!(count, 1);
    assert_eq!(matches[0].pattern_id(), 0);
    assert_eq!(matches[0].start(), 1);
    assert_eq!(matches[0].end(), 4);
}

#[test]
fn test_dfa_from_patterns_multiple() {
    let patterns: Vec<&[u8]> = vec![b"abc", b"x", b"yz"];
    let dfa = JitDfa::from_patterns(&patterns).unwrap();
    
    let mut matches = vec![Match::from_parts(0, 0, 0); 10];
    let count = dfa.scan(b"xabcyz", &mut matches);
    assert_eq!(count, 3);
    assert_eq!(matches[0].pattern_id(), 1); // x
    assert_eq!(matches[0].start(), 0);
    assert_eq!(matches[0].end(), 1);
    
    assert_eq!(matches[1].pattern_id(), 0); // abc
    assert_eq!(matches[1].start(), 1);
    assert_eq!(matches[1].end(), 4);
    
    assert_eq!(matches[2].pattern_id(), 2); // yz
    assert_eq!(matches[2].start(), 4);
    assert_eq!(matches[2].end(), 6);
}

#[test]
fn test_has_match_empty() {
    let patterns: Vec<&[u8]> = vec![b"abc"];
    let dfa = JitDfa::from_patterns(&patterns).unwrap();
    
    assert!(!dfa.has_match(b""));
}

#[test]
fn test_has_match_true() {
    let patterns: Vec<&[u8]> = vec![b"abc"];
    let dfa = JitDfa::from_patterns(&patterns).unwrap();
    
    assert!(dfa.has_match(b"foo abc bar"));
}

#[test]
fn test_has_match_false() {
    let patterns: Vec<&[u8]> = vec![b"abc"];
    let dfa = JitDfa::from_patterns(&patterns).unwrap();
    
    assert!(!dfa.has_match(b"foo abd bar"));
}