brainfuck interpreter
brainfuck
cli
rust
chore: renamed parser::parser to parser::parse_brackets
+28
-28
+22
-22
src/evaluator.rs
+22
-22
src/evaluator.rs
···
282
282
use crate::CellOOB;
283
283
use crate::DataPointerOOB;
284
284
use crate::lexer::tokenizer;
285
-
use crate::parser::parser;
285
+
use crate::parser::parse_brackets;
286
286
287
287
#[test]
288
288
fn data_pointer() {
289
289
// tests that data pointer is working
290
290
let tokens = tokenizer("+>++>+++-<-<-");
291
-
let map = parser(&tokens.clone()).unwrap();
291
+
let map = parse_brackets(&tokens.clone()).unwrap();
292
292
let mut machine = VM::new(Some(3), None, None, None, None);
293
293
294
294
machine
···
302
302
#[test]
303
303
fn data_pointer_oob_left() {
304
304
let tokens = tokenizer("<");
305
-
let map = parser(&tokens.clone()).unwrap();
305
+
let map = parse_brackets(&tokens.clone()).unwrap();
306
306
let mut machine = VM::new(Some(1), None, None, None, None);
307
307
let result = machine.run(&tokens, &map, std::io::empty(), std::io::empty());
308
308
···
312
312
#[test]
313
313
fn data_pointer_oob_right() {
314
314
let tokens = tokenizer(">>>>");
315
-
let map = parser(&tokens.clone()).unwrap();
315
+
let map = parse_brackets(&tokens.clone()).unwrap();
316
316
let mut machine = VM::new(Some(1), None, None, None, None);
317
317
let result = machine.run(&tokens, &map, std::io::empty(), std::io::empty());
318
318
···
322
322
#[test]
323
323
fn increment() {
324
324
let tokens = tokenizer("++++");
325
-
let map = parser(&tokens.clone()).unwrap();
325
+
let map = parse_brackets(&tokens.clone()).unwrap();
326
326
let mut machine = VM::new(Some(1), None, None, None, None);
327
327
328
328
machine
···
334
334
#[test]
335
335
fn decrement() {
336
336
let tokens = tokenizer("++++---");
337
-
let map = parser(&tokens.clone()).unwrap();
337
+
let map = parse_brackets(&tokens.clone()).unwrap();
338
338
let mut machine = VM::new(Some(1), None, None, None, None);
339
339
340
340
machine
···
349
349
// move to second cell, subtract from 0 -> 255, then add
350
350
// from 255 back to 0
351
351
let tokens = tokenizer("->-+");
352
-
let map = parser(&tokens.clone()).unwrap();
352
+
let map = parse_brackets(&tokens.clone()).unwrap();
353
353
let mut machine = VM::new(Some(2), None, None, None, None);
354
354
355
355
machine
···
362
362
#[test]
363
363
fn input() {
364
364
let tokens = tokenizer(",");
365
-
let map = parser(&tokens.clone()).unwrap();
365
+
let map = parse_brackets(&tokens.clone()).unwrap();
366
366
let mut machine = VM::new(Some(1), None, None, None, None);
367
367
let fake_input = std::io::Cursor::new(b"A");
368
368
···
375
375
#[test]
376
376
fn input_overflow() {
377
377
let tokens = tokenizer(",");
378
-
let map = parser(&tokens.clone()).unwrap();
378
+
let map = parse_brackets(&tokens.clone()).unwrap();
379
379
let mut machine = VM::new(Some(1), None, None, None, None);
380
380
let fake_input = std::io::Cursor::new(b"AB");
381
381
···
388
388
#[test]
389
389
fn input_zero() {
390
390
let tokens = tokenizer(",");
391
-
let map = parser(&tokens.clone()).unwrap();
391
+
let map = parse_brackets(&tokens.clone()).unwrap();
392
392
let mut machine = VM::new(Some(1), None, None, None, None);
393
393
let fake_input = std::io::Cursor::new(b"0");
394
394
···
401
401
#[test]
402
402
fn output() {
403
403
let tokens = tokenizer(",.");
404
-
let map = parser(&tokens.clone()).unwrap();
404
+
let map = parse_brackets(&tokens.clone()).unwrap();
405
405
let mut machine = VM::new(Some(1), None, None, None, None);
406
406
let fake_input = std::io::Cursor::new(b"1");
407
407
let mut capture_buffer: Vec<u8> = Vec::new();
···
415
415
#[test]
416
416
fn looping() {
417
417
let tokens = tokenizer("+++[>+<-]>");
418
-
let map = parser(&tokens.clone()).unwrap();
418
+
let map = parse_brackets(&tokens.clone()).unwrap();
419
419
let mut machine = VM::new(Some(3), None, None, None, None);
420
420
421
421
machine
···
429
429
fn loop_skips_next_inst() {
430
430
// making sure loop code isn't skipping
431
431
let tokens = tokenizer("++[-]>++");
432
-
let map = parser(&tokens.clone()).unwrap();
432
+
let map = parse_brackets(&tokens.clone()).unwrap();
433
433
let mut machine = VM::new(Some(2), None, None, None, None);
434
434
435
435
machine
···
445
445
let tokens = tokenizer(
446
446
"++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.",
447
447
);
448
-
let map = parser(&tokens.clone()).unwrap();
448
+
let map = parse_brackets(&tokens.clone()).unwrap();
449
449
let mut machine = VM::new(None, None, None, None, None);
450
450
let mut capture_buffer: Vec<u8> = Vec::new();
451
451
···
459
459
#[test]
460
460
fn repeat() {
461
461
let tokens = tokenizer(",>,[<.>-]");
462
-
let map = parser(&tokens.clone()).unwrap();
462
+
let map = parse_brackets(&tokens.clone()).unwrap();
463
463
let mut machine = VM::new(None, None, None, None, None);
464
464
let mut capture_buffer: Vec<u8> = Vec::new();
465
465
let fake_input = std::io::Cursor::new(b"AB");
···
475
475
#[test]
476
476
fn nesting_loops() {
477
477
let tokens = tokenizer("[[][]]");
478
-
let map = parser(&tokens.clone()).unwrap();
478
+
let map = parse_brackets(&tokens.clone()).unwrap();
479
479
let mut machine = VM::new(Some(1), None, None, None, None);
480
480
let result = machine.run(&tokens, &map, std::io::empty(), std::io::empty());
481
481
···
485
485
#[test]
486
486
fn data_pointer_wrap_right() {
487
487
let tokens = tokenizer(">");
488
-
let map = parser(&tokens.clone()).unwrap();
488
+
let map = parse_brackets(&tokens.clone()).unwrap();
489
489
let mut machine = VM::new(Some(1), Some(DataPointerOOB::Wrap), None, None, None);
490
490
let result = machine.run(&tokens, &map, std::io::empty(), std::io::empty());
491
491
assert!(result.is_ok());
···
495
495
#[test]
496
496
fn data_pointer_wrap_left() {
497
497
let tokens = tokenizer("<");
498
-
let map = parser(&tokens.clone()).unwrap();
498
+
let map = parse_brackets(&tokens.clone()).unwrap();
499
499
let mut machine = VM::new(Some(1), Some(DataPointerOOB::Wrap), None, None, None);
500
500
let result = machine.run(&tokens, &map, std::io::empty(), std::io::empty());
501
501
assert!(result.is_ok());
···
505
505
#[test]
506
506
fn cell_oob_error_increment() {
507
507
let tokens = tokenizer("-+");
508
-
let map = parser(&tokens.clone()).unwrap();
508
+
let map = parse_brackets(&tokens.clone()).unwrap();
509
509
let mut machine = VM::new(Some(1), None, Some(CellOOB::Error), None, None);
510
510
let result = machine.run(&tokens, &map, std::io::empty(), std::io::empty());
511
511
assert!(result.is_err());
···
514
514
#[test]
515
515
fn cell_oob_error_decrement() {
516
516
let tokens = tokenizer(&"+".repeat(256));
517
-
let map = parser(&tokens.clone()).unwrap();
517
+
let map = parse_brackets(&tokens.clone()).unwrap();
518
518
let mut machine = VM::new(Some(1), None, Some(CellOOB::Error), None, None);
519
519
let result = machine.run(&tokens, &map, std::io::empty(), std::io::empty());
520
520
assert!(result.is_err());
···
523
523
#[test]
524
524
fn read_raw() {
525
525
let tokens = tokenizer(",");
526
-
let map = parser(&tokens.clone()).unwrap();
526
+
let map = parse_brackets(&tokens.clone()).unwrap();
527
527
let mut machine = VM::new(Some(1), None, None, Some(InputType::Raw), None);
528
528
let fake_input = std::io::Cursor::new("1");
529
529
machine
···
535
535
#[test]
536
536
fn write_raw() {
537
537
let tokens = tokenizer(",.");
538
-
let map = parser(&tokens.clone()).unwrap();
538
+
let map = parse_brackets(&tokens.clone()).unwrap();
539
539
let mut machine = VM::new(
540
540
Some(1),
541
541
None,
+2
-2
src/main.rs
+2
-2
src/main.rs
···
8
8
use crate::evaluator::InputType;
9
9
use crate::evaluator::OutputType;
10
10
use crate::lexer::tokenizer;
11
-
use crate::parser::parser;
11
+
use crate::parser::parse_brackets;
12
12
13
13
#[derive(Parser)]
14
14
#[clap(version, about, long_about = None)]
···
50
50
let tokens = tokenizer(&content);
51
51
52
52
// 3 - make jump map
53
-
let map = parser(&tokens)?;
53
+
let map = parse_brackets(&tokens)?;
54
54
55
55
let mut machine = evaluator::VM::new(
56
56
Some(args.length),
+4
-4
src/parser.rs
+4
-4
src/parser.rs
···
22
22
impl std::error::Error for SyntaxError {}
23
23
24
24
// all this does pre-calc loop brackets
25
-
pub fn parser(tokens: &[u8]) -> Result<Vec<usize>, SyntaxError> {
25
+
pub fn parse_brackets(tokens: &[u8]) -> Result<Vec<usize>, SyntaxError> {
26
26
let mut jump_map = vec![0; tokens.len()];
27
27
let mut balance = Vec::new();
28
28
···
56
56
57
57
#[test]
58
58
fn are_balanced() {
59
-
let result = parser(&tokenizer("[]")).unwrap();
59
+
let result = parse_brackets(&tokenizer("[]")).unwrap();
60
60
assert!(!result.is_empty());
61
61
}
62
62
63
63
#[test]
64
64
fn are_unbalanced_right() {
65
-
let result = parser(&tokenizer("[]]"));
65
+
let result = parse_brackets(&tokenizer("[]]"));
66
66
assert!(result.is_err());
67
67
}
68
68
69
69
#[test]
70
70
fn are_unbalanced_left() {
71
-
let result = parser(&tokenizer("[[]"));
71
+
let result = parse_brackets(&tokenizer("[[]"));
72
72
assert!(result.is_err());
73
73
}
74
74
}