clex_gen 0.3.6

A generator for clex language
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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

use clex_gen::clex_language::ast::{
    CharacterSet, DataType, PositiveReferenceType, ReferenceType, UnitExpression,
};
use clex_gen::{clex_language, get_ast};

#[test]
fn test_get_ast_with_complex_pattern() {
    let language = "(N[5,7]) (?: (N[1,5]) N[-10000,10000]{\\2}){\\1}";
    let ast = get_ast(language.to_string()).unwrap();

    assert_eq!(
        ast.expression,
        vec![
            UnitExpression::CapturingGroup {
                group_number: 1,
                range: (
                    PositiveReferenceType::ByLiteral(5),
                    PositiveReferenceType::ByLiteral(7)
                ),
            },
            UnitExpression::NonCapturingGroup {
                nest_exp: vec![
                    UnitExpression::CapturingGroup {
                        group_number: 2,
                        range: (
                            PositiveReferenceType::ByLiteral(1),
                            PositiveReferenceType::ByLiteral(5)
                        ),
                    },
                    UnitExpression::Primitives {
                        data_type: DataType::Integer(
                            ReferenceType::ByLiteral(-10000),
                            ReferenceType::ByLiteral(10000)
                        ),
                        repetition: PositiveReferenceType::ByGroup { group_number: 2 },
                    },
                ],
                repetition: PositiveReferenceType::ByGroup { group_number: 1 },
            },
            UnitExpression::Eof,
        ]
    );
}

#[test]
fn test_get_ast_with_backreference() {
    let language = "S {\\1}";
    let ast = get_ast(language.to_string()).unwrap();

    assert_eq!(
        ast.expression,
        vec![
            UnitExpression::Primitives {
                data_type: DataType::String(
                    PositiveReferenceType::ByLiteral(
                        clex_language::ast::DEFAULT_MIN_STRING_SIZE as u64
                    ),
                    PositiveReferenceType::ByLiteral(
                        clex_language::ast::DEFAULT_MAX_STRING_SIZE as u64
                    ),
                    CharacterSet::get_default_charset()
                ),
                repetition: PositiveReferenceType::ByGroup { group_number: 1 },
            },
            UnitExpression::Eof
        ]
    );
}

#[test]
fn test_custom_charset_with_string() {
    let language = "S[1, 10, 'asghdgad']";
    let ast = get_ast(language.to_string()).unwrap();

    assert_eq!(
        ast.expression,
        vec![
            UnitExpression::Primitives {
                data_type: DataType::String(
                    PositiveReferenceType::ByLiteral(1),
                    PositiveReferenceType::ByLiteral(10),
                    CharacterSet::Custom("asghdgad".to_string())
                ),
                repetition: PositiveReferenceType::ByLiteral(1),
            },
            UnitExpression::Eof
        ]
    );
}

#[test]
fn test_charset_with_string() {
    let language = "S[10, 10, @CH_ALL@]";
    let ast = get_ast(language.to_string()).unwrap();

    assert_eq!(
        ast.expression,
        vec![
            UnitExpression::Primitives {
                data_type: DataType::String(
                    PositiveReferenceType::ByLiteral(10),
                    PositiveReferenceType::ByLiteral(10),
                    CharacterSet::All
                ),
                repetition: PositiveReferenceType::ByLiteral(1),
            },
            UnitExpression::Eof
        ]
    );
}