Hurray, now there are arrays in minicode! (#26)

Author: leonovk

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "minicode"
-version = "1.3.7"
+version = "1.4.0"
 authors = ["Kirill Leonov <leonov7632@gmail.com>"]
 edition = "2021"
 repository = "https://github.com/leonovk/minicode"

Cargo.toml

@@ -0,0 +1,23 @@
+use crate::opcode::ValueType;
+use crate::opcode::ValueType::*;
+use std::collections::HashMap;
+
+pub fn push<'a>(key: &'a String, value: &'a String, target: &mut HashMap<&'a String, ValueType>) {
+    let second_value = match target.get(value) {
+        Some(some) => some.clone(),
+        None => match value.parse::<f64>() {
+            Ok(i) => Int(i),
+            Err(_) => Line(value.to_string()),
+        },
+    };
+
+    let first_value: &mut Vec<ValueType> = match target.get_mut(key) {
+        Some(some) => match some {
+            Arr(a) => a,
+            _ => panic!("not is array"),
+        },
+        None => panic!("not is array"),
+    };
+
+    first_value.push(second_value);
+}

src/interpreter/arrays.rs

@@ -12,18 +12,19 @@ pub fn calculate<'a>(
 ) {
     let old_value = match target.get(key).expect("Variable value not found") {
         Int(int) => int,
-        Line(_s) => panic!("wrong type for calculate"),
+        _ => panic!("wrong type for calculate"),
     };
 
     let operational_meaning = match value {
         Int(int) => int,
         Line(str) => match target.get(str) {
             Some(some) => match some {
                 Int(link_int) => link_int,
-                Line(_line) => panic!("wrong type for calculate"),
+                _ => panic!("wrong type for calculate"),
             },
             None => panic!("wrong type for calculate"),
         },
+        Arr(_arr) => panic!("wrong type for calculate"),
     };
 
     target.insert(

src/interpreter/calculate.rs

@@ -19,12 +19,13 @@ pub fn condition(
             Some(some) => condition_result(first_value, some, operator),
             None => condition_result(first_value, &Line(str.to_string()), operator),
         },
+        Arr(_arr) => panic!("you can't compare arrays"),
     }
 }
 
 fn condition_result(first: &ValueType, second: &ValueType, operator: &ComparisonOperators) -> bool {
     if type_are_different(first, second) {
-        panic!("You cannot compare values of different types!");
+        panic!("You cannot compare values of different types, or arrays!");
     }
 
     match operator {
@@ -36,6 +37,12 @@ fn condition_result(first: &ValueType, second: &ValueType, operator: &Comparison
 }
 
 fn type_are_different(v1: &ValueType, v2: &ValueType) -> bool {
+    if let ValueType::Arr(_) = v1 {
+        return true;
+    } else if let ValueType::Arr(_) = v2 {
+        return true;
+    }
+
     match (v1, v2) {
         (ValueType::Int(_), ValueType::Line(_)) => true,
         (ValueType::Line(_), ValueType::Int(_)) => true,

src/interpreter/condition.rs

@@ -12,6 +12,7 @@ pub fn create<'a>(key: &'a String, value: &ValueType, target: &mut HashMap<&'a S
                 None => target.insert(key, value.clone()),
             },
         },
+        Arr(_arr) => target.insert(key, Arr(Vec::new())),
     };
 }
 
@@ -30,28 +31,42 @@ fn complex_assignments_value<'a>(
     }
 }
 
+// > a b 1
 fn multiple_values<'a>(
     values: Vec<&str>,
     target: &HashMap<&'a String, ValueType>,
 ) -> Option<ValueType> {
+    let index = match values[1].to_string().parse::<f64>() {
+        Ok(p) => p,
+        Err(_) => match target.get(&values[1].to_string()) {
+            Some(some) => match some {
+                Int(i) => *i,
+                _ => return None,
+            },
+            None => return None,
+        },
+    };
+
     match target.get(&values[0].to_string()) {
         Some(some) => match some {
             Int(_i) => None,
-            Line(str) => match values[1].to_string().parse::<f64>() {
-                Ok(parsed) => Some(Line(parse_char(str, parsed))),
-                Err(_) => match target.get(&values[1].to_string()) {
-                    Some(some_second) => match some_second {
-                        Int(sec_int) => Some(Line(parse_char(str, *sec_int))),
-                        Line(_l) => None,
-                    },
-                    None => None,
-                },
-            },
+            Line(l) => Some(Line(parse_char(l, index))),
+            Arr(arr) => Some(parse_elem(arr, index)),
         },
         None => None,
     }
 }
 
+fn parse_elem(vec: &Vec<ValueType>, index: f64) -> ValueType {
+    let elem = &vec[index as usize];
+
+    match elem {
+        Line(l) => Line(l.to_string()),
+        Int(i) => Int(*i),
+        Arr(a) => Arr(a.to_vec()),
+    }
+}
+
 fn parse_char(str: &String, index: f64) -> String {
     if (index as usize) > (str.len() - 1) {
         return "".to_string();
@@ -60,11 +75,13 @@ fn parse_char(str: &String, index: f64) -> String {
     }
 }
 
+// > a b
 fn one_value<'a>(values: Vec<&str>, target: &HashMap<&'a String, ValueType>) -> Option<ValueType> {
     match target.get(&values[0].to_string()) {
         Some(s) => match s {
             Int(int) => Some(Int(*int)),
             Line(str) => Some(Line(str.to_string())),
+            Arr(arr) => Some(Arr(arr.to_vec())),
         },
         None => None,
     }

src/interpreter/create.rs

@@ -18,6 +18,7 @@ pub fn include(
             Some(s) => match s {
                 Line(l) => result_args_value.push(l.to_string()),
                 Int(i) => result_args_value.push(i.to_string()),
+                Arr(_a) => panic!("You can't pass arrays as arguments"),
             },
         };
     }

src/interpreter/include.rs

@@ -5,13 +5,15 @@ use crate::opcode::ValueType::*;
 use std::collections::HashMap;
 use std::thread;
 use std::time::Duration;
+mod arrays;
 mod calculate;
 mod condition;
 mod create;
 mod execute;
 mod include;
 mod print_file;
 mod print_value;
+use arrays::push;
 use calculate::calculate;
 use condition::condition;
 use create::create;
@@ -41,6 +43,7 @@ pub fn exegete(operations: Vec<OpCode>, args: Vec<String>) {
 
         match operation {
             Create(k, v) => create(k, v, &mut addresses),
+            ArrayPush(k, v) => push(k, v, &mut addresses),
             Print(k) => print_value(k, &addresses),
             Operation(k, o, v) => calculate(k, o, v, &mut addresses),
             ErrorCode(e) => {

src/interpreter/mod.rs

@@ -10,6 +10,7 @@ pub fn print_file(key: &String, path: &String, storage: &HashMap<&String, ValueT
     let printed_content = match value {
         Line(line) => line.to_string().replace("\\n", "\n"),
         Int(int) => int.to_string(),
+        Arr(_arr) => panic!("you can't print an array"),
     };
 
     match write_content_to_file(&printed_content, path) {

src/interpreter/print_file.rs

@@ -9,6 +9,7 @@ pub fn print_value(key: &String, storage: &HashMap<&String, ValueType>) {
         Some(s) => match s {
             Int(i) => println!("{}", i),
             Line(s) => println!("{}", s),
+            Arr(_a) => panic!("you can't print an array"),
         },
         None => println!("{}", key),
     };

src/interpreter/print_value.rs

@@ -2,6 +2,7 @@
 pub enum ValueType {
     Int(f64),
     Line(String),
+    Arr(Vec<ValueType>),
 }
 
 #[derive(PartialEq, Debug)]
@@ -23,6 +24,7 @@ pub enum ComparisonOperators {
 #[derive(PartialEq, Debug)]
 pub enum OpCode {
     Create(String, ValueType),
+    ArrayPush(String, String),
     Print(String),
     PrintFile(String, String),
     Operation(String, OperationType, ValueType),

src/opcode/mod.rs

@@ -0,0 +1,22 @@
+use crate::opcode::OpCode;
+use crate::opcode::OpCode::*;
+use crate::opcode::ValueType::*;
+
+// [] a
+pub fn appropriation_array(data: Vec<&str>) -> OpCode {
+    let value_name = data[1].to_string();
+
+    Create(value_name, Arr(Vec::new()))
+}
+
+// []< a b
+pub fn push_array(data: Vec<&str>) -> OpCode {
+    if data.len() != 3 {
+        return ErrorCode("the operation is not specified correctly".to_string());
+    }
+
+    let arr_name = data[1].to_string();
+    let value_name = data[2].to_string();
+
+    ArrayPush(arr_name, value_name)
+}

src/parser/arrays.rs

@@ -1,4 +1,5 @@
 mod appropriation;
+mod arrays;
 mod calculation;
 mod condition;
 mod exec;

src/parser/mod.rs

@@ -2,6 +2,7 @@ pub use crate::opcode::OpCode;
 pub use crate::opcode::OpCode::*;
 
 use super::appropriation::appropriation;
+use super::arrays::*;
 use super::calculation::calculation;
 use super::condition::condition;
 use super::exec::exec;
@@ -18,6 +19,8 @@ pub fn get_opcode(line: &String) -> OpCode {
 
     match command {
         ">" => appropriation(data),
+        "[]" => appropriation_array(data),
+        "[]<" => push_array(data),
         "p" => print(data),
         "f" => file(data),
         "$>" => user_var(data),
@@ -27,7 +30,8 @@ pub fn get_opcode(line: &String) -> OpCode {
         "&" => exec(data),
         "->" => include(data, false),
         "-->" => include(data, true),
-        "sleep" => sleep(data),
+        "-_-" => sleep(data),
+        "#" => EmptyLine,
         _ => ErrorCode("Could not recognize the command".to_string()),
     }
 }

src/parser/opcode_parser.rs

@@ -0,0 +1,25 @@
+# Сначало заполняем массив
+
+[] a
+> empty_line
+> word hello
+> i 0
+> char word i
+[]< a char
+= i + 1
+? char ! empty_line 7
+
+# Затем выбираем из него нужные элементы, кладем их в переменные
+# и печатаем на экран
+
+> h a 0
+> e a 1
+> l a 2
+> ll a 3
+> o a 4
+
+p h
+p e
+p l
+p ll
+p o

tests/examples/arrays_1.mcode

@@ -0,0 +1,13 @@
+[] a
+[]< a 23
+[]< a 10
+
+> b a 0
+> c a 1
+> sum 0
+
+= sum + b
+= sum + c
+
+# output: 33
+p sum

tests/examples/arrays_2.mcode

@@ -1,5 +1,5 @@
 > text lol kek cheburek
 p start sleep now
-sleep 10
+-_- 10
 p stop sleep now
 p text

tests/examples/sleep.mcode

@@ -1,2 +1,2 @@
 p sleep 2
-sleep 10
+-_- 10

tests/examples/sleep_2.mcode

@@ -1,2 +1,2 @@
 p sleep 3
-sleep 10
+-_- 10