celsium 0.1.7

A library for building interpreters
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

use super::StackValue;

pub fn format_for_print(value: &StackValue, newline: bool) -> String {
    match value {
        StackValue::Bool { value } => {
            if !newline {
                if *value {
                    return "PATIESS".to_owned();
                } else {
                    return "NEPATIESS".to_owned();
                }
            } else {
                if *value {
                    return "PATIESS\n".to_owned();
                } else {
                    return "NEPATIESS\n".to_owned();
                }
            }
        }
        StackValue::Int { value } => {
            if !newline {
                return format!("{}", value);
            } else {
                return format!("{}\n", value);
            }
        }
        StackValue::String { value } => {
            if !newline {
                return format!("{}", value);
            } else {
                return format!("{}\n", value);
            }
        }
        StackValue::Array { value } => {
            let mut printable_str: String = "[".to_string();
            let mut counter = 0;
            for i in value {
                let formated: String = format_for_print(&i.clone(), false).as_str().to_owned();
                match i {
                    StackValue::String { value: _ } => {
                        printable_str = printable_str + "\"" + &formated + "\"";
                    }
                    _ => {
                        printable_str += &formated;
                    }
                }

                if counter != value.len() - 1 {
                    printable_str += ";";
                }
                counter += 1;
            }
            if newline {
                printable_str += "]\n";
            } else {
                printable_str += "]";
            }
            return printable_str;
        }
        StackValue::Object { value: fields } => {
            let mut printable_object = format!("Objekts {{\n");
            let mut index = 0;
            let length = &fields.len();
            for field in fields {
                printable_object += &format!(
                    "   {}: {}\n",
                    field.name,
                    format_for_print(&field.value, false)
                );
                if &(index + 2) == length {
                    //printable_object += "\n";
                }
                index += 1;
            }
            printable_object += "}";
            if !newline {
                return format!("{}", printable_object);
            } else {
                return format!("{}\n", printable_object);
            }
        }
        StackValue::Float { value } => {
            if !newline {
                return format!("{}", value.to_string().replace(".", ","));
            } else {
                return format!("{}\n", value.to_string().replace(".", ","));
            }
        }
    }
}