brim 4.2.2

An optimizing brain* interpreter.
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

use std::{
    fs::{self, File},
    io::{stdout, stdin, BufReader, Read},
};

use sarge::prelude::*;

use brim::{
    helper::{err, warn},
    interpret, parse,
    token::optimize,
};

#[cfg(feature = "debug")]
sarge! {
    Args,

    'h' help: bool,
    #ok 'i' input: String,
    #ok 'o' output: String,

    #ok 'w' @BRIM_DEBUG_WIDTH debug_width: usize,
}

#[cfg(not(feature = "debug"))]
sarge! {
    Args,

    'h' help: bool,
    #ok 'i' input: String,
    #ok 'o' output: String,
}

fn main() {
    let (args, files) = Args::parse().unwrap_or_else(|e| err("failed to parse arguments", e));

    if args.help || files.is_empty() {
        warn(include_str!("usage.txt"));

        return;
    }

    let mut stdin = if let Some(i) = args.input {
        let file = File::open(i).unwrap_or_else(|e| err("failed to open input file", e));

        Box::new(BufReader::new(file)) as Box<dyn Read>
    } else {
        Box::new(BufReader::new(stdin())) as Box<dyn Read>
    }.bytes().map(|data| data.unwrap_or_else(|e| err("failed to read input", e)));

    if let Some(o) = args.output {
        let mut file = File::create(o).unwrap_or_else(|e| err("failed to open output file", e));

        for filename in files.iter().skip(1) {
            let input = fs::read_to_string(filename).unwrap_or_else(|e| err("failed", e));

            let toks = parse(&input);
            let toks = optimize(&toks);

            #[cfg(not(feature = "debug"))]
            interpret(&toks, &mut stdin, &mut file);

            #[cfg(feature = "debug")]
            interpret(&toks, &mut stdin, &mut file, args.debug_width.unwrap_or(8));
        }
    } else {
        for filename in files.iter().skip(1) {
            let input = fs::read_to_string(filename).unwrap_or_else(|e| err("failed", e));

            let toks = parse(&input);
            let toks = optimize(&toks);

            #[cfg(not(feature = "debug"))]
            interpret(&toks, &mut stdin, &mut stdout());

            #[cfg(feature = "debug")]
            interpret(&toks, &mut stdin, &mut stdout(), args.debug_width.unwrap_or(8));
        }
    }
}