composint-macro 0.1.0

Space efficient structs using otherwise useless bits
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

use proc_macro2::TokenStream;
use quote::quote;

use super::data::Data;

pub(crate) fn generate_struct_definition(data: &Data) -> TokenStream {
    let name = &data.type_name;
    let block_count = calc_size::<usize>(data);

    quote! {
        struct #name([usize; #block_count]);
    }
}

pub(crate) fn generate_struct_impl(data: &Data) -> TokenStream {
    let type_name = &data.type_name;
    
    let field_body = generate_impl_body(&data);

    quote! {
        impl #type_name {
            #(#field_body)*
        }
    }
}

fn calc_size<T>(data: &Data) -> usize {
    let total_size = data.fields
        .pairs()
        .map(|p| p.value().bits.base10_parse::<usize>())
        .map(|lit| lit.unwrap_or(0))
        .sum::<usize>();

    let total_size = match total_size % 8 {
        0 => total_size / 8,
        _ => total_size / 8 + 1,
    };

    let ptr_size = std::mem::size_of::<T>();
    let blocks = (total_size / ptr_size).min(1);
    let rem = total_size.checked_rem(blocks * ptr_size).unwrap_or(1);

    match rem {
        0 => blocks,
        _ => blocks + 1,
    }
} 

fn generate_impl_body(data: &Data) -> Vec<TokenStream> {
    let mut streams = Vec::<TokenStream>::with_capacity(data.field_count());

    let names = data.field_names();
    let types = data.field_types();
    let offsets = data.field_cumulative_offsets();
    let sizes = data.field_sizes();

    let i = names
        .iter()
        .zip(types.iter())
        .zip(offsets.iter())
        .zip(sizes.iter())
        .map(|a| (a.0.0.0, a.0.0.1, a.0.1, a.1));

    for (name, ty, &offset, &size) in i {
        let stream = quote! {
            pub fn #name(&self) -> #ty {
                let size_ratio = std::mem::size_of::<#ty>();
                let ptr = unsafe {
                    self.0
                        .as_slice()
                        .as_ptr()
                        .cast::<u8>()
                        .add(#offset / 8)
                };

                let mut output = 0;

                let bytes_to_traverse = #size / 8;

                for i in 0..=bytes_to_traverse {
                    let data = unsafe { *ptr.add(i) };

                    for n in 0..8 {
                        output += ((data >> n) & 1) << (bytes_to_traverse - i + n);
                    }
                }

                output as #ty
            }
        };

        streams.push(stream);
    }

    streams
}