const-frac 0.0.3

Types for supporting floating point constants.
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

use crate::Frac;
use syn:: {
    Expr, ExprPath, Lit, Token,
    parse:: { self, Parse, ParseStream },
    punctuated::Punctuated,
};
use quote:: { quote, ToTokens };
use proc_macro2::TokenStream;

pub struct ClonedPath(pub ExprPath);

impl AsRef<ExprPath> for ClonedPath {
    fn as_ref(&self) -> &ExprPath {
        &self.0
    }
}

pub struct TokenFrac<T>
where
    T: AsRef<ExprPath>
{
    pub frac: Frac,
    pub path: Option<T>,
}

impl Parse for TokenFrac<ClonedPath> {
    fn parse(input: ParseStream) -> parse::Result<Self> {
        use Lit::*;

        let mut it = Punctuated::<Expr, Token![,]>::parse_separated_nonempty(input)?.into_iter();
        let path = match it.next() {
            Some(Expr::Path(ref expr)) => expr.clone().into(),
            Some(Expr::Group(ref expr)) => match &*expr.expr {
                &Expr::Path(ref expr) => expr.clone().into(),
                _ => return Err(input.error(format!("{:?}", expr))),
            },
            Some(expr) => return Err(input.error(format!("{:?}", expr))),
            None => None,
        };
        let (lit, neg) = match it.next() {
            Some(Expr::Lit(ref expr)) => (expr.lit.clone(), false),
            Some(Expr::Group(ref expr)) => match &*expr.expr {
                &Expr::Lit(ref expr) => (expr.lit.clone(), false),
                _ => return Err(input.error(format!("{:?}", expr))),
            },
            Some(Expr::Unary(ref expr)) => match &*expr.expr {
                &Expr::Lit(ref expr) => (expr.lit.clone(), true),
                _ => return Err(input.error(format!("{:?}", expr))),
            },
            Some(expr) => return Err(input.error(format!("{:?}", expr))),
            None => return Err(input.error("No value specified.")),
        };
        let mut s = match lit {
            Str(s) => s.value(),
            ByteStr(s) => String::from_utf8(s.value()).unwrap(),
            Byte(s) => {
                let ch: char = s.value().into();
                let mut s = String::new();

                s.extend(Some(ch));
                s
            },
            Char(ch) => {
                let mut s = String::new();

                s.extend(Some(ch.value()));
                s
            },
            Int(s) => s.to_string(),
            Float(s) => s.to_string(),
            Bool(s) => if s.value() { "1".to_string() } else { "0".to_string() },
            Verbatim(s) => s.to_string(),
        };

        if neg {
            s.insert(0, '-');
        }
        Ok(Self {
            frac: s.parse().map_err(|_| input.error("can't parse"))?,
            path: path.map(|path| ClonedPath(path)),
        })
    }
}

impl<T> ToTokens for TokenFrac<T>
where
    T: AsRef<ExprPath>
{
    fn to_tokens(&self, tokens: &mut TokenStream) {
        let neg = self.frac.is_negative();
        let numer = self.frac.numer();
        let denom = self.frac.denom();
        let exp2 = self.frac.exp2();
        let exp5 = self.frac.exp5();
        let exp_pi = self.frac.exp_pi();

        tokens.extend(match self.path {
            Some(ref path) => {
                let path = path.as_ref();

                quote! {
                    #path::Frac::new(#neg, #numer, #denom, #exp2, #exp5, #exp_pi)
                }
            },
            None => quote! {
                Frac::new(#neg, #numer, #denom, #exp2, #exp5, #exp_pi)
            },
        });
    }
}