From f6384015d62e30379e449b8abfd3d643097f7c28 Mon Sep 17 00:00:00 2001
From: Jack Halford <jack@crans.org>
Date: Thu, 15 Feb 2018 11:09:27 +0100
Subject: [PATCH] starting to convert vga buffer to a terminal

---
 kernel-rs/src/vga/buffer.rs | 43 ++++++++++++++++++++++++++++---------
 1 file changed, 33 insertions(+), 10 deletions(-)

diff --git a/kernel-rs/src/vga/buffer.rs b/kernel-rs/src/vga/buffer.rs
index d5491b1d..c8aa0643 100644
--- a/kernel-rs/src/vga/buffer.rs
+++ b/kernel-rs/src/vga/buffer.rs
@@ -41,48 +41,70 @@ const BUFFER_ROWS: usize = 25;
 const BUFFER_COLS: usize = 80 * 2;
 
 pub struct Writer {
-    pub position: usize,
+    pub buffer_pos: usize,
     pub color_code: ColorCode,
     buffer: [u8; BUFFER_ROWS * BUFFER_COLS],
+    command: [u8; 10],
+    command_len: usize,
 }
 
 impl Writer {
     pub const fn new() -> Writer {
         Writer {
-            position: 0,
+            buffer_pos: 0,
             color_code: ColorCode::new(Color::White, Color::Black),
             buffer: [0; BUFFER_ROWS * BUFFER_COLS],
+            command: [0; 10],
+            command_len: 0,
         }
     }
 
     pub fn keypress(&mut self, ascii: u8) {
-        self.write_byte(ascii);
+        match ascii {
+            b'\n' => {
+                self.command_len = 0;
+                self.write_byte(b'\n');
+                println!("{:?}", self.command.iter());
+                self.write_byte(b'>');
+            }
+            byte => {
+                if self.command_len >= 10 { return };
+
+                self.write_byte(byte);
+                self.command_len += 1;
+            }
+        }
         self.flush();
     }
 
     pub fn write_byte(&mut self, byte: u8) {
-        let i = self.position;
+        let i = self.buffer_pos;
 
         match byte {
 
             b'\n' => {
-                let current_line = self.position / (BUFFER_COLS);
-                self.position = (current_line + 1) * BUFFER_COLS;
+                let current_line = self.buffer_pos / (BUFFER_COLS);
+                self.buffer_pos = (current_line + 1) * BUFFER_COLS;
             }
             byte => {
                 self.buffer[i] = byte;
                 self.buffer[i + 1] = self.color_code.0;
-                self.position += 2;
+                self.buffer_pos += 2;
             }
         }
 
-        if self.position >= self.buffer.len() {
+        if self.buffer_pos >= self.buffer.len() {
             self.scroll();
         }
+    }
 
-        let cursor_position = self.position / 2;
+    fn flush_cursor(&self)
+    {
+        let cursor_position = self.buffer_pos / 2;
+        // 14 awaits the rightmost 8bits
         cpuio::outb(14, 0x3D4);
         cpuio::outb((cursor_position >> 8) as u8, 0x3D5);
+        // 15 awaits the leftmost 8bits
         cpuio::outb(15, 0x3D4);
         cpuio::outb((cursor_position >> 0) as u8 & 0x00ff, 0x3D5);
     }
@@ -90,6 +112,7 @@ impl Writer {
     pub fn flush(&mut self) {
         let slice = unsafe { core::slice::from_raw_parts_mut(0xb8000 as *mut u8, 4000) };
         slice.as_mut().clone_from_slice(&self.buffer);
+        self.flush_cursor();
     }
 
     fn scroll(&mut self) {
@@ -106,7 +129,7 @@ impl Writer {
             self.buffer[((BUFFER_ROWS - 1) * BUFFER_COLS) + (col * 2)] = b' ';
         }
 
-        self.position = (BUFFER_ROWS - 1) * BUFFER_COLS;
+        self.buffer_pos = (BUFFER_ROWS - 1) * BUFFER_COLS;
     }
 }