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

use super::config::ConfigSection;
use super::imports::ImportsSection;
use super::dlm::DLMSection;
use super::enums::EnumsSection;
use super::quickfuncs::QuickFuncsSection;
use super::data::DataSection;
use super::security::SecuritySection;

/// Main DixScript AST structure
/// Represents a complete parsed .mdix file
#[derive(Debug, Clone, PartialEq)]
pub struct DixScript {
    pub config: Option<ConfigSection>,
    pub imports: Option<ImportsSection>,
    pub dlm: Option<DLMSection>,
    pub enums: Option<EnumsSection>,
    pub quick_functions: Option<QuickFuncsSection>,
    pub data: Option<DataSection>,
    pub security: Option<SecuritySection>,
}

impl DixScript {
    /// Create a new empty DixScript AST
    pub fn new() -> Self {
        DixScript {
            config: None,
            imports: None,
            dlm: None,
            enums: None,
            quick_functions: None,
            data: None,
            security: None,
        }
    }
    
    /// Create a DixScript AST with all sections
    pub fn with_sections(
        config: Option<ConfigSection>,
        imports: Option<ImportsSection>,
        dlm: Option<DLMSection>,
        enums: Option<EnumsSection>,
        quick_functions: Option<QuickFuncsSection>,
        data: Option<DataSection>,
        security: Option<SecuritySection>,
    ) -> Self {
        DixScript {
            config,
            imports,
            dlm,
            enums,
            quick_functions,
            data,
            security,
        }
    }
}

impl Default for DixScript {
    fn default() -> Self {
        Self::new()
    }
}

impl std::fmt::Display for DixScript {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        // @CONFIG Section
        if let Some(ref config) = self.config {
            writeln!(f, "{}", config)?;
            writeln!(f)?;
        }
        
        // @IMPORTS Section
        if let Some(ref imports) = self.imports {
            writeln!(f, "{}", imports)?;
            writeln!(f)?;
        }
        
        // @DLM Section
        if let Some(ref dlm) = self.dlm {
            writeln!(f, "{}", dlm)?;
            writeln!(f)?;
        }
        
        // @ENUMS Section
        if let Some(ref enums) = self.enums {
            writeln!(f, "{}", enums)?;
            writeln!(f)?;
        }
        
        // @QUICKFUNCS Section
        if let Some(ref quick_funcs) = self.quick_functions {
            writeln!(f, "{}", quick_funcs)?;
            writeln!(f)?;
        }
        
        // @DATA Section
        if let Some(ref data) = self.data {
            writeln!(f, "{}", data)?;
            writeln!(f)?;
        }
        
        // @SECURITY Section
        if let Some(ref security) = self.security {
            writeln!(f, "{}", security)?;
        }
        
        Ok(())
    }
}

impl std::cmp::Eq for DixScript {}