moon_script 0.8.2

Fast and simple scripting language based on Rust.
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

use alloc::fmt::Debug;
use alloc::format;
use alloc::string::String;
use alloc::string::ToString;
use alloc::vec::Vec;
use core::fmt::{Display, Formatter};
use simple_detailed_error::{SimpleErrorDetail, SimpleErrorExplanation};

use ast::Statement;

use crate::function::MoonFunction;
use crate::value::FullValue;

pub mod optimized_ast;
pub mod ast;

/// An error occurred when running a script
#[derive(Debug)]
pub enum RuntimeError {
    /// A function returned [Result::<_, String>::Err], being this is string an error message that
    /// is returned in 'function_error_message'.
    FunctionError { function_error_message: String },
    /// A predicate couldn't be calculated, this is the same as a [RuntimeError::FunctionError], but
    /// specific for 'if' and 'while' predicates.
    CannotTurnPredicateToBool { type_of_statement: &'static str, function_error_message: String },
    /// An argument to a function couldn't be parsed as a [crate::MoonValue].
    CannotParseArgument,
    /// A function tried to run, but an argument was missing.
    AnArgumentIsMissing,
}

impl RuntimeError {
    pub(crate) fn explain(&self) -> String {
        match self {
            RuntimeError::CannotTurnPredicateToBool { type_of_statement, function_error_message } =>
                format!("Could not parse predicate of a {type_of_statement} block due to: {function_error_message}"),
            RuntimeError::FunctionError { function_error_message } =>
                format!("Could not execute a function due to: {function_error_message}"),
            RuntimeError::CannotParseArgument => "A function argument type is wrong".to_string(),
            RuntimeError::AnArgumentIsMissing => "A function is missing an argument".to_string(),
        }
    }
}

impl SimpleErrorDetail for RuntimeError {
    fn explain_error(&self) -> SimpleErrorExplanation {
        SimpleErrorExplanation::new().explanation(self.explain())
    }
}

impl Display for RuntimeError{
    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
        f.write_str(&self.explain_error().to_display_struct(true).to_string())
    }
}

#[derive(Clone, Debug, PartialEq)]
pub(crate) struct ASTFunction {
    pub(crate) function: MoonFunction,
    pub(crate) args: Vec<FullValue>,
}

#[derive(Clone, Debug, PartialEq)]
pub(crate) struct ConditionalStatements {
    pub(crate) condition: FullValue,
    pub(crate) statements: Vec<Statement>,
}


#[derive(Debug, Clone, PartialEq)]
pub(crate) struct RuntimeVariable {
    pub(crate) value: FullValue,
}

impl From<FullValue> for RuntimeVariable {
    fn from(value: FullValue) -> Self {
        RuntimeVariable::new(value)
    }
}

impl RuntimeVariable {
    pub(crate) fn new<Value: Into<FullValue>>(value: Value) -> Self {
        Self { value: value.into() }
    }
}