LowLevelDevs/Zxq5-OS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

idk

Browse Source 
idk
This commit is contained in:
FantasyPvP
2023-09-30 12:10:03 +01:00
parent 0c72895f66
commit 9e7335e05f
11 changed files with 94 additions and 109 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/system/kernel/render.rs
+1 -1
View File
@@ -81,7 +81,7 @@ lazy_static! {
buffer: unsafe { &mut *(0xb8000 as *mut Buffer) },
userspace: BufferSwap {
chars: [[ScreenChar {
character: 179u8,
character: 178u8,
colour: ColorCode::new(Color::White, Color::Black),
}; BUFFER_WIDTH]; BUFFER_HEIGHT]
},
src/system/kernel/tasks/keyboard.rs
-20
View File
@@ -20,26 +20,6 @@ static WAKER: AtomicWaker = AtomicWaker::new();
static SCANCODE_QUEUE: OnceCell<ArrayQueue<u8>> = OnceCell::uninit();
/*
pub async fn print_keypresses() {
let mut scancodes = ScanCodeStream::new();
let mut keyboard = Keyboard::new(layouts::Uk105Key, ScancodeSet1, HandleControl::Ignore);
while let Some(scancode) = scancodes.next().await {
if let Ok(Some(key_event)) = keyboard.add_byte(scancode) {
if let Some(key) = keyboard.process_keyevent(key_event) {
match key {
DecodedKey::Unicode(character) => {
let mut cmd = CMD.lock();
cmd.input(character).await;
}
DecodedKey::RawKey(key) => print!("{:?}", key),
}
}
}
}
}
*/
lazy_static! {
pub static ref KEYBOARD: Mutex<KeyboardHandler> = Mutex::new(KeyboardHandler::new());
}
src/system/std/io.rs
+39 -38
View File
@@ -11,40 +11,55 @@ pub use crate::{print, println, serial_print, serial_println};
use lazy_static::lazy_static;
use spin::Mutex;
pub async fn stdin() -> String {
let string = KEYBOARD.lock().get_string().await;
string
}
pub struct Stdin {}
impl Stdin {
pub async fn readline() -> String {
let string = KEYBOARD.lock().get_string().await;
string
}
pub async fn stdchar() -> char {
let chr = KEYBOARD.lock().get_keystroke().await;
chr
}
pub fn text_mode() {
RENDERER.lock().text_mode().unwrap();
}
pub fn sandbox_mode() {
RENDERER.lock().sandbox_mode().unwrap();
}
pub fn switch_mode() {
if RENDERER.lock().sandbox == true {
RENDERER.lock().text_mode().unwrap();
} else {
RENDERER.lock().sandbox_mode().unwrap();
pub async fn keystroke() -> char {
let chr = KEYBOARD.lock().get_keystroke().await;
chr
}
}
pub fn clear() {
RENDERER.lock().clear();
pub struct Screen {}
impl Screen {
pub fn terminal_mode() {
RENDERER.lock().text_mode().unwrap();
}
pub fn application_mode() {
RENDERER.lock().sandbox_mode().unwrap();
}
pub fn switch() {
if RENDERER.lock().sandbox == true {
RENDERER.lock().text_mode().unwrap();
} else {
RENDERER.lock().sandbox_mode().unwrap();
}
}
pub fn clear() {
RENDERER.lock().clear();
}
}
/// TODO: get a working implementation for CLI apps
/// elements can be created using their from_str() method
/// you can then render the element to the current frame using the render() method
/// the position of the element by passing a tuple (x,y) to render()
///
/// nothing will appear on the screen until the frame is actually rendered by
/// the render_frame method on the renderer
///
pub type Frame = [ [ char; BUFFER_WIDTH ]; BUFFER_HEIGHT];
#[derive(Clone)]
@@ -53,13 +68,6 @@ pub struct Element {
dimensions: (u8, u8)
}
/// elements can be created using their from_str() method
/// you can then render the element to the current frame using the render() method
/// the position of the element by passing a tuple (x,y) to render()
///
/// nothing will appear on the screen until the frame is actually rendered by
/// the render_frame method on the renderer
impl Element {
pub fn from_str(elemstr: String) -> Self {
let mut element = Element { frame: Vec::<Vec<char>>::new(), dimensions: (0, 0) };
@@ -143,8 +151,6 @@ impl core::fmt::Display for FrameGen {
#[macro_export]
macro_rules! println_log {
() => ($crate::print_log!("/n"));
@@ -156,7 +162,6 @@ macro_rules! print_log {
($($arg:tt)*) => ($crate::std::io::_log(format_args!($($arg)*)));
}
#[macro_export]
macro_rules! println {
() => ($crate::print!("/n"));
@@ -170,7 +175,6 @@ macro_rules! print {
pub use crate::kernel::render::Color;
#[doc(hidden)]
pub fn _print(args: core::fmt::Arguments) {
use core::fmt::Write;
@@ -203,9 +207,6 @@ pub fn write(args: core::fmt::Arguments, cols: (Color, Color)) {
crate::kernel::render::write(args, cols);
}
pub fn mkfs() {
use crate::kernel::fs;
fs::mkfs();
src/user/bin/calc/calc.rs
+1 -1
View File
@@ -380,7 +380,7 @@ impl Application for Calculator {
if args.len() == 0 {
loop {
print!("enter equation > ");
let inp = std::io::stdin().await;
let inp = std::io::Stdin::readline().await;
println!("{}", inp);
if inp == String::from("exit\n") {
return Ok(());
src/user/bin/crystal_rpg/init.rs
+2 -2
View File
@@ -31,7 +31,7 @@ impl Application for GameLoop {
}
async fn run(&mut self, _args: Vec<String>) -> Result<(), Error> {
let mut username: String = io::stdin().await;
let mut username: String = io::Stdin::readline().await;
username = username.trim().to_string();
let mut player = Player::new(username);
@@ -101,7 +101,7 @@ impl Application for GameLoop {
loop {
println!("{}", io::stdchar().await)
println!("{}", io::Stdin::keystroke().await)
}
Ok(())
src/user/bin/crystalfetch.rs
+3 -5
View File
@@ -2,7 +2,7 @@ use async_trait::async_trait;
use alloc::{boxed::Box, format, string::String, vec::Vec};
use log::info;
use crate::{std::os::OS, std::io::{Color, write, clear}, println, std::application::{
use crate::{std::os::OS, std::io::{Color, write, Screen}, println, std::application::{
Application,
Error,
}, std};
@@ -39,7 +39,6 @@ pub struct CrystalFetch {}
#[async_trait]
impl Application for CrystalFetch {
fn new() -> Self {
Self {}
}
@@ -49,7 +48,7 @@ impl Application for CrystalFetch {
let os = OS.lock().os.clone();
let version = OS.lock().version.clone();
clear();
Screen::clear();
let logo_string = CRYSTAL_LOGO;
let info_string = format!(
@@ -59,15 +58,14 @@ impl Application for CrystalFetch {
[ Github » https://github.com/FantasyPvP/CrystalOS-Restructured
[ Author » FantasyPvP / ZXQ5", os, version);
// write to output
let spacer = "\n".repeat(24 - logo_string.lines().count() - 4 - info_string.lines().count());
// write values to console
write(format_args!("{}", logo_string), (Color::Cyan, Color::Black));
println!("\n\n");
println!("{}", info_string);
println!("{}", spacer);
Ok(())
}
src/user/bin/mod.rs
+1
View File
@@ -6,3 +6,4 @@ pub mod shell;
//pub mod shellrewrite;
pub mod tasks;
mod gigachad_detector;
mod shellrewrite;
src/user/bin/shell.rs
+6 -6
View File
@@ -14,7 +14,7 @@ use crate::{
std::application::{Application, Error},
user::bin::*,
};
use crate::std::io::{Color, write};
use crate::std::io::{Color, write, Screen};
use crate::user::bin::gigachad_detector::GigachadDetector;
lazy_static! {
@@ -41,7 +41,7 @@ pub async fn eventloop() {
CMD.lock().prompt();
loop {
let string = crate::std::io::stdin().await;
let string = crate::std::io::Stdin::readline().await;
CMD.lock().current.push_str(&string);
match exec().await {
Ok(_) => {
@@ -112,9 +112,9 @@ async fn exec() -> Result<(), Error> {
}
"clear" => {
interrupts::without_interrupts(|| {
crate::std::io::clear();
});
Screen::clear();
// not sure why this code was here but leaving it in case weird bugs happen so i remember to add it back if so
//interrupts::without_interrupts(|| {});
}
"print" => {
@@ -123,7 +123,7 @@ async fn exec() -> Result<(), Error> {
println!("{}", x);
}
"switch" => {
crate::std::io::switch_mode();
Screen::switch();
}
"gigachad?" => {
let mut gigachad_detector = GigachadDetector::new();
src/user/bin/shellrewrite.rs
+27 -36
View File
@@ -13,7 +13,7 @@ use alloc::{
use crate::{
kernel::tasks::{executor::Executor, Task},
std::application::{Application, Error},
std::io::{print, println, stdin},
std::io::{print, println, Stdin, Screen},
user::bin::*,
};
@@ -30,33 +30,40 @@ use super::*;
// - chained execution ( multiple commands linked together) eg: '5 + 5 | echo' which calculates
// the result of 5 + 5 and then sends the result to an echo command which prints it to console
/// initialises a global tasks struct, this can be accessed from anywhere in the program;
lazy_static! {
pub static ref TASKS: Mutex<Vec<Task>> = Mutex::new(Vec::new());
}
/// starts the shell
/// this function should be directly called by main.rs or by an init system
pub fn init_sh(args: Option<Vec<String>>) -> Result<(), String> {
fn new_function() {
}
pub fn userspace() -> Result<(), String> {
let mut executor = Executor::new();
loop {
executor.spawn(Task::new(next()));
let tasks = TASKS.lock();
while tasks.len() > 0 {
let next = tasks[0].clone();
tasks.remove(0);
executor.spawn(next);
}
drop(tasks);
executor.try_run();
}
//
// executor.spawn(Task::new(new_function()));
// loop {
// executor.try_run()
// }
Ok(())
}
// struct Shell {}
//
// impl Application for Shell {
// fn new() -> Shell {
// Shell {}
// }
// async fn run(&mut self, _: Vec<String>) -> Result<(), Error> {
// Ok(())
// }
// }
fn parse_args(command: String) -> Result<(String, Vec<String>), String> {
let mut args: Vec<String> = Vec::new();
@@ -83,19 +90,3 @@ fn parse_args(command: String) -> Result<(String, Vec<String>), String> {
// Ok(Vec::<String::new()>)
//}
async fn next() {
let command: String = stdin();
let parsed = match parse_args(command) {
Ok(x) => x,
Err(e) => {
println!("Error Parsing Command: Invalid Syntax")
}
};
// tokens will eventually be parsed here
/*
- PARSER
- this will allow the use of more complex commands later down the line
*/
TASKS.lock().push(Task::new(parsed));
}