bitfields-impl 1.0.3

Macro for generating flexible bitfields. Useful for low-level code (embedded or emulators).
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

use proc_macro2::TokenStream;
use quote::quote;
use syn::Visibility;

use crate::generation::common::{does_field_have_getter, does_field_have_setter};
use crate::parsing::bitfield_field::BitfieldField;
use crate::parsing::types::get_bits_from_type;

pub(crate) fn generate_get_bit_tokens(
    vis: Visibility,
    bitfield_type: &syn::Type,
    fields: &[BitfieldField],
    ignored_fields_struct: bool,
) -> TokenStream {
    let bitfield_type_bits = get_bits_from_type(bitfield_type).unwrap() as usize;
    let get_bit_documentation = "Returns a bit from the given index. Returns false for out-of-bounds and fields without read access.".to_string();
    let checked_get_bit_documentation = "Returns a bit from the given index. Returns an error for out-of-bounds and fields without read access.".to_string();

    let false_return_for_non_readable_fields = fields
        .iter()
        .filter(|field| !does_field_have_getter(field) && !field.padding)
        .map(|field| {
            let field_bits = field.bits as usize;
            let field_offset = field.offset as usize;
            let field_end_bits = field_offset + field_bits;
            quote! {
                if index >= #field_offset && index < #field_end_bits {
                    return false;
                }
            }
        });

    let error_return_for_write_only_fields = fields
        .iter()
        .filter(|field| !does_field_have_getter(field) && !field.padding)
        .map(|field| {
            let field_bits = field.bits as usize;
            let field_offset = field.offset as usize;
            let field_end_bits = field_offset + field_bits;
            quote! {
                if index >= #field_offset && index < #field_end_bits {
                    return Err("Can't read from a write-only field.");
                }
            }
        });

    let struct_val_ident = if ignored_fields_struct {
        quote! { self.val }
    } else {
        quote! { self.0 }
    };

    quote! {
        #[doc = #get_bit_documentation]
        #vis const fn get_bit(&self, index: usize) -> bool {
            if index > #bitfield_type_bits {
                return false;
            }

            #( #false_return_for_non_readable_fields )*

            (#struct_val_ident >> index) & 1 != 0
        }

        #[doc = #checked_get_bit_documentation]
        #vis const fn checked_get_bit(&self, index: usize) -> ::core::result::Result<bool, &'static str> {
            if index > #bitfield_type_bits {
                return Err("Index out of bounds.");
            }

            #( #error_return_for_write_only_fields )*

            Ok((#struct_val_ident >> index) & 1 != 0)
        }
    }
}

pub(crate) fn generate_set_bit_tokens(
    vis: Visibility,
    bitfield_type: &syn::Type,
    fields: &[BitfieldField],
    ignored_fields_struct: bool,
) -> TokenStream {
    let bitfield_type_bits = get_bits_from_type(bitfield_type).unwrap() as usize;
    let set_bit_documentation = "Sets a bit at given index with the given value. Is no-op for out-of-bounds and fields without write access.".to_string();
    let checked_set_bit_documentation = "Sets a bit at given index with the given value. Returns an error for out-of-bounds and fields without write access.".to_string();

    let no_op_for_non_writable_fields =
        fields.iter().filter(|field| !does_field_have_setter(field)).map(|field| {
            let field_bits = field.bits as usize;
            let field_offset = field.offset as usize;
            let field_end_bits = field_offset + field_bits;
            quote! {
                if index >= #field_offset && index < #field_end_bits {
                    return;
                }
            }
        });

    let error_return_for_non_writable_fields =
        fields.iter().filter(|field| !does_field_have_setter(field)).map(|field| {
            let field_bits = field.bits as usize;
            let field_offset = field.offset as usize;
            let field_end_bits = field_offset + field_bits;
            quote! {
                if index >= #field_offset && index < #field_end_bits {
                    return Err("Can't write to a non-writable or padding field.");
                }
            }
        });

    let struct_val_ident = if ignored_fields_struct {
        quote! { self.val }
    } else {
        quote! { self.0 }
    };

    quote! {
        #[doc = #set_bit_documentation]
        #vis const fn set_bit(&mut self, index: usize, bit: bool) {
            if index > #bitfield_type_bits {
                return;
            }

            #( #no_op_for_non_writable_fields )*

            if bit {
                #struct_val_ident |= 1 << index;
            } else {
                #struct_val_ident &= !(1 << index);
            }
        }

        #[doc = #checked_set_bit_documentation]
        #vis const fn checked_set_bit(&mut self, index: usize, bit: bool) -> ::core::result::Result<(), &'static str> {
            if index > #bitfield_type_bits {
                return Err("Index out of bounds.");
            }

            #( #error_return_for_non_writable_fields )*

            if bit {
                #struct_val_ident |= 1 << index;
            } else {
                #struct_val_ident &= !(1 << index);
            }

            Ok(())
        }
    }
}