windows-rdl 0.100.0

RDL parser library and ECMA-335 generator
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

#[derive(Debug, Clone)]
pub struct Field {
    pub attrs: Vec<syn::Attribute>,
    pub name: syn::Ident,
    pub ty: FieldType,
    pub bitfields: Vec<BitfieldMember>,
}

#[derive(Debug, Clone)]
pub struct BitfieldMember {
    pub name: Option<syn::Ident>,
    pub width: u32,
}

#[derive(Debug, Clone)]
pub enum FieldType {
    Type(Box<syn::Type>),
    Nested(Box<NestedRecord>),
}

#[derive(Debug, Clone)]
pub struct NestedRecord {
    pub attrs: Vec<syn::Attribute>,
    pub is_union: bool,
    pub fields: Vec<Field>,
}

impl syn::parse::Parse for Field {
    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
        let attrs = input.call(syn::Attribute::parse_outer)?;
        let name: syn::Ident = input.parse()?;
        input.parse::<syn::Token![:]>()?;

        // The type position may be an inline anonymous nested struct/union,
        // optionally preceded by its own attributes.
        let inner_attrs = input.call(syn::Attribute::parse_outer)?;
        let (ty, bitfields) = if input.peek(syn::Token![struct]) || input.peek(syn::Token![union]) {
            (
                FieldType::Nested(Box::new(NestedRecord::parse(input, inner_attrs)?)),
                vec![],
            )
        } else if inner_attrs.is_empty() {
            let ty = FieldType::Type(Box::new(input.parse()?));
            // A backing integer field may be followed by a `{ ... }` block listing its
            // bit-field members in the concise C-like form.
            let bitfields = if input.peek(syn::token::Brace) {
                parse_bitfield_block(input)?
            } else {
                vec![]
            };
            (ty, bitfields)
        } else {
            return Err(input
                .error("attributes are only allowed on an inline nested struct/union field type"));
        };

        Ok(Self {
            attrs,
            name,
            ty,
            bitfields,
        })
    }
}

fn parse_bitfield_block(input: syn::parse::ParseStream) -> syn::Result<Vec<BitfieldMember>> {
    let content;
    syn::braced!(content in input);
    let members = content
        .parse_terminated(<BitfieldMember as syn::parse::Parse>::parse, syn::Token![,])?
        .into_iter()
        .collect();
    Ok(members)
}

impl syn::parse::Parse for BitfieldMember {
    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
        let name = if input.peek(syn::Token![_]) {
            input.parse::<syn::Token![_]>()?;
            None
        } else {
            Some(input.parse::<syn::Ident>()?)
        };
        input.parse::<syn::Token![:]>()?;
        let width: syn::LitInt = input.parse()?;
        Ok(Self {
            name,
            width: width.base10_parse()?,
        })
    }
}

impl NestedRecord {
    fn parse(input: syn::parse::ParseStream, attrs: Vec<syn::Attribute>) -> syn::Result<Self> {
        let is_union = input.peek(syn::Token![union]);
        if is_union {
            input.parse::<syn::Token![union]>()?;
        } else {
            input.parse::<syn::Token![struct]>()?;
        }

        let content;
        syn::braced!(content in input);
        let fields = content
            .parse_terminated(<Field as syn::parse::Parse>::parse, syn::Token![,])?
            .into_iter()
            .collect();

        Ok(Self {
            attrs,
            is_union,
            fields,
        })
    }
}