brainfuck interpreter
brainfuck
cli
rust
fixed up tests, renamed ASCII -> Ascii
- cargo clippy complained sob
+23
-23
+23
-23
src/evaluator.rs
+23
-23
src/evaluator.rs
···
44
44
45
45
#[derive(Clone, ValueEnum, Debug, PartialEq)]
46
46
pub enum InputType {
47
-
ASCII,
47
+
Ascii,
48
48
Raw,
49
49
}
50
50
51
51
#[derive(Clone, ValueEnum, Debug, PartialEq)]
52
52
pub enum OutputType {
53
-
ASCII,
53
+
Ascii,
54
54
Raw,
55
55
}
56
56
···
78
78
inst_pointer: 0,
79
79
data_oob: data_oob.unwrap_or(DataPointerOOB::Error),
80
80
cell_oob: cell_oob.unwrap_or(CellOOB::Wrap),
81
-
input_type: input_type.unwrap_or(InputType::ASCII),
82
-
output_type: output_type.unwrap_or(OutputType::ASCII),
81
+
input_type: input_type.unwrap_or(InputType::Ascii),
82
+
output_type: output_type.unwrap_or(OutputType::Ascii),
83
83
// while args in main pass defaults, using .unwrap_or makes for easier testing
84
84
}
85
85
}
···
233
233
// tests that data pointer is working
234
234
let tokens = tokenizer("+>++>+++-<-<-");
235
235
let map = parser(&tokens.clone()).unwrap();
236
-
let mut machine = VM::new(Some(3), None, None);
236
+
let mut machine = VM::new(Some(3), None, None, None, None);
237
237
238
238
machine
239
239
.run(&tokens, &map, std::io::empty(), std::io::empty())
···
247
247
fn data_pointer_oob_left() {
248
248
let tokens = tokenizer("<");
249
249
let map = parser(&tokens.clone()).unwrap();
250
-
let mut machine = VM::new(Some(1), None, None);
250
+
let mut machine = VM::new(Some(1), None, None, None, None);
251
251
let result = machine.run(&tokens, &map, std::io::empty(), std::io::empty());
252
252
253
253
assert!(result.is_err());
···
257
257
fn data_pointer_oob_right() {
258
258
let tokens = tokenizer(">>>>");
259
259
let map = parser(&tokens.clone()).unwrap();
260
-
let mut machine = VM::new(Some(1), None, None);
260
+
let mut machine = VM::new(Some(1), None, None, None, None);
261
261
let result = machine.run(&tokens, &map, std::io::empty(), std::io::empty());
262
262
263
263
assert!(result.is_err());
···
267
267
fn increment() {
268
268
let tokens = tokenizer("++++");
269
269
let map = parser(&tokens.clone()).unwrap();
270
-
let mut machine = VM::new(Some(1), None, None);
270
+
let mut machine = VM::new(Some(1), None, None, None, None);
271
271
272
272
machine
273
273
.run(&tokens, &map, std::io::empty(), std::io::empty())
···
279
279
fn decrement() {
280
280
let tokens = tokenizer("++++---");
281
281
let map = parser(&tokens.clone()).unwrap();
282
-
let mut machine = VM::new(Some(1), None, None);
282
+
let mut machine = VM::new(Some(1), None, None, None, None);
283
283
284
284
machine
285
285
.run(&tokens, &map, std::io::empty(), std::io::empty())
···
294
294
// from 255 back to 0
295
295
let tokens = tokenizer("->-+");
296
296
let map = parser(&tokens.clone()).unwrap();
297
-
let mut machine = VM::new(Some(2), None, None);
297
+
let mut machine = VM::new(Some(2), None, None, None, None);
298
298
299
299
machine
300
300
.run(&tokens, &map, std::io::empty(), std::io::empty())
···
307
307
fn input() {
308
308
let tokens = tokenizer(",");
309
309
let map = parser(&tokens.clone()).unwrap();
310
-
let mut machine = VM::new(Some(1), None, None);
310
+
let mut machine = VM::new(Some(1), None, None, None, None);
311
311
let fake_input = std::io::Cursor::new(b"A");
312
312
313
313
machine
···
320
320
fn input_overflow() {
321
321
let tokens = tokenizer(",");
322
322
let map = parser(&tokens.clone()).unwrap();
323
-
let mut machine = VM::new(Some(1), None, None);
323
+
let mut machine = VM::new(Some(1), None, None, None, None);
324
324
let fake_input = std::io::Cursor::new(b"AB");
325
325
326
326
machine
···
333
333
fn input_zero() {
334
334
let tokens = tokenizer(",");
335
335
let map = parser(&tokens.clone()).unwrap();
336
-
let mut machine = VM::new(Some(1), None, None);
336
+
let mut machine = VM::new(Some(1), None, None, None, None);
337
337
let fake_input = std::io::Cursor::new(b"0");
338
338
339
339
machine
···
346
346
fn output() {
347
347
let tokens = tokenizer(",.");
348
348
let map = parser(&tokens.clone()).unwrap();
349
-
let mut machine = VM::new(Some(1), None, None);
349
+
let mut machine = VM::new(Some(1), None, None, None, None);
350
350
let fake_input = std::io::Cursor::new(b"1");
351
351
let mut capture_buffer: Vec<u8> = Vec::new();
352
352
···
360
360
fn looping() {
361
361
let tokens = tokenizer("+++[>+<-]>");
362
362
let map = parser(&tokens.clone()).unwrap();
363
-
let mut machine = VM::new(Some(3), None, None);
363
+
let mut machine = VM::new(Some(3), None, None, None, None);
364
364
365
365
machine
366
366
.run(&tokens, &map, std::io::empty(), std::io::empty())
···
374
374
// making sure loop code isn't skipping
375
375
let tokens = tokenizer("++[-]>++");
376
376
let map = parser(&tokens.clone()).unwrap();
377
-
let mut machine = VM::new(Some(2), None, None);
377
+
let mut machine = VM::new(Some(2), None, None, None, None);
378
378
379
379
machine
380
380
.run(&tokens, &map, std::io::empty(), std::io::empty())
···
390
390
"++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.",
391
391
);
392
392
let map = parser(&tokens.clone()).unwrap();
393
-
let mut machine = VM::new(None, None, None);
393
+
let mut machine = VM::new(None, None, None, None, None);
394
394
let mut capture_buffer: Vec<u8> = Vec::new();
395
395
396
396
machine
···
404
404
fn repeat() {
405
405
let tokens = tokenizer(",>,[<.>-]");
406
406
let map = parser(&tokens.clone()).unwrap();
407
-
let mut machine = VM::new(None, None, None);
407
+
let mut machine = VM::new(None, None, None, None, None);
408
408
let mut capture_buffer: Vec<u8> = Vec::new();
409
409
let fake_input = std::io::Cursor::new(b"AB");
410
410
let expected = b"A".repeat(66);
···
420
420
fn nesting_loops() {
421
421
let tokens = tokenizer("[[][]]");
422
422
let map = parser(&tokens.clone()).unwrap();
423
-
let mut machine = VM::new(Some(1), None, None);
423
+
let mut machine = VM::new(Some(1), None, None, None, None);
424
424
let result = machine.run(&tokens, &map, std::io::empty(), std::io::empty());
425
425
426
426
assert!(result.is_ok());
···
430
430
fn data_pointer_wrap_right() {
431
431
let tokens = tokenizer(">");
432
432
let map = parser(&tokens.clone()).unwrap();
433
-
let mut machine = VM::new(Some(1), Some(DataPointerOOB::Wrap), None);
433
+
let mut machine = VM::new(Some(1), Some(DataPointerOOB::Wrap), None, None, None);
434
434
let result = machine.run(&tokens, &map, std::io::empty(), std::io::empty());
435
435
assert!(result.is_ok());
436
436
assert_eq!(machine.data_pointer, 0);
···
440
440
fn data_pointer_wrap_left() {
441
441
let tokens = tokenizer("<");
442
442
let map = parser(&tokens.clone()).unwrap();
443
-
let mut machine = VM::new(Some(1), Some(DataPointerOOB::Wrap), None);
443
+
let mut machine = VM::new(Some(1), Some(DataPointerOOB::Wrap), None, None, None);
444
444
let result = machine.run(&tokens, &map, std::io::empty(), std::io::empty());
445
445
assert!(result.is_ok());
446
446
assert_eq!(machine.data_pointer, (machine.tape.len() - 1));
···
450
450
fn cell_oob_error_increment() {
451
451
let tokens = tokenizer("-+");
452
452
let map = parser(&tokens.clone()).unwrap();
453
-
let mut machine = VM::new(Some(1), None, Some(CellOOB::Error));
453
+
let mut machine = VM::new(Some(1), None, Some(CellOOB::Error), None, None);
454
454
let result = machine.run(&tokens, &map, std::io::empty(), std::io::empty());
455
455
assert!(result.is_err());
456
456
}
···
459
459
fn cell_oob_error_decrement() {
460
460
let tokens = tokenizer(&"+".repeat(256));
461
461
let map = parser(&tokens.clone()).unwrap();
462
-
let mut machine = VM::new(Some(1), None, Some(CellOOB::Error));
462
+
let mut machine = VM::new(Some(1), None, Some(CellOOB::Error), None, None);
463
463
let result = machine.run(&tokens, &map, std::io::empty(), std::io::empty());
464
464
assert!(result.is_err());
465
465
}