akern-gkgoat-fork/ableos/src/scratchpad.rs

use alloc::{format, vec::Vec};

/// 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 mut engine = rhai::Engine::new();

    let ret = engine.eval::<i64>("1 + 2");

    match ret {
        // Ok(x) => println!("{}", x),
        // Err(e) => println!("{}", e),
        _ => (),
    }

    loop {}
}
lazy_static::lazy_static!(
    pub static ref KEYBUFF: spin::Mutex<Vec<char>> = spin::Mutex::new(
        Vec::new())
    ;
);