brainfrick 1.1.2

An optimizing brainfuck interpreter with helpful errors.
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 itertools::Itertools;
use std::sync::Arc;

use crate::{
    error::{Error, ErrorKind, Index},
    step::{LoopKind, Step},
    Brainfuck,
};

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct IndexedStep {
    step: Step,
    index: Index,
}

pub(crate) fn parse(code: String, max_steps: usize) -> Result<Brainfuck, Error> {
    let code = Arc::new(code);

    let indexed_steps: Vec<IndexedStep> = code
        .lines()
        .enumerate()
        .flat_map(|(line, content)| {
            content.bytes().enumerate().filter_map(move |(col, byte)| {
                // now we have both the line and col
                let index = Index::new(line, col);
                match byte {
                    b'+' => Some(Step::Add(1)),
                    b'-' => Some(Step::Add(-1)),
                    b'>' => Some(Step::Move(1)),
                    b'<' => Some(Step::Move(-1)),
                    b'.' => Some(Step::Output),
                    b',' => Some(Step::Input),
                    b'?' => Some(Step::Debug),
                    b'[' => Some(Step::Loop(LoopKind::Begin, 0)),
                    b']' => Some(Step::Loop(LoopKind::End, 0)),
                    _ => None,
                }
                .map(|step| IndexedStep { step, index })
            })
        })
        // optimization by combining repeated steps
        .coalesce(|left, right| {
            match (left.step, right.step) {
                (Step::Add(a), Step::Add(b)) => Some(Step::Add(a.wrapping_add(b))),
                (Step::Move(a), Step::Move(b)) => {
                    Some(Step::Move(a.checked_add(b).expect("Pointer overflow")))
                }
                _ => None,
            }
            .map_or(Err((left, right)), |combined| {
                Ok(IndexedStep {
                    step: combined,
                    index: left.index,
                })
            })
        })
        .collect();

    // split indexes from steps (makes everything easier)
    let mut steps = Vec::with_capacity(indexed_steps.len());
    let mut indexes = Vec::with_capacity(indexed_steps.len());
    for IndexedStep { step, index } in indexed_steps {
        steps.push(step);
        indexes.push(index);
    }

    // match loops together
    let mut open_brackets = Vec::with_capacity(steps.len());
    for (i, step) in steps.iter_mut().enumerate() {
        if let Step::Loop(kind, jump) = step {
            match kind {
                LoopKind::Begin => open_brackets.push((i, jump)),
                LoopKind::End => match open_brackets.pop() {
                    // make them refer to each other
                    Some((open_i, open_jump)) => {
                        *open_jump = i;
                        *jump = open_i;
                    }
                    None => {
                        return Err(Error {
                            kind: ErrorKind::UnmatchedBracket,
                            index: indexes[i],
                            brainfuck: code,
                            output: None,
                        })
                    }
                },
            }
        }
    }

    // make sure they all got matched
    match open_brackets.pop() {
        None => Ok(Brainfuck {
            steps,
            indexes,
            code,
            max_steps,
        }),
        Some((i, _)) => Err(Error {
            kind: ErrorKind::UnmatchedBracket,
            index: indexes[i],
            brainfuck: code,
            output: None,
        }),
    }
}