mun_abi 0.3.0

Rust wrapper for the Mun ABI
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 crate::{
    AssemblyInfo, DispatchTable, FunctionDefinition, FunctionPrototype, FunctionSignature, Guid,
    ModuleInfo, StructInfo, StructMemoryKind, TypeInfo, TypeInfoData,
};
use std::{
    ffi::{c_void, CStr},
    os::raw::c_char,
    ptr,
};

pub(crate) const FAKE_TYPE_GUID: Guid =
    Guid([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]);
pub(crate) const FAKE_DEPENDENCY: &str = "path/to/dependency.munlib";
pub(crate) const FAKE_FIELD_NAME: &str = "field_name";
pub(crate) const FAKE_FN_NAME: &str = "fn_name";
pub(crate) const FAKE_MODULE_PATH: &str = "path::to::module";
pub(crate) const FAKE_STRUCT_NAME: &str = "StructName";
pub(crate) const FAKE_TYPE_NAME: &str = "TypeName";

pub(crate) fn fake_assembly_info(
    symbols: ModuleInfo,
    dispatch_table: DispatchTable,
    dependencies: &[*const c_char],
) -> AssemblyInfo {
    AssemblyInfo {
        symbols,
        dispatch_table,
        dependencies: dependencies.as_ptr(),
        num_dependencies: dependencies.len() as u32,
    }
}

pub(crate) fn fake_dispatch_table(
    fn_prototypes: &[FunctionPrototype],
    fn_ptrs: &mut [*const c_void],
) -> DispatchTable {
    assert_eq!(fn_prototypes.len(), fn_ptrs.len());

    DispatchTable {
        prototypes: fn_prototypes.as_ptr(),
        fn_ptrs: fn_ptrs.as_mut_ptr(),
        num_entries: fn_prototypes.len() as u32,
    }
}

pub(crate) fn fake_fn_signature(
    arg_types: &[&TypeInfo],
    return_type: Option<&TypeInfo>,
) -> FunctionSignature {
    FunctionSignature {
        arg_types: arg_types.as_ptr().cast::<*const TypeInfo>(),
        return_type: return_type.map_or(ptr::null(), |t| t as *const TypeInfo),
        num_arg_types: arg_types.len() as u16,
    }
}

pub(crate) fn fake_fn_prototype(
    name: &CStr,
    arg_types: &[&TypeInfo],
    return_type: Option<&TypeInfo>,
) -> FunctionPrototype {
    FunctionPrototype {
        name: name.as_ptr(),
        signature: fake_fn_signature(arg_types, return_type),
    }
}

pub(crate) fn fake_module_info(
    path: &CStr,
    functions: &[FunctionDefinition],
    types: &[&TypeInfo],
) -> ModuleInfo {
    ModuleInfo {
        path: path.as_ptr(),
        functions: functions.as_ptr(),
        num_functions: functions.len() as u32,
        types: types.as_ptr().cast::<*const TypeInfo>(),
        num_types: types.len() as u32,
    }
}

pub(crate) fn fake_struct_info(
    field_names: &[*const c_char],
    field_types: &[&TypeInfo],
    field_offsets: &[u16],
    memory_kind: StructMemoryKind,
) -> StructInfo {
    assert!(field_names.len() == field_types.len());
    assert!(field_types.len() == field_offsets.len());

    StructInfo {
        field_names: field_names.as_ptr(),
        field_types: field_types.as_ptr().cast::<*const TypeInfo>(),
        field_offsets: field_offsets.as_ptr(),
        num_fields: field_names.len() as u16,
        memory_kind,
    }
}

pub(crate) fn fake_type_info(
    name: &CStr,
    size: u32,
    alignment: u8,
    data: TypeInfoData,
) -> TypeInfo {
    TypeInfo {
        guid: FAKE_TYPE_GUID,
        name: name.as_ptr(),
        size_in_bits: size,
        alignment,
        data,
    }
}