kbvm 0.1.5

An implementation of the XKB specification
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
114

use {
    crate::xkb::{
        code::Code,
        code_map::CodeMap,
        diagnostic::DiagnosticSink,
        interner::Interner,
        kccgst::{
            formatter::{Format, Formatter},
            lexer::{Lexer, LexerError},
            parser::{parse_item, snoop_ty_and_name},
            token::Token,
        },
        meaning::MeaningCache,
        span::Spanned,
    },
    bstr::ByteSlice,
    std::sync::Arc,
    walkdir::WalkDir,
};

fn l(
    map: &mut CodeMap,
    i: &mut Interner,
    code: &Code,
) -> Result<Vec<Vec<Spanned<Token>>>, Spanned<LexerError>> {
    let span = map.add(None, None, &code);
    let mut res = vec![];
    let mut lexer = Lexer::new(None, &code, span.lo);
    loop {
        let mut tokens = vec![];
        lexer.lex_item(i, &mut tokens)?;
        if tokens.is_empty() {
            break;
        }
        res.push(tokens);
    }
    Ok(res)
}

fn s(interner: &Interner, t: &impl Format) -> Vec<u8> {
    let mut out = vec![];
    let mut f = Formatter::new(interner, &mut out);
    t.format(&mut f).unwrap();
    out
}

#[test]
fn round_trip() {
    let mut interner = Interner::default();
    let mut meaning_cache = MeaningCache::default();
    for f in ["compat", "geometry", "keycodes", "symbols", "types"] {
        let dir = format!("{}/../xkeyboard-config/{f}", env!("CARGO_MANIFEST_DIR"));
        let dir = WalkDir::new(&dir);
        for f in dir {
            let f = f.unwrap();
            if f.path().is_file() {
                if let Some(f) = f.path().file_name() {
                    if f == "README" || f == "meson.build" {
                        continue;
                    }
                }
                let path = Arc::new(f.into_path());
                let input = std::fs::read(path.as_path()).unwrap();
                let code = Code::new(&Arc::new(input));
                let mut map = CodeMap::default();
                let mut diag = vec![];
                let mut diagnostics = DiagnosticSink::new(&mut diag);
                let tokens = match l(&mut map, &mut interner, &code) {
                    Ok(t) => t,
                    Err(e) => panic!("{}: {:?}", path.display(), e),
                };
                for tokens in &tokens {
                    let (default, ty, name) =
                        snoop_ty_and_name(tokens, &interner, &mut meaning_cache).unwrap();
                    eprintln!(
                        "{}: {:?} {:?} {:?}",
                        path.display(),
                        default,
                        ty,
                        name.map(|n| interner.get(n.val).as_bstr())
                    );
                    let item = parse_item(
                        &mut map,
                        &mut diagnostics,
                        &interner,
                        &mut meaning_cache,
                        tokens,
                        0,
                        &mut { u64::MAX },
                    );
                    let item = match item {
                        Ok(i) => i,
                        Err(e) => {
                            diagnostics.push(&mut map, e.val.diagnostic_kind(), e);
                            for d in diag {
                                eprintln!("{}", d.with_code());
                            }
                            panic!();
                        }
                    };
                    let s = Arc::new(s(&interner, &item.val));
                    // println!("{}", s.as_bstr());
                    let code = Code::new(&s);
                    let t2 = match l(&mut map, &mut interner, &code) {
                        Ok(t) => t,
                        Err(e) => panic!("{}: {:?}", path.display(), e),
                    };
                    assert_eq!(t2.len(), 1);
                    assert_eq!(&t2[0], tokens, "{}", path.display());
                }
            }
        }
    }
}