VGA Text Mode (ja)

[giscus[bot]]

VGA Text Mode (ja)

VGAテキストモードは画面にテキストを出力するシンプルな方法です。この記事では、すべてのunsafeな要素を別のモジュールにカプセル化することで、それを安全かつシンプルに扱えるようにするインターフェースを作ります。また、Rustのフォーマッティングマクロのサポートも実装します。

https://os.phil-opp.com/ja/vga-text-mode/

[Hosiery2326]

If it isn't "println!("{}", info);" then wouldn't it be "println!("{}", _info);"?

[seal]

An underscore before a variable is a way of telling the compiler that even if the variable is un-used to throw no warning.

fn foo() -> Result<Foo, ()> {
    Ok(Foo)
}

fn main() {
    let x = foo();  // warning: unused variable: `x`
    let _x = foo(); // no warning
    println!("1");
} // x and _x are dropped here

As we are using the info variable in the println there's no need to put an underscore before it.

[Hosiery2326]

I learned a lot, thank you very much.

[yalikes]

in my environment(rust nightly 1.67), implement Formatting Macros by implement fmt::Write didn't work. rustc compliant that "method write_fmt not found for this struct" and suggest me to add "use core::fmt::Write;". After I do that, the code compiles.

[yalikes]

sorry, I didn't notice that you have a use core::fmt::Write statement.

[Orkiin]

I was wondering if the new_line method could be refactored to use iterators instead. I managed to do it for clear_row
(i don't know how to format it so it's shown as a code snipet)
impl Writer {
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);
}
}
}
here we are iterating over all the columns in a specific row so instead we can use
self.buffer.chars[row].iter()
but we want to change it so instead we need to use
self.buffer.chars[row].iter_mut()
then we map all values to write(blank)
but because iterators are lazy and we need to consume them i managed it in the following way
for _ in self.buffer.chars[row].iter_mut().map(|x| (*x).write(blank) ) {}
i know is ugly but currently i don't know how to do it with collect() or another consuming method.

But every thing I have tried with new_line to make something similar ends up with an error because i can't zip a mutable iterator without encapsulating it and if i put the mutable iterator then zip it with an immutable one the borrow checker will tell me I can't do that.

[seal]

You can format using ``` ( three backticks before and after the code )
e.g.

( And you get the colored syntax by adding "rs" , or "go" etc on the line with the backtics

impl Writer {
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);
}
}
}

[Orkiin]

I wanted to reply but ended making a new comment.

[Orkiin]

Thanks what i meant is that I wrote clear_row like this

fn clear_row(&mut self, row: usize) {
        let blank = ScreenChar {
            ascii_character: b' ',
            color_code: self.color_code,
        };
        for _ in self.buffer.chars[row].iter_mut().map(|x| (*x).write(blank)) {}
    }

and I wanted to do something similar for new_line and came up with something like this

fn new_line(&mut self) {
        for (row, next_row) in self.buffer.chars.iter_mut().zip(self.buffer.chars.iter().next) {
            for _ in row.iter_mut().zip(next_row.iter()).map(|(x, y)| {
                let character = y.read();
                (*x).write(character);
            }) {}
        }
        self.clear_row(BUFFER_HEIGHT - 1);
        self.column_position = 0;
    }

but i get the next error

error[E0502]: cannot borrow `self.buffer.chars` as immutable because it is also borrowed as mutable
  --> src/vga_buffer.rs:90:65
   |
90 |         for (row, next_row) in self.buffer.chars.iter_mut().zip(self.buffer.chars.iter().next){
   |                                ---------------------------- --- ^^^^^^^^^^^^^^^^^^^^^^^^ immutable borrow occurs here
   |                                |                            |
   |                                |                            mutable borrow later used by call
   |                                mutable borrow occurs here

For more information about this error, try `rustc --explain E0502`.

[bjorn3]

You can use self.buffer.chars.windows(2) or self.buffer.chars.array_windows::<[_; 2]>() I think.

[T-O-R-U-S]

In my opinion, a println! macro that implicitly locks the Writer should not be implemented; I think the user explicitly locking the Writer instead of implicitly doing it will go a long way to protect against deadlocks; it also lines up with Rust's idea of explicit being better than implicit.

[dreamerlzl]

I believe an update for the $crate variable would be helpful.
Update