brainfuck interpreter
brainfuck
cli
rust
read_ascii & read_raw added!
- renamed input/output in run -> reader/writer for clarity
- read_raw test added
+50
-17
+50
-17
src/evaluator.rs
+50
-17
src/evaluator.rs
···
150
150
Ok(())
151
151
}
152
152
153
+
fn read_ascii<R: std::io::Read>(&mut self, input: &mut R) -> Result<(), RuntimeError> {
154
+
// set up buffer as u8 array with 1 space
155
+
let mut buffer = [0u8; 1];
156
+
157
+
input
158
+
.read_exact(&mut buffer)
159
+
.map_err(RuntimeError::IoError)?;
160
+
self.tape[self.data_pointer] = buffer[0];
161
+
162
+
Ok(())
163
+
}
164
+
165
+
fn read_raw<R: std::io::Read>(&mut self, input: &mut R) -> Result<(), RuntimeError> {
166
+
let mut buffer: String = String::new();
167
+
let mut single = [0u8; 1];
168
+
169
+
while buffer.len() < 3 {
170
+
match input.read(&mut single) {
171
+
Ok(0) => break, // eof
172
+
Ok(_) if single[0].is_ascii_digit() => buffer.push(single[0] as char),
173
+
// non-digit, consumed but discarded so it doesnt overflow into next input cmd
174
+
Ok(_) => break,
175
+
Err(e) => return Err(RuntimeError::IoError(e)),
176
+
}
177
+
}
178
+
179
+
self.tape[self.data_pointer] = buffer.parse::<u8>().unwrap_or(0);
180
+
181
+
Ok(())
182
+
}
183
+
153
184
pub fn run<R: std::io::Read, W: std::io::Write>(
154
185
&mut self,
155
186
tokens: &[u8],
156
187
jump_map: &[usize],
157
-
mut input: R,
158
-
mut output: W,
188
+
mut reader: R,
189
+
mut writer: W,
159
190
) -> Result<(), RuntimeError> {
160
191
while self.inst_pointer < tokens.len() {
161
192
let current = tokens[self.inst_pointer];
···
174
205
}
175
206
176
207
b',' => {
177
-
let mut buffer = [0u8; 1];
178
-
loop {
179
-
match input.read(&mut buffer) {
180
-
Ok(n) => {
181
-
if n == 0 {
182
-
self.tape[self.data_pointer] = 0;
183
-
break;
184
-
} else {
185
-
self.tape[self.data_pointer] = buffer[0];
186
-
break;
187
-
}
188
-
}
189
-
Err(e) => Err(RuntimeError::IoError(e))?,
190
-
}
208
+
if self.input_type == InputType::Ascii {
209
+
self.read_ascii(&mut reader)?;
210
+
} else if self.input_type == InputType::Raw {
211
+
self.read_raw(&mut reader)?;
191
212
}
192
213
}
193
214
194
215
b'.' => {
195
-
output
216
+
writer
196
217
.write_all(&[self.tape[self.data_pointer]])
197
218
.map_err(RuntimeError::IoError)?;
198
219
}
···
462
483
let mut machine = VM::new(Some(1), None, Some(CellOOB::Error), None, None);
463
484
let result = machine.run(&tokens, &map, std::io::empty(), std::io::empty());
464
485
assert!(result.is_err());
486
+
}
487
+
488
+
#[test]
489
+
fn read_raw() {
490
+
let tokens = tokenizer(",");
491
+
let map = parser(&tokens.clone()).unwrap();
492
+
let mut machine = VM::new(Some(1), None, None, Some(InputType::Raw), None);
493
+
let fake_input = std::io::Cursor::new("1");
494
+
machine
495
+
.run(&tokens, &map, fake_input, std::io::empty())
496
+
.unwrap();
497
+
assert_eq!(machine.tape[0], 1);
465
498
}
466
499
}