matrix65 0.2.0

Matrix Mode Serial Communicator for MEGA65
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 crate::commands;
use crate::serial;
use reedline_repl_rs::clap::{Arg, ArgMatches, Command};
use reedline_repl_rs::{Repl, Result};
use serialport::SerialPort;

/// Provide a state to be passed to each command.
/// Main funtion is to store the serial port
struct Context<'a> {
    pub port: &'a mut Box<dyn SerialPort>,
}

pub fn start_repl(port: &mut Box<dyn SerialPort>) -> Result<()> {
    let context = Context { port };
    let mut repl = Repl::new(context)
        .with_name("matrix65")
        .with_version(env!("CARGO_PKG_VERSION"))
        .with_description(env!("CARGO_PKG_DESCRIPTION"))
        .with_banner("Welcome to matrix65!")
        .with_command(Command::new("reset").about("Reset MEGA65"), reset)
        .with_command(Command::new("go64").about("Go to C64 mode"), go64)
        .with_command(Command::new("stop").about("Halt CPU"), stop)
        .with_command(Command::new("start").about("Resume CPU"), start)
        .with_command(
            Command::new("dasm")
                .about("Disassemble memory (prefix hex values w. 0x....)")
                .arg(Arg::new("address").required(true))
                .arg(Arg::new("length").required(true)),
            peek,
        )
        .with_command(
            Command::new("filehost").about("Start the filehost"),
            filehost,
        );
    repl.run()
}

/// Helper function to convert error type
fn handle_result(result: core::result::Result<(), anyhow::Error>) -> Result<Option<String>> {
    match result {
        Err(err) => Err(reedline_repl_rs::Error::IllegalDefaultError(
            err.to_string(),
        )),
        Ok(()) => Ok(None),
    }
}

/// Wrap peek command
fn peek(_args: ArgMatches, context: &mut Context) -> Result<Option<String>> {
    let address = _args.value_of("address").unwrap().to_string();
    let length = _args
        .value_of("length")
        .unwrap_or("1")
        .to_string()
        .parse::<usize>()?;
    let result = commands::peek(context.port, address, length, None, true);
    handle_result(result)
}

/// Wrap reset command
fn reset(_args: ArgMatches, context: &mut Context) -> Result<Option<String>> {
    handle_result(commands::reset(context.port, false))
}

/// Wrap go64 command
fn go64(_args: ArgMatches, context: &mut Context) -> Result<Option<String>> {
    handle_result(serial::go64(context.port))
}

/// Wrap stop cpu command
fn stop(_args: ArgMatches, context: &mut Context) -> Result<Option<String>> {
    handle_result(serial::stop_cpu(context.port))
}

/// Wrap start cpu command
fn start(_args: ArgMatches, context: &mut Context) -> Result<Option<String>> {
    handle_result(serial::start_cpu(context.port))
}

/// Wrap filehost command
fn filehost(_args: ArgMatches, context: &mut Context) -> Result<Option<String>> {
    handle_result(commands::filehost(context.port))
}