progress on serial and added editor
This commit is contained in:
@@ -26,8 +26,11 @@ common = { path = "../common" }
|
||||
egui = "0.33.3"
|
||||
eframe = "0.33.3"
|
||||
egui_tiles = "0.14.1"
|
||||
#assembler = { path = "../assembler" }
|
||||
|
||||
egui_code_editor = "0.2.21"
|
||||
egui_file = "0.25.0"
|
||||
dirs = "6.0.0"
|
||||
assembler = { path = "../assembler" }
|
||||
egui_extras = "0.33.3"
|
||||
|
||||
[features]
|
||||
default = ["mainstore-prealloc"]
|
||||
|
||||
@@ -17,9 +17,16 @@ pub struct DsaArgs {
|
||||
|
||||
#[arg(long = "iomap")]
|
||||
io_map: Option<PathBuf>,
|
||||
|
||||
#[arg(long = "headless")]
|
||||
headless: bool,
|
||||
}
|
||||
|
||||
impl DsaArgs {
|
||||
pub fn headless(&self) -> bool {
|
||||
self.headless
|
||||
}
|
||||
|
||||
pub fn get_memory_map(&self) -> MemoryMap {
|
||||
self.memory_map
|
||||
.as_ref()
|
||||
|
||||
@@ -15,6 +15,7 @@ pub enum Interrupt {
|
||||
|
||||
// IRQ's (32-63)
|
||||
Hardware(u8),
|
||||
SerialIn = 32,
|
||||
|
||||
// Syscalls (64-255)
|
||||
// OS defined, program uses INT 64-127
|
||||
@@ -33,6 +34,7 @@ impl Interrupt {
|
||||
Interrupt::WriteToReadOnly => 6,
|
||||
Interrupt::ReadFromWriteOnly => 7,
|
||||
Interrupt::UnmappedIo => 8,
|
||||
Interrupt::SerialIn => 32,
|
||||
Interrupt::Hardware(x) => {
|
||||
if *x < 32 || *x > 63 {
|
||||
0
|
||||
|
||||
@@ -23,7 +23,7 @@ pub struct Emulator {
|
||||
shared_state: Arc<SharedState>,
|
||||
|
||||
// Interrupts
|
||||
interrupts: mpsc::Receiver<u8>,
|
||||
interrupts: mpsc::Receiver<Interrupt>,
|
||||
pending_fault: Option<Interrupt>,
|
||||
|
||||
// memory
|
||||
@@ -45,7 +45,7 @@ pub struct Emulator {
|
||||
unsafe impl Send for Emulator {}
|
||||
impl Emulator {
|
||||
pub fn new() -> Self {
|
||||
let (sender, receiver) = mpsc::channel::<u8>();
|
||||
let (sender, receiver) = mpsc::channel::<Interrupt>();
|
||||
|
||||
Self {
|
||||
interrupts: receiver,
|
||||
@@ -163,6 +163,8 @@ impl Emulator {
|
||||
while self.shared_state.reseting.load(Ordering::Relaxed) {
|
||||
thread::sleep(Duration::from_millis(100));
|
||||
}
|
||||
|
||||
self.internal_state.halted = false;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -182,19 +184,19 @@ impl Emulator {
|
||||
self.check_update();
|
||||
}
|
||||
|
||||
// if the cpu didn't halt on it's own then it's ready to run again.
|
||||
if !self.internal_state.halted {
|
||||
return;
|
||||
}
|
||||
|
||||
loop {
|
||||
// Check for interrupts.
|
||||
if let Ok(code) = self.interrupts.recv_timeout(Duration::from_millis(100)) {
|
||||
if let Ok(int) = self.interrupts.recv_timeout(Duration::from_millis(100)) {
|
||||
self.internal_state.halted = false;
|
||||
self.interrupt(Interrupt::Software(code));
|
||||
self.interrupt(int);
|
||||
break;
|
||||
}
|
||||
|
||||
// if the cpu didn't halt on it's own then it's ready to run again.
|
||||
if !self.internal_state.halted {
|
||||
return;
|
||||
}
|
||||
|
||||
// UI is resetting the emulator
|
||||
self.check_update();
|
||||
}
|
||||
@@ -230,7 +232,7 @@ impl Emulator {
|
||||
}
|
||||
|
||||
match self.interrupts.try_recv() {
|
||||
Ok(code) => self.interrupt(Interrupt::Software(code)),
|
||||
Ok(int) => self.interrupt(int),
|
||||
Err(TryRecvError::Disconnected) => break 'emu,
|
||||
Err(TryRecvError::Empty) => {}
|
||||
}
|
||||
@@ -270,14 +272,21 @@ impl Emulator {
|
||||
|
||||
#[inline]
|
||||
fn interrupt(&mut self, int: Interrupt) {
|
||||
let idt = self.reg(Register::Idr);
|
||||
self.push(Register::Pcx);
|
||||
*self.mut_reg(Register::Pcx) =
|
||||
self.mem_read_word(self.reg(Register::Idr) + int.code() as u32 * 4)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn push(&mut self, reg: Register) {
|
||||
*self.mut_reg(Register::Spr) -= 4;
|
||||
let spr = self.reg(Register::Spr);
|
||||
let pcx = self.reg(Register::Pcx);
|
||||
self.mem_write_word(spr, pcx);
|
||||
self.mem_write_word(self.reg(Register::Spr), self.reg(reg));
|
||||
}
|
||||
|
||||
*self.mut_reg(Register::Pcx) = self.mem_read_word(idt + int.code() as u32 * 4)
|
||||
#[inline]
|
||||
fn pop(&mut self, reg: Register) {
|
||||
*self.mut_reg(reg) = self.mem_read_word(self.reg(Register::Spr));
|
||||
*self.mut_reg(Register::Spr) += 4;
|
||||
}
|
||||
|
||||
#[inline]
|
||||
@@ -477,24 +486,15 @@ impl Emulator {
|
||||
self.interrupt(Interrupt::Software(word.imm16() as u8));
|
||||
}
|
||||
Some(Opcode::Hlt) => self.halt(),
|
||||
Some(Opcode::IRet) => todo!(),
|
||||
Some(Opcode::IRet) => {
|
||||
self.pop(Register::Ret);
|
||||
*self.mut_reg(Register::Pcx) = self.reg(Register::Ret);
|
||||
}
|
||||
None => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn push(&mut self, reg: Register) {
|
||||
*self.mut_reg(Register::Spr) -= 4;
|
||||
self.mem_write_word(self.reg(Register::Spr), self.reg(reg));
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn pop(&mut self, reg: Register) {
|
||||
*self.mut_reg(reg) = self.mem_read_word(self.reg(Register::Spr));
|
||||
*self.mut_reg(Register::Spr) += 4;
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn mem_read_byte(&mut self, addr: u32) -> u8 {
|
||||
self.mainstore.read_byte(addr)
|
||||
|
||||
@@ -4,6 +4,8 @@ use arc_swap::ArcSwap;
|
||||
|
||||
use crate::backend::processor::processor::ProcessorSnapshot;
|
||||
|
||||
use super::interrupts::Interrupt;
|
||||
|
||||
pub struct SharedState {
|
||||
pub proc: ArcSwap<ProcessorSnapshot>,
|
||||
|
||||
@@ -11,11 +13,11 @@ pub struct SharedState {
|
||||
pub paused: AtomicBool,
|
||||
pub update_req: AtomicBool,
|
||||
|
||||
interrupt_queue: mpsc::Sender<u8>,
|
||||
pub interrupt_queue: mpsc::Sender<Interrupt>,
|
||||
}
|
||||
|
||||
impl SharedState {
|
||||
pub fn new(sender: mpsc::Sender<u8>) -> Self {
|
||||
pub fn new(sender: mpsc::Sender<Interrupt>) -> Self {
|
||||
Self {
|
||||
reseting: AtomicBool::new(false),
|
||||
proc: ArcSwap::new(Arc::new(ProcessorSnapshot::default())),
|
||||
|
||||
@@ -1,6 +1,8 @@
|
||||
pub mod controller;
|
||||
pub mod display;
|
||||
pub mod editor;
|
||||
pub mod framebuffer;
|
||||
pub mod memory;
|
||||
pub mod registers;
|
||||
pub mod serial;
|
||||
|
||||
|
||||
@@ -83,13 +83,15 @@ impl Component for Controller {
|
||||
// Status info
|
||||
ui.label(format!(
|
||||
"Status: {}",
|
||||
match (state.halted, paused) {
|
||||
(true, false) => "Halted",
|
||||
(_, false) => "Running",
|
||||
(_, true) => "Paused",
|
||||
match paused {
|
||||
true => "Paused",
|
||||
false => "Running",
|
||||
}
|
||||
));
|
||||
|
||||
ui.label(format!("Halted: {}", state.halted));
|
||||
ui.separator();
|
||||
|
||||
let pcx = state.registers[Register::Pcx as usize];
|
||||
let clock = state.clock;
|
||||
let time = state.time.as_micros();
|
||||
@@ -97,7 +99,7 @@ impl Component for Controller {
|
||||
|
||||
ui.label(format!("Clock: {clock}"));
|
||||
ui.label(format!("Pcx: 0x{pcx:08X}"));
|
||||
ui.label(format!("Elapsed: {}micros", time));
|
||||
ui.label(format!("Elapsed: {} micros", time));
|
||||
ui.label(format!("Freq: {}MHz", mips));
|
||||
});
|
||||
}
|
||||
|
||||
@@ -1,7 +1,68 @@
|
||||
use egui::{Color32, FontId, Vec2};
|
||||
|
||||
use crate::{MemoryBank, Page, backend::memory::PhysAddr};
|
||||
|
||||
use super::Component;
|
||||
pub use crate::io::display::Display;
|
||||
|
||||
pub struct Display {
|
||||
width: usize,
|
||||
height: usize,
|
||||
addr: PhysAddr,
|
||||
|
||||
mem: MemoryBank,
|
||||
buffer: Vec<u8>,
|
||||
visible: bool,
|
||||
}
|
||||
|
||||
impl Display {
|
||||
pub fn new(width: u32, height: u32, addr: PhysAddr, mem: MemoryBank) -> Self {
|
||||
Self {
|
||||
width: width as usize,
|
||||
height: height as usize,
|
||||
addr,
|
||||
mem,
|
||||
buffer: Vec::new(),
|
||||
visible: true,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn visible(&mut self) -> &mut bool {
|
||||
&mut self.visible
|
||||
}
|
||||
|
||||
pub fn width(&self) -> usize {
|
||||
self.width
|
||||
}
|
||||
|
||||
pub fn height(&self) -> usize {
|
||||
self.height
|
||||
}
|
||||
|
||||
fn internal_read(&self) -> Vec<u8> {
|
||||
let pages = (0..((self.width * self.height).div_ceil(Page::SIZE)))
|
||||
.map(|i| {
|
||||
let page = self.mem.read_page(self.addr + i as u32 * 4096);
|
||||
page.as_slice().to_owned()
|
||||
})
|
||||
.flatten()
|
||||
.take((self.width * self.height) as usize)
|
||||
.collect::<Vec<u8>>();
|
||||
pages
|
||||
}
|
||||
|
||||
pub fn changed(&mut self) -> bool {
|
||||
let temp = self.internal_read();
|
||||
if temp != self.buffer {
|
||||
self.buffer = temp;
|
||||
return true;
|
||||
}
|
||||
false
|
||||
}
|
||||
|
||||
pub fn read(&mut self) -> Vec<u8> {
|
||||
self.internal_read()
|
||||
}
|
||||
}
|
||||
|
||||
impl Component for Display {
|
||||
fn title(&self) -> &str {
|
||||
|
||||
@@ -0,0 +1,799 @@
|
||||
use std::fmt::Write;
|
||||
use std::fs::{self, File};
|
||||
use std::sync::Arc;
|
||||
use std::sync::atomic::Ordering;
|
||||
use std::{
|
||||
ffi::OsStr,
|
||||
path::{Path, PathBuf},
|
||||
};
|
||||
|
||||
pub mod syntax;
|
||||
|
||||
use assembler::prelude::Assembler;
|
||||
use common::prelude::Instruction;
|
||||
use egui::{Align, Context, Key, Layout, Ui};
|
||||
use egui_code_editor::{CodeEditor, ColorTheme, Completer, Syntax};
|
||||
use egui_extras::{Column, TableBuilder};
|
||||
use egui_file::FileDialog;
|
||||
|
||||
use crate::{MemoryBank, Page, SharedState};
|
||||
|
||||
use super::Component;
|
||||
|
||||
pub struct Editor {
|
||||
state: Arc<SharedState>,
|
||||
memory: MemoryBank,
|
||||
|
||||
// editor state
|
||||
path: Option<PathBuf>,
|
||||
unsaved: bool,
|
||||
text: String,
|
||||
buffer: String,
|
||||
|
||||
// editor widget
|
||||
editor: CodeEditor,
|
||||
completer: Completer,
|
||||
|
||||
// output / loading
|
||||
output: Output,
|
||||
load_offset: u32,
|
||||
offset_str: String,
|
||||
|
||||
// cursor - currently unused
|
||||
cursor_col: usize,
|
||||
cursor_line: usize,
|
||||
|
||||
// file dialogs
|
||||
open_file_dialog: Option<FileDialog>,
|
||||
save_file_dialog: Option<FileDialog>,
|
||||
|
||||
// other
|
||||
visible: bool,
|
||||
show_output: bool,
|
||||
error: Option<String>,
|
||||
}
|
||||
|
||||
impl Component for Editor {
|
||||
fn title(&self) -> &'static str {
|
||||
"Editor"
|
||||
}
|
||||
|
||||
fn visible(&mut self) -> &mut bool {
|
||||
&mut self.visible
|
||||
}
|
||||
|
||||
fn ui(&mut self, ui: &mut Ui, ctx: &Context) {
|
||||
if self.buffer != self.text {
|
||||
self.unsaved = true;
|
||||
}
|
||||
|
||||
ui.vertical(|ui| {
|
||||
// Top bar
|
||||
|
||||
if ui.input(|i| i.key_pressed(Key::S) && i.modifiers.ctrl) {
|
||||
self.save();
|
||||
}
|
||||
|
||||
self.render_toolbar(ui, ctx);
|
||||
|
||||
ui.add_space(4.0); // Add some spacing instead of just a separator
|
||||
ui.separator();
|
||||
|
||||
let remaining_height = f32::max(ui.available_height() - 100.0, 100.0);
|
||||
|
||||
ui.allocate_ui_with_layout(
|
||||
egui::Vec2::new(ui.available_width(), remaining_height),
|
||||
Layout::left_to_right(Align::Min),
|
||||
|ui| {
|
||||
if self.show_output {
|
||||
egui::SidePanel::right("Editor Output").show_inside(ui, |ui| {
|
||||
self.output.ui(ui, ctx);
|
||||
});
|
||||
}
|
||||
self.render_editor(ui, ctx);
|
||||
},
|
||||
);
|
||||
|
||||
self.render_bottom_bar(ui, ctx);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
impl Editor {
|
||||
#[must_use]
|
||||
pub fn new(state: Arc<SharedState>, memory: MemoryBank) -> Self {
|
||||
Self {
|
||||
memory,
|
||||
state,
|
||||
path: None,
|
||||
text: String::new(),
|
||||
buffer: String::new(),
|
||||
completer: Completer::new_with_syntax(&Syntax::default()).with_user_words(),
|
||||
editor: CodeEditor::default()
|
||||
.id_source("editor")
|
||||
.with_fontsize(12.0)
|
||||
.with_rows(0)
|
||||
.with_theme(THEME)
|
||||
.with_syntax(Syntax::default())
|
||||
.with_numlines(true),
|
||||
output: Output::new(),
|
||||
unsaved: true,
|
||||
cursor_col: 1,
|
||||
cursor_line: 1,
|
||||
visible: false,
|
||||
load_offset: 0,
|
||||
offset_str: String::new(),
|
||||
error: None,
|
||||
open_file_dialog: None,
|
||||
save_file_dialog: None,
|
||||
show_output: false,
|
||||
}
|
||||
}
|
||||
|
||||
fn filename(&self) -> &str {
|
||||
if let Some(path) = &self.path {
|
||||
return path
|
||||
.file_name()
|
||||
.unwrap_or_else(|| OsStr::new("Unnamed!"))
|
||||
.to_str()
|
||||
.unwrap_or_else(|| unreachable!("File name should be valid UTF-8."));
|
||||
}
|
||||
"Unnamed!"
|
||||
}
|
||||
|
||||
fn extension(&self) -> &str {
|
||||
if let Some(path) = &self.path {
|
||||
return path
|
||||
.extension()
|
||||
.unwrap_or_else(|| OsStr::new("Unknown!"))
|
||||
.to_str()
|
||||
.unwrap_or_else(|| unreachable!("File name should be valid UTF-8."));
|
||||
}
|
||||
"Unknown!"
|
||||
}
|
||||
|
||||
fn save(&mut self) {
|
||||
if self.open_file_dialog.is_some() {
|
||||
// TODO: Flash an error stating you can only have one menu open at once.
|
||||
self.open_file_dialog = None;
|
||||
}
|
||||
|
||||
if let Some(path) = &self.path {
|
||||
// Save to existing path
|
||||
self.buffer = self.text.clone();
|
||||
|
||||
let text = if path.extension().is_some_and(|ext| ext == "dsb") {
|
||||
let mut res = Vec::new();
|
||||
for line in self.text.lines() {
|
||||
for line in line.split_whitespace() {
|
||||
match u32::from_str_radix(line, 16) {
|
||||
Ok(num) => res.push(num),
|
||||
Err(e) => {
|
||||
self.error = Some(format!("Failed to parse file: {e}"));
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
res.into_iter()
|
||||
.flat_map(u32::to_be_bytes)
|
||||
.collect::<Vec<u8>>()
|
||||
} else {
|
||||
self.text.as_bytes().to_vec()
|
||||
};
|
||||
|
||||
if let Err(why) = std::fs::write(path, text) {
|
||||
self.error = Some(format!("Failed to save file: {why}"));
|
||||
} else {
|
||||
self.unsaved = false;
|
||||
}
|
||||
} else {
|
||||
// Open the save dialog.
|
||||
let work_dir = std::env::current_dir().unwrap_or_else(|_| {
|
||||
dirs::home_dir()
|
||||
.expect("Couldn't get your current working directory or your home directory.")
|
||||
});
|
||||
|
||||
if self.save_file_dialog.is_none() {
|
||||
let mut dialog = FileDialog::save_file().initial_path(work_dir);
|
||||
dialog.open();
|
||||
self.save_file_dialog = Some(dialog);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn open(&mut self) {
|
||||
let work_dir = std::env::current_dir().unwrap_or_else(|_| {
|
||||
dirs::home_dir()
|
||||
.expect("Couldn't get your current working directory or your home directory.")
|
||||
});
|
||||
|
||||
if self.save_file_dialog.is_some() {
|
||||
// TODO: Flash an error stating you can only have one menu open at once.
|
||||
self.save_file_dialog = None;
|
||||
}
|
||||
|
||||
if self.open_file_dialog.is_none() {
|
||||
let mut dialog = FileDialog::open_file();
|
||||
if let Some(p) = &self.path
|
||||
&& let Some(path) = p.parent().map(Path::to_path_buf)
|
||||
{
|
||||
dialog.set_path(path);
|
||||
} else {
|
||||
dialog.set_path(work_dir);
|
||||
}
|
||||
|
||||
dialog.open();
|
||||
self.open_file_dialog = Some(dialog);
|
||||
}
|
||||
|
||||
let syntax = match self.extension() {
|
||||
"dsa" => syntax::dsa(),
|
||||
"dsc" => syntax::dsc(),
|
||||
"rs" => Syntax::rust(),
|
||||
_ => Syntax::default(),
|
||||
};
|
||||
|
||||
self.completer = Completer::new_with_syntax(&syntax).with_user_words();
|
||||
self.editor = self.editor.clone().with_syntax(syntax);
|
||||
}
|
||||
|
||||
fn handle_file_dialogs(&mut self, ctx: &egui::Context) {
|
||||
// Handle open dialog
|
||||
if let Some(dialog) = &mut self.open_file_dialog
|
||||
&& dialog.show(ctx).selected()
|
||||
{
|
||||
if let Some(file) = dialog.path() {
|
||||
// check if the file is a binary file
|
||||
if file.extension().is_some_and(|ext| ext == "dsb") {
|
||||
match std::fs::read(file) {
|
||||
Ok(content) => {
|
||||
let mut res = String::new();
|
||||
for (i, b) in content.iter().enumerate() {
|
||||
_ = write!(res, "{b:02x}");
|
||||
if i % 4 == 3 {
|
||||
res.push('\n');
|
||||
}
|
||||
}
|
||||
self.text = res.clone();
|
||||
self.buffer = res;
|
||||
self.path = Some(file.to_path_buf());
|
||||
self.unsaved = false;
|
||||
self.error = None;
|
||||
}
|
||||
Err(e) => {
|
||||
self.error = Some(format!("Failed to read file: {e}"));
|
||||
}
|
||||
}
|
||||
} else {
|
||||
match std::fs::read_to_string(file) {
|
||||
Ok(content) => {
|
||||
self.text = content.clone();
|
||||
self.buffer = content;
|
||||
self.path = Some(file.to_path_buf());
|
||||
self.unsaved = false;
|
||||
self.error = None;
|
||||
}
|
||||
Err(e) => {
|
||||
self.error = Some(format!("Failed to read file: {e}"));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
self.open_file_dialog = None;
|
||||
}
|
||||
|
||||
// Handle save dialog
|
||||
if let Some(dialog) = &mut self.save_file_dialog
|
||||
&& dialog.show(ctx).selected()
|
||||
{
|
||||
if let Some(file) = dialog.path() {
|
||||
self.buffer = self.text.clone();
|
||||
|
||||
let content = if file.extension().is_some_and(|ext| ext == "dsb") {
|
||||
let mut res = Vec::new();
|
||||
for line in self.text.lines() {
|
||||
for line in line.split_whitespace() {
|
||||
match u32::from_str_radix(line, 16) {
|
||||
Ok(num) => res.push(num),
|
||||
Err(e) => {
|
||||
self.error = Some(format!("Failed to parse file: {e}"));
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
res.into_iter()
|
||||
.flat_map(u32::to_be_bytes)
|
||||
.collect::<Vec<u8>>()
|
||||
} else {
|
||||
self.text.clone().as_bytes().to_vec()
|
||||
};
|
||||
|
||||
match std::fs::write(file, content) {
|
||||
Ok(()) => {
|
||||
self.path = Some(file.to_path_buf());
|
||||
self.unsaved = false;
|
||||
self.error = None;
|
||||
}
|
||||
Err(e) => {
|
||||
self.error = Some(format!("Failed to save file: {e}"));
|
||||
}
|
||||
}
|
||||
}
|
||||
self.save_file_dialog = None;
|
||||
}
|
||||
}
|
||||
|
||||
fn render_editor(&mut self, ui: &mut Ui, _ctx: &Context) {
|
||||
let available_width = ui.available_width();
|
||||
let mut editor = self.editor.clone().desired_width(available_width - 500.0);
|
||||
editor.show_with_completer(ui, &mut self.text, &mut self.completer);
|
||||
}
|
||||
|
||||
fn render_bottom_bar(&self, ui: &mut Ui, _ctx: &Context) {
|
||||
ui.horizontal(|ui| {
|
||||
// error display
|
||||
ui.label(
|
||||
egui::RichText::new(self.error.clone().unwrap_or_default())
|
||||
.color(egui::Color32::RED),
|
||||
);
|
||||
|
||||
// line and col
|
||||
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
|
||||
ui.label(format!("Ln {}, Col {}", self.cursor_line, self.cursor_col));
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
fn build(&mut self) {
|
||||
if let Some(path) = &self.path {
|
||||
match path.extension().and_then(|ext| ext.to_str()) {
|
||||
Some("dsa") => {
|
||||
let mut assembler = Assembler::new(path);
|
||||
assembler.start(());
|
||||
|
||||
// Or block until done
|
||||
*self.output.mut_data() = match assembler.output() {
|
||||
Ok(instructions) => instructions,
|
||||
Err(e) => {
|
||||
self.error = Some(e.to_string());
|
||||
return;
|
||||
}
|
||||
};
|
||||
}
|
||||
// Some("dsc") => {
|
||||
// let dsa_path = Path::new(path).with_extension("dsa");
|
||||
// let mut compiler = Compiler::new(path);
|
||||
|
||||
// let is_lib = false;
|
||||
// compiler.start(is_lib);
|
||||
|
||||
// if let Err(e) = compiler.write_result(&dsa_path) {
|
||||
// self.error = Some(e.to_string());
|
||||
// return;
|
||||
// }
|
||||
|
||||
// let mut assembler = Assembler::new(&dsa_path);
|
||||
// assembler.start(());
|
||||
|
||||
// // Or block until done
|
||||
// self.output = match assembler.output() {
|
||||
// Ok(instructions) => instructions,
|
||||
// Err(e) => {
|
||||
// self.error = Some(format!("Assembler error: {e}"));
|
||||
// return;
|
||||
// }
|
||||
// };
|
||||
// }
|
||||
Some("dsb") => {
|
||||
if let Ok(bytes) = fs::read(path) {
|
||||
*self.output.mut_data() = bytes;
|
||||
} else {
|
||||
self.error = Some("Failed to read file".to_string());
|
||||
}
|
||||
}
|
||||
_ => {
|
||||
self.error = Some(format!("Invalid file type: {}", self.filename()));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn render_toolbar(&mut self, ui: &mut Ui, ctx: &Context) {
|
||||
self.handle_file_dialogs(ctx);
|
||||
|
||||
ui.horizontal(|ui| {
|
||||
ui.label(format!("File type: {}", self.extension()));
|
||||
ui.label(format!("Filename: {}", self.filename()));
|
||||
ui.label(format!("Unsaved: {}", self.unsaved));
|
||||
|
||||
// number of lines in the file
|
||||
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
|
||||
let line_count = self.text.lines().count();
|
||||
ui.label(format!("Lines: {line_count}"));
|
||||
});
|
||||
});
|
||||
|
||||
ui.horizontal(|ui| {
|
||||
ui.spacing_mut().button_padding = egui::vec2(8.0, 4.0);
|
||||
ui.spacing_mut().item_spacing.x = 6.0;
|
||||
|
||||
// Opens a file
|
||||
// ui.add_enabled(false, egui::Button::new("Open"));
|
||||
if ui.button("Open").clicked() {
|
||||
self.open();
|
||||
}
|
||||
|
||||
// Saves the current file
|
||||
// ui.add_enabled(false, egui::Button::new("Save"));
|
||||
if ui.button("Save").clicked() {
|
||||
self.save();
|
||||
}
|
||||
|
||||
// // builds the current file
|
||||
// ui.add_enabled(false, egui::Button::new("Build"));
|
||||
if ui.button("Build").clicked() && !self.unsaved {
|
||||
self.build();
|
||||
}
|
||||
|
||||
// // Loads the generated binary into the assembler at the provided offset
|
||||
// ui.add_enabled(false, egui::Button::new("Load"));
|
||||
if ui.button("Load").clicked() {
|
||||
if self.error.is_some() {
|
||||
self.error = Some("Can't load program at invalid offset!".to_string());
|
||||
}
|
||||
|
||||
let program: Vec<Page> = Page::paginate(self.output.data()).collect();
|
||||
|
||||
self.state.reseting.store(true, Ordering::Relaxed);
|
||||
self.memory.clear();
|
||||
for (i, page) in program.iter().enumerate() {
|
||||
self.memory.write_page(i as u32 * 4096, &page);
|
||||
}
|
||||
self.state.reseting.store(false, Ordering::Relaxed);
|
||||
}
|
||||
|
||||
// Entry widget to enter a load offset
|
||||
if ui.text_edit_singleline(&mut self.offset_str).changed() {
|
||||
if let Some(offset) = parse_address(&self.offset_str) {
|
||||
self.load_offset = offset;
|
||||
self.error = None;
|
||||
} else {
|
||||
self.error = Some("Invalid offset".to_string());
|
||||
}
|
||||
}
|
||||
|
||||
ui.checkbox(&mut self.show_output, "Show Output")
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
fn parse_address(address: &str) -> Option<u32> {
|
||||
address.strip_prefix("0x").map_or_else(
|
||||
|| {
|
||||
address.strip_prefix("0b").map_or_else(
|
||||
|| {
|
||||
address.strip_prefix("0o").map_or_else(
|
||||
|| address.parse::<u32>().ok(),
|
||||
|oct| u32::from_str_radix(oct, 8).ok(),
|
||||
)
|
||||
},
|
||||
|bin| u32::from_str_radix(bin, 2).ok(),
|
||||
)
|
||||
},
|
||||
|hex| u32::from_str_radix(hex, 16).ok(),
|
||||
)
|
||||
}
|
||||
|
||||
pub const THEME: ColorTheme = ColorTheme {
|
||||
name: "Theme",
|
||||
dark: true,
|
||||
bg: "#1b1b1b",
|
||||
cursor: "#de5252", // fg4
|
||||
selection: "#28323B", // bg2
|
||||
comments: "#444444", // gray1
|
||||
functions: "#7CCCC7", // green1
|
||||
keywords: "#6C81E0", // red1
|
||||
literals: "#A3ABFF", // fg1
|
||||
numerics: "#8A46CF", // purple1
|
||||
punctuation: "#99C9C9", // orange1
|
||||
strs: "#618c84", // aqua1
|
||||
types: "#B8B9D4", // yellow1
|
||||
special: "#de5252", // blue1
|
||||
};
|
||||
|
||||
struct Output {
|
||||
pub data: Vec<u8>,
|
||||
|
||||
show_bytes: bool,
|
||||
show_words: bool,
|
||||
show_ascii: bool,
|
||||
show_instruction: bool,
|
||||
show_decimal: bool,
|
||||
}
|
||||
|
||||
impl Output {
|
||||
fn new() -> Self {
|
||||
Self {
|
||||
data: vec![],
|
||||
show_bytes: true,
|
||||
show_words: true,
|
||||
show_ascii: true,
|
||||
show_instruction: true,
|
||||
show_decimal: true,
|
||||
}
|
||||
}
|
||||
|
||||
fn mut_data(&mut self) -> &mut Vec<u8> {
|
||||
&mut self.data
|
||||
}
|
||||
|
||||
fn data(&self) -> &Vec<u8> {
|
||||
&self.data
|
||||
}
|
||||
|
||||
fn ui(&mut self, ui: &mut Ui, _ctx: &Context) {
|
||||
// Output area with synchronized scrolling
|
||||
egui::ScrollArea::vertical()
|
||||
.id_salt("output_scroll")
|
||||
.max_width(400.0)
|
||||
.show(ui, |ui| {
|
||||
if self.data.is_empty() {
|
||||
ui.label(
|
||||
egui::RichText::new("No output data")
|
||||
.font(egui::FontId::monospace(12.0))
|
||||
.color(egui::Color32::GRAY),
|
||||
);
|
||||
return;
|
||||
}
|
||||
|
||||
ui.horizontal(|ui| {
|
||||
ui.toggle_value(&mut self.show_bytes, "Bytes");
|
||||
ui.toggle_value(&mut self.show_words, "Words");
|
||||
ui.toggle_value(&mut self.show_decimal, "Decimal");
|
||||
ui.toggle_value(&mut self.show_ascii, "Ascii");
|
||||
ui.toggle_value(&mut self.show_instruction, "Instructions");
|
||||
});
|
||||
|
||||
ui.separator();
|
||||
|
||||
let mut table = TableBuilder::new(ui)
|
||||
.resizable(false) // makes all columns resizable at once
|
||||
.column(Column::initial(55.0)); // addr
|
||||
|
||||
if self.show_bytes {
|
||||
table = table.column(Column::initial(90.0));
|
||||
}
|
||||
if self.show_words {
|
||||
table = table.column(Column::initial(75.0));
|
||||
}
|
||||
if self.show_decimal {
|
||||
table = table.column(Column::initial(80.0));
|
||||
}
|
||||
if self.show_ascii {
|
||||
table = table.column(Column::initial(50.0));
|
||||
}
|
||||
if self.show_instruction {
|
||||
table = table.column(Column::initial(200.0).clip(true));
|
||||
}
|
||||
|
||||
table
|
||||
.header(20.0, |mut header| {
|
||||
header.col(|ui| {
|
||||
ui.label("Addr");
|
||||
});
|
||||
if self.show_bytes {
|
||||
header.col(|ui| {
|
||||
ui.label("Bytes");
|
||||
});
|
||||
}
|
||||
if self.show_words {
|
||||
header.col(|ui| {
|
||||
ui.label("Word");
|
||||
});
|
||||
}
|
||||
if self.show_decimal {
|
||||
header.col(|ui| {
|
||||
ui.label("Decimal");
|
||||
});
|
||||
}
|
||||
if self.show_ascii {
|
||||
header.col(|ui| {
|
||||
ui.label("Ascii");
|
||||
});
|
||||
}
|
||||
if self.show_instruction {
|
||||
header.col(|ui| {
|
||||
ui.label("Instruction");
|
||||
});
|
||||
}
|
||||
})
|
||||
.body(|mut body| {
|
||||
// Process bytes in chunks of 4
|
||||
for (line_num, chunk) in self.data.chunks(4).enumerate() {
|
||||
body.row(18.0, |mut row| {
|
||||
let address = line_num * 4;
|
||||
|
||||
let value = u32::from_le_bytes(*chunk.as_array().unwrap());
|
||||
|
||||
// Address column
|
||||
row.col(|ui| {
|
||||
ui.label(
|
||||
egui::RichText::new(format!("0x{address:04X}"))
|
||||
.font(egui::FontId::monospace(12.0)),
|
||||
);
|
||||
});
|
||||
|
||||
if self.show_bytes {
|
||||
row.col(|ui| {
|
||||
// Individual bytes column
|
||||
ui.label(
|
||||
egui::RichText::new(
|
||||
chunk
|
||||
.iter()
|
||||
.map(|b| format!("{b:02X}"))
|
||||
.collect::<Vec<_>>()
|
||||
.join(" "),
|
||||
)
|
||||
.font(egui::FontId::monospace(12.0))
|
||||
.color(egui::Color32::from_rgb(200, 200, 255)),
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
if self.show_words {
|
||||
row.col(|ui| {
|
||||
// Hex column
|
||||
ui.label(
|
||||
egui::RichText::new(format!("0x{value:08X}"))
|
||||
.font(egui::FontId::monospace(12.0))
|
||||
.color(egui::Color32::from_rgb(255, 100, 100)),
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
if self.show_decimal {
|
||||
row.col(|ui| {
|
||||
ui.label(
|
||||
egui::RichText::new(format!("{value}"))
|
||||
.font(egui::FontId::monospace(12.0))
|
||||
.color(egui::Color32::from_rgb(100, 255, 100)),
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
if self.show_ascii {
|
||||
let ascii = value.to_le_bytes();
|
||||
row.col(|ui| {
|
||||
ui.label(
|
||||
egui::RichText::new(String::from_utf8_lossy(&ascii))
|
||||
.font(egui::FontId::monospace(12.0))
|
||||
.color(egui::Color32::from_rgb(100, 255, 255)),
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
if self.show_instruction {
|
||||
row.col(|ui| {
|
||||
ui.label(
|
||||
egui::RichText::new(format!(
|
||||
"{:?}",
|
||||
Instruction(value)
|
||||
))
|
||||
.font(egui::FontId::monospace(12.0))
|
||||
.color(egui::Color32::from_rgb(255, 100, 255)),
|
||||
);
|
||||
});
|
||||
}
|
||||
})
|
||||
}
|
||||
});
|
||||
|
||||
// egui::Grid::new("output_grid")
|
||||
// .spacing([5.0, 2.0]) // Horizontal and vertical spacing
|
||||
// .num_columns(4)
|
||||
// .striped(false)
|
||||
// .show(ui, |ui| {
|
||||
// ui.label("Address");
|
||||
|
||||
// if self.show_bytes {
|
||||
// ui.label("Bytes");
|
||||
// }
|
||||
// if self.show_words {
|
||||
// ui.label("Word");
|
||||
// }
|
||||
// if self.show_decimal {
|
||||
// ui.label("Decimal");
|
||||
// }
|
||||
// if self.show_ascii {
|
||||
// ui.label("Ascii");
|
||||
// }
|
||||
// if self.show_instruction {
|
||||
// ui.label("Hex");
|
||||
// }
|
||||
// ui.end_row();
|
||||
|
||||
// // Process bytes in chunks of 4
|
||||
// for (line_num, chunk) in self.data.chunks(4).enumerate() {
|
||||
// let address = line_num * 4;
|
||||
|
||||
// // Convert chunk to u32 (little-endian)
|
||||
// let mut bytes = [0u8; 4];
|
||||
// for (i, &byte) in chunk.iter().enumerate() {
|
||||
// if i < 4 {
|
||||
// bytes[i] = byte;
|
||||
// }
|
||||
// }
|
||||
// let value = u32::from_le_bytes(bytes);
|
||||
|
||||
// // Address column
|
||||
// ui.with_layout(
|
||||
// egui::Layout::left_to_right(egui::Align::Center),
|
||||
// |ui| {
|
||||
// ui.set_min_width(80.0);
|
||||
// let style = ui.style_mut();
|
||||
// style.visuals.widgets.inactive.bg_fill =
|
||||
// egui::Color32::from_gray(30);
|
||||
// ui.label(
|
||||
// egui::RichText::new(format!("0x{address:04X}"))
|
||||
// .font(egui::FontId::monospace(12.0)),
|
||||
// );
|
||||
// },
|
||||
// );
|
||||
|
||||
// // Individual bytes column
|
||||
// let byte_str = chunk
|
||||
// .iter()
|
||||
// .map(|b| format!("{b:02X}"))
|
||||
// .collect::<Vec<_>>()
|
||||
// .join(" ");
|
||||
|
||||
// if self.show_bytes {
|
||||
// ui.label(
|
||||
// egui::RichText::new(format!("{byte_str:<11}"))
|
||||
// .font(egui::FontId::monospace(12.0))
|
||||
// .color(egui::Color32::from_rgb(200, 200, 255)),
|
||||
// );
|
||||
// }
|
||||
|
||||
// if self.show_words {
|
||||
// // Hex column
|
||||
// ui.label(
|
||||
// egui::RichText::new(format!("0x{value:08X}"))
|
||||
// .font(egui::FontId::monospace(12.0))
|
||||
// .color(egui::Color32::from_rgb(255, 100, 100)),
|
||||
// );
|
||||
// }
|
||||
|
||||
// if self.show_decimal {
|
||||
// ui.label(
|
||||
// egui::RichText::new(format!("{value}"))
|
||||
// .font(egui::FontId::monospace(12.0))
|
||||
// .color(egui::Color32::from_rgb(100, 255, 100)),
|
||||
// );
|
||||
// }
|
||||
|
||||
// if self.show_ascii {
|
||||
// let ascii = value.to_le_bytes();
|
||||
// ui.label(
|
||||
// egui::RichText::new(String::from_utf8_lossy(&ascii))
|
||||
// .font(egui::FontId::monospace(12.0))
|
||||
// .color(egui::Color32::from_rgb(100, 255, 255)),
|
||||
// );
|
||||
// }
|
||||
|
||||
// if self.show_instruction {
|
||||
// ui.label(
|
||||
// egui::RichText::new(format!("{:?}", Instruction(value)))
|
||||
// .font(egui::FontId::monospace(12.0))
|
||||
// .color(egui::Color32::from_rgb(255, 100, 255)),
|
||||
// );
|
||||
// }
|
||||
|
||||
// ui.end_row();
|
||||
// }
|
||||
// });
|
||||
});
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,48 @@
|
||||
use std::collections::BTreeSet;
|
||||
|
||||
use egui_code_editor::Syntax;
|
||||
|
||||
pub fn dsa() -> Syntax {
|
||||
Syntax {
|
||||
quotes: BTreeSet::from(['"', '\'']),
|
||||
language: "Assembly",
|
||||
case_sensitive: false,
|
||||
comment: "//",
|
||||
comment_multiline: ["/*", "*/"],
|
||||
hyperlinks: BTreeSet::from(["HTTP", "HTTPS"]),
|
||||
keywords: BTreeSet::from([
|
||||
"NOP", "MOV", "CMOV", "LDB", "LDBS", "LDH", "LDHS", "LDW", "STB", "STH", "STW", "LLI",
|
||||
"LUI", "LWI", "JMP", "JNZ", "JEZ", "JNC", "JIC", "IEQ", "INE", "IGE", "IGT", "ILE",
|
||||
"ILT", "SHL", "SHR", "ADD", "SUB", "AND", "OR", "NOT", "XOR", "NAND", "NOR", "XNOR",
|
||||
"IRET", "RET", "CALL", "INT", "PUSH", "POP", "HLT",
|
||||
]),
|
||||
types: BTreeSet::from(["DB", "DW", "DH", "RESB", "RESH", "RESW", "INCLUDE"]),
|
||||
special: BTreeSet::from([
|
||||
"RG0", "RG1", "RG2", "RG3", "RG4", "RG5", "RG6", "RG7", "RG8", "RG9", "RGA", "RGB",
|
||||
"RGC", "RGD", "RGE", "RGF", "ACC", "SPR", "BPR", "IDR", "MMR", "ZERO", "PCX", "STS",
|
||||
"CIR",
|
||||
]),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn dsc() -> Syntax {
|
||||
Syntax {
|
||||
quotes: BTreeSet::from(['"', '\'', '`']),
|
||||
language: "Damn Simple Code",
|
||||
case_sensitive: false,
|
||||
comment: "//",
|
||||
comment_multiline: ["/*", "*/"],
|
||||
hyperlinks: BTreeSet::from(["HTTP", "HTTPS"]),
|
||||
keywords: BTreeSet::from([
|
||||
"INCLUDE", "FN", "LET", "CONST", "STATIC", "IF", "ELSE", "WHILE", "FOR", "BREAK",
|
||||
"CONTINUE", "LOOP", "RETURN", "CLASS", "DEFER", "PUB", "CONST",
|
||||
]),
|
||||
types: BTreeSet::from([
|
||||
"U32", "U16", "U8", "I32", "I16", "I8", "STR", "CHAR", "BOOL", "VOID",
|
||||
]),
|
||||
special: BTreeSet::from([
|
||||
",", ";", ".", ":", "=", "+", "-", "*", "/", "%", "&", "|", "^", "~", "!", "?", "<",
|
||||
">", "<<", ">>", "==", "!=", "<=", ">=", "&&", "||",
|
||||
]),
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,138 @@
|
||||
use std::num::ParseIntError;
|
||||
|
||||
use common::prelude::Instruction;
|
||||
|
||||
use crate::{MemoryBank, frontend::components::Component};
|
||||
|
||||
pub struct MemoryInspector {
|
||||
memory: MemoryBank,
|
||||
|
||||
view_size: u32,
|
||||
view_addr: u32,
|
||||
visible: bool,
|
||||
addr_input: String,
|
||||
}
|
||||
|
||||
impl MemoryInspector {
|
||||
#[must_use]
|
||||
pub fn new(memory: MemoryBank) -> Self {
|
||||
Self {
|
||||
memory,
|
||||
view_size: 1024,
|
||||
view_addr: 0,
|
||||
visible: false,
|
||||
addr_input: String::from("0x00"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Component for MemoryInspector {
|
||||
fn title(&self) -> &'static str {
|
||||
"Memory Inspector"
|
||||
}
|
||||
|
||||
fn visible(&mut self) -> &mut bool {
|
||||
&mut self.visible
|
||||
}
|
||||
|
||||
fn ui(&mut self, ui: &mut egui::Ui, ctx: &egui::Context) {
|
||||
// Right column - Memory
|
||||
ui.vertical(|ui| {
|
||||
ui.heading("Memory Inspector");
|
||||
ui.add_space(10.0);
|
||||
|
||||
// Address input section
|
||||
ui.horizontal(|ui| {
|
||||
ui.label("Address:");
|
||||
|
||||
let address_response = ui.add(
|
||||
egui::TextEdit::singleline(&mut self.addr_input)
|
||||
.hint_text("0x1000 or 4096")
|
||||
.desired_width(150.0),
|
||||
);
|
||||
|
||||
ui.add_space(10.0);
|
||||
|
||||
// Search button
|
||||
let search_clicked = ui.button("🔍 Search").clicked();
|
||||
|
||||
// Handle Enter key in text field
|
||||
let enter_pressed =
|
||||
address_response.lost_focus() && ctx.input(|i| i.key_pressed(egui::Key::Enter));
|
||||
|
||||
if search_clicked || enter_pressed {
|
||||
if let Ok(new) = parse_address(&self.addr_input) {
|
||||
if new % 4 == 0 {
|
||||
self.view_addr = new;
|
||||
} else {
|
||||
println!("Address must be 4-byte aligned");
|
||||
}
|
||||
} else {
|
||||
println!("Invalid address");
|
||||
// state.error_log.push("Invalid address".to_string());
|
||||
}
|
||||
}
|
||||
|
||||
ui.label("(hex or decimal)");
|
||||
});
|
||||
|
||||
ui.add_space(10.0);
|
||||
|
||||
// Memory table
|
||||
egui::ScrollArea::vertical()
|
||||
.auto_shrink(true)
|
||||
.id_salt("memory_inspector_scroll")
|
||||
.show(ui, |ui| {
|
||||
egui::Grid::new("memory_grid")
|
||||
.spacing([12.0, 2.0])
|
||||
.min_col_width(5.0)
|
||||
.striped(true)
|
||||
.show(ui, |ui| {
|
||||
// Header
|
||||
ui.strong("Address");
|
||||
|
||||
for i in 0..4 {
|
||||
ui.strong(format!("{i:X}"));
|
||||
}
|
||||
|
||||
ui.strong("Decimal");
|
||||
ui.strong("Instruction");
|
||||
|
||||
ui.end_row();
|
||||
|
||||
// Memory data (8 bytes per row)
|
||||
for (row, word) in (0..self.view_size / 4)
|
||||
.map(|i| i * 4)
|
||||
.map(|i| (i, self.memory.read_word(self.view_addr + i)))
|
||||
{
|
||||
let row_address = self.view_addr + (row * 4);
|
||||
ui.monospace(format!("0x{row_address:08X} ({row_address})"));
|
||||
for byte in word.to_le_bytes() {
|
||||
ui.monospace(format!("{byte:02X}"));
|
||||
}
|
||||
|
||||
ui.monospace(format!("{word}"));
|
||||
ui.monospace(format!("{:?}", Instruction(word)));
|
||||
ui.end_row();
|
||||
}
|
||||
});
|
||||
});
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
fn parse_address(address: &str) -> Result<u32, ParseIntError> {
|
||||
if let Some(hex_part) = address.strip_prefix("0x") {
|
||||
return u32::from_str_radix(hex_part, 16);
|
||||
}
|
||||
|
||||
if let Some(bin_part) = address.strip_prefix("0b") {
|
||||
return u32::from_str_radix(bin_part, 2);
|
||||
}
|
||||
|
||||
if let Some(oct_part) = address.strip_prefix("0o") {
|
||||
return u32::from_str_radix(oct_part, 8);
|
||||
}
|
||||
|
||||
address.parse::<u32>()
|
||||
}
|
||||
@@ -1,4 +1,83 @@
|
||||
use crate::{frontend::components::Component, io::serial::Serial};
|
||||
use std::sync::{
|
||||
Arc,
|
||||
atomic::Ordering,
|
||||
mpsc::{Receiver, Sender},
|
||||
};
|
||||
|
||||
use super::Component;
|
||||
use crate::{
|
||||
MemoryBank, SharedState,
|
||||
backend::{memory::PhysAddr, processor::interrupts::Interrupt},
|
||||
};
|
||||
|
||||
/// ## SERIAL LAYOUT: (from the perspective of code inside the emulator)
|
||||
/// - [base+0x00]: write valid flag - set by kernel after writing a byte to serial
|
||||
/// - [base+0x01]: write byte - data payload for emulator to read
|
||||
/// - [base+0x02]: read valid flag - set by emulator after writing a byte to serial
|
||||
/// - [base+0x03]: read byte - data payload for kernel to read
|
||||
pub struct Serial {
|
||||
pub read_rx: Receiver<u8>,
|
||||
pub write_tx: Sender<u8>,
|
||||
pub read_buff: Vec<u8>,
|
||||
pub write_buff: String,
|
||||
|
||||
pub visible: bool,
|
||||
}
|
||||
|
||||
impl Serial {
|
||||
fn uart_io_thread(
|
||||
mem: MemoryBank,
|
||||
state: Arc<SharedState>,
|
||||
uart_base: PhysAddr,
|
||||
tx: Sender<u8>,
|
||||
rx: Receiver<u8>,
|
||||
) {
|
||||
loop {
|
||||
let word = mem.read_word(uart_base);
|
||||
|
||||
// Kernel → emulator: valid flag in bits 31:24, data in bits 23:16
|
||||
if (word >> 24) as u8 == 0x01 {
|
||||
let byte = (word >> 16) as u8;
|
||||
let _ = tx.send(byte);
|
||||
mem.write_word(uart_base, 0x00); // clear the whole word
|
||||
}
|
||||
|
||||
// Emulator → kernel: your existing rx path
|
||||
if (word >> 8) as u8 == 0x00 {
|
||||
if let Ok(byte) = rx.try_recv() {
|
||||
state.interrupt_queue.send(Interrupt::SerialIn).unwrap();
|
||||
|
||||
mem.write_byte(uart_base + 3, byte);
|
||||
mem.write_byte(uart_base + 2, 0x01);
|
||||
}
|
||||
}
|
||||
|
||||
std::thread::sleep(std::time::Duration::from_millis(1));
|
||||
}
|
||||
}
|
||||
|
||||
pub fn new(uart_base: PhysAddr, state: Arc<SharedState>, mem_handle: MemoryBank) -> Self {
|
||||
let (read_tx, read_rx) = std::sync::mpsc::channel();
|
||||
let (write_tx, write_rx) = std::sync::mpsc::channel();
|
||||
let _ = std::thread::spawn(move || {
|
||||
Self::uart_io_thread(mem_handle, state, uart_base, read_tx, write_rx)
|
||||
});
|
||||
|
||||
Self {
|
||||
visible: false,
|
||||
write_tx,
|
||||
read_rx,
|
||||
read_buff: Vec::new(),
|
||||
write_buff: String::new(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn update(&mut self) {
|
||||
while let Ok(byte) = self.read_rx.try_recv() {
|
||||
self.read_buff.push(byte);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Component for Serial {
|
||||
fn title(&self) -> &str {
|
||||
@@ -9,9 +88,23 @@ impl Component for Serial {
|
||||
&mut self.visible
|
||||
}
|
||||
|
||||
fn ui(&mut self, ui: &mut egui::Ui, ctx: &egui::Context) {
|
||||
fn ui(&mut self, ui: &mut egui::Ui, _ctx: &egui::Context) {
|
||||
self.update();
|
||||
|
||||
ui.label(String::from_utf8(self.buffer.clone()).unwrap());
|
||||
// Text field for input and a send button
|
||||
ui.text_edit_multiline(&mut self.write_buff);
|
||||
if ui.button("Send").clicked() {
|
||||
self.write_buff.push(0 as char);
|
||||
for byte in self.write_buff.bytes() {
|
||||
self.write_tx.send(byte).unwrap();
|
||||
}
|
||||
self.write_buff.clear();
|
||||
}
|
||||
|
||||
// Display received data
|
||||
ui.label(String::from_utf8(self.read_buff.clone()).unwrap());
|
||||
if ui.button("Clear").clicked() {
|
||||
self.read_buff.clear();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,15 +1,16 @@
|
||||
use eframe::NativeOptions;
|
||||
use eframe::egui;
|
||||
use std::mem;
|
||||
use std::sync::Arc;
|
||||
use std::sync::atomic::Ordering;
|
||||
|
||||
mod components;
|
||||
use components::{
|
||||
Component, controller::Controller, display::Display, editor::Editor, framebuffer::FrameBuffer,
|
||||
memory::MemoryInspector, registers::Registers, serial::Serial,
|
||||
};
|
||||
|
||||
use crate::frontend::components::Component;
|
||||
use crate::frontend::components::framebuffer::FrameBuffer;
|
||||
use crate::io::serial::Serial;
|
||||
use crate::{MemoryBank, SharedState, config::VERSION};
|
||||
use components::{controller::Controller, display::Display, registers::Registers};
|
||||
|
||||
pub fn run_app(state: Arc<SharedState>, mem_handle: MemoryBank) -> eframe::Result<()> {
|
||||
eframe::run_native(
|
||||
@@ -90,6 +91,8 @@ impl DsaUi {
|
||||
Box::new(FrameBuffer::new(320, 240, 0x30000, mem_handle.clone())),
|
||||
Box::new(Registers::new(state.clone())),
|
||||
Box::new(Serial::new(0x40000, state.clone(), mem_handle.clone())),
|
||||
Box::new(Editor::new(state.clone(), mem_handle.clone())),
|
||||
Box::new(MemoryInspector::new(mem_handle.clone())),
|
||||
];
|
||||
components.iter_mut().for_each(|c| *c.visible() = false);
|
||||
|
||||
|
||||
@@ -1,62 +0,0 @@
|
||||
// use super::{IoAccess, IoHandle};
|
||||
use crate::{MemoryBank, Page, backend::memory::PhysAddr};
|
||||
|
||||
pub struct Display {
|
||||
width: usize,
|
||||
height: usize,
|
||||
addr: PhysAddr,
|
||||
|
||||
mem: MemoryBank,
|
||||
buffer: Vec<u8>,
|
||||
visible: bool,
|
||||
}
|
||||
|
||||
impl Display {
|
||||
pub fn new(width: u32, height: u32, addr: PhysAddr, mem: MemoryBank) -> Self {
|
||||
Self {
|
||||
width: width as usize,
|
||||
height: height as usize,
|
||||
addr,
|
||||
mem,
|
||||
buffer: Vec::new(),
|
||||
visible: true,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn visible(&mut self) -> &mut bool {
|
||||
&mut self.visible
|
||||
}
|
||||
|
||||
pub fn width(&self) -> usize {
|
||||
self.width
|
||||
}
|
||||
|
||||
pub fn height(&self) -> usize {
|
||||
self.height
|
||||
}
|
||||
|
||||
fn internal_read(&self) -> Vec<u8> {
|
||||
let pages = (0..((self.width * self.height).div_ceil(Page::SIZE)))
|
||||
.map(|i| {
|
||||
let page = self.mem.read_page(self.addr + i as u32 * 4096);
|
||||
page.as_slice().to_owned()
|
||||
})
|
||||
.flatten()
|
||||
.take((self.width * self.height) as usize)
|
||||
.collect::<Vec<u8>>();
|
||||
pages
|
||||
}
|
||||
|
||||
pub fn changed(&mut self) -> bool {
|
||||
let temp = self.internal_read();
|
||||
if temp != self.buffer {
|
||||
self.buffer = temp;
|
||||
return true;
|
||||
}
|
||||
false
|
||||
}
|
||||
|
||||
pub fn read(&mut self) -> Vec<u8> {
|
||||
self.internal_read()
|
||||
}
|
||||
}
|
||||
@@ -1,46 +0,0 @@
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
pub mod display;
|
||||
pub mod serial;
|
||||
// #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
|
||||
// pub enum DeviceId {
|
||||
// Display,
|
||||
// Serial,
|
||||
// Random,
|
||||
// Timer,
|
||||
// }
|
||||
|
||||
// pub trait IoHandle: Send {
|
||||
// /// Return the size (in bytes) of the device's addressable region.
|
||||
// fn size(&self) -> usize;
|
||||
|
||||
// /// Return the access permissions for the device.
|
||||
// fn access(&self) -> IoAccess;
|
||||
|
||||
// /// Return the DeviceId
|
||||
// fn id(&self) -> DeviceId;
|
||||
// }
|
||||
|
||||
// #[derive(Clone, Copy, Debug, PartialEq)]
|
||||
// pub struct IoAccess(u8);
|
||||
|
||||
// impl IoAccess {
|
||||
// pub const READ: Self = Self(0b01);
|
||||
// pub const WRITE: Self = Self(0b10);
|
||||
|
||||
// /// Convenience alias for Read + Write.
|
||||
// pub const READWRITE: Self = Self(Self::READ.0 | Self::WRITE.0);
|
||||
// pub const NONE: Self = Self(0);
|
||||
|
||||
// /// Bitwise OR – returns a new `IoAccess` that contains all flags from both operands.
|
||||
// #[inline]
|
||||
// pub fn or(self, other: Self) -> Self {
|
||||
// Self(self.0 | other.0)
|
||||
// }
|
||||
|
||||
// /// Check if a flag is present.
|
||||
// #[inline]
|
||||
// pub fn contains(&self, flag: Self) -> bool {
|
||||
// self.0 & flag.0 != 0
|
||||
// }
|
||||
// }
|
||||
@@ -1,48 +0,0 @@
|
||||
use std::{
|
||||
path::Component,
|
||||
sync::{
|
||||
Arc,
|
||||
mpsc::{Receiver, Sender},
|
||||
},
|
||||
};
|
||||
|
||||
use crate::{MemoryBank, SharedState, backend::memory::PhysAddr};
|
||||
|
||||
pub struct Serial {
|
||||
pub receiver: Receiver<u8>,
|
||||
pub buffer: Vec<u8>,
|
||||
|
||||
pub visible: bool,
|
||||
}
|
||||
|
||||
impl Serial {
|
||||
fn uart_io_thread(mem: MemoryBank, uart_base: PhysAddr, tx: Sender<u8>) {
|
||||
loop {
|
||||
let word = mem.read_word(uart_base);
|
||||
// println!("word {:#010X}", word);
|
||||
if word >> 24 == 0x01 {
|
||||
let byte = ((word >> 16) & 0xFF) as u8;
|
||||
let _ = tx.send(byte);
|
||||
mem.write_word(uart_base, 0x00_00_00_00); // clear valid flag
|
||||
}
|
||||
std::hint::spin_loop();
|
||||
}
|
||||
}
|
||||
|
||||
pub fn new(uart_base: PhysAddr, state: Arc<SharedState>, mem_handle: MemoryBank) -> Self {
|
||||
let (sender, receiver) = std::sync::mpsc::channel();
|
||||
let _ = std::thread::spawn(move || Self::uart_io_thread(mem_handle, uart_base, sender));
|
||||
|
||||
Self {
|
||||
visible: false,
|
||||
receiver,
|
||||
buffer: Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn update(&mut self) {
|
||||
while let Ok(byte) = self.receiver.try_recv() {
|
||||
self.buffer.push(byte);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -5,7 +5,6 @@ pub mod args;
|
||||
pub mod backend;
|
||||
pub mod config;
|
||||
pub mod frontend;
|
||||
pub mod io;
|
||||
|
||||
pub use backend::memory::ram::*;
|
||||
pub use backend::{processor::processor::Emulator, processor::state::SharedState};
|
||||
|
||||
@@ -47,5 +47,17 @@ fn main() {
|
||||
.spawn(move || emulator.run().unwrap())
|
||||
.unwrap();
|
||||
|
||||
run_app(state, mem_handle).unwrap()
|
||||
if args.headless() {
|
||||
run_server(&args);
|
||||
} else {
|
||||
run_app(state, mem_handle).unwrap()
|
||||
}
|
||||
}
|
||||
|
||||
fn run_server(args: &DsaArgs) {
|
||||
if args.headless() {
|
||||
println!("Running in headless mode");
|
||||
} else {
|
||||
println!("Running in GUI mode");
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user