ral-macro 0.2.0

The ral procedural macro implementations
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

use syn::parse::{Parse, ParseStream, Result};
use syn::spanned::Spanned;
use syn::token::{Colon, Comma};
use syn::{braced, Attribute, Ident, LitInt, LitStr};

use crate::field::_Fields;
use crate::parse::{attrs_to_meta_map, get_meta};
use crate::spanned::_Spanned;
use crate::uses::_Uses;

pub(super) struct _RegisterWithUses(pub(super) _Uses, pub(super) _Register);

impl Parse for _RegisterWithUses {
    fn parse(input: ParseStream) -> Result<Self> {
        let uses = input.parse::<_Uses>()?;
        let register = input.parse::<_Register>()?;
        Ok(_RegisterWithUses(uses, register))
    }
}

pub(super) struct _Register {
    pub(super) name: Ident,
    pub(super) description: Option<LitStr>,
    pub(super) offset: _Spanned<u32>,
    pub(super) value_size: _Spanned<u32>,
    pub(super) reset_mask: LitInt,
    pub(super) reset_value: LitInt,
    pub(super) access: Option<LitStr>,
    pub(super) fields: _Fields,
}

impl Parse for _Register {
    fn parse(input: ParseStream) -> Result<Self> {
        let mut attrs = input.call(Attribute::parse_outer)?;
        let name: Ident = input.parse()?;
        let content;
        let _ = braced!(content in input);
        attrs.extend(content.call(Attribute::parse_inner)?);
        let mut attrs = attrs_to_meta_map(attrs)?;
        let description = get_meta("doc", &mut attrs, name.span()).ok();
        let access = get_meta("access", &mut attrs, name.span()).ok();
        if !attrs.is_empty() {
            Err(syn::Error::new(
                name.span(),
                format!("Unexpected attributes specified, only 'doc' attribute expected"),
            ))?
        }
        let mut offset = Err(syn::Error::new(
            name.span(),
            format!("Register offset is not specified"),
        ));
        let mut value_size = Err(syn::Error::new(
            name.span(),
            format!("Register value size is not specified"),
        ));
        let mut reset_mask = Err(syn::Error::new(
            name.span(),
            format!("Register reset mask is not specified"),
        ));
        let mut reset_value = Err(syn::Error::new(
            name.span(),
            format!("Register reset value is not specified"),
        ));
        let mut fields: Result<_Fields> = Ok(_Fields::empty());
        while !content.is_empty() {
            let field_name: Ident = content.parse()?;
            let _: Colon = content.parse()?;
            match field_name.to_string().as_str() {
                "offset" => offset = content.parse(),
                "value_size" => value_size = content.parse(),
                "reset_mask" => reset_mask = content.parse(),
                "reset_value" => reset_value = content.parse(),
                "fields" => fields = content.parse(),
                field => Err(syn::Error::new(
                    field_name.span(),
                    format!("Found unexpected field {}", field),
                ))?,
            }
            if content.is_empty() {
                break;
            }
            let _: Comma = content.parse()?;
        }
        let value_size = _Spanned::from(value_size).and_then(validate_value_size)?;
        let fields = fields?;
        fields.validate(value_size.value)?;

        Ok(_Register {
            name,
            description,
            offset: _Spanned::from(offset)?,
            value_size,
            reset_mask: reset_mask?,
            reset_value: reset_value?,
            access,
            fields,
        })
    }
}

fn validate_value_size(value_size: _Spanned<u32>) -> Result<_Spanned<u32>> {
    let value = value_size.value;
    if value < 8 || value > 64 || (value & (value - 1)) != 0 {
        Err(syn::Error::new(
            value_size.span(),
            format!(
                "Unsupported register size value {}, must be 8 <= power of 2 <= 64",
                value
            ),
        ))?
    }
    Ok(value_size)
}