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
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

pub(crate) mod get_access;

use get_access::GetAccessFunction;
use rtlola_streamir::{
    formatter::{
        expressions::{
            DefaultConstantFormatter, DefaultExprFormatter, DefaultFunctionFormatter,
            DefaultOperatorFormatter, ExprFormatter,
        },
        files::FilesFormatter,
        types::TypeFormatter,
    },
    ir::{expressions::Expr, OutputReference, StreamReference, Type, WindowReference},
};
use std::fmt::Write;

use crate::{types::TupleType, SolidityFormatter};

impl DefaultExprFormatter for SolidityFormatter {
    fn sync_access(&self, sr: StreamReference, parameters: Vec<Expr>) -> String {
        match sr {
            StreamReference::In(_) | StreamReference::Out(OutputReference::Unparameterized(_)) => {
                self.name(sr).into()
            }
            StreamReference::Out(OutputReference::Parameterized(_)) => {
                let parameters = parameters.into_iter().fold(String::new(), |mut res, p| {
                    write!(res, "[{}]", self.expr(p)).unwrap();
                    res
                });
                self.access_buffer_value(sr, "0", parameters)
            }
        }
    }

    fn offset_access(
        &self,
        sr: StreamReference,
        offset: u32,
        default: Expr,
        parameters: Vec<Expr>,
    ) -> String {
        self.call_function(
            GetAccessFunction { sr },
            parameters
                .into_iter()
                .map(|p| self.expr(p))
                .chain([offset.to_string(), self.expr(default)])
                .collect(),
        )
    }

    fn hold_access(&self, sr: StreamReference, default: Expr, parameters: Vec<Expr>) -> String {
        self.call_function(
            GetAccessFunction { sr },
            parameters
                .into_iter()
                .map(|p| self.expr(p))
                .chain(["0".into(), self.expr(default)])
                .collect(),
        )
    }

    fn get_access(&self, _sr: StreamReference, _default: Expr, _parameters: Vec<Expr>) -> String {
        unimplemented!()
    }

    fn is_fresh(&self, _sr: StreamReference, _parameters: Vec<Expr>) -> String {
        unimplemented!()
    }

    fn sliding_window_access(&self, _wref: usize, _default: Option<Expr>) -> String {
        unimplemented!()
    }

    fn discrete_window_access(&self, _wref: usize, _default: Option<Expr>) -> String {
        unimplemented!()
    }

    fn instance_aggregation(&self, _wref: usize, _default: Option<Expr>) -> String {
        unimplemented!()
    }

    fn parameter_access(&self, sr: StreamReference, p: usize) -> String {
        self.stream_parameter(sr).unwrap()[p].name.to_owned()
    }

    fn lambda_parameter_access(&self, _wref: WindowReference, _idx: usize) -> String {
        unimplemented!()
    }

    fn cast(&self, ty: Type, expr: Expr) -> String {
        format!("{}({})", self.ty(ty), self.expr(expr))
    }

    fn tuple(&self, inner: Vec<Expr>) -> String {
        let inner_tys = inner.iter().map(|e| e.ty.clone()).collect();
        let tuple = TupleType(inner_tys);
        let expr = tuple.expr(inner, self);
        self.add_requirement(tuple);
        expr
    }
}

impl DefaultConstantFormatter for SolidityFormatter {
    fn constant_int(&self, i: i64, bits: u16) -> String {
        format!("int{bits}({i})")
    }

    fn constant_uint(&self, i: u64, bits: u16) -> String {
        format!("uint{bits}({i})")
    }
}

impl DefaultFunctionFormatter for SolidityFormatter {}

impl DefaultOperatorFormatter for SolidityFormatter {}