AbleOS/ableos
2
2
Fork 13
Code Issues Pull requests 1 Projects Releases Wiki Activity

Merge pull request 'clparse' (#26) from clparse into master

Browse source 
Reviewed-on: https://git.ablecorp.us:443/able/ableos/pulls/26
This commit is contained in:
able 2022-08-07 03:13:26 +00:00
parent 2200b5bbda e768c308e6
commit 99fc12cd7c
18 changed files with 418 additions and 60 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

11
Cargo.lock generated
View file

@ -31,6 +31,7 @@ dependencies = [
"axel",
"bitflags",
"bootloader",
"clparse",
"cpuio",
"ext2",
"externc-libm",
@ -161,6 +162,16 @@ version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
[[package]]
name = "clparse"
version = "0.1.0"
source = "git+https://git.ablecorp.us/able/core_utils#46a97f827bd11f3cea8dcab797b9697d9485c4b3"
dependencies = [
"hashbrown",
"log",
"toml",
]
[[package]]
name = "colored"
version = "2.0.0"

20
ableos/Cargo.toml
View file

@ -22,9 +22,19 @@ run-args = [
"-soundhw",
"pcspk",
# "-device",
# "VGA",
# "-device",
# "virtio-gpu-pci",
"-device",
"VGA",
# "-device", "virtio-gpu-pci",
"vmware-svga",
"-device",
"sb16",
# "-machine", "pcspk-audiodev=0",
@ -49,7 +59,6 @@ test-args = [
lazy_static = { version = "1.4.0", features = ["spin_no_std"] }
qrcode = { path = "../qrcode-rust" }
bitflags = "1.2.1"
linked_list_allocator = "0.9.0"
lliw = "0.2.0"
spin = "0.9"
pretty-hex = "0.2.1"
@ -62,7 +71,12 @@ versioning = { git = "https://git.ablecorp.us/able/aos_userland" }
# embedded-graphics = "*"
pc-keyboard = "0.5"
# mini-backtrace = "0.1"
clparse = { git = "https://git.ablecorp.us/able/core_utils", default-features = false }
[dependencies.linked_list_allocator]
version = "0.9.0"
features = ["use_spin_nightly"]
[dependencies.log]
version = "0.4.17"
default-features = false

4
ableos/assets/kernel.toml
View file

@ -6,8 +6,8 @@ user_processes = ["shell"]
enabled = true
level = "Trace"
log_to_serial = true
filter = ["ableos::ps2_mouse"]
# "ableos::vterm"]
log_to_vterm = false
filter = ["ableos::ps2_mouse", "ableos::vterm"]
[tests]

9
ableos/src/arch/x86_64/interrupts.rs
View file

@ -1,6 +1,12 @@
/*
* Copyright (c) 2022, able <abl3theabove@gmail.com>
*
* SPDX-License-Identifier: MPL-2.0
*/
use core::panic::PanicInfo;
use crate::{arch::gdt, print, println, rhai_shell::KEYBUFF};
use crate::{arch::gdt, println, rhai_shell::KEYBUFF};
use cpuio::outb;
use pic8259::ChainedPics;
use qrcode::QrCode;
@ -134,7 +140,6 @@ extern "x86-interrupt" fn keyboard_interrupt_handler(_stack_frame: InterruptStac
DecodedKey::Unicode(chr) => match chr {
'\n' => {
KEYBUFF.lock().push('\n');
trace!("ENTER");
}
// Backspace
'\u{8}' => {

9
ableos/src/arch/x86_64/mod.rs
View file

@ -1,3 +1,9 @@
/*
* Copyright (c) 2022, able <abl3theabove@gmail.com>
*
* SPDX-License-Identifier: MPL-2.0
*/
pub mod drivers;
pub mod gdt;
pub mod init;
@ -10,7 +16,10 @@ use crate::arch::drivers::allocator;
use bootloader::{entry_point, BootInfo};
use x86_64::{instructions::hlt, VirtAddr};
#[cfg(not(test))]
entry_point![start];
#[cfg(not(test))]
#[no_mangle]
pub fn start(boot_info: &'static BootInfo) -> ! {
let phys_mem_offset = VirtAddr::new(boot_info.physical_memory_offset);

1
ableos/src/boot_conf.rs
View file

@ -52,6 +52,7 @@ impl Default for KernelConfig {
pub struct LoggingConfig {
pub enabled: bool,
pub log_to_serial: bool,
pub log_to_vterm: bool,
pub level: LogLevel,
pub filter: Vec<String>,
}

20
ableos/src/devices/pci/devices.rs Normal file
View file

@ -0,0 +1,20 @@
/*
* Copyright (c) 2022, able <abl3theabove@gmail.com>
*
* SPDX-License-Identifier: MPL-2.0
*/
use super::vendors::Vendor::{self, *};
#[derive(PartialEq, Clone, Eq, Debug)]
pub struct DeviceID {
pub vendor: Vendor,
pub id: u16,
}
impl DeviceID {
pub const fn new(vendor: Vendor, id: u16) -> Self {
Self { vendor, id }
}
}
pub const VMWARE_SVGA2: DeviceID = DeviceID::new(VMware, 0x0405);
pub const S3INC_TRIO64V2: DeviceID = DeviceID::new(S3Inc, 0x8900);

68
ableos/src/devices/pci/enums.rs
View file

@ -1,3 +1,11 @@
/*
* Copyright (c) 2022, able <abl3theabove@gmail.com>
*
* SPDX-License-Identifier: MPL-2.0
*/
use core::fmt::Display;
/// The major class specification for a PCI device.
#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Hash)]
@ -176,3 +184,63 @@ impl From<u16> for PciFullClass {
Self::from_u16(n)
}
}
impl Display for PciFullClass {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, " Class: ")?;
match self {
PciFullClass::Unclassified_NonVgaCompatible => write!(f, "\0LIGHTBLUE\0")?,
PciFullClass::Unclassified_VgaCompatible => write!(f, "\0LIGHTBLUE\0")?,
PciFullClass::MassStorage_ScsiBus => write!(f, "\0CYAN\0")?,
PciFullClass::MassStorage_IDE => write!(f, "\0CYAN\0")?,
PciFullClass::MassStorage_Floppy => write!(f, "\0CYAN\0")?,
PciFullClass::MassStorage_IpiBus => write!(f, "\0CYAN\0")?,
PciFullClass::MassStorage_RAID => write!(f, "\0CYAN\0")?,
PciFullClass::MassStorage_ATA => write!(f, "\0CYAN\0")?,
PciFullClass::MassStorage_SATA => write!(f, "\0CYAN\0")?,
PciFullClass::MassStorage_SerialSCSI => write!(f, "\0CYAN\0")?,
PciFullClass::MassStorage_NVM => write!(f, "\0CYAN\0")?,
PciFullClass::MassStorage_Other => write!(f, "\0CYAN\0")?,
PciFullClass::Network_Ethernet => write!(f, "\0MAGENTA\0")?,
PciFullClass::Network_TokenRing => write!(f, "\0MAGENTA\0")?,
PciFullClass::Network_FDDI => write!(f, "\0MAGENTA\0")?,
PciFullClass::Network_ATM => write!(f, "\0MAGENTA\0")?,
PciFullClass::Network_ISDN => write!(f, "\0MAGENTA\0")?,
PciFullClass::Network_WorldFlip => write!(f, "\0MAGENTA\0")?,
PciFullClass::Network_PICMG => write!(f, "\0MAGENTA\0")?,
PciFullClass::Network_Infiniband => write!(f, "\0MAGENTA\0")?,
PciFullClass::Network_Fabric => write!(f, "\0MAGENTA\0")?,
PciFullClass::Network_Other => write!(f, "\0MAGENTA\0")?,
PciFullClass::Display_VGA => write!(f, "\0YELLOW\0")?,
PciFullClass::Display_XGA => write!(f, "\0YELLOW\0")?,
PciFullClass::Display_3D => write!(f, "\0YELLOW\0")?,
PciFullClass::Display_Other => write!(f, "\0YELLOW\0")?,
PciFullClass::Multimedia_Video => write!(f, "\0LIGHTBLUE\0")?,
PciFullClass::Multimedia_AudioController => write!(f, "\0LIGHTBLUE\0")?,
PciFullClass::Multimedia_Telephony => write!(f, "\0LIGHTBLUE\0")?,
PciFullClass::Multimedia_AudioDevice => write!(f, "\0LIGHTBLUE\0")?,
PciFullClass::Multimedia_Other => write!(f, "\0LIGHTBLUE\0")?,
PciFullClass::Memory_RAM => write!(f, "\0BLUE\0")?,
PciFullClass::Memory_Flash => write!(f, "\0WHITE\0")?,
PciFullClass::Memory_Other => write!(f, "\0LIGHTGREY\0")?,
PciFullClass::Bridge_Host => write!(f, "\0GREEN\0")?,
PciFullClass::Bridge_ISA => write!(f, "\0GREEN\0")?,
PciFullClass::Bridge_EISA => write!(f, "\0GREEN\0")?,
PciFullClass::Bridge_MCA => write!(f, "\0GREEN\0")?,
PciFullClass::Bridge_PciToPci => write!(f, "\0GREEN\0")?,
PciFullClass::Bridge_PCMCIA => write!(f, "\0GREEN\0")?,
PciFullClass::Bridge_NuBus => write!(f, "\0GREEN\0")?,
PciFullClass::Bridge_CardBus => write!(f, "\0GREEN\0")?,
PciFullClass::Bridge_RACEway => write!(f, "\0GREEN\0")?,
PciFullClass::Bridge_PciToPciSemiTransparent => write!(f, "\0GREEN\0")?,
PciFullClass::Bridge_InfinibandToPci => write!(f, "\0GREEN\0")?,
PciFullClass::Bridge_Other => write!(f, "\0GREEN\0")?,
PciFullClass::Unknown => write!(f, "\0RED\0")?,
}
write!(f, "{:?} ({:#06X})\0RESET\0", self, self.as_u16())?;
Ok(())
}
}

35
ableos/src/devices/pci/mod.rs
View file

@ -10,12 +10,17 @@ use core::fmt::{Display, Error, Formatter};
#[macro_use]
extern crate serde;
pub mod devices;
mod enums;
pub mod support;
pub mod vendors;
pub use enums::*;
pub mod port;
use port::*;
use self::devices::DeviceID;
// PciDeviceInfo ///////////////////////////////////////////////////////////////
#[allow(dead_code)]
@ -25,8 +30,7 @@ use port::*;
pub struct PciDeviceInfo {
pub device: u8,
pub bus: u8,
pub device_id: u16,
pub vendor_id: u16,
pub device_id: DeviceID,
pub full_class: PciFullClass,
pub header_type: u8,
pub bars: [u32; 6],
@ -46,18 +50,13 @@ impl PciDeviceInfo {
}
impl Display for PciDeviceInfo {
fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
let vendor_name = name_for_vendor_id(self.vendor_id);
let vendor_name = &self.device_id.vendor;
writeln!(
f,
"Device {:X} | Bus {:X} | Vendor: {}",
"Device {} | Bus {:X} | Vendor: {}",
self.device, self.bus, vendor_name
)?;
writeln!(
f,
" Class: {:?} ({:#06X})",
self.full_class,
self.full_class.as_u16()
)?;
writeln!(f, "{}", self.full_class)?;
writeln!(f, " Header type: {:X}", self.header_type)?;
write!(f, " Supported functions: 0")?;
for (i, b) in self.supported_fns.iter().enumerate().skip(1) {
@ -86,15 +85,6 @@ impl Display for PciDeviceInfo {
// Public functions ////////////////////////////////////////////////////////////
/// Converts a u16 vendor id into a human-readable name.
pub fn name_for_vendor_id(vendor_id: u16) -> String {
match vendor_id {
0x8086 => "Intel Corp. (0x8086)".into(),
0x1234 => "QEMU (0x1234)".into(),
_ => format!("Unknown({:#06X})", vendor_id),
}
}
/// Brute force scans for devices 0-31 on buses 0-255.
pub fn brute_force_scan() -> Vec<PciDeviceInfo> {
let mut infos = Vec::new();
@ -152,8 +142,11 @@ fn check_device(bus: u8, device: u8) -> Option<PciDeviceInfo> {
Some(PciDeviceInfo {
device,
bus,
device_id,
vendor_id,
device_id: DeviceID {
vendor: vendor_id.into(),
id: device_id,
},
// vendor_id,
full_class: pci_class,
header_type,
bars,

15
ableos/src/devices/pci/support.rs Normal file
View file

@ -0,0 +1,15 @@
/*
* Copyright (c) 2022, able <abl3theabove@gmail.com>
*
* SPDX-License-Identifier: MPL-2.0
*/
use super::devices::*;
pub fn check_pci_support(device_id: DeviceID) -> bool {
match device_id {
VMWARE_SVGA2 => true,
S3INC_TRIO64V2 => true,
_ => false,
}
}

68
ableos/src/devices/pci/vendors.rs Normal file
View file

@ -0,0 +1,68 @@
/*
* Copyright (c) 2022, able <abl3theabove@gmail.com>
*
* SPDX-License-Identifier: MPL-2.0
*/
use core::fmt::Display;
#[derive(PartialEq, Debug, Clone, Eq)]
#[repr(u16)]
pub enum Vendor {
Qemu = 0x1234,
VMware = 0x15AD,
VirtIO = 0x1AF4,
Ati = 1002,
Intel = 0x8086,
S3Inc = 0x5333,
Unknown(u16),
}
impl From<u16> for Vendor {
fn from(vendor_id: u16) -> Self {
use Vendor::*;
match vendor_id {
0x15AD => VMware,
0x8086 => Intel,
1002 => Ati,
id => Unknown(id),
}
}
}
impl Into<u16> for Vendor {
fn into(self) -> u16 {
use Vendor::*;
match self {
VMware => 0x15AD,
Ati => 1002,
Qemu => 0x1234,
VirtIO => 0x1AF4,
Intel => 0x8086,
S3Inc => 0x5333,
Unknown(id) => id,
}
}
}
impl Display for Vendor {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
use Vendor::*;
let mut ret: String = match self {
Qemu => "\0PINK\0QEMU (0x1234)".into(),
VirtIO => "\0PINK\0VirtIO (0x1AF4)".into(),
VMware => "\0PINK\0VMWARE (0x15AD)".into(),
S3Inc => "\0YELLOW\0S3 Incorporated (0x5333)".into(),
Intel => "\0BLUE\0Intel Corp. (0x8086)".into(),
Ati => "\0RED\0ATI (0x1002)".into(),
Unknown(id) => format!("\0RED\0Unknown ({:#6})", id),
};
ret.push_str("\0RESET\0");
write!(f, "{}", ret)?;
Ok(())
}
}

21
ableos/src/lib.rs
View file

@ -1,3 +1,9 @@
/*
* Copyright (c) 2022, Able <able@ablecorp.us>
*
* SPDX-License-Identifier: MPL-2.0
*/
//! main library for the AbleOS kernel.
//! exposing all the kernel functionality to the rest of the kernel.
//!
@ -11,6 +17,10 @@
naked_functions,
prelude_import,
)]
#![feature(arbitrary_enum_discriminant)]
#![feature(custom_test_frameworks)]
#![reexport_test_harness_main = "test_main"]
#![test_runner(crate::test_runner)]
#[macro_use]
pub extern crate log;
@ -74,8 +84,8 @@ pub mod ipc;
pub mod panic;
mod unicode_utils;
pub mod vga_e;
// pub mod vgai;
pub mod vterm;
// pub mod vgai;
#[prelude_import]
pub use prelude::rust_2021::*;
@ -94,3 +104,12 @@ pub use scratchpad::*;
pub use utils::*;
pub use virtio::*;
pub use wasm::*;
#[cfg(test)]
pub mod tests;
#[cfg(test)]
pub use tests::test_kernel_main;
#[cfg(test)]
use crate::tests::test_runner;

46
ableos/src/logger.rs
View file

@ -1,3 +1,9 @@
/*
* Copyright (c) 2022, Able <able@ablecorp.us>
*
* SPDX-License-Identifier: MPL-2.0
*/
use crate::{kmain::KERNEL_CONF, time::fetch_time};
use lliw::Fg;
use log::{Level, LevelFilter, Metadata, Record, SetLoggerError};
@ -18,22 +24,13 @@ impl log::Log for SimpleLogger {
use Fg::*;
let color = match record.level() {
log::Level::Error => (Fg::Red, "$RED$"),
log::Level::Warn => (Fg::LightYellow, "$LIGHTYELLOW$"),
log::Level::Info => (Fg::LightWhite, "$LIGHTGRAY$"),
log::Level::Debug => (Fg::Blue, "$BLUE$"),
log::Level::Trace => (Fg::Yellow, "$YELLOW$"),
log::Level::Error => (Fg::Red, "\0RED\0"),
log::Level::Warn => (Fg::LightYellow, "\0LIGHTYELLOW\0"),
log::Level::Info => (Fg::LightWhite, "\0LIGHTGREY\0"),
log::Level::Debug => (Fg::Blue, "\0BLUE\0"),
log::Level::Trace => (Fg::Yellow, "\0YELLOW\0"),
};
/*
let msg = format!(
"[{}{}$RESET$][$GREEN${}$RESET$]{}\n",
color.1,
record.level(),
time_float,
record.args()
);
*/
let mod_path = match record.module_path() {
Some(p) => {
if KERNEL_CONF.logging.filter.contains(&p.to_string()) {
@ -50,16 +47,31 @@ impl log::Log for SimpleLogger {
None => 0,
};
if KERNEL_CONF.logging.log_to_vterm {
let msg = format!(
// "[{}{}$RESET$][$GREEN${}$RESET$]{}\n",
"[{}{:05}\0RESET\0][\0GREEN\0{}\0RESET\0][\0BLUE\0{}@{}\0RESET\0] {}",
color.1,
record.level(),
time_float,
mod_path,
line,
record.args(),
);
println!("{msg}");
}
if KERNEL_CONF.logging.log_to_serial {
serial_println!(
"[{}{:05}{}][{}{}{}][{}{}@{}{}] {}",
color.0,
record.level(),
Fg::Reset,
Fg::Green,
Reset,
Green,
time_float,
Reset,
Fg::Blue,
Blue,
mod_path,
line,
Reset,

8
ableos/src/panic.rs
View file

@ -1,8 +1,14 @@
/*
* Copyright (c) 2022, able <abl3theabove@gmail.com>
*
* SPDX-License-Identifier: MPL-2.0
*/
use core::panic::PanicInfo;
use log::error;
use crate::arch::interrupts::{bsod, BSODSource};
#[cfg(not(test))]
#[panic_handler]
fn panic_handler(info: &PanicInfo) -> ! {
error!("{:?}", info);

46
ableos/src/scratchpad.rs
View file

@ -1,8 +1,15 @@
/*
* Copyright (c) 2022, Able <able@ablecorp.us>
*
* SPDX-License-Identifier: MPL-2.0
*/
use crate::arch::drivers::sysinfo::master;
use crate::arch::interrupts::{reset_pit_for_cpu, set_pit_2};
use crate::image::mono_bitmap::bruh;
use crate::devices::pci::brute_force_scan;
use crate::systeminfo::{KERNEL_VERSION, RELEASE_TYPE};
use crate::time::fetch_time;
use crate::KERNEL_STATE;
use crate::{
arch::shutdown, filesystem::FILE_SYSTEM, rhai_shell::KEYBUFF, vterm::VTerm,
wasm_jumploader::run_program,
@ -64,16 +71,18 @@ pub fn scratchpad() {
// bruh();
// panic!(":>");
println!("\0RED\0OHNO\0RESET\0");
// for c in 0..144_697 {
// trace!("{:?}", char::from_u32(c));
// }
// bruh();
for x in brute_force_scan() {
println!("{}", x);
}
disable();
let tick_time = fetch_time();
let hostname = &KERNEL_STATE.lock().hostname;
let allocator = ALLOCATOR.lock();
let size = allocator.size();
@ -84,7 +93,7 @@ pub fn scratchpad() {
println!(
"{}
,-------. OS: \0BLUE\0AbleOS\0RESET\0
,'\\ _ _`. Host: None
,'\\ _ _`. Host: \0PINK\0{}\0RESET\0
/ \\)_)-)_)-\\ Kernel: \0RED\0AKern-{}-v{}\0RESET\0
: : Uptime: \0GREEN\0{}\0RESET\0
\\ / Packages: None
@ -98,6 +107,7 @@ pub fn scratchpad() {
// include_str!("../assets/balloon.txt"),
// kstate.hostname,
BANNER_WIDTH,
hostname,
RELEASE_TYPE,
KERNEL_VERSION,
tick_time,
@ -193,6 +203,21 @@ pub fn command_parser(user: String, command: String) {
let bin_name = iter.next().unwrap();
let mut strin = String::new();
for stri in iter {
trace!("{}", stri);
strin.push_str(stri);
}
let conf_args;
match clparse::Arguments::parse_from_string(strin) {
Ok(ok) => conf_args = ok,
Err(err) => {
println!("ERROR: {}", err);
error!("{}", err);
return;
}
};
match bin_name {
// note: able asked for rhaish to stay in the repo but will be removed
// in the future so just comment it out for now
@ -206,9 +231,12 @@ pub fn command_parser(user: String, command: String) {
}
}
"echo" => {
echo_file(iter.next().unwrap().to_string(), fs);
}
"echo" => match conf_args.1.arguments.get("p") {
Some(path) => echo_file(path.to_string(), fs),
None => println!("No path provided"),
},
"test" => {}
"quit" => shutdown(),
@ -241,8 +269,8 @@ pub fn command_parser(user: String, command: String) {
let mut binary = vec![];
file.read_to_end(&mut binary).unwrap();
let args = iter.collect::<Vec<&str>>();
println!("{:?}", args);
// let args = iter.collect::<Vec<&str>>();
// println!("{:?}", args);
run_program(&binary);
}
}

70
ableos/src/tests/mod.rs Normal file
View file

@ -0,0 +1,70 @@
/*
* Copyright (c) 2022, able <abl3theabove@gmail.com>
*
* SPDX-License-Identifier: MPL-2.0
*/
use core::panic::PanicInfo;
use kernel::arch::arch::sloop;
pub trait Testable {
fn run(&self) -> ();
}
impl<T> Testable for T
where
T: Fn(),
{
fn run(&self) {
serial_print!("{}...\t", core::any::type_name::<T>());
self();
serial_println!("[ok]");
}
}
pub fn test_runner(tests: &[&dyn Testable]) {
serial_println!("Running {} tests", tests.len());
for test in tests {
test.run();
}
exit_qemu(QemuExitCode::Success);
}
pub fn test_panic_handler(info: &PanicInfo) -> ! {
serial_println!("[failed]\n");
serial_println!("Error: {}\n", info);
exit_qemu(QemuExitCode::Failed);
}
#[panic_handler]
fn panic(info: &PanicInfo) -> ! {
test_panic_handler(info);
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u32)]
pub enum QemuExitCode {
Success = 0x10,
Failed = 0x11,
}
pub fn exit_qemu(exit_code: QemuExitCode) -> ! {
use x86_64::instructions::port::Port;
unsafe {
let mut port = Port::new(0xf4);
port.write(exit_code as u32);
}
loop {}
}
entry_point!(test_kernel_main);
/// Entry point for `cargo test`
pub fn test_kernel_main(boot_info: &'static BootInfo) -> ! {
// init(boot_info.physical_memory_offset);
test_main();
loop {}
}
use bootloader::{entry_point, BootInfo};
use crate::test_main;

6
ableos/src/tests.rs → ableos/src/tests/old_tests.rs
View file

@ -1,3 +1,9 @@
/*
* Copyright (c) 2022, able <abl3theabove@gmail.com>
*
* SPDX-License-Identifier: MPL-2.0
*/
use crate::{
kmain::KERNEL_CONF,
network::socket::{SimpleSock, Socket, SocketReturns},

13
repbuild/src/main.rs
View file

@ -1,5 +1,6 @@
/*
* Copyright (c) 2022, Umut İnan Erdoğan <umutinanerdogan@pm.me>
* Copyright (c) 2022, able <abl3theabove@gmail.com>
*
* SPDX-License-Identifier: MPL-2.0
*/
@ -18,6 +19,8 @@ enum Subcommand {
Help,
Run,
Empty,
/// Run all tests for all architectures
Test,
Unknown(String),
}
@ -27,6 +30,7 @@ impl Subcommand {
"doc" => Subcommand::Doc,
"help" => Subcommand::Help,
"run" => Subcommand::Run,
"test" => Subcommand::Test,
"" => Subcommand::Empty,
unknown => Subcommand::Unknown(unknown.to_string()),
}
@ -44,6 +48,15 @@ fn main() {
let options = options();
match options.subcommand {
Subcommand::Test => {
Command::new("cargo")
.args(["test", "--target=json_targets/x86_64-ableos.json"])
.current_dir(fs::canonicalize("./ableos").unwrap())
.status()
.unwrap();
// panic!("Test Infrastructure missing");
}
Subcommand::Doc => {
let machine_text = options
.arguments