spacey 1.2.0

a tiny yet performant whitespace vmm/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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

use clap::{App, Arg, ArgMatches};
use spacey::interpreter::interpreter::InterpretError;
use spacey::{Interpreter, InterpreterConfig};
use std::time::Instant;

fn args() -> ArgMatches {
    App::new("spacey")
        .about("a lightweight whitespace interpreter")
        .version("0.1.0")
        .author("Cedric Schwyter <cedricschwyter@bluewin.ch>")
        .arg(
            Arg::new("file")
                .short('f')
                .long("file")
                .takes_value(true)
                .required(true)
                .help("whitespace source file to interpret"),
        )
        .arg(
            Arg::new("heap-size")
                .short('s')
                .long("heap-size")
                .takes_value(true)
                .required(false)
                .help("the size of the heap address space (each heap address stores one i32)"),
        )
        .arg(
            Arg::new("ir")
                .short('i')
                .long("ir")
                .required(false)
                .takes_value(false)
                .help("prints intermediate representation of instructions"),
        )
        .arg(
            Arg::new("debug")
                .short('d')
                .long("debug")
                .takes_value(false)
                .required(false)
                .help("prints debug information after each executed instruction"),
        )
        .arg(
            Arg::new("debug-heap")
                .short('m')
                .long("debug-heap")
                .takes_value(false)
                .required(false)
                .help("prints a heap dump after each executed instruction"),
        )
        .arg(
            Arg::new("quiet")
                .short('q')
                .long("quiet")
                .required(false)
                .takes_value(false)
                .help("suppresses all output other than what the whitespace program is producing"),
        )
        .get_matches()
}

fn main() -> Result<(), InterpretError> {
    let args = args();
    let file_name = args.value_of("file").unwrap();
    let heap_size = match args.value_of("heap-size") {
        Some(size) => size.parse().unwrap(),
        None => 524288,
    };
    let ir = args.is_present("ir");
    let debug = args.is_present("debug");
    let debug_heap = args.is_present("debug-heap");
    let quiet = args.is_present("quiet");
    if !quiet {
        println!(
        "initializing, loading and parsing the provided source, creating the virtual machine..."
    );
    }
    let start = Instant::now();
    let config = InterpreterConfig::new(file_name, heap_size, ir, debug, debug_heap, false);
    let mut interpreter = Interpreter::new(config)?;
    let end = Instant::now();
    if !quiet {
        println!(
            "initialized in {} ms ({} ns)",
            end.duration_since(start).as_millis(),
            end.duration_since(start).as_nanos()
        );
    }

    if !ir {
        if !quiet {
            println!("starting to execute whitespace routine...\n\n");
        }
        let start = Instant::now();
        interpreter.run()?;
        let end = Instant::now();
        if !quiet {
            println!(
                "\n\n\nroutine took {} ms ({} ns)",
                end.duration_since(start).as_millis(),
                end.duration_since(start).as_nanos()
            );
        }
    }

    Ok(())
}