added print! and println! macro

Author: acetim

.cargo/config.toml

@@ -4,3 +4,6 @@ build-std-features = ["compiler-builtins-mem"]
 build-std = ["core", "compiler_builtins"]
 [build]
 target = "x86_64-ShabbOS.json"
+
+[target.'cfg(target_os="none")']
+runner = "bootimage runner"

Cargo.lock

@@ -10,7 +10,11 @@ panic = "abort"
 
 [dependencies]
 bootloader = "0.9"
-
+volatile = "0.2.6"
+spin = "0.5.2"
+[dependencies.lazy_static]
+version = "1.0"
+features = ["spin_no_std"]
 [[bin]]
 name ="ShabbOS"
 test = false

Cargo.toml

@@ -0,0 +1,18 @@
+
+use core::fmt;
+
+
+#[macro_export]
+macro_rules! println {
+    () => ($crate::print!("\n"));
+    ($($arg:tt)*) => ($crate::print!("{}\n", format_args!($($arg)*)));
+}
+#[macro_export]
+macro_rules! print{
+    ($($arg:tt)*)=> ($crate::macros::print(format_args!($($arg)*)))
+}
+
+pub fn print(args: fmt::Arguments) {
+    use core::fmt::Write;
+    crate::vga_buffer::WRITER.lock().write_fmt(args).unwrap();
+}

src/macros.rs

@@ -2,21 +2,19 @@
 #![no_std]
 #![no_main]
 
+mod vga_buffer;
+mod macros;
+
 use core::panic::PanicInfo;
 
 
 
-static hello: &[u8] = b"hello world";
+
 
 #[unsafe(no_mangle)]
 pub extern "C" fn _start()->!{
-    let vga_buffer = 0xb8000 as *mut u8;
-    for(i,&byte) in hello.iter().enumerate(){
-        unsafe {
-            *vga_buffer.offset(i as isize *2) = byte;//char
-            *vga_buffer.offset(i as isize *2+1) = 0xb;//color
-        }
-    }
+    println!("hello number {}",3);
+
     loop{}
 }
 

src/main.rs

@@ -0,0 +1,119 @@
+
+use volatile::Volatile;
+use core::fmt;
+use spin::Mutex;
+use lazy_static::lazy_static;
+const BUFFER_WIDTH:usize = 80;
+const BUFFER_HEIGHT:usize = 25;
+const VGA_BUFFER_ADDR:u64 = 0xb8000;
+#[derive(Debug,Clone,Copy,PartialEq,Eq)]
+#[repr(u8)]
+
+pub enum Color{
+    Black = 0,
+    Blue=1,
+    Green=2,
+    Cyan=3,
+    Red=4,
+    Magenta=5,
+    Brown=6,
+    LightGray=7,
+    DarkGray=8,
+    LightBlue=9,
+    LightGreen=10,
+    LightCyan=11,
+    LightRed=12,
+    Pink=13,
+    Yellow=14,
+    White=15,
+}
+
+#[derive(Debug,Clone,Copy,PartialEq,Eq)]
+#[repr(transparent)]
+struct ColorCode(u8);
+impl ColorCode{
+    pub fn new(foreground:Color, background : Color)-> ColorCode{
+        ColorCode((foreground as u8) | (background as u8) <<4)
+    }
+}
+
+
+
+#[derive(Debug,Clone,Copy,PartialEq,Eq)]
+#[repr(C)]
+struct ScreenChar{
+    ascii_character:u8,
+    color_code:ColorCode,
+}
+
+#[repr(transparent)]
+struct Buffer{
+    chars:[[Volatile<ScreenChar>;BUFFER_WIDTH];BUFFER_HEIGHT],
+}
+
+pub struct Writer {
+    column_position:usize,
+    color_code:ColorCode,
+    buffer: &'static mut Buffer,
+}
+impl Writer{
+    fn write_byte(&mut self,byte:u8){
+        match byte{
+            b'\n'=>{self.new_line()}
+            byte=>{
+                if(self.column_position >=BUFFER_WIDTH){
+                    self.new_line();
+                }
+                let row=BUFFER_HEIGHT-1;
+                let col = self.column_position;
+                self.buffer.chars[row][col].write(ScreenChar{
+                    ascii_character:byte,
+                    color_code:self.color_code,
+                    });
+                self.column_position+=1;
+            }
+        }
+    }
+    fn write_string(&mut self,string:&str){
+        for byte in string.bytes(){
+            match byte{
+                0x20..=0x7e | b'\n'=> self.write_byte(byte),
+                _=>self.write_byte(0xfe)//blank square
+            }
+        }
+    }
+    fn new_line(&mut self){
+        for row in 1..BUFFER_HEIGHT{
+            for col in 0..BUFFER_WIDTH{
+                let char = self.buffer.chars[row][col].read();
+                self.buffer.chars[row-1][col].write(char);
+            }
+        }
+        self.clear_row(BUFFER_HEIGHT-1);
+        self.column_position = 0;
+    }
+    fn clear_row(&mut self,row: usize){
+        let blank = ScreenChar{
+            ascii_character:b' ',
+            color_code:self.color_code
+        };
+        for col in 0..BUFFER_WIDTH{
+            self.buffer.chars[row][col].write(blank);
+        }
+    }
+}
+
+impl fmt::Write for Writer{
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        self.write_string(s);
+        Ok(())
+    }
+}
+
+lazy_static! {
+    pub static ref WRITER:Mutex<Writer> = Mutex::new(Writer{
+        column_position:0,
+        color_code:ColorCode::new(Color::LightCyan,Color::Black),
+        buffer:unsafe{&mut *(0xb8000 as *mut Buffer)}
+    });
+}