derivre 0.3.6

A derivative-based regular expression engine
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
83
84

use derivre::Regex;

fn check_is_match(rx: &mut Regex, s: &str, exp: bool) {
    if rx.is_match(s) == exp {
    } else {
        panic!(
            "error for: {:?}; expected {}",
            s,
            if exp { "match" } else { "no match" }
        );
    }
}

fn match_(rx: &mut Regex, s: &str) {
    check_is_match(rx, s, true);
}

fn match_many(rx: &mut Regex, ss: &[&str]) {
    for s in ss {
        match_(rx, s);
    }
}

fn no_match(rx: &mut Regex, s: &str) {
    check_is_match(rx, s, false);
}

fn no_match_many(rx: &mut Regex, ss: &[&str]) {
    for s in ss {
        no_match(rx, s);
    }
}

fn look(rx: &mut Regex, s: &str, exp: Option<usize>) {
    let res = rx.lookahead_len(s);
    if res == exp {
    } else {
        panic!(
            "lookahead len error for: {:?}; expected {:?}, got {:?}",
            s, exp, res
        )
    }
}

fn main() {
    let mut rx = Regex::new("[ab]c").unwrap();
    assert!(rx.is_match("ac"));
    assert!(rx.is_match("bc"));
    assert!(!rx.is_match("xxac"));
    assert!(!rx.is_match("acxx"));

    let mut rx = Regex::new("[abx]*(?P<stop>[xq]*y)").unwrap();
    assert!(rx.lookahead_len("axxxxxxxy") == Some(1));
    assert!(rx.lookahead_len("axxxxxxxqqqy") == Some(4));
    assert!(rx.lookahead_len("axxxxxxxqqq").is_none());
    assert!(rx.lookahead_len("ccqy").is_none());

    let mut rx = Regex::new("a[bc](de|fg)").unwrap();
    no_match(&mut rx, "abd");
    match_(&mut rx, "abde");
    look(&mut rx, "abde", Some(0));

    no_match(&mut rx, "abdea");
    println!("{:?}", rx);

    let mut rx = Regex::new("a[bc]*(de|fg)*x").unwrap();
    no_match_many(&mut rx, &["", "a", "b", "axb"]);
    match_many(&mut rx, &["ax", "abdex", "abcbcbcbcdex", "adefgdefgx"]);
    println!("{:?}", rx);
    //
    //
    //

    eprintln!("\n\n\nSTART");
    let parser = regex_syntax::ParserBuilder::new()
        // .dot_matches_new_line(false)
        // .unicode(false)
        // .utf8(false)
        .build();
    let mut rx = Regex::new_with_parser(parser, "a(bc+|b[eh])g|.h").unwrap();
    println!("{:?}", rx);
    no_match(&mut rx, "abh");
    println!("{:?}", rx);
}