126 lines
2.4 KiB
Rust
126 lines
2.4 KiB
Rust
use std::time::{Instant};
|
|
use decimal::d128;
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub enum Operator {
|
|
Plus,
|
|
Minus,
|
|
Multiply,
|
|
Divide,
|
|
Modulo,
|
|
Caret,
|
|
LeftParen, // lexer only
|
|
RightParen, // lexer only
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub enum UnaryOperator {
|
|
Percent,
|
|
Factorial,
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub enum TextOperator {
|
|
To,
|
|
Of,
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub enum Constant {
|
|
Pi,
|
|
E,
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub enum FunctionIdentifier {
|
|
Sqrt,
|
|
Cbrt,
|
|
|
|
Log,
|
|
Ln,
|
|
Exp,
|
|
|
|
Round,
|
|
Ceil,
|
|
Floor,
|
|
Abs,
|
|
|
|
Sin,
|
|
Cos,
|
|
Tan,
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub enum LexerKeyword {
|
|
Per,
|
|
PercentChar,
|
|
In,
|
|
}
|
|
|
|
mod units;
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub enum Token {
|
|
Operator(Operator),
|
|
UnaryOperator(UnaryOperator),
|
|
Number(d128),
|
|
FunctionIdentifier(FunctionIdentifier),
|
|
Constant(Constant),
|
|
Paren, // parser only
|
|
Per, // lexer only
|
|
LexerKeyword(LexerKeyword),
|
|
TextOperator(TextOperator),
|
|
Negative, // parser only
|
|
Unit(units::Unit),
|
|
}
|
|
|
|
pub type TokenVector = Vec<Token>;
|
|
|
|
mod lexer;
|
|
mod parser;
|
|
mod evaluator;
|
|
mod lookup;
|
|
|
|
fn main() {
|
|
let lex_start = Instant::now();
|
|
|
|
use std::env;
|
|
let args: Vec<String> = env::args().collect();
|
|
let s = if args.len() >= 2 { &args[1] } else { "0.1" };
|
|
|
|
match lexer::lex(s) {
|
|
Ok(tokens) => {
|
|
let lex_time = Instant::now().duration_since(lex_start).as_nanos() as f32;
|
|
|
|
let parse_start = Instant::now();
|
|
match parser::parse(&tokens) {
|
|
Ok(ast) => {
|
|
let parse_time = Instant::now().duration_since(parse_start).as_nanos() as f32;
|
|
|
|
let eval_start = Instant::now();
|
|
match evaluator::evaluate(&ast) {
|
|
Ok(answer) => {
|
|
let eval_time = Instant::now().duration_since(eval_start).as_nanos() as f32;
|
|
|
|
println!("Lexed TokenVector: {:?}", tokens);
|
|
println!("Parsed AstNode: {:#?}", ast);
|
|
|
|
println!("Evaluated value: {} {:?}", answer.value, answer.unit);
|
|
|
|
println!("\u{23f1} {:.3}ms lexing", lex_time/1000.0/1000.0);
|
|
println!("\u{23f1} {:.3}ms parsing", parse_time/1000.0/1000.0);
|
|
println!("\u{23f1} {:.3}ms evaluation", eval_time/1000.0/1000.0);
|
|
},
|
|
Err(e) => println!("Eval error: {}", e),
|
|
}
|
|
|
|
},
|
|
Err(e) => println!("Parsing error: {}", e),
|
|
}
|
|
|
|
},
|
|
Err(e) => println!("Lexing error: {}", e),
|
|
}
|
|
|
|
}
|