brain 0.1.2

Compiler for the brain programming language. Compiles brain into optimized brainfuck code. Also includes a brainfuck 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

use parser::{Slice};
use instructions::Instructions;
use memory::MemoryLayout;

use super::errors::Error;

pub fn read_input(
    instructions: &mut Instructions,
    mem: &mut MemoryLayout,
    name: String,
    slice: Option<Slice>,
) -> Result<(), Error> {
    if mem.is_declared(&name) {
        read_into_existing_name(instructions, mem, name, slice)
    }
    else {
        read_into_new_name(instructions, mem, name, slice)
    }
}

fn read_into_existing_name(
    instructions: &mut Instructions,
    mem: &mut MemoryLayout,
    name: String,
    slice: Option<Slice>,
) -> Result<(), Error> {
    if slice.is_some() {
        return Err(Error::IllegalRedeclaration {name: name});
    }

    let (position, size) = mem.get_cell_contents(&name).unwrap();

    instructions.move_right_by(position);
    instructions.read_consecutive(size);
    instructions.move_left_by(position);
    Ok(())
}

fn read_into_new_name(
    instructions: &mut Instructions,
    mem: &mut MemoryLayout,
    name: String,
    slice: Option<Slice>,
) -> Result<(), Error> {
    if slice.is_none() {
        return Err(Error::UndeclaredIdentifier {name: name});
    }
    let slice = slice.unwrap();

    let size = match slice {
        Slice::SingleValue(s) => s,
        Slice::Unspecified => {
            return Err(Error::UnspecifiedInputSizeUnsupported {name: name});
        },
    };

    if size == 0 {
        return Err(Error::DeclaredZeroSize {
            name: name,
        });
    }

    let position = mem.declare(&name, size);
    instructions.move_right_by(position);
    instructions.read_consecutive(size);
    instructions.move_left_by(position);
    Ok(())
}