bin_codec_derive 0.1.0

binary encoder decoder with bit field
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

use crate::Endin;
use crate::attribute::FieldAttr;
use proc_macro::TokenStream;
use proc_macro2::TokenStream as TokenStream2;
use quote::*;
use syn::*;

mod field;
mod named;
mod unnamed;
mod variant;

pub(crate) fn encode(input: TokenStream, ed: Endin) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let generics = input.generics;
    let where_clause = &generics.where_clause;
    let name = input.ident;
    let codec: TokenStream2 = match &input.data {
        Data::Struct(data_struct) => encode_struct(&data_struct, &ed),
        _ => unimplemented!()
    };
    let size: TokenStream2 = match &input.data {
        Data::Struct(data_struct) => size_struct(&data_struct, &ed),
        _ => unimplemented!()
    };
    let trait_name = match ed {
        Endin::Big => quote!(bin_codec::EncodeBe),
        Endin::Little => quote!(bin_codec::EncodeLe),
    };
    let expanded = quote! {
        impl #generics #trait_name for #name #generics #where_clause {
            fn encode_offset<__CTX>(&self, target: &mut [u8], ctx: &mut __CTX, offset: &mut usize, bits: usize) {
                use bin_codec::*;
                let target_ptr = target.as_mut_ptr();
                #codec
            }

            fn bits_with_user_define(&self, bits: Option<usize>) -> usize {
                #size
            }
        }
    };
    TokenStream::from(expanded)
}

pub(crate) fn decode(input: TokenStream, ed: Endin) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let attr = FieldAttr::from_attrs(&input.attrs);
    let generics = input.generics;
    let where_clause = &generics.where_clause;
    let name = &input.ident;
    let codec: TokenStream2 = match &input.data {
        Data::Struct(data_struct) => decode_struct(&data_struct, name, &ed),
        _ => unimplemented!(),
    };
    let trait_name = match ed {
        Endin::Big => quote!(bin_codec::DecodeBe),
        Endin::Little => quote!(bin_codec::DecodeLe),
    };
    let context_type = attr.context.map(|l| quote!(#l)).unwrap_or(quote!(()));
    let has_next = attr.has_next.map(|l| quote!(*sd = ShouldDecode::HasNext(#l);));
    let expanded = quote! {
        impl #generics #trait_name for #name #generics #where_clause {
            type Context = #context_type;
            fn decode_offset(data: &[u8], data_start: &mut usize, sd: &mut ShouldDecode, ctx: &mut Self::Context, bits: usize) -> bin_codec::Result<Self> {
                #codec
                #has_next
                Ok(rt)
            }

            fn default_bits() -> usize {
                0
            }
        }
    };
    TokenStream::from(expanded)
}

fn encode_struct(data: &DataStruct, ed: &Endin) -> TokenStream2 {
    match &data.fields {
        Fields::Named(named) => self::named::encode(named, ed),
        Fields::Unnamed(unnamed) => self::unnamed::encode(unnamed, ed),
        Fields::Unit => unimplemented!(),
    }
}

fn size_struct(data: &DataStruct, ed: &Endin) -> TokenStream2 {
    match &data.fields {
        Fields::Named(named) => self::named::size(named, ed),
        Fields::Unnamed(unnamed) => self::unnamed::size(unnamed, ed),
        Fields::Unit => unimplemented!(),
    }
}

fn decode_struct(data: &DataStruct, name: &Ident, ed: &Endin) -> TokenStream2 {
    match &data.fields {
        Fields::Named(named) => {
            let (ref values, ref fields) = self::named::decode(named, ed);
            quote! {
                #(let #fields = #values;)*
                let rt = #name {
                    #(#fields,)*
                };
            }
        }
        Fields::Unnamed(unnamed) => {
            let (ref values, ref fields) = self::unnamed::decode(unnamed, ed);
            quote! {
                #(let #fields = #values;)*
                let rt = #name (
                    #(#fields,)*
                );
            }
        }
        Fields::Unit => unimplemented!("`unit struct` not implemented"),
    }
}