vb6parse 1.0.0

vb6parse is a library for parsing and analyzing VB6 code, from projects, to controls, to modules, and forms.
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

use vb6parse::{ModuleFile, SourceFile};

use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
use std::hint::black_box;

// Define file size categories
#[derive(Debug)]
enum FileSize {
    Small,  // < 2KB
    Medium, // 2-10KB
    Large,  // > 10KB
}

impl FileSize {
    fn categorize(bytes: &[u8]) -> Self {
        let size = bytes.len();
        if size < 2048 {
            FileSize::Small
        } else if size < 10240 {
            FileSize::Medium
        } else {
            FileSize::Large
        }
    }

    fn as_str(&self) -> &str {
        match self {
            FileSize::Small => "small",
            FileSize::Medium => "medium",
            FileSize::Large => "large",
        }
    }
}

struct ModuleBenchmark {
    name: String,
    data: Vec<u8>,
    size_category: FileSize,
}

impl ModuleBenchmark {
    fn new(name: &str, data: &[u8]) -> Self {
        let size_category = FileSize::categorize(data);
        Self {
            name: name.to_owned(),
            data: data.to_vec(),
            size_category,
        }
    }
}

fn module_benchmarks(criterion: &mut Criterion) {
    let modules = vec![
        ModuleBenchmark::new(
            "Physics_Logic.bas",
            include_bytes!("../tests/data/vb6-code/Game-physics-basic/Physics_Logic.bas"),
        ),
        ModuleBenchmark::new(
            "Levels/mod_PublicVars.bas",
            include_bytes!("../tests/data/vb6-code/Levels-effect/mod_PublicVars.bas"),
        ),
        ModuleBenchmark::new(
            "HistogramsAdv/mod_PublicVars.bas",
            include_bytes!("../tests/data/vb6-code/Histograms-advanced/mod_PublicVars.bas"),
        ),
        ModuleBenchmark::new(
            "MapEditor/Declarations.bas",
            include_bytes!("../tests/data/vb6-code/Map-editor-2D/Declarations.bas"),
        ),
        ModuleBenchmark::new(
            "MapEditor/Subs.bas",
            include_bytes!("../tests/data/vb6-code/Map-editor-2D/Subs.bas"),
        ),
        ModuleBenchmark::new(
            "Histograms/mod_PublicVars.bas",
            include_bytes!("../tests/data/vb6-code/Histograms-basic/mod_PublicVars.bas"),
        ),
        ModuleBenchmark::new(
            "ArtificialLife/Declarations.bas",
            include_bytes!("../tests/data/vb6-code/Artificial-life/Declarations.bas"),
        ),
    ];

    let mut group = criterion.benchmark_group("module_files");

    for module in &modules {
        let benchmark_name = format!("{}/{}", module.size_category.as_str(), module.name);

        group.throughput(Throughput::Bytes(module.data.len() as u64));
        group.bench_with_input(
            BenchmarkId::from_parameter(&benchmark_name),
            &module,
            |bench, module| {
                let source_file =
                    SourceFile::decode_with_replacement(&module.name, module.data.as_slice())
                        .expect("Failed to decode module file");

                bench.iter(|| {
                    black_box(ModuleFile::parse(black_box(&source_file)));
                });
            },
        );
    }

    group.finish();
}

criterion_group!(benches, module_benchmarks);
criterion_main!(benches);