usze 0.1.0

Sometimes you just need a calculator
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
99

use atty::Stream;
use std::{
    env,
    error::Error,
    io::{self, BufRead, Write},
};

use usze::*;

fn eval_and_print_till_terminal(env: &mut Env) -> Result<(), Box<dyn Error>> {
    print!("{} ", env);
    io::stdout().flush()?;
    while let Some(true) = env.eval() {
        print!("\n{} ", env);
        io::stdout().flush()?;
    }
    Ok(())
}

fn eval_stdin(env: &mut Env, verbose: bool) -> Result<(), Box<dyn Error>> {
    let stdin = io::stdin().lock();

    for line in stdin.lines() {
        if let Ok(line) = line {
            for (i, word) in line.split_whitespace().enumerate() {
                let op = Op::try_from(word)?;
                if verbose && i != 0 {
                    if i == 1 {
                        println!("");
                    }
                    println!("{}", env);
                }
                env.push(op);
            }

            eval_and_print_till_terminal(env)?;
        }
    }

    Ok(())
}

fn push_from_args(env: &mut Env) -> Result<(), Box<dyn Error>> {
    for arg in env::args().skip(1) {
        for word in arg.split_whitespace() {
            let op = Op::try_from(word)?;
            env.push(op)
        }
    }

    Ok(())
}

fn push_from_stdin(env: &mut Env) -> Result<(), Box<dyn Error>> {
    let stdin = io::stdin().lock();

    for line in stdin.lines() {
        if let Ok(line) = line {
            for word in line.split_whitespace() {
                let op = Op::try_from(word)?;
                env.push(op)
            }
        }
    }

    Ok(())
}

fn main() -> Result<(), Box<dyn Error>> {
    let interactive = atty::is(Stream::Stdin);
    let verbose = interactive || atty::is(atty::Stream::Stdout);

    let mut env = Env::new();

    if interactive {
        push_from_args(&mut env)?;
        eval_and_print_till_terminal(&mut env)?;
        loop {
            eval_stdin(&mut env, verbose)?;
        }
    } else {
        /*
        could possibly achieve the desired effect by seeking back through the stack
        and evaluating the first command we come to?

        that would mean we could have

        rpn "3 +" << 4
        which would then rearnage to "3 4 +"

        */
        push_from_args(&mut env)?;
        push_from_stdin(&mut env)?;
        eval_and_print_till_terminal(&mut env)?;
        println!("");
    }

    Ok(())
}