1
#[allow(dead_code)]
2
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3
#[repr(u8)]
4
pub enum Color {
5
    Black = 0,
6
    Blue = 1,
7
    Green = 2,
8
    Cyan = 3,
9
    Red = 4,
10
    Magenta = 5,
11
    Brown = 6,
12
    LightGray = 7,
13
    DarkGray = 8,
14
    LightBlue = 9,
15
    LightGreen = 10,
16
    LightCyan = 11,
17
    LightRed = 12,
18
    Pink = 13,
19
    Yellow = 14,
20
    White = 15,
21
}

1
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2
#[repr(transparent)]
3
struct ColorCode(u8);
4

5
impl ColorCode {
6
    fn new(foreground: Color, background: Color) -> ColorCode {
7
        ColorCode((background as u8) << 4 | (foreground as u8))
8
    }
9
}

1
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2
#[repr(C)]
3
struct ScreenChar {
4
    ascii_character: u8,
5
    color_code: ColorCode,
6
}
7

8
const BUFFER_HEIGHT: usize = 25;
9
const BUFFER_WIDTH: usize = 80;
10

11
#[repr(transparent)]
12
struct Buffer {
13
    chars: [[ScreenChar; BUFFER_WIDTH]; BUFFER_HEIGHT],
14
}

1
pub struct Writer {
2
    column_position: usize,
3
    color_code: ColorCode,
4
    buffer: &'static mut Buffer,
5
}

1
impl Writer {
2
    pub fn write_byte(&mut self, byte: u8) {
3
        match byte {
4
            b'\n' => self.new_line(),
5
            byte => {
6
                if self.column_position >= BUFFER_WIDTH {
7
                    self.new_line();
8
                }
9

10
                let row = BUFFER_HEIGHT - 1;
11
                let col = self.column_position;
12

13
                let color_code = self.color_code;
14
                self.buffer.chars[row][col] = ScreenChar {
15
                    ascii_character: byte,
16
                    color_code,
17
                };
18
                self.column_position += 1;
19
            }
20
        }
21
    }
22

23
    fn new_line(&mut self) {/* TODO */}
24
}

1
impl Writer {
2
    pub fn write_string(&mut self, s: &str) {
3
        for byte in s.bytes() {
4
            match byte {
5
                // 若属于可打印的ASCII字符或换行符，则打印
6
                0x20..=0x7e | b'\n' => self.write_byte(byte),
7
                // 若不属于可打印的ASCII字符，则打印0xfe
8
                _ => self.write_byte(0xfe),
9
            }
10

11
        }
12
    }
13
}

1
[dependencies]
2
volatile = "0.2.6"

1
use volatile::Volatile;
2

3
struct Buffer {
4
    chars: [[Volatile<ScreenChar>; BUFFER_WIDTH]; BUFFER_HEIGHT],
5
}

1
impl Writer {
2
    pub fn write_byte(&mut self, byte: u8) {
3
        match byte {
4
            b'\n' => self.new_line(),
5
            byte => {
6
                ...
7

8
                self.buffer.chars[row][col].write(ScreenChar {
9
                    ascii_character: byte,
10
                    color_code,
11
                });
12
                ...
13
            }
14
        }
15
    }
16
    ...
17
}

1
use core::fmt;
2

3
impl fmt::Write for Writer {
4
    fn write_str(&mut self, s: &str) -> fmt::Result {
5
        self.write_string(s);
6
        Ok(())
7
    }
8
}

1
pub fn print_something() {
2
    use core::fmt::Write;
3
    let mut writer = Writer {
4
        column_position: 0,
5
        color_code: ColorCode::new(Color::Yellow, Color::Black),
6
        buffer: unsafe { &mut *(0xb8000 as *mut Buffer) },
7
    };
8

9
    writer.write_byte(b'H');
10
    writer.write_string("ello! ");
11
    write!(writer, "The numbers are {} and {}", 42, 1.0/3.0).unwrap();
12
}

1
impl Writer {
2
    fn new_line(&mut self) {
3
        for row in 1..BUFFER_HEIGHT {
4
            for col in 0..BUFFER_WIDTH {
5
                let character = self.buffer.chars[row][col].read();
6
                self.buffer.chars[row - 1][col].write(character);
7
            }
8
        }
9
        self.clear_row(BUFFER_HEIGHT - 1);
10
        self.column_position = 0;
11
    }
12

13
    fn clear_row(&mut self, row: usize) {/* TODO */}
14
}

1
impl Writer {
2
    fn clear_row(&mut self, row: usize) {
3
        let blank = ScreenChar {
4
            ascii_character: b' ',
5
            color_code: self.color_code,
6
        };
7
        for col in 0..BUFFER_WIDTH {
8
            self.buffer.chars[row][col].write(blank);
9
        }
10
    }
11
}

1
[dependencies.lazy_static]
2
version = "1.0"
3
features = ["spin_no_std"]

1
use lazy_static::lazy_static;
2

3
lazy_static! {
4
    pub static ref WRITER: Writer = Writer {
5
        column_position: 0,
6
        color_code: ColorCode::new(Color::Yellow, Color::Black),
7
        buffer: unsafe { &mut *(0xb8000 as *mut Buffer) },
8
    };
9
}

1
[dependencies]
2
spin = "0.5.2"

1
use spin::Mutex;
2
...
3
lazy_static! {
4
    pub static ref WRITER: Mutex<Writer> = Mutex::new(Writer {
5
        column_position: 0,
6
        color_code: ColorCode::new(Color::Yellow, Color::Black),
7
        buffer: unsafe { &mut *(0xb8000 as *mut Buffer) },
8
    });
9
}

1
#[no_mangle]
2
pub extern "C" fn _start() -> ! {
3
    use core::fmt::Write;
4
    vga_buffer::WRITER.lock().write_str("Hello again").unwrap();
5
    write!(vga_buffer::WRITER.lock(), ", some numbers: {} {}", 42, 1.337).unwrap();
6

7
    loop {}
8
}

1
#[macro_export]
2
macro_rules! println {
3
    () => (print!("\n"));
4
    ($($arg:tt)*) => (print!("{}\n", format_args!($($arg)*)));
5
}

1
#[macro_export]
2
macro_rules! print {
3
    ($($arg:tt)*) => ($crate::io::_print(format_args!($($arg)*)));
4
}

1
#[macro_export]
2
macro_rules! print {
3
    ($($arg:tt)*) => ($crate::vga_buffer::_print(format_args!($($arg)*)));
4
}
5

6
#[macro_export]
7
macro_rules! println {
8
    () => ($crate::print!("\n"));
9
    ($($arg:tt)*) => ($crate::print!("{}\n", format_args!($($arg)*)));
10
}
11

12
#[doc(hidden)]
13
pub fn _print(args: fmt::Arguments) {
14
    use core::fmt::Write;
15
    WRITER.lock().write_fmt(args).unwrap();
16
}

1
#[no_mangle]
2
pub extern "C" fn _start() {
3
    println!("Hello World{}", "!");
4

5
    loop {}
6
}

1
/// 函数在panic时被调用
2
#[panic_handler]
3
fn panic(info: &PanicInfo) -> ! {
4
    println!("{}", info);
5
    loop {}
6
}