rx82 0.4.0

An emulator for the RX82 fantasy retro computer system.
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

use anyhow::Result;
use clap::{Parser, Subcommand};

use std::{fs, path::PathBuf};

use rx82::{
    asm::{Assembler, Disassembler},
    monitor::Monitor,
};

#[derive(Debug, Parser)]
struct Cli {
    #[clap(subcommand)]
    command: Command,
}

#[derive(Debug, Subcommand)]
enum Command {
    /// Assemble a source file.
    Asm {
        /// Enable verbose debugging.
        #[clap(short, long)]
        debug: bool,
        /// Path to the source file.
        path: PathBuf,
    },
    /// Disassemble a binary file.
    Dis {
        /// Path to the binary file.
        path: PathBuf,
    },
    /// Start the interactive monitor.
    Mon {
        /// Path to a binary file to load.
        path: Option<PathBuf>,
    },
    /// Assemble and load a source file into the monitor.
    Run {
        /// Enable verbose debugging.
        #[clap(short, long)]
        debug: bool,
        /// Path to the source file.
        path: PathBuf,
    },
}

fn main() -> Result<()> {
    let cli = Cli::parse();
    match cli.command {
        Command::Asm { debug, path } => {
            let source = fs::read_to_string(&path)?;
            let mut asm = Assembler::from(source.as_str());
            asm.debug = debug;
            let data = asm.assemble()?;
            let mut bin_path = path.clone();
            bin_path.set_extension("bin");
            fs::write(bin_path, data)?;
            Ok(())
        }
        Command::Dis { path } => {
            let code = fs::read(&path)?;
            for source in Disassembler::from(code.as_slice()) {
                println!("    {source}");
            }
            Ok(())
        }
        Command::Mon { path: Some(path) } => {
            let mut mon = Monitor::default();
            let data = fs::read(path)?;
            mon.sys.mem.load(0x0000, &data)?;
            mon.run()
        }
        Command::Mon { path: None, .. } => Monitor::default().run(),
        Command::Run { debug, path } => {
            let source = fs::read_to_string(&path)?;
            let data = Assembler::from(source.as_str()).assemble()?;
            let mut mon = Monitor::default();
            mon.sys.mem.load(0x0000, &data)?;
            mon.step = debug;
            mon.run()
        }
    }
}