dixscript 1.0.0

Config, code, and encryption in one file — a data interchange format with compile-time functions, AES-256/ChaCha20 built-in, and cross-platform FFI
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

use super::position::Position;
use super::data_types::DataType;
use super::statements::QuickFuncStatement;
use super::expressions::Expression;

/// @QUICKFUNCS Section
#[derive(Debug, Clone, PartialEq)]
pub struct QuickFuncsSection {
    pub functions: Vec<QuickFunction>,
    pub position: Position,
}

impl QuickFuncsSection {
    pub fn new(functions: Vec<QuickFunction>, position: Position) -> Self {
        QuickFuncsSection { functions, position }
    }
}

impl std::fmt::Display for QuickFuncsSection {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        writeln!(f, "@QUICKFUNCS(")?;
        for (i, func) in self.functions.iter().enumerate() {
            write!(f, "  ~{}", func.name)?;
            if let Some(ref rt) = func.return_type {
                write!(f, "<{}>", rt)?;
            }
            if let Some(ref scope) = func.scope_list {
                write!(f, " => {}", scope.join(","))?;
            }
            write!(f, "(")?;
            for (j, param) in func.parameters.iter().enumerate() {
                write!(f, "{}", param)?;
                if j < func.parameters.len() - 1 {
                    write!(f, ", ")?;
                }
            }
            writeln!(f, ") {{")?;
            for stmt in &func.body {
                writeln!(f, "    {}", stmt)?;
            }
            write!(f, "  }}")?;
            if i < self.functions.len() - 1 {
                writeln!(f, ",")?;
            } else {
                writeln!(f)?;
            }
        }
        write!(f, ")")
    }
}

/// QuickFunction definition
#[derive(Debug, Clone, PartialEq)]
pub struct QuickFunction {
    pub name: String,
    pub return_type: Option<DataType>,
    pub scope_list: Option<Vec<String>>,
    pub parameters: Vec<QuickFuncParam>,
    pub body: Vec<QuickFuncStatement>,
    pub position: Position,
}

impl QuickFunction {
    pub fn new(
        name: String,
        return_type: Option<DataType>,
        scope_list: Option<Vec<String>>,
        parameters: Vec<QuickFuncParam>,
        body: Vec<QuickFuncStatement>,
        position: Position,
    ) -> Self {
        QuickFunction {
            name,
            return_type,
            scope_list,
            parameters,
            body,
            position,
        }
    }
}

impl std::fmt::Display for QuickFunction {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "~{}", self.name)?;
        if let Some(ref rt) = self.return_type {
            write!(f, "<{}>", rt)?;
        }
        if let Some(ref scope) = self.scope_list {
            write!(f, " => {}", scope.join(","))?;
        }
        write!(f, "(")?;
        for (i, param) in self.parameters.iter().enumerate() {
            write!(f, "{}", param)?;
            if i < self.parameters.len() - 1 {
                write!(f, ", ")?;
            }
        }
        write!(f, ") {{ ")?;
        for stmt in &self.body {
            write!(f, "{}; ", stmt)?;
        }
        write!(f, "}}")
    }
}

/// QuickFunction parameter
#[derive(Debug, Clone, PartialEq)]
pub struct QuickFuncParam {
    pub name: String,
    pub data_type: Option<DataType>,
    pub default_value: Option<Expression>,
    pub position: Position,
}

impl QuickFuncParam {
    pub fn new(
        name: String,
        data_type: Option<DataType>,
        default_value: Option<Expression>,
        position: Position,
    ) -> Self {
        QuickFuncParam {
            name,
            data_type,
            default_value,
            position,
        }
    }
}

impl std::fmt::Display for QuickFuncParam {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name)?;
        if let Some(ref dt) = self.data_type {
            write!(f, "<{}>", dt)?;
        }
        if let Some(ref default) = self.default_value {
            write!(f, " = {}", default)?;
        }
        Ok(())
    }
      }