Introducing the hottest library crate in town (libk!)

libk/src/io/ascii.rs

@@ -0,0 +1,210 @@
+use core::fmt;
+use spin::{Lazy, Mutex};
+use x86_64::instructions::interrupts;
+
+pub use super::framebuffer::screensize_px;
+use super::framebuffer::{Color, FRAMEBUFFER_WRITER};
+
+mod font;
+use font::FONT;
+
+static FONT_WIDTH: u32 = 8;
+static FONT_HEIGHT: u32 = 16;
+
+pub static WRITER: Lazy<Mutex<Writer>> = Lazy::new(|| Mutex::new(Writer::new()));
+
+pub fn screensize_chars() -> (u32, u32) {
+    let writer = WRITER.lock();
+    (writer.screen_width, writer.screen_height)
+}
+
+pub struct Writer {
+    /// Measured in chars not pixels.
+    screen_width: u32,
+    /// Measured in chars not pixels.
+    screen_height: u32,
+    /// 16 pixels tall.
+    text_line: u32,
+    /// 8 pixels wide.
+    text_col: u32,
+
+    fg_color: Color,
+    bg_color: Color,
+
+    offset1: usize,
+    offset2: usize,
+}
+
+impl Writer {
+    pub fn new() -> Self {
+        if let Some(writer) = FRAMEBUFFER_WRITER.lock().as_mut() {
+            Self {
+                screen_width: writer.width() as u32 / 8,
+                screen_height: writer.height() as u32 / 16,
+                text_line: 0,
+                text_col: 0,
+                fg_color: Color::White,
+                bg_color: Color::Black,
+                offset1: 16,
+                offset2: 0,
+            }
+        } else {
+            panic!("Framebuffer writer not initialized");
+        }
+    }
+
+    pub fn write_char(&mut self, c: u16) {
+        if c as u8 == b'\n' {
+            self.newline();
+            return;
+        }
+
+        // get the character data from the font array. -- each byte is a row of pixels
+        let data: &[u8] = &FONT[c as usize * 16..(c as usize + 1) * 16];
+
+        if let Some(writer) = FRAMEBUFFER_WRITER.lock().as_mut() {
+            for row in 0..16 {
+                let line: u8 = data[row];
+                for col in 0..8 {
+                    let pixel_x: u32 = self.text_col * FONT_WIDTH + col;
+                    let pixel_y: u32 = self.text_line * FONT_HEIGHT + row as u32;
+
+                    if line & (0x80 >> col) != 0 {
+                        // write the foreground color
+                        writer.write_pixel(pixel_x as usize, pixel_y as usize, self.fg_color);
+                    } else {
+                        // write the background color
+                        writer.write_pixel(pixel_x as usize, pixel_y as usize, self.bg_color);
+                    }
+                }
+            }
+        }
+
+        // go to next position
+        if self.text_col + 1 >= self.screen_width {
+            self.newline();
+        } else {
+            self.text_col += 1;
+        }
+    }
+
+    pub fn set_offset(&mut self, offset1: usize, offset2: usize) {
+        self.offset1 = offset1;
+        self.offset2 = offset2;
+    }
+
+    pub fn dimensions(&self) -> (u32, u32) {
+        (self.screen_width, self.screen_height)
+    }
+
+    pub fn next_char(&mut self) {
+        self.text_col += 1;
+    }
+
+    pub fn newline(&mut self) {
+        self.text_col = 0;
+
+        if self.text_line + 1 >= self.screen_height {
+            self.text_line = 0;
+        } else {
+            self.text_line += 1;
+        }
+    }
+
+    pub fn write_string(&mut self, s: &str) {
+        for c in s.chars() {
+            self.write_char(c as u16);
+        }
+    }
+
+    pub fn set_colour(&mut self, fg: Color, bg: Color) {
+        self.fg_color = fg;
+        self.bg_color = bg;
+    }
+
+    pub fn reset_colour(&mut self) {
+        self.fg_color = Color::White;
+        self.bg_color = Color::Black;
+    }
+}
+
+impl core::fmt::Write for Writer {
+    fn write_str(&mut self, s: &str) -> core::fmt::Result {
+        self.write_string(s);
+        Ok(())
+    }
+}
+
+fn write(args: fmt::Arguments, fg: Color, bg: Color) {
+    use core::fmt::Write;
+
+    interrupts::without_interrupts(|| {
+        let mut writer = WRITER.lock();
+        writer.set_colour(fg, bg);
+        writer.write_fmt(args).unwrap();
+        writer.reset_colour();
+    });
+}
+
+pub fn _print(args: fmt::Arguments) {
+    x86_64::instructions::interrupts::without_interrupts(|| {
+        write(args, Color::White, Color::Black);
+    })
+}
+
+pub fn _print_err(args: fmt::Arguments) {
+    x86_64::instructions::interrupts::without_interrupts(|| {
+        write(args, Color::Red, Color::Black);
+    })
+}
+
+pub fn _print_log(args: fmt::Arguments) {
+    x86_64::instructions::interrupts::without_interrupts(|| {
+        write(args, Color::Yellow, Color::Black);
+    })
+}
+
+pub fn clear_screen() {
+    interrupts::without_interrupts(|| {
+        let mut writer = WRITER.lock();
+        writer.text_line = 0;
+        writer.text_col = 0;
+
+        if let Some(writer) = FRAMEBUFFER_WRITER.lock().as_mut() {
+            writer.clear();
+        }
+    });
+}
+
+#[macro_export]
+macro_rules! println_log {
+	() => ($crate::print_log!("\n"));
+	($($arg:tt)*) => ($crate::print_log!("{}\n", format_args!($($arg)*)));
+}
+
+#[macro_export]
+macro_rules! print_log {
+	($($arg:tt)*) => ($crate::io::ascii::_print_log(format_args!($($arg)*)));
+}
+
+#[macro_export]
+macro_rules! println {
+	() => ($crate::print!("\n"));
+	($($arg:tt)*) => ($crate::print!("{}\n", format_args!($($arg)*)));
+}
+
+#[macro_export]
+macro_rules! print {
+	($($arg:tt)*) => ($crate::io::ascii::_print(format_args!($($arg)*)));
+}
+
+#[macro_export]
+macro_rules! printlnerr {
+    () => ($crate::printerr!("\n"));
+    ($($arg:tt)*) => ($crate::printerr!("{}\n", format_args!($($arg)*)));
+}
+
+#[macro_export]
+macro_rules! printerr {
+    ($($arg:tt)*) => ($crate::_print_err(format_args!($($arg)*)));
+}