Rewrite emulatorv1.0.0-alpha1

This is a complete rewrite and restructure of the entire emulator
project, as part of the effort in locking down the Bedrock specification
and in creating much better tooling for creating and using Bedrock
programs.

This commit adds a command-line argument scheme, an embedded assembler,
a headless emulator for use in non-graphical environments, deferred
window creation for programs that do not access the screen device,
and new versions of phosphor and bedrock-core. The new version of
phosphor supports multi-window programs, which will make it possible to
implement program forking in the system device later on, and the new
version of bedrock-core implements the final core specification.

1 files changed, 230 insertions, 0 deletions

diff --git a/src/devices/local_device.rs b/src/devices/local_device.rs
new file mode 100644
index 0000000..14a8f71
--- /dev/null
+++ b/src/devices/local_device.rs
@@ -0,0 +1,230 @@
+use crate::*;
+
+use bedrock_core::*;
+
+use std::collections::VecDeque;
+use std::io::{BufRead, Stdout, Write};
+use std::sync::mpsc::{self, TryRecvError};
+
+
+pub struct LocalDevice {
+    wake: bool,
+
+    stdin_connected: bool,
+    stdin_control: bool,
+    stdin_rx: mpsc::Receiver<Vec<u8>>,
+    stdin_queue: VecDeque<u8>,
+    stdin_excess: VecDeque<u8>,
+    stdout: Stdout,
+
+    stdout_connected: bool,
+
+    decode_stdin: bool,
+    encode_stdout: bool,
+    decode_buffer: Option<u8>,
+}
+
+impl LocalDevice {
+    pub fn new(config: &EmulatorConfig) -> Self {
+        // Fill input queue with initial transmission.
+        let mut stdin_queue = VecDeque::new();
+        if let Some(bytes) = &config.initial_transmission {
+            for byte in bytes { stdin_queue.push_front(*byte) }
+        }
+        // Spawn a thread to enable non-blocking reads of stdin.
+        let (stdin_tx, stdin_rx) = std::sync::mpsc::channel();
+        std::thread::spawn(move || loop {
+            let mut stdin = std::io::stdin().lock();
+            match stdin.fill_buf() {
+                Ok(buf) if !buf.is_empty() => {
+                    let length = buf.len();
+                    stdin_tx.send(buf.to_vec()).unwrap();
+                    stdin.consume(length);
+                }
+                _ => break,
+            };
+        });
+
+        Self {
+            wake: true,
+
+            stdin_connected: true,
+            stdin_control: false,
+            stdin_rx,
+            stdin_queue,
+            stdin_excess: VecDeque::new(),
+            stdout: std::io::stdout(),
+
+            stdout_connected: true,
+
+            decode_stdin: config.encode_stdin,
+            encode_stdout: config.encode_stdout,
+            decode_buffer: None,
+        }
+    }
+
+    pub fn stdin_length(&mut self) -> u8 {
+        self.fetch_stdin_data();
+        self.stdin_queue.len().try_into().unwrap_or(u8::MAX)
+    }
+
+    pub fn stdin_enable(&mut self) {
+        if !self.stdin_control {
+            self.stdin_queue.clear();
+            self.stdin_control = true;
+        }
+    }
+
+    pub fn stdin_read(&mut self) -> u8 {
+        self.fetch_stdin_data();
+        self.stdin_queue.pop_front().unwrap_or(0)
+    }
+
+    pub fn stdout_write(&mut self, value: u8) {
+        macro_rules! hex {
+            ($value:expr) => { match $value {
+            0x0..=0x9 => $value + b'0',
+            0xa..=0xf => $value - 0x0a + b'a',
+            _ => unreachable!("Cannot encode value as hex digit: 0x{:02x}", $value),
+            } };
+        }
+        if self.encode_stdout {
+            let encoded = [hex!(value >> 4), hex!(value & 0xf), b' '];
+            self.stdout_write_raw(&encoded);
+        } else {
+            self.stdout_write_raw(&[value]);
+        };
+    }
+
+    fn stdout_write_raw(&mut self, bytes: &[u8]) {
+        if let Err(_) = self.stdout.write_all(bytes) {
+            if self.stdout_connected {
+                self.stdout_connected = false;
+                self.wake = true;  // wake because stdout was disconnected.
+            }
+        }
+    }
+
+    pub fn stdout_disable(&mut self) {
+        if self.encode_stdout {
+            self.stdout_write_raw(&[b'\n']);
+        }
+    }
+
+    pub fn fetch_stdin_data(&mut self) {
+        while self.stdin_control {
+            match self.stdin_excess.pop_front() {
+                Some(byte) => self.fetch_byte(byte),
+                None => break,
+            }
+        }
+        match self.stdin_rx.try_recv() {
+            Ok(tx) => {
+                for byte in tx {
+                    match self.stdin_control {
+                        true => self.fetch_byte(byte),
+                        false => self.stdin_excess.push_back(byte),
+                    }
+                }
+            }
+            Err(TryRecvError::Empty) => (),
+            Err(TryRecvError::Disconnected) => {
+                self.stdin_control = false;
+                if self.stdin_connected {
+                    self.stdin_connected = false;
+                    self.wake = true; // wake because stdin was disconnected.
+                }
+            }
+        }
+    }
+
+    fn fetch_byte(&mut self, byte: u8) {
+        if self.decode_stdin {
+            let decoded = match byte {
+                b'0'..=b'9' => byte - b'0',
+                b'a'..=b'f' => byte - b'a' + 0x0a,
+                b'A'..=b'F' => byte - b'A' + 0x0a,
+                b'\n' => {
+                    self.decode_buffer = None;
+                    self.stdin_control = false;
+                    self.wake = true;  // wake because a transmission ended.
+                    return;
+                },
+                _ => return,
+            };
+            if let Some(high) = std::mem::take(&mut self.decode_buffer) {
+                self.stdin_queue.push_back((high << 4) | decoded);
+                self.wake = true; // wake because a byte was received.
+            } else {
+                self.decode_buffer = Some(decoded);
+            }
+        } else {
+            self.stdin_queue.push_back(byte);
+            self.wake = true; // wake because a byte was received.
+        }
+    }
+
+    pub fn flush(&mut self) {
+        self.stdout.flush().unwrap();
+    }
+}
+
+
+impl Drop for LocalDevice {
+    fn drop(&mut self) {
+        self.flush();
+    }
+}
+
+
+impl Device for LocalDevice {
+    fn read(&mut self, port: u8) -> u8 {
+        match port {
+            0x0 => read_b!(self.stdin_connected),
+            0x1 => 0xff,
+            0x2 => read_b!(self.stdin_control),
+            0x3 => 0xff,
+            0x4 => self.stdin_length(),
+            0x5 => 0xff,
+            0x6 => self.stdin_read(),
+            0x7 => self.stdin_read(),
+            0x8 => todo!(),
+            0x9 => todo!(),
+            0xa => todo!(),
+            0xb => todo!(),
+            0xc => todo!(),
+            0xd => todo!(),
+            0xe => todo!(),
+            0xf => todo!(),
+            _ => unreachable!(),
+        }
+    }
+
+    fn write(&mut self, port: u8, value: u8) -> Option<Signal> {
+        match port {
+            0x0 => (),
+            0x1 => (),
+            0x2 => self.stdin_enable(),
+            0x3 => self.stdout_disable(),
+            0x4 => self.stdin_queue.clear(),
+            0x5 => (),
+            0x6 => self.stdout_write(value),
+            0x7 => self.stdout_write(value),
+            0x8 => todo!(),
+            0x9 => todo!(),
+            0xa => todo!(),
+            0xb => todo!(),
+            0xc => todo!(),
+            0xd => todo!(),
+            0xe => todo!(),
+            0xf => todo!(),
+            _ => unreachable!(),
+        };
+        return None;
+    }
+
+    fn wake(&mut self) -> bool {
+        self.fetch_stdin_data();
+        std::mem::take(&mut self.wake)
+    }
+}