carried out parsing operations

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "minicode"
-version = "0.1.3"
+version = "1.0.1"
 edition = "2021"
 
 [dependencies]

src/parser/appropriation.rs

@@ -0,0 +1,12 @@
+use crate::opcode::OpCode;
+use crate::opcode::OpCode::*;
+use crate::opcode::ValueType::*;
+
+pub fn appropriation(data: Vec<&str>) -> OpCode {
+    let value_name = data[1].to_string();
+    let value: String = data.into_iter().skip(2).collect::<Vec<&str>>().join(" ");
+    match value.parse::<i64>() {
+        Ok(parsed) => Create(value_name, Int(parsed)),
+        Err(_e) => Create(value_name, Line(value)),
+    }
+}

src/parser/calculation.rs

@@ -0,0 +1,22 @@
+use crate::opcode::OpCode;
+use crate::opcode::OpCode::*;
+use crate::opcode::OperationType::*;
+
+pub fn calculation(data: Vec<&str>) -> OpCode {
+    if data.len() != 4 {
+        return ErrorCode("the operation is not specified correctly".to_string());
+    }
+
+    let value_name = data[1].to_string();
+
+    let op = match data[2] {
+        "+" => Increment,
+        "-" => Decrement,
+        _ => return ErrorCode("wrong operation".to_string()),
+    };
+
+    match data[3].to_string().parse::<i64>() {
+        Ok(parsed) => Operation(value_name, op, parsed),
+        Err(_e) => ErrorCode("wrong type for operation".to_string()),
+    }
+}

src/parser/condition.rs

@@ -0,0 +1,23 @@
+use crate::opcode::OpCode;
+use crate::opcode::OpCode::*;
+
+pub fn condition(data: Vec<&str>) -> OpCode {
+    let value_name = data[1].to_string();
+    let true_or_false = match data[2] {
+        "=" => true,
+        "!" => false,
+        _ => return ErrorCode("wrong condition".to_string()),
+    };
+
+    let target_value = match data[3].parse::<i64>() {
+        Ok(parsed) => parsed,
+        Err(_) => return ErrorCode("wrong target value for operation".to_string()),
+    };
+
+    let target_pointer = match data[4].parse::<usize>() {
+        Ok(parsed) => parsed,
+        Err(_) => return ErrorCode("wrong target pointer".to_string()),
+    };
+
+    Condition(value_name, target_value, true_or_false, target_pointer)
+}

src/parser/file.rs

@@ -0,0 +1,10 @@
+use crate::files::get_content;
+pub use crate::opcode::OpCode;
+pub use crate::opcode::OpCode::*;
+pub use crate::opcode::ValueType::*;
+
+pub fn file(data: Vec<&str>) -> OpCode {
+    let value_name = data[1].to_string();
+    let content = get_content(&data[2].to_string());
+    Create(value_name, Line(content))
+}

src/parser/mod.rs

@@ -1,5 +1,9 @@
-mod opcode_operations;
+mod appropriation;
+mod calculation;
+mod condition;
+mod file;
 mod opcode_parser;
+mod user_var;
 use crate::opcode::*;
 
 pub fn parse(lines: &Vec<String>) -> Vec<OpCode> {

src/parser/opcode_parser.rs

@@ -1,23 +1,27 @@
 pub use crate::opcode::OpCode;
 pub use crate::opcode::OpCode::*;
 
-use super::opcode_operations;
+use super::appropriation::appropriation;
+use super::calculation::calculation;
+use super::condition::condition;
+use super::file::file;
+use super::user_var::user_var;
 
 pub fn get_opcode(line: &String) -> OpCode {
     let parts: Vec<&str> = line.split_whitespace().collect();
 
     if parts[0] == ">" {
-        opcode_operations::appropriation(parts)
+        appropriation(parts)
     } else if parts[0] == "p" {
         Print(parts[1].to_string())
     } else if parts[0] == "f" {
-        opcode_operations::file(parts)
+        file(parts)
     } else if parts[0] == "$>" {
-        opcode_operations::user_var(parts)
+        user_var(parts)
     } else if parts[0] == "=" {
-        opcode_operations::calculation(parts)
+        calculation(parts)
     } else if parts[0] == "?" {
-        opcode_operations::condition(parts)
+        condition(parts)
     } else {
         ErrorCode("Could not recognize the command".to_string())
     }

src/parser/user_var.rs

@@ -0,0 +1,16 @@
+use crate::opcode::OpCode;
+use crate::opcode::OpCode::*;
+use crate::opcode::ValueType::*;
+use std::io;
+
+pub fn user_var(data: Vec<&str>) -> OpCode {
+    let mut input = String::new();
+    let value_name = data[1].to_string();
+    let output = data.into_iter().skip(2).collect::<Vec<&str>>().join(" ");
+    println!("{}", output);
+    io::stdin().read_line(&mut input).expect("cant read");
+    match input.trim().parse::<i64>() {
+        Ok(parsed) => Create(value_name, Int(parsed)),
+        Err(_e) => Create(value_name, Line(input)),
+    }
+}