ableos_time/ableos/src/scratchpad.rs

use {
    crate::{
        devices::{pci_inner::DeviceClass, Device, DEVICE_TABLE},
        proc::PID,
        wasm_jumploader::interp,
    },
    alloc::{format, vec::Vec},
    pci::PortOps,
};

/// Experimental scratchpad for testing.
pub fn scratchpad() {
    let mut dev_list = Vec::new();
    let bus_scan;
    unsafe {
        bus_scan = pci::scan_bus(&PciIO {}, pci::CSpaceAccessMethod::IO);
    }
    for dev in bus_scan {
        dev_list.push(dev);
    }

    let device_table = &mut *DEVICE_TABLE.lock();

    for x in dev_list {
        let device_name = format!("{:?}-{}", DeviceClass::from_u8(x.id.class), x.id.device_id);

        device_table
            .devices
            .insert(device_name.clone(), Device::Pci(x));
    }

    /*
        for (key, _value) in device_table.devices.iter() {
            debug!("{}", key);
        }
    */
    // interp();

    rhai_shell();
}

pub struct PciIO {}

impl PortOps for PciIO {
    unsafe fn read8(&self, port: u16) -> u8 {
        cpuio::inb(port as u16)
    }

    unsafe fn read16(&self, port: u16) -> u16 {
        cpuio::inw(port as u16)
    }

    unsafe fn read32(&self, port: u16) -> u32 {
        cpuio::inl(port as u16)
    }

    unsafe fn write8(&self, port: u16, val: u8) {
        cpuio::outb(val, port as u16);
    }

    unsafe fn write16(&self, port: u16, val: u16) {
        cpuio::outw(val, port as u16);
    }

    unsafe fn write32(&self, port: u16, val: u32) {
        cpuio::outl(val, port as u16);
    }
}
/*
/// An experimental process message format
pub struct ProcessMessage {
    pub to_pid: PID,
    pub from_pid: PID,
    pub message: [u8; 2048],

    pub sender_time: SecondsTime,
}
//
// use libwasm::syscalls::time_calls::SecondsTime;

impl ProcessMessage {
    pub fn new(to_pid: PID, from_pid: PID, message: [u8; 2048]) -> Self {
        ProcessMessage {
            to_pid,
            from_pid,
            message,
            sender_time: SecondsTime {
                seconds: 0,
                milliseconds: 0,
            },
        }
    }
}
*/

pub fn rhai_shell() {
    let engine = rhai::Engine::new();
    let mut buf = String::new();
    print!("> ");

    loop {
        match x86_64::instructions::interrupts::without_interrupts(|| KEYBUFF.lock().pop()) {
            Some('\n') => {
                match engine.eval::<rhai::Dynamic>(&buf) {
                    Ok(o) => println!("{o}"),
                    Err(e) => println!("Eval error: {e}"),
                };

                buf.clear();
                print!("> ");
            }
            Some('\u{0008}') => {
                buf.pop();
            }
            Some(chr) => buf.push(chr),
            None => (),
        }
    }
}
lazy_static::lazy_static!(
    pub static ref KEYBUFF: spin::Mutex<Vec<char>> = spin::Mutex::new(
        Vec::new())
    ;
);

use alloc::string::String;

use crate::arch::sloop;