tur-cli 0.1.0

Command-line interface for Turing machine simulator
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

use clap::Parser;
use std::path::Path;
use tur::loader::ProgramLoader;
use tur::machine::TuringMachine;
use tur::ExecutionResult;

#[derive(Parser)]
#[clap(author, version, about, long_about = None, arg_required_else_help = true)]
struct Cli {
    /// The Turing machine program file to execute
    #[clap(short, long)]
    program: String,

    /// The input to the Turing machine
    #[clap(short, long)]
    input: Vec<String>,

    /// Print each step of the execution
    #[clap(short = 'd', long)]
    debug: bool,
}

fn main() {
    let cli = Cli::parse();

    let program = ProgramLoader::load_program(Path::new(&cli.program)).unwrap();
    let mut machine = TuringMachine::new(&program);

    for (i, input_str) in cli.input.iter().enumerate() {
        if i < machine.tapes.len() {
            machine.tapes[i] = input_str.chars().collect();
        }
    }

    if cli.debug {
        let print_state = |machine: &TuringMachine| {
            let tapes_str = machine
                .get_tapes_as_strings()
                .iter()
                .map(|s| s.to_string())
                .collect::<Vec<String>>()
                .join(", ");

            println!(
                "Step: {}, State: {}, Tapes: [{}], Heads: {:?}",
                machine.get_step_count(),
                machine.get_state(),
                tapes_str,
                machine.get_head_positions()
            );
        };

        print_state(&machine);

        loop {
            match machine.step() {
                ExecutionResult::Continue => {
                    print_state(&machine);
                }
                ExecutionResult::Halt => {
                    println!("\nMachine halted.");
                    break;
                }
                ExecutionResult::Error(e) => {
                    println!("\nMachine error: {}", e);
                    break;
                }
            }
        }
        println!("\nFinal tapes:");
    } else {
        machine.run_to_completion();
    }

    println!("{}", machine.get_tapes_as_strings().join("\n"));
}