mady_macro_core 0.1.0-alpha

🌲 mady's subpackage
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

use syn::{parse_quote_spanned, Error};

use crate::{
    error::ParseError,
    parser::{Recorder, VarType},
};

use std::collections::HashSet;

pub fn gen_declare(c: &Recorder) -> Result<Vec<syn::Stmt>, Error> {
    let mut stmts = vec![];
    for n in c.graph.nodes() {
        let node = c.graph.node_weight(n);
        match node {
            VarType::Tmp(v) | VarType::Grad(v) => {
                let ident = v.to_ident();
                stmts.push(parse_quote_spanned! {v.span()=>
                    let mut #ident;
                });
                for e in c.graph.to_edges(n) {
                    let edge = c.graph.edge_weight(e);
                    let ident = edge.to_ident();
                    stmts.push(parse_quote_spanned! {edge.span()=>
                        let #ident;
                    });
                }
            }
            VarType::IF(..) | VarType::IFEL(..) => unimplemented!("logic WIP"),
            VarType::Null => {}
        }
    }
    Ok(stmts)
}

pub fn gen_backward(c: &Recorder) -> Result<Vec<syn::Stmt>, Error> {
    let mut stmts = vec![];
    let roots = HashSet::<_>::from_iter(c.graph.roots());
    let mut grads = HashSet::new();
    let mut tys = c.tys().iter().rev();
    for n in c.graph.topological_iter() {
        grads.insert(n);
        let node = c.graph.node_weight(n);
        match node {
            VarType::Tmp(v) | VarType::Grad(v) => {
                let node_ident = v.to_ident();
                if roots.contains(&n) {
                    let node_ty = tys.next().ok_or(ParseError::NotFindType.new(v.span()))?;
                    stmts.push(parse_quote_spanned! {v.span()=>
                        #node_ident = <#node_ty>::mady_one();
                    });
                }
                for e in c.graph.to_edges(n) {
                    let edge = c.graph.edge_weight(e);
                    let edge_ident = edge.to_ident();
                    let t = c.graph.to_node(e);
                    let to_node = c.graph.node_weight(t).id().to_ident();

                    if grads.contains(&t) {
                        stmts.push(parse_quote_spanned! {edge.span()=>
                            #to_node += #node_ident.mady_chain(#edge_ident).clone();
                        });
                    } else {
                        grads.insert(t);
                        stmts.push(parse_quote_spanned! {edge.span()=>
                            #to_node = #node_ident.mady_chain(#edge_ident).clone();
                        });
                    }
                }
            }
            VarType::IF(..) | VarType::IFEL(..) => unimplemented!("logic WIP"),
            VarType::Null => {}
        }
    }

    Ok(stmts)
}