xc3_write_derive 0.1.0

xc3_write derive macros
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
152
153
154
155

use proc_macro2::{Ident, TokenStream};
use syn::{ext::IdentExt, parenthesized, Attribute, LitInt};

pub struct FieldOptions {
    pub field_type: Option<FieldType>,
    pub align: Option<u64>,
    pub pad_size_to: Option<u64>,
}

// TODO: Separate count field similar to #[bw(calc(...))]?
pub enum FieldType {
    SavePosition,
    SharedOffset,
    Offset(Ident),
    OffsetCount(Ident, Ident),
    CountOffset(Ident, Ident),
}

impl FieldOptions {
    pub fn from_attrs(attrs: &[Attribute]) -> Self {
        let mut field_type = None;
        let mut align = None;
        let mut pad_size_to = None;

        for a in attrs {
            if a.path().is_ident("xc3") {
                // TODO: add types like offset32 or offset64_count32
                // TODO: separate offset and count fields?
                let _ = a.parse_nested_meta(|meta| {
                    if meta.path.is_ident("offset") {
                        // #[xc3(offset(u32))]
                        field_type = Some(FieldType::Offset(parse_ident(&meta)?));
                    } else if meta.path.is_ident("offset_count") {
                        // #[xc3(offset_count(u32, u32))]
                        let (offset, count) = parse_two_idents(&meta)?;
                        field_type = Some(FieldType::OffsetCount(offset, count));
                    } else if meta.path.is_ident("count_offset") {
                        // #[xc3(count_offset(u32, u32)]
                        let (count, offset) = parse_two_idents(&meta)?;
                        field_type = Some(FieldType::CountOffset(count, offset));
                    } else if meta.path.is_ident("align") {
                        // #[xc3(align(4096))]
                        align = Some(parse_u64(&meta)?);
                    } else if meta.path.is_ident("pad_size_to") {
                        // #[xc3(pad_size_to(128))]
                        pad_size_to = Some(parse_u64(&meta)?);
                    } else if meta.path.is_ident("shared_offset") {
                        // #[xc3(shared_offset)]
                        field_type = Some(FieldType::SharedOffset);
                    } else if meta.path.is_ident("save_position") {
                        // #[xc3(save_position)]
                        field_type = Some(FieldType::SavePosition);
                    }
                    Ok(())
                });
            }
        }

        Self {
            field_type,
            align,
            pad_size_to,
        }
    }
}

fn parse_u64(meta: &syn::meta::ParseNestedMeta<'_>) -> Result<u64, syn::Error> {
    let content;
    parenthesized!(content in meta.input);
    let lit: LitInt = content.parse().unwrap();
    lit.base10_parse()
}

fn parse_ident(meta: &syn::meta::ParseNestedMeta<'_>) -> Result<Ident, syn::Error> {
    let content;
    parenthesized!(content in meta.input);
    let ty: Ident = content.parse()?;
    Ok(ty)
}

fn parse_two_idents(meta: &syn::meta::ParseNestedMeta<'_>) -> Result<(Ident, Ident), syn::Error> {
    let content;
    parenthesized!(content in meta.input);
    let types = content.parse_terminated(Ident::parse_any, syn::Token![,])?;
    Ok((types[0].clone(), types[1].clone()))
}

pub struct TypeOptions {
    pub magic: Option<TokenStream>,
    pub has_base_offset: bool,
    pub align_after: Option<u64>,
}

impl TypeOptions {
    pub fn from_attrs(attrs: &[Attribute]) -> Self {
        let mut magic = None;
        let mut has_base_offset = false;
        let mut align_after = None;

        for a in attrs {
            if a.path().is_ident("xc3") {
                let _ = a.parse_nested_meta(|meta| {
                    if meta.path.is_ident("magic") {
                        // #[xc3(magic(b"MAGIC"))]
                        let content;
                        parenthesized!(content in meta.input);
                        let lit: TokenStream = content.parse().unwrap();
                        magic = Some(lit);
                    } else if meta.path.is_ident("base_offset") {
                        // #[xc3(base_offset)]
                        has_base_offset = true;
                    } else if meta.path.is_ident("align_after") {
                        // #[xc3(align_after(4096))]
                        align_after = Some(parse_u64(&meta)?);
                    }
                    Ok(())
                });
            }
        }

        Self {
            magic,
            has_base_offset,
            align_after,
        }
    }
}

pub struct VariantOptions {
    pub magic: Option<TokenStream>,
}

impl VariantOptions {
    pub fn from_attrs(attrs: &[Attribute]) -> Self {
        let mut magic = None;

        for a in attrs {
            if a.path().is_ident("xc3") {
                let _ = a.parse_nested_meta(|meta| {
                    if meta.path.is_ident("magic") {
                        // #[xc3(magic(b"MAGIC"))]
                        // #[xc3(magic(5u32))]
                        let content;
                        parenthesized!(content in meta.input);
                        let lit: TokenStream = content.parse().unwrap();
                        magic = Some(lit);
                    }
                    Ok(())
                });
            }
        }

        Self { magic }
    }
}