tr-lang 0.4.0

A programming language made to bring syntax closer to Turkish
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 crate::hashmap;
use crate::mem::Object;
use std::collections::HashMap;

pub type Stack = Vec<Object>;
type GStack = Vec<Stack>;
type GHash = Vec<HashMap<String, Object>>;

#[derive(Clone, Debug)]
pub struct StackMemory {
    gstack: GStack,
}

#[derive(Clone, Debug)]
pub struct HashMemory {
    ghashs: GHash,
}

impl StackMemory {
    pub fn new() -> Self {
        Self {
            gstack: vec![vec![]],
        }
    }

    // Stack Manipulation
    pub fn pop(&mut self) -> Option<Object> {
        for stack in self.gstack.iter_mut().rev() {
            match stack.pop() {
                Some(a) => return Some(a.clone()),
                None => (),
            }
        }
        None
    }
    pub fn push(&mut self, a: Object) {
        if let Some(last) = self.gstack.last_mut() {
            last.push(a);
        }
    }
    pub fn push_glob(&mut self, a: Object) {
        if let Some(first) = self.gstack.first_mut() {
            first.push(a);
        }
    }
    pub fn push_ret(&mut self, a: Object) {
        let glen = self.gstack.len();
        if let Some(ret) = self.gstack.get_mut(glen - 2) {
            ret.push(a);
        }
    }
    pub fn new_stack(&mut self) {
        self.gstack.push(vec![]);
    }
    pub fn del_stack(&mut self) -> Option<Stack> {
        self.gstack.pop()
    }

    // Stack Info
    pub fn len(&self) -> usize {
        let mut l: usize = 0;
        for stack in self.gstack.iter() {
            l += stack.len();
        }
        l
    }

    // Iter
    pub fn iter_vec(&mut self) -> Vec<Object> {
        let mut s = vec![];
        for stack in self.gstack.iter_mut() {
            s.append(stack);
        }
        s
    }
}

impl HashMemory {
    pub fn new() -> Self {
        Self {
            ghashs: vec![hashmap! {}],
        }
    }

    // Map Manipulation
    pub fn remove(&mut self, key: String) -> Option<Object> {
        for hash in self.ghashs.iter_mut().rev() {
            match hash.remove(&key) {
                Some(a) => return Some(a.clone()),
                None => (),
            }
        }
        None
    }

    pub fn insert(&mut self, key: String, val: Object) {
        if let Some(last) = self.ghashs.last_mut() {
            last.insert(key, val);
        }
    }

    pub fn insert_glob(&mut self, key: String, val: Object) {
        if let Some(first) = self.ghashs.first_mut() {
            first.insert(key, val);
        }
    }

    pub fn new_hash(&mut self) {
        self.ghashs.push(hashmap! {});
    }

    pub fn del_hash(&mut self) -> Option<HashMap<String, Object>> {
        self.ghashs.pop()
    }

    pub fn get(&mut self, key: &String) -> Option<&Object> {
        for hash in self.ghashs.iter().rev() {
            match hash.get(key) {
                Some(a) => return Some(a),
                None => (),
            }
        }
        None
    }

    pub fn get_mut(&mut self, key: &String) -> Option<&mut Object> {
        for hash in self.ghashs.iter_mut().rev() {
            match hash.get_mut(key) {
                Some(a) => return Some(a),
                None => (),
            }
        }
        None
    }

    pub fn into_keys(&mut self) -> Vec<String> {
        let mut s: Vec<String> = vec![];
        for i in self.ghashs.iter_mut().rev() {
            s.append(&mut i.clone().into_keys().collect::<Vec<String>>());
        }
        s
    }
}