bfc-rs 1.1.0

A Brainfuck compiler for x86-64 Linux implemented in Rust.
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

const HI_BF: &str = include_str!("../../../hi.bf");

use super::{
    super::Parser,
    BrainfuckInstr,
    optimize
};

#[test]
/// Tests the optimization of a representative Brainfuck program, "hi.bf".
fn test_hi_bf() {
    let mut parser = Parser::new();
    let mut code = parser
    .parse(HI_BF)
    .expect("Parser shat the bed: hi.bf should be a valid Brainfuck program.");
    optimize(&mut code);
    let expected_code: Vec<BrainfuckInstr> = vec![
        DataAdd(72),
        PointerInc,
        DataAdd(105),
        PointerInc,
        DataAdd(33),
        PointerInc,
        DataAdd(10),
        PointerSub(3),
        Print(4)
    ];
    assert_eq!(&code, &expected_code)
}

use BrainfuckInstr::*;
#[test]
/// Test for pointer arithmetic optimization.
fn test_ptr_arithmetic() {
    let mut code: Vec<BrainfuckInstr> = vec![
        PointerInc, PointerInc, PointerInc,
        PointerDec,
        PointerInc,
        PointerDec, PointerDec, PointerDec, PointerDec
    ];
    optimize(&mut code);
    let expected_code: Vec<BrainfuckInstr> = vec![
        PointerAdd(3),
        PointerDec,
        PointerInc,
        PointerSub(4)
    ];
    assert_eq!(&code, &expected_code)
}
#[test]
/// Test for data arithmetic optimization.
fn test_data_arithmetic() {
    let mut code: Vec<BrainfuckInstr> = vec![
        DataDec, DataDec,
        DataInc,
        PointerDec,
        Print(5),
        DataDec,
        DataInc, DataInc, DataInc
    ];
    optimize(&mut code);
    let expected_code: Vec<BrainfuckInstr> = vec![
        DataSub(2),
        DataInc,
        PointerDec,
        Print(5),
        DataDec,
        DataAdd(3)
    ];
    assert_eq!(&code, &expected_code)
}

#[test]
/// Test for printing optimization.
fn test_print() {
    let mut code: Vec<BrainfuckInstr> = vec![
        PutByte, PointerInc, PutByte,
        PointerDec,
        PutByte, PointerInc, PutByte, PointerInc, PutByte,
        PointerDec,
        PutByte
    ];
    optimize(&mut code);
    let expected_code: Vec<BrainfuckInstr> = vec![
        Print(2),
        PointerDec,
        Print(3),
        PointerDec,
        PutByte
    ];
    assert_eq!(&code, &expected_code)
}