rtlola2solidity 0.1.0

A compiler from RTLola to Solidity through StreamIR
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

use itertools::Itertools;
use rtlola_streamir::{
    formatter::types::TypeFormatter,
    ir::{memory::Parameter, OutputReference},
};
use std::fmt::Write;

use crate::{functions::FunctionDefinition, RequirementKey, SolidityFormatter};

pub(super) struct SpawnFunction {
    pub(super) sr: OutputReference,
}

impl FunctionDefinition for SpawnFunction {
    fn header(&self, f: &SolidityFormatter) -> String {
        let parameter = f
            .stream_parameter(rtlola_streamir::ir::StreamReference::Out(self.sr))
            .map(|p| {
                p.iter()
                    .map(|Parameter { name, ty }| format!("{} {name}", f.ty(ty.clone())))
                    .join(",")
            })
            .unwrap_or_default();
        format!("{}({parameter})", self.name(f))
    }

    fn body(self, f: &SolidityFormatter) -> String {
        let name = f.name(rtlola_streamir::ir::StreamReference::Out(self.sr));
        match self.sr {
            OutputReference::Unparameterized(_) => format!("{name}_spawned = true;"),
            OutputReference::Parameterized(_) => {
                let param_access =
                    f.param_access(rtlola_streamir::ir::StreamReference::Out(self.sr));

                let mut res = String::new();
                if f.streams_with_iteration.contains(&self.sr) {
                    writeln!(res, "if (!{name}_buffer{param_access}.{name}_spawned) {{").unwrap();
                    let p = &format!(
                        "{name}Param({{ {} }})",
                        f.stream_parameter(rtlola_streamir::ir::StreamReference::Out(self.sr))
                            .unwrap()
                            .iter()
                            .map(|Parameter { name, .. }| format!("{name}: {name}"))
                            .join(",")
                    );
                    writeln!(res, "{name}_params.push({p});",).unwrap();
                    writeln!(res, "}}").unwrap();
                }
                writeln!(res, "{name}_buffer{param_access}.{name}_spawned = true;").unwrap();
                res
            }
        }
    }

    fn key(&self) -> RequirementKey {
        RequirementKey::SpawnFunction(rtlola_streamir::ir::StreamReference::Out(self.sr))
    }

    fn name(&self, f: &SolidityFormatter) -> String {
        format!(
            "spawn_{}",
            f.name(rtlola_streamir::ir::StreamReference::Out(self.sr))
        )
    }
}