vbscript 0.2.3

Rust VBScript lexer and parser
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
111
112
113

use std::time::Duration;

use criterion::{BatchSize, Criterion, Throughput, criterion_group, criterion_main};
use indoc::indoc;
use vbscript::lexer::Lexer;
use vbscript::parser::Parser;

pub fn lex_function(c: &mut Criterion) {
    let input = indoc! { r#"
        'tests stuff
        Function foo(bar)
            foo = bar + 1
        End Function
    "#};
    bench_lexer(c, "function", input);
}

pub fn lex_class(c: &mut Criterion) {
    let input = indoc! { r#"
        Class foo
            Public Sub bar()
                foo = bar(1)
            End Sub
            Public Function bar(bar)
                bar = bar + 1
            End Function
        End Class

        Dim obj
        Set obj = New foo
        obj.bar
        Dim x
        x = obj.bar(1)
    "#};
    bench_lexer(c, "class", input);
}

pub fn lex_script(c: &mut Criterion) {
    let input = indoc! {r#"
        'tests stuff
        Function foo(bar)
            foo = bar + 1
        End Function

        Sub bar()
            foo = foo(1)
        End Sub

        Dim x
        x = 1

        If x = 1 Then
            bar()
        End If

        Do While x < 10
            x = x + 1
        Loop
    "#};
    bench_lexer(c, "script", input);
}

pub fn parse_complex_expression(c: &mut Criterion) {
    let input = indoc! {r#"
        x = a(1,2).b.c("test").d(1).e & "test" & foo(1,2).bar.baz(1).qux
    "#};
    bench_parser(c, "complex_expression", input);
}

fn bench_lexer(c: &mut Criterion, name: &str, input: &str) {
    // Lexing: measured in bytes
    let mut group = c.benchmark_group("lexer");
    group.measurement_time(Duration::from_millis(7500));

    // To measure throughput, we need to tell `criterion`
    // how big our input is.
    group.throughput(Throughput::Bytes(input.len() as u64));
    group.bench_with_input(name, input, |b, input| {
        b.iter_batched(
            || Lexer::new(input),         // <- Our lexer is made HERE
            |mut lexer| lexer.tokenize(), // <- and runs HERE
            BatchSize::SmallInput,
        )
    });
    group.finish();
}

fn bench_parser(c: &mut Criterion, name: &str, input: &str) {
    // Lexing: measured in bytes
    let mut group = c.benchmark_group("parser");
    group.measurement_time(Duration::from_millis(7500));

    // To measure throughput, we need to tell `criterion`
    // how big our input is.
    group.throughput(Throughput::Bytes(input.len() as u64));
    group.bench_with_input(name, input, |b, input| {
        b.iter_batched(
            || Parser::new(input),      // <- Our lexer is made HERE
            |mut parser| parser.file(), // <- and runs HERE
            BatchSize::SmallInput,
        )
    });
    group.finish();
}

criterion_group!(
    benches,
    lex_function,
    lex_script,
    lex_class,
    parse_complex_expression
);
criterion_main!(benches);