alex/volcanic

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

use super::*;

pub(super) fn params(decls: &[Decl]) -> String {
    decls
        .iter()
        .filter(|decl| select::api_matches(decl.api.as_deref()))
        .map(|decl| format!("{}: {}", rust_ident(&decl.name), rust_param_type(decl)))
        .collect::<Vec<_>>()
        .join(", ")
}

pub(super) fn rust_param_type(decl: &Decl) -> String {
    if decl.arrays.is_empty() {
        return rust_decl_type(decl, false);
    }
    // C array parameters decay to a pointer to the first element
    let mut element = decl.clone();
    element.arrays.remove(0);
    let pointee_const = decl.pointer_const.is_empty() && decl.base_const;
    format!(
        "*{} {}",
        if pointee_const { "const" } else { "mut" },
        rust_decl_type(&element, false)
    )
}

pub(super) fn call_args(decls: &[Decl]) -> String {
    decls
        .iter()
        .filter(|decl| select::api_matches(decl.api.as_deref()))
        .map(|decl| rust_ident(&decl.name))
        .collect::<Vec<_>>()
        .join(", ")
}

pub(super) fn rust_decl_type(decl: &Decl, is_return: bool) -> String {
    let mut ty = if is_return && decl.base == "void" && decl.pointer_const.is_empty() {
        "()".to_string()
    } else {
        rust_base(&decl.base)
    };

    for pointee_const in &decl.pointer_const {
        ty = format!("*{} {ty}", if *pointee_const { "const" } else { "mut" });
    }

    for dim in decl.arrays.iter().rev() {
        ty = format!("[{ty}; {}]", array_dim(dim));
    }

    ty
}

pub(super) fn rust_base(base: &str) -> String {
    match base {
        "void" => "c_void".to_string(),
        "char" => "c_char".to_string(),
        "float" => "f32".to_string(),
        "double" => "f64".to_string(),
        "int" => "c_int".to_string(),
        "int8_t" => "i8".to_string(),
        "uint8_t" => "u8".to_string(),
        "int16_t" => "i16".to_string(),
        "uint16_t" => "u16".to_string(),
        "int32_t" => "i32".to_string(),
        "uint32_t" => "u32".to_string(),
        "int64_t" => "i64".to_string(),
        "uint64_t" => "u64".to_string(),
        "size_t" => "usize".to_string(),
        other => other.to_string(),
    }
}

pub(super) fn array_dim(dim: &str) -> String {
    if dim.bytes().all(|b| b.is_ascii_digit()) {
        dim.to_string()
    } else {
        format!("{dim} as usize")
    }
}