christoph/lecture-operating-system-development
1
Fork 0
Code Activity

removed old obsolete code

Browse Source
This commit is contained in:
Christoph Urlacher
2022-07-19 15:01:52 +02:00
parent 2f47dc8f94
commit 11cd85ca18
4 changed files with 0 additions and 196 deletions
Download Patch File Download Diff File Expand all files Collapse all files

95
c_os/devices/BufferedCGA.cc
View File

@ -1,95 +0,0 @@
#include "BufferedCGA.h"
#include "kernel/Globals.h"
// Can't initialize in constructor as memory management already needs working CGA for output
// NOTE: This has to be called when memorymanagement is active
void BufferedCGA::init(unsigned int pages) {
this->scrollback_buffer = std::make_unique<ScrollbackBuffer>(ROWS, pages); // No delete since it's only off when shutting the os down
this->screen_buffer = std::make_unique<CGA::cga_page_t>();
if (this->scrollback_buffer == NULL || this->screen_buffer == NULL) {
log << ERROR << "Error initializing scrollback buffer" << endl;
return;
}
this->initialized = true;
log << INFO << "Initialized scrollback buffer" << endl;
}
void BufferedCGA::display_scrollback() {
if (this->initialized) {
if (this->scrollback == 0) {
// Use pagebuffer
mmem::memcpy<CGA::cga_page_t>((CGA::cga_page_t*)CGA_START, this->screen_buffer.get());
} else {
// Use scrollback
this->scrollback_buffer->get((CGA::cga_line_t*)CGA_START, this->scrollback - 1);
}
} else {
log << DEBUG << "ScrollbackBuffer not initialized" << endl;
}
}
void BufferedCGA::print(char* string, int n, unsigned char attrib) {
if (this->scrollback != 0) {
// Display newest content from buffer when new prints happen
this->scrollback = 0;
this->display_scrollback();
}
CGA::print(string, n, attrib);
}
void BufferedCGA::scrollup() {
if (this->initialized) {
this->scrollback_buffer->put((CGA::cga_line_t*)CGA_START);
} else {
log << DEBUG << "ScrollbackBuffer not initialized" << endl;
}
CGA::scrollup();
}
void BufferedCGA::clear() {
CGA::clear();
this->scrollback = 0;
if (this->initialized) {
this->scrollback_buffer->clear();
mmem::zero<CGA::cga_page_t>(this->screen_buffer.get());
} else {
log << DEBUG << "ScrollbackBuffer not initialized" << endl;
}
}
void BufferedCGA::scroll_page_backward() {
if (this->initialized) {
// If this is the first scrollback we have to save the current screen content
if (this->scrollback == 0) {
mmem::memcpy<CGA::cga_page_t>(this->screen_buffer.get(), (CGA::cga_page_t*)CGA_START);
}
// current_page can be equal to scrollback_buffer->pages
// as we have a separate pagebuffer for the current screen content
if (this->scrollback < this->scrollback_buffer->pages) {
this->scrollback = this->scrollback + 1;
}
this->display_scrollback();
} else {
log << DEBUG << "ScrollbackBuffer not initialized" << endl;
}
}
void BufferedCGA::scroll_page_forward() {
if (this->initialized) {
if (this->scrollback > 0) {
this->scrollback = this->scrollback - 1;
}
this->display_scrollback();
} else {
log << DEBUG << "ScrollbackBuffer not initialized" << endl;
}
}

37
c_os/devices/BufferedCGA.h
View File

@ -1,37 +0,0 @@
#ifndef __BUFFEREDCGA_INCLUDE_H_
#define __BUFFEREDCGA_INCLUDE_H_
#include "devices/CGA.h"
#include "devices/Keyboard.h"
#include "user/lib/Logger.h"
#include "user/ScrollbackBuffer.h"
#include <memory>
// NOTE: I added this file, I will probably replace this in the end by an application
class BufferedCGA : public CGA {
private:
std::unique_ptr<ScrollbackBuffer> scrollback_buffer; // Contains previous pages
std::unique_ptr<CGA::cga_page_t> screen_buffer; // Contains the current page separately from the scrollback.
bool initialized; // Don't do ScrollbackBuffer actions if not initialized
// TODO: Just check if pointers have value
BufferedCGA(const BufferedCGA&) = delete;
Logger log;
public:
BufferedCGA() : initialized(false), scrollback(0), log("BufferedCGA") {}
unsigned char scrollback; // The page that is displayed, public to enable page display
void init(unsigned int pages); // Scrollback needs to be initialized after memorymanagement
void display_scrollback(); // Write the current_page to CGA memory
void scroll_page_backward(); // Scroll up the page history
void scroll_page_forward(); // Scroll down the page history (to the current page)
void print(char* string, int n, unsigned char attrib = STD_ATTR) override;
void scrollup() override;
void clear() override;
};
#endif

33
c_os/user/ScrollbackBuffer.cc
View File

@ -1,33 +0,0 @@
#include "user/ScrollbackBuffer.h"
// NOTE: I added this file
void ScrollbackBuffer::put(CGA::cga_line_t* line) {
CGA::cga_line_t* destination = (CGA::cga_line_t*)this->buffer.get() + this->pos;
mmem::memcpy<CGA::cga_line_t>(destination, line);
this->pos = (this->pos + 1) % this->rows;
}
void ScrollbackBuffer::get(CGA::cga_line_t* destination, unsigned char page) const {
if (page < 0 || page >= this->pages) {
return;
}
// We reverse the pagenumber so page 0 is always the newest page
unsigned char rpage = this->pages - page - 1;
// Copy linewise because page may wrap around buffer borders
unsigned int wrapline;
for (unsigned int line = 0; line < (this->rows / this->pages); ++line) {
wrapline = (this->pos + rpage * (this->rows / this->pages) + line) % this->rows;
mmem::memcpy<CGA::cga_line_t>(destination + line, (CGA::cga_line_t*)this->buffer.get() + wrapline);
}
}
void ScrollbackBuffer::clear() {
for (unsigned char page = 0; page < this->pages; ++page) {
mmem::zero<CGA::cga_page_t>(this->buffer.get() + page);
}
this->pos = 0;
}

31
c_os/user/ScrollbackBuffer.h
View File

@ -1,31 +0,0 @@
#ifndef __SCROLLBACKBUFFER_INCLUDE_H_
#define __SCROLLBACKBUFFER_INCLUDE_H_
#include "devices/CGA.h"
#include "user/lib/MyLib.h"
#include <memory>
#include <stddef.h>
class ScrollbackBuffer {
private:
std::unique_ptr<CGA::cga_page_t[]> buffer; // Circular buffer to store lines that left the screen
unsigned int pos; // Buffer write position
ScrollbackBuffer(const ScrollbackBuffer&) = delete;
public:
const unsigned int pages; // Number of pages in buffer
const unsigned int rows; // Number of lines in buffer
ScrollbackBuffer(unsigned char rows, unsigned char pages)
: pos(0), pages(pages), rows(rows * pages) {
this->buffer = std::make_unique<CGA::cga_page_t[]>(pages); // Allocate with new because it's quite large (and I want to use the allocator)
this->clear(); // Null out the buffer so no crap gets displayed
}
void put(CGA::cga_line_t* line);
void get(CGA::cga_line_t* destination, unsigned char page) const;
void clear();
};
#endif