woojin 0.1.1

Woojinlang interpreter written as Rust
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

pub mod error;
pub mod token;
pub mod value;

use lazy_static::lazy_static;
use token::{Calc, WoojinResult};
use std::{
  process,
  io::{Write}, sync::{Arc, Mutex}, collections::HashMap,
};
use nom::{IResult};
use value::{WoojinValue, ValueCalc};

#[derive(Debug)]
pub enum Statements {
  Nop,
  Comment(String),
  Input(Box<Statements>),
  Value(WoojinValue),
  Print(Vec<Box<Statements>>),
  Println(Vec<Box<Statements>>),
  Roar(WoojinValue),
  DecVar(String, Box<Statements>, bool),
  Calc(Calc),
  Sleep(Box<Statements>),
  Exit(i32)
}

#[derive(Debug)]
pub struct WoojinVariable {
  pub value: WoojinValue,
  pub is_mut: bool
}

pub(crate) type NomResult<'a, T> = IResult<&'a str, T>;
lazy_static!{
  pub(crate) static ref VARS: Arc<Mutex<HashMap<String, WoojinVariable>>> = {
    Arc::new(Mutex::new(HashMap::new()))
  };
}

pub fn exec(stmt: &Statements) -> Result<WoojinValue, crate::error::WoojinError> {
  match stmt {
    Statements::Exit(num) => { std::process::exit(*num); },
    Statements::Print(values) => {
      for (i, value) in values.iter().enumerate() {
        print!("{}", exec(value)?.to_print());
        if i != values.len() - 1 { print!(" "); }
      }
      std::io::stdout().flush().unwrap();
    },
    Statements::Println(values) => {
      for (i, value) in values.iter().enumerate() {
        print!("{}", exec(value)?.to_print());
        if i != values.len() - 1 { print!(" "); } else { print!("\n"); }
      }
      std::io::stdout().flush().unwrap();
    },
    Statements::Input(val) => {
      let mut input: String = String::new();
      exec(&Statements::Print(vec![Box::new(Statements::Value(exec(val.clone())?))]))?;
      std::io::stdin().read_line(&mut input).unwrap();
      return Ok(WoojinValue::String(input.trim().to_string()));
    },
    Statements::DecVar(name, value, is_mut) => {
      let mut vars: std::sync::MutexGuard<HashMap<String, WoojinVariable>> = VARS.lock().unwrap();
      if vars.contains_key(name) { error(&format!("Variable {} is already declared", name)); }
      vars.insert(name.clone(), WoojinVariable { value: exec(&value)?, is_mut: *is_mut });
    },
    Statements::Calc(calc) => { return check_calc(calc.clone()); },
    Statements::Roar(val) => error(&val.to_print()),
    Statements::Value(val) => return Ok(val.clone()),
    Statements::Sleep(val) => {
      match exec(&**val)? {
        WoojinValue::Int(num) => std::thread::sleep(std::time::Duration::from_millis(num as u64)),
        _ => error(&"The param of the sleep function must be an integer")
      }
    },
    Statements::Nop => {}
    Statements::Comment(_) => {}
  }
  Ok(WoojinValue::Unit)
}

pub fn error(msg: &impl ToString) -> ! {
  eprintln!("\x1b[1m\x1b[31mWJ\x1b[0m: {}", msg.to_string());
  process::exit(1);
}

pub(crate) fn check_calc(calc: Calc) -> WoojinResult<WoojinValue> {
  match calc {
    Calc::Add(a, b) => Ok(check_calc(*a)?.add(&check_calc(*b)?)?),
    Calc::Sub(a, b) => Ok(check_calc(*a)?.sub(&check_calc(*b)?)?),
    Calc::Mul(a, b) => Ok(check_calc(*a)?.mul(&check_calc(*b)?)?),
    Calc::Div(a, b) => Ok(check_calc(*a)?.div(&check_calc(*b)?)?),
    Calc::Value(val) => return Ok(val.clone()),
  }
}