nom-derive-impl 0.10.1

Custom derive nom parsers from struct
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

use crate::config::*;
use crate::meta::attr::{MetaAttr, MetaAttrType};
use proc_macro2::Span;
use syn::{spanned::Spanned, Error, Result};

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ParserEndianness {
    Unspecified,
    LittleEndian,
    BigEndian,
    SetEndian,
}

pub fn get_object_endianness(config: &Config) -> ParserEndianness {
    // first, check struct endianness
    if config.object_endianness != ParserEndianness::Unspecified {
        return config.object_endianness;
    }
    // finally, return global endianness
    config.global_endianness
}

pub fn set_object_endianness(
    span: Span,
    endianness: ParserEndianness,
    meta_list: &[MetaAttr],
    config: &mut Config,
) -> Result<()> {
    config.object_endianness = endianness;
    // first, check local attribute
    let mut req_big_endian = false;
    let mut req_little_endian = false;
    let mut req_set_endian = false;
    let mut span_endian = None;
    for meta in meta_list {
        match meta.attr_type {
            MetaAttrType::BigEndian => req_big_endian = true,
            MetaAttrType::LittleEndian => req_little_endian = true,
            MetaAttrType::SetEndian => req_set_endian = true,
            _ => continue,
        }
        span_endian = Some(meta.span());
    }
    // test if 2 or more flags are set
    if two_or_more(req_big_endian, req_little_endian, req_set_endian) {
        return Err(Error::new(
            span_endian.unwrap_or(span),
            "cannot be both big, little and/or set endian",
        ));
    }
    if req_big_endian {
        config.object_endianness = ParserEndianness::BigEndian;
    } else if req_little_endian {
        config.object_endianness = ParserEndianness::LittleEndian;
    } else if req_set_endian {
        config.object_endianness = ParserEndianness::SetEndian;
    };
    Ok(())
}

fn two_or_more(a: bool, b: bool, c: bool) -> bool {
    if a {
        b | c
    } else {
        b & c
    }
}

pub fn get_local_endianness(
    span: Span,
    meta_list: &[MetaAttr],
    config: &Config,
) -> Result<ParserEndianness> {
    // first, check local attribute
    let mut req_big_endian = false;
    let mut req_little_endian = false;
    let mut req_set_endian = false;
    for meta in meta_list {
        match meta.attr_type {
            MetaAttrType::BigEndian => req_big_endian = true,
            MetaAttrType::LittleEndian => req_little_endian = true,
            MetaAttrType::SetEndian => req_set_endian = true,
            _ => (),
        }
    }
    // test if 2 or more flags are set
    if two_or_more(req_big_endian, req_little_endian, req_set_endian) {
        return Err(Error::new(
            span,
            "cannot be both big, little and/or set endian",
        ));
    }
    if req_big_endian {
        return Ok(ParserEndianness::BigEndian);
    } else if req_little_endian {
        return Ok(ParserEndianness::LittleEndian);
    } else if req_set_endian {
        return Ok(ParserEndianness::SetEndian);
    };
    // otherwise, get object-level endianness
    Ok(get_object_endianness(config))
}

pub fn validate_endianness(
    attr_endianness: ParserEndianness,
    object_endianness: ParserEndianness,
    global_endianness: ParserEndianness,
) -> Result<()> {
    let mut req_big_endian = false;
    let mut req_little_endian = false;
    let mut req_set_endian = false;

    match attr_endianness {
        ParserEndianness::Unspecified => (),
        ParserEndianness::BigEndian => req_big_endian = true,
        ParserEndianness::LittleEndian => req_little_endian = true,
        _ => unreachable!(),
    }

    match object_endianness {
        ParserEndianness::Unspecified => (),
        ParserEndianness::BigEndian => req_big_endian = true,
        ParserEndianness::LittleEndian => req_little_endian = true,
        ParserEndianness::SetEndian => req_set_endian = true,
    }

    match global_endianness {
        ParserEndianness::Unspecified => (),
        ParserEndianness::BigEndian => req_big_endian = true,
        ParserEndianness::LittleEndian => req_little_endian = true,
        _ => unreachable!(),
    }

    if req_big_endian & req_little_endian {
        return Err(Error::new(
            Span::call_site(),
            "Object cannot be both big and little endian",
        ));
    }

    if req_set_endian & (req_big_endian | req_little_endian) {
        return Err(Error::new(
            Span::call_site(),
            "Object cannot be both SetEndian, and specify big or little endian",
        ));
    }

    Ok(())
}