mathhook-macros 0.2.0

Procedural macros for MathHook - expr!, symbol!, symbols!, function!
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

//! Symbol macro parser
use super::codegen::{CodeGenerator, SymbolType};
use super::errors;
use proc_macro::TokenStream;
use syn::parse::{Parse, ParseStream};
use syn::punctuated::Punctuated;
use syn::{Ident, Lit, Token};

pub struct SymbolParser;

struct SingleSymbol {
    name: String,
    symbol_type: SymbolType,
}

impl Parse for SingleSymbol {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        if input.peek(Lit) {
            let lit: Lit = input.parse()?;
            if let Lit::Str(s) = lit {
                let name = s.value();
                let symbol_type = if input.peek(Token![;]) {
                    input.parse::<Token![;]>()?;
                    parse_symbol_type(input)?
                } else {
                    SymbolType::Scalar
                };
                Ok(SingleSymbol { name, symbol_type })
            } else {
                Err(errors::invalid_syntax(
                    "expected string literal or identifier",
                    lit.span(),
                ))
            }
        } else if input.peek(Ident) {
            let ident: Ident = input.parse()?;
            let name = ident.to_string();
            let symbol_type = if input.peek(Token![;]) {
                input.parse::<Token![;]>()?;
                parse_symbol_type(input)?
            } else {
                SymbolType::Scalar
            };
            Ok(SingleSymbol { name, symbol_type })
        } else {
            Err(errors::invalid_syntax(
                "expected identifier or string literal",
                input.span(),
            ))
        }
    }
}

struct MultipleSymbols {
    names: Vec<String>,
    symbol_type: SymbolType,
}

impl Parse for MultipleSymbols {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let idents = Punctuated::<Ident, Token![,]>::parse_separated_nonempty(input)?;

        if idents.is_empty() {
            return Err(errors::empty_symbols_list(input.span()));
        }

        let names: Vec<String> = idents.iter().map(|i| i.to_string()).collect();

        let symbol_type = if input.peek(Token![=>]) {
            input.parse::<Token![=>]>()?;
            parse_symbol_type(input)?
        } else {
            SymbolType::Scalar
        };

        Ok(MultipleSymbols { names, symbol_type })
    }
}

fn parse_symbol_type(input: ParseStream) -> syn::Result<SymbolType> {
    let type_ident: Ident = input.parse()?;
    match type_ident.to_string().as_str() {
        "scalar" => Ok(SymbolType::Scalar),
        "matrix" => Ok(SymbolType::Matrix),
        "operator" => Ok(SymbolType::Operator),
        "quaternion" => Ok(SymbolType::Quaternion),
        other => Err(errors::unsupported_type(other, type_ident.span())),
    }
}

impl SymbolParser {
    pub fn parse_single(input: TokenStream) -> syn::Result<proc_macro2::TokenStream> {
        let parsed: SingleSymbol = syn::parse(input)?;
        Ok(CodeGenerator::generate_single(
            &parsed.name,
            parsed.symbol_type,
        ))
    }

    pub fn parse_multiple(input: TokenStream) -> syn::Result<proc_macro2::TokenStream> {
        let parsed: MultipleSymbols = syn::parse(input)?;
        Ok(CodeGenerator::generate_multiple(
            &parsed.names,
            parsed.symbol_type,
        ))
    }
}