src

src/debug.rs

@@ -0,0 +1,41 @@
+
+pub fn debugging(formule: &str) {
+    let mut numbers: Vec<i32> = vec![]; // Массив для хранения чисел
+    let mut chars = formule.chars().peekable(); // Создаем peekable-итератор
+
+    if let Some(first_char) = chars.next() {
+        if first_char == '!' as char {
+            while let Some(c) = chars.next() {
+                if c >= 'a' as char {
+                    continue;
+                } else if c == ' ' {
+                    continue;
+                } else {
+                    if String::from(c) == "+" || String::from(c) == "-" || String::from(c) == "" || String::from(c) == "+" {
+
+                    }
+                    numbers.push(c as i32 - 48); // Заполняем массив числами
+                    println!("symbol: {}", c); // Выводим символ
+
+                    // Выводим следующий символ, если он есть
+                    if let Some(next_char) = chars.peek() {
+                        println!("next symbol: {}", next_char);
+                    } else {
+                        println!("next symbol: None");
+                    }
+
+                    println!("size: {}", numbers.len()); // Выводим текущий размер массива
+                    {
+                        let a = c as i32;
+                        // Здесь вы можете использовать переменную `a`
+                        println!("a = {}", a - 48);
+                        println!("-----");
+                    }
+                }
+            }
+            println!("DEBUG numbers: {:?}", numbers); // Выводим массив чисел
+        } else {
+            // па преколу
+        }
+    }
+}

src/main.rs

@@ -0,0 +1,168 @@
+use colored::Colorize; // Импортируем библиотеку для работы с цветами
+use std::io::{self, Write}; // Импортируем библиотеки для работы с вводом и выводом
+
+//import
+mod debug; // Импортируем модуль debug.rs
+use crate::debug::debugging;
+
+fn main() {
+    println!(
+        "{}, ver: {}, by: {} ; print 'H' to see help ; to exit print 'Q'",
+        env!("CARGO_PKG_NAME"),
+        env!("CARGO_PKG_VERSION").bold().cyan(),
+        env!("CARGO_PKG_AUTHORS").bold().cyan()
+    );
+    begin(); // запуск кода
+}
+
+fn begin() {
+    let prefix = ">> "; // Префикс для ввода
+    print!("{}", prefix); // Выводим префикс
+    io::stdout().flush().unwrap(); // Принудительный вывод префикса (необходимо для корректного отображения префикса)
+
+    let mut input = String::new(); // Строка для ввода
+
+    io::stdin() // Ввод с клавиатуры
+        .read_line(&mut input)
+        .expect("Failed to read line");
+
+    if input.chars().nth(0).unwrap() == 'H' || input.chars().nth(0).unwrap() == 'h' {
+        // Выводим помощь
+        println!(
+            "{}\n{}\n{}\n{}\n{}\n{}",
+            "calc help".bold().red(),
+            "'!' = debug mode".italic(),
+            "'+' = addition".italic(),
+            "'-' = subtraction".italic(),
+            "'*' = multiplication".italic(),
+            "'/' = division".italic()
+        );
+        begin()
+    }
+
+    println!("You entered: {}", input.trim()); // Выводим введенное значение
+
+    debugging(&input.trim()); // Вызываем функцию дебаг
+    calculate(formatting(&input.trim())); // Вызываем функцию вычисления
+    let_start_again()
+}
+
+fn formatting(formule: &str) -> Vec<String> {
+    if formule == "exit" || formule == "quit" || formule == "q" || formule == "Q" {
+        println!("{}", "Bye!".bold().on_green());
+        std::process::exit(0); // Выход
+    }
+
+    let mut stack: Vec<String> = vec![String::from("")]; // Массив для хранения чисел в виде строк
+    let mut dot_count = 0; // Счетчик точек в текущем числе
+
+    for c in formule.chars() {
+        if c.is_digit(10) {
+            // Если символ является цифрой
+            stack.last_mut().unwrap().push(c);
+        } else if c == '.' {
+            // Если символ является точкой
+            if dot_count > 0 {
+                // Если уже есть одна точка в текущем числе, это ошибка
+                println!(
+                    "{}",
+                    "Error: Invalid number format with multiple decimal points."
+                        .bold()
+                        .red()
+                );
+                begin();
+            } else {
+                stack.last_mut().unwrap().push(c);
+                dot_count += 1; // Увеличиваем счетчик точек
+            }
+        } else if c == '+' || c == '-' || c == '*' || c == '/' {
+            // Если символ является оператором
+            stack.push(String::from(c)); // Добавляем оператор в стек
+            stack.push(String::from("")); // Добавляем пустую строку в стек
+            dot_count = 0; // Сбрасываем счетчик точек при переходе к новому числу
+        } else if c == ' ' || c == '!' {
+            // Если символ является пробелом
+            continue;
+        } else {
+            println!("{}", "Error: Invalid characters entered!".bold().red());
+            begin();
+        }
+    }
+
+    if formule.chars().nth(0).unwrap() == '!' {
+        println!("DEBUG: {:?}", formule);
+        println!("DEBUG len: {:?}", formule.len());
+    }
+
+    stack // спасибо чату жпт что подсказал что надо поставить эту хуйню :D
+}
+
+fn calculate(formula: Vec<String>) -> f32 {
+    let mut values: Vec<f32> = Vec::new();
+    let mut operators: Vec<String> = Vec::new();
+
+    let mut i = 0;
+    while i < formula.len() {
+        let token = &formula[i];
+        if let Ok(num) = token.parse::<f32>() {
+            values.push(num);
+        } else if token == "*" || token == "/" {
+            // Проверяем, есть ли следующий токен и является ли он числом
+            if i + 1 >= formula.len() || formula[i + 1].parse::<f32>().is_err() {
+                println!(
+                    "{}",
+                    "Error: Invalid syntax, operator followed by another operator or end of input."
+                        .bold()
+                        .red()
+                );
+                begin();
+            }
+
+            let op = token;
+            i += 1;
+            let next_value = formula[i].parse::<f32>().unwrap();
+            let last_value = values.pop().unwrap();
+            let result = if op == "*" {
+                last_value * next_value
+            } else {
+                last_value / next_value
+            };
+            values.push(result);
+        } else if token == "+" || token == "-" {
+            // Проверяем, есть ли следующий токен и является ли он числом
+            if i + 1 >= formula.len() || formula[i + 1].parse::<f32>().is_err() {
+                println!(
+                    "{}",
+                    "Error: Invalid syntax, operator followed by another operator or end of input."
+                        .bold()
+                        .red()
+                );
+                begin();
+            }
+
+            operators.push(token.clone());
+        }
+        i += 1;
+    }
+
+    let mut result = values[0];
+    let mut value_index = 1;
+
+    for operator in operators {
+        let next_value = values[value_index];
+        if operator == "+" {
+            result += next_value;
+        } else {
+            result -= next_value;
+        }
+        value_index += 1;
+    }
+
+    println!("Result: {}", result);
+
+    result
+}
+
+fn let_start_again() {
+    begin()
+}