low-level-programming/rust_experiments/src/lib.rs

#![feature(no_std, lang_items, const_fn)]
#![no_std]

extern crate rlibc;

#[no_mangle]
pub extern fn rust_main() {
    clear();
    checkerboard(vga_buffer::Color::Red);

    loop {}
}

fn clear() {
    use vga_buffer::*;

    let blank_color = ColorCode::new( Color::White, Color::Black);
    for i in 0..BUFFER_WIDTH {
        for j in 0..BUFFER_HEIGHT {
            write_to_coord(i, j, b' ', blank_color);
        }
    }
}

fn checkerboard(color: vga_buffer::Color) {
    use vga_buffer::*;

    let active = ColorCode::new(color, color);
    let blank = ColorCode::new(Color::White, Color::Black);
    for i in 0..BUFFER_WIDTH {
        for j in 0..BUFFER_HEIGHT {
            if (i + j) % 2 == 0 {
                write_to_coord(i, j, b' ', active);
            } else {
                write_to_coord(i, j, b' ', blank);
            }
        }
    }
}

mod vga_buffer {
    #[repr(u8)]
    #[derive(Clone, Copy)]
    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(Clone, Copy)]
    pub struct ColorCode(u8);
    impl ColorCode {
        pub const fn new(foreground: Color, background: Color) -> ColorCode {
            ColorCode((background as u8) << 4 | (foreground as u8))
        }
    }

    #[repr(C)]
    struct ScreenChar {
        ascii_char: u8,
        color_code: ColorCode
    }

    pub const BUFFER_HEIGHT: usize = 25;
    pub const BUFFER_WIDTH: usize = 80;
    const BUFFER_PTR: usize = 0xb8000;

    pub fn charloop() {
        for ch in 32..255 {
            let ptr = BUFFER_PTR + 2*ch as usize;
            let data = ScreenChar {
                ascii_char: ch,
                color_code: ColorCode::new(Color::Black, Color::White)
            };

            unsafe {
                *(ptr as *mut _) = data;
            }
        }
    }

    pub fn write_to_coord(x: usize, y: usize, character: u8, color_code: ColorCode) {
        let ptr = BUFFER_PTR + (2*x as usize) + (BUFFER_WIDTH*2*y as usize);
        let data = ScreenChar {
            ascii_char: character,
            color_code: color_code,
        };

        if x > BUFFER_WIDTH || y > BUFFER_HEIGHT {
            return;
        }

        unsafe {
            *(ptr as *mut _) = data;
        }
    }
}

#[lang = "eh_personality"]
extern fn eh_personality() {}

#[lang = "panic_fmt"]
extern fn panic_fmt() -> ! { loop {}}