bit_seq 0.2.1

A procedural macro for creating bit sequences.
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

use syn::{Expr, ExprLit, ExprPath, LitInt, Result, Token};
use syn::parse::{Parse, ParseStream, Peek};

pub struct BitSeqInput {
    bit_segments: Vec<BitSegment>,
}

pub enum BitSegment {
    Bits(syn::LitInt),
    Expr(syn::Expr, syn::LitInt),
}

impl BitSeqInput {
    pub fn segments(&self) -> &Vec<BitSegment> {
        &self.bit_segments
    }

    fn parse_length_definition(input: &ParseStream) -> Result<syn::LitInt> {
        if !input.peek(Token![:]) {
            return Err(input.error("expected `:`"));
        }

        input.parse::<Token![:]>()?;

        if !input.peek(syn::LitInt) {
            return Err(input.error("expected integer that specifies size of bit sequence"));
        }

        input.parse::<syn::LitInt>()
    }

    // parse unary operator to bit segment expression
    fn parse_unary(input: &ParseStream) -> Result<BitSegment> {
        let expr = input.parse::<Expr>()?;
        let size = BitSeqInput::parse_length_definition(&input)?;
        Ok(BitSegment::Expr(expr, size))
    }

    // parse ident and num expression to bit segement
    fn parse_expr(input: &ParseStream) -> Result<BitSegment> {
        let val = if input.peek(syn::Ident) {
            let ident = input.parse::<syn::Ident>()?;
            syn::Expr::Path(ExprPath {
                attrs: vec![],
                qself: None,
                path: ident.into(),
            })
        } else {
            let num = input.parse::<syn::LitInt>()?;
            syn::Expr::Lit(
                ExprLit {
                    attrs: vec![],
                    lit: syn::Lit::Int(num),
                })
        };

        let size = BitSeqInput::parse_length_definition(&input)?;
        Ok(BitSegment::Expr(val, size))
    }

    // parse raw bits
    fn parse_bits(input: &ParseStream) -> Result<BitSegment> {
        let num = input.parse::<syn::LitInt>()?;
        let num_string = num.to_string();

        if num_string.starts_with('-') {
            return Err(syn::Error::new(num.span(), "negative numbers are not allowed"));
        }

        // check for hexadecimal literal
        if num_string.starts_with("0x") {
            let bit_len = (num_string.len() - 2) * 4;
            let lit_len = LitInt::new(&bit_len.to_string(), num.span());

            let expr = syn::Expr::Lit(
                ExprLit {
                    attrs: vec![],
                    lit: syn::Lit::Int(num),
                });

            return Ok(BitSegment::Expr(expr, lit_len));
        }

        // check for binary literal
        let is_binary = num_string.chars().all(|c| c == '0' || c == '1');
        if !is_binary {
            let err = format!("expected bit sequence but got integer instead.");
            return Err(syn::Error::new(num.span(), err));
        }
        Ok(BitSegment::Bits(num))
    }
}

impl Parse for BitSeqInput {
    fn parse(input: ParseStream) -> Result<Self> {
        let mut bit_segments = Vec::new();

        while !input.is_empty() {
            if peek_expr_with_token(|expr| matches!(expr, Expr::Unary(_)), Token![:], input) {
                let segment = BitSeqInput::parse_unary(&input)?;
                bit_segments.push(segment);
            } else if input.peek(syn::Ident)
                || (input.peek(syn::LitInt) && input.peek2(Token![:]))
            {
                let segment = BitSeqInput::parse_expr(&input)?;
                bit_segments.push(segment);
            } else if input.peek(syn::LitInt) {
                let segment = BitSeqInput::parse_bits(&input)?;
                bit_segments.push(segment);
            }
            // parse an expression segment
            else {
                return Err(input.error("expected bit sequence, hex or length defined expression"));
            }
        }

        Ok(BitSeqInput {
            bit_segments,
        })
    }
}

// Helper
fn peek_expr_with_token<T: Peek>(check: fn(Expr) -> bool, token: T, input: ParseStream) -> bool {
    let forked = input.fork();
    let expr_check = match forked.parse::<Expr>() {
        Ok(expr) => check(expr),
        Err(_) => false,
    };

    expr_check && forked.peek(token)
}