calc/src/main.rs

use std::collections::HashMap;
use std::io;
use std::io::Write;

fn main() {
  let stdin = io::stdin();
  let mut buffer = String::new();

  loop {
    print!("> ");
    io::stdout().flush().unwrap();

    stdin.read_line(&mut buffer).unwrap();

    let tokens = tokenisator(&buffer);
    let rpn = to_rpn(tokens);

    buffer.clear();
  }
}

fn tokenisator(task: &str) -> Vec<Token> {
  let mut tokens = Vec::<Token>::new();
  let chars: Vec<char> = task.chars().collect();
  let mut pointer = 0;

  while pointer < task.len() {
    dbg!(pointer, task.len());

    let c = chars[pointer];
    match c {
      '0' .. '9' => {
        let mut end = pointer;
        while end < task.len() {
          let cur_c = chars[end];
          if !cur_c.is_ascii_digit() {
            break;
          }
          end += 1;
        }
        tokens.push(Token::Number(
          task.get(pointer..end).unwrap().parse::<i32>().unwrap()
        ));
        pointer = end-1;
      }
      '+' => tokens.push(Token::Addition),
      '-' => tokens.push(Token::Substruction),
      '*' => tokens.push(Token::Multiplication),
      '/' => tokens.push(Token::Division),
      '(' => tokens.push(Token::BracketOpen),
      ')' => tokens.push(Token::BracketClose),
      _ => {}
    }

    pointer += 1;
  }

  println!("{}", task);

  for t in &tokens {
    println!("{:?}", t);
  }

  return tokens;
}

fn to_rpn(tokens: Vec<Token>) -> Vec<Token> {
  let mut out_buf = Vec::<Token>::new();
  let mut act_buf = Vec::<Token>::new();

  let priority = HashMap::from([
    (Token::BracketOpen,    0),
    (Token::Addition,       1),
    (Token::Substruction,   1),
    (Token::Multiplication, 2),
    (Token::Division,       2),
  ]);

  for t in tokens {
    match t {
      Token::Number(_) => out_buf.push(t),
      Token::BracketOpen => act_buf.push(t),
      Token::BracketClose => {
        while matches!(act_buf.last().unwrap(), Token::BracketOpen) {
          out_buf.push(act_buf.pop().unwrap());
        }
        act_buf.pop();
      }
      _ => {
        if !act_buf.is_empty() {
          while priority.get(&t).unwrap() < priority.get(act_buf.last().unwrap()).unwrap() {
            out_buf.push(act_buf.pop().unwrap());
            if act_buf.is_empty() { break; }
          }
        }

        act_buf.push(t);
      }
    }
  }

  act_buf.reverse();
  out_buf.append(&mut act_buf);

  return out_buf;
}

#[derive(Debug)]
#[derive(Eq, Hash, PartialEq)]
enum Token {
  Number(i32),
  Addition,
  Substruction,
  Multiplication,
  Division,
  BracketOpen,
  BracketClose,
}