myriad-rs 0.2.0

VM runtime for Polka bytecode, computation core.
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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

use core::cell::RefCell;
use alloc::rc::Rc;
use alloc::{boxed::Box, string::String, vec::Vec};
use crate::{Device, Value};

pub const CONSOLE_ID: u8 = 0x10;
pub const PORT_STDIN: u8 = 0x00;
pub const PORT_STDOUT: u8 = 0x01;
pub const PORT_STDERR: u8 = 0x02;
pub const PORT_FLUSH: u8 = 0x03;

pub trait Console {
    fn read_byte(&mut self) -> Result<Option<u8>, String>;
    fn write_stdout(&mut self, byte: u8) -> Result<(), String>;
    fn write_stderr(&mut self, byte: u8) -> Result<(), String>;
    fn flush(&mut self) -> Result<(), String>;

    fn write_stdout_bulk(&mut self, bytes: &[u8]) -> Result<(), String> {
        for &b in bytes { self.write_stdout(b)?; }
        Ok(())
    }
    fn write_stderr_bulk(&mut self, bytes: &[u8]) -> Result<(), String> {
        for &b in bytes { self.write_stderr(b)?; }
        Ok(())
    }
}

impl Device for Box<dyn Console> {
    fn read(&mut self, port: u8) -> Result<(Value, bool), String> {
        let v = match port {
            PORT_STDIN => match self.read_byte()? {
                Some(b) => Value::from_int(b as i64),
                None => Value::from_int(-1),
            },
            _ => Value::from_int(0),
        };
        Ok((v, false))
    }

    fn write(&mut self, port: u8, val: Value, is_handle: bool, heap: &mut crate::memory::Heap)
        -> Result<(), String>
    {
        if is_handle { heap.rc_dec_handle(val.raw())?; return Ok(()); }
        let n = val.as_int();
        match port {
            PORT_STDOUT => self.write_stdout((n & 0xFF) as u8),
            PORT_STDERR => self.write_stderr((n & 0xFF) as u8),
            PORT_FLUSH => self.flush(),
            _ => Ok(()),
        }
    }

    fn write_bytes(&mut self, port: u8, bytes: &[u8], _heap: &mut crate::memory::Heap)
        -> Result<(), String>
    {
        match port {
            PORT_STDOUT => self.write_stdout_bulk(bytes),
            PORT_STDERR => self.write_stderr_bulk(bytes),
            _ => Ok(()),
        }
    }
}

pub type SharedBuf = Rc<RefCell<Vec<u8>>>;

pub struct BufferConsole {
    pub out_buf: SharedBuf,
    pub err_buf: SharedBuf,
    pub stdin_buf: SharedBuf,
}

impl BufferConsole {
    pub fn new() -> Self {
        Self {
            out_buf: Rc::new(RefCell::new(Vec::new())),
            err_buf: Rc::new(RefCell::new(Vec::new())),
            stdin_buf: Rc::new(RefCell::new(Vec::new())),
        }
    }
    pub fn handles(&self) -> (SharedBuf, SharedBuf) {
        (self.out_buf.clone(), self.err_buf.clone())
    }
    pub fn stdin_handle(&self) -> SharedBuf {
        self.stdin_buf.clone()
    }
}

impl Console for BufferConsole {
    fn read_byte(&mut self) -> Result<Option<u8>, String> {
        let mut buf = self.stdin_buf.borrow_mut();
        if buf.is_empty() { Ok(None) } else { Ok(Some(buf.remove(0))) }
    }
    fn write_stdout(&mut self, byte: u8) -> Result<(), String> {
        self.out_buf.borrow_mut().push(byte); Ok(())
    }
    fn write_stderr(&mut self, byte: u8) -> Result<(), String> {
        self.err_buf.borrow_mut().push(byte); Ok(())
    }
    fn flush(&mut self) -> Result<(), String> { Ok(()) }

    fn write_stdout_bulk(&mut self, bytes: &[u8]) -> Result<(), String> {
        self.out_buf.borrow_mut().extend_from_slice(bytes); Ok(())
    }
    fn write_stderr_bulk(&mut self, bytes: &[u8]) -> Result<(), String> {
        self.err_buf.borrow_mut().extend_from_slice(bytes); Ok(())
    }
}