463 lines
9.9 KiB
C
463 lines
9.9 KiB
C
#ifndef COLORS_H
|
|
#define COLORS_H
|
|
|
|
#include "types.h"
|
|
#include <stdarg.h>
|
|
#include <stddef.h>
|
|
|
|
#define VGA_WIDTH 80
|
|
#define VGA_HEIGHT 25
|
|
|
|
#define VGA_MEMORY_ADDRESS 0xB8000
|
|
|
|
/*
|
|
* FOR INPUT
|
|
*/
|
|
|
|
#define KEYBOARD_BUFFER_SIZE 256
|
|
|
|
static char _keyboard_buffer[KEYBOARD_BUFFER_SIZE];
|
|
static uint16_t _kb_head = 0;
|
|
static uint16_t _kb_tail = 0;
|
|
|
|
/* IN VGA - Video Memory Arrya:
|
|
* short
|
|
* 1s byte (left most) -> TEXT COLOR
|
|
* 2s byte -> BACK COLOR
|
|
* 3rd and 4rt byte -> TEXT (unsigned char) AKA CodePoint
|
|
*/
|
|
|
|
typedef struct __attribute__((packed)) _VGA {
|
|
unsigned char codepoint; // 3rd and 4th byte
|
|
unsigned char color; // 1st byte: text color, 2nd byte: background color
|
|
// LAST BIT IS BLINKING FLAG
|
|
} _VGA;
|
|
|
|
typedef enum _VGA_COLOR {
|
|
BLACK = 0x0,
|
|
BLUE = 0x1,
|
|
GREEN = 0x2,
|
|
CYAN = 0x3,
|
|
RED = 0x4,
|
|
MAGENTA = 0x5,
|
|
BROWN = 0x6,
|
|
LIGHT_GREY = 0x7,
|
|
DARK_GREY = 0x8,
|
|
LIGHT_BLUE = 0x9,
|
|
LIGHT_GREEN = 0xA,
|
|
LIGHT_CYAN = 0xB,
|
|
LIGHT_RED = 0xC,
|
|
LIGHT_MAGENTA = 0xD,
|
|
YELLOW = 0xE,
|
|
WHITE = 0xF
|
|
} _VGA_COLOR;
|
|
|
|
typedef struct _VGA_screen_space {
|
|
unsigned int line;
|
|
unsigned int column;
|
|
|
|
} _VGA_screen_space;
|
|
|
|
static _VGA_screen_space cursor_pos = {0, 0};
|
|
static _VGA_screen_space text_pos = {0, 0};
|
|
|
|
static unsigned int tab_pos = 0;
|
|
|
|
#define DEFAULT_BG BLUE
|
|
#define DEFAULT_FG WHITE
|
|
|
|
/*
|
|
* END OF DECLARATIONS
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
* START OF OUTPUT FUNCTIONS
|
|
*/
|
|
|
|
int printf(const char *fmt, ...);
|
|
|
|
// Convert _VGA_COLOR to color byte
|
|
static inline unsigned char __vga_color_byte(_VGA_COLOR fg, _VGA_COLOR bg, int blink) {
|
|
unsigned char color = (bg << 4) | fg;
|
|
if (blink) {
|
|
color |= 0x80; // Set the blinking BIT
|
|
// to the highest bit
|
|
}
|
|
return color;
|
|
}
|
|
|
|
// Get pointer to VGA memory
|
|
static inline volatile _VGA *__vga_memory() {
|
|
return (volatile _VGA *)VGA_MEMORY_ADDRESS;
|
|
}
|
|
|
|
static inline void __clear_screen() {
|
|
volatile _VGA *vga = __vga_memory();
|
|
for (int i = 0; i < VGA_WIDTH * VGA_HEIGHT; i++) {
|
|
vga[i].codepoint = ' ';
|
|
vga[i].color = __vga_color_byte(DEFAULT_FG, DEFAULT_BG, 0);
|
|
}
|
|
}
|
|
|
|
static inline void __clear_screen_colored(_VGA_COLOR background) {
|
|
volatile _VGA *vga = __vga_memory();
|
|
for (int i = 0; i < VGA_WIDTH * VGA_HEIGHT; i++) {
|
|
vga[i].codepoint = ' ';
|
|
vga[i].color = __vga_color_byte(WHITE, background, 0);
|
|
}
|
|
}
|
|
|
|
static inline int __put_char_VGA_POS(_VGA _c, _VGA_screen_space _position, int _blink) {
|
|
if (_position.line > VGA_HEIGHT || _position.column > VGA_WIDTH)
|
|
return 0;
|
|
|
|
volatile _VGA *vga = __vga_memory();
|
|
|
|
if (_c.codepoint == '\n') {
|
|
text_pos.line++;
|
|
text_pos.column = 0;
|
|
return 1;
|
|
}
|
|
|
|
if (_c.codepoint == '\t') {
|
|
int spaces = 4 - (_position.column % 4);
|
|
if (spaces == 0)
|
|
spaces = 4;
|
|
|
|
int written = 0;
|
|
while (spaces--) {
|
|
if (_position.column >= VGA_WIDTH) {
|
|
_position.column = 0;
|
|
_position.line++;
|
|
if (_position.line >= VGA_HEIGHT) {
|
|
// TODO: scroll or wrap
|
|
break;
|
|
}
|
|
}
|
|
|
|
vga[(_position.line * VGA_WIDTH) + _position.column].codepoint = ' ';
|
|
vga[(_position.line * VGA_WIDTH) + _position.column].color = _c.color;
|
|
_position.column++;
|
|
written++;
|
|
}
|
|
|
|
text_pos.line = _position.line;
|
|
text_pos.column = _position.column;
|
|
|
|
return written;
|
|
}
|
|
|
|
vga[(_position.line * VGA_WIDTH) + _position.column].codepoint = _c.codepoint;
|
|
vga[(_position.line * VGA_WIDTH) + _position.column].color = _c.color;
|
|
|
|
return 1;
|
|
}
|
|
|
|
static inline int __put_char(int column, int line, unsigned codepoint, _VGA_COLOR foreground, _VGA_COLOR background, int _blink) {
|
|
_VGA __temp_vga;
|
|
__temp_vga.color = __vga_color_byte(foreground, background, _blink);
|
|
__temp_vga.codepoint = codepoint;
|
|
|
|
_VGA_screen_space __temp_vga_space;
|
|
__temp_vga_space.column = column;
|
|
__temp_vga_space.line = line;
|
|
|
|
return __put_char_VGA_POS(__temp_vga, __temp_vga_space, _blink);
|
|
}
|
|
|
|
static inline int __put_string(int column, int line, const char *__args, _VGA_COLOR foreground, _VGA_COLOR background, int _blink) {
|
|
unsigned long _counter = 0;
|
|
|
|
while (*__args != '\0') {
|
|
|
|
if (column >= VGA_WIDTH) {
|
|
column = 0;
|
|
line++;
|
|
|
|
if (line >= VGA_HEIGHT) {
|
|
// TODO: SCROLL OR LOOP...
|
|
}
|
|
}
|
|
|
|
_counter += __put_char(column++, line, *__args++, foreground, background, _blink);
|
|
}
|
|
|
|
return _counter;
|
|
}
|
|
|
|
static inline int __print_string(const char *__args, _VGA_COLOR foreground, _VGA_COLOR background, int _blink) {
|
|
unsigned long _counter = 0;
|
|
|
|
while (*__args != '\0') {
|
|
|
|
if (text_pos.column >= VGA_WIDTH) {
|
|
text_pos.column = 0;
|
|
text_pos.line++;
|
|
|
|
if (text_pos.line >= VGA_HEIGHT) {
|
|
// TODO: SCROLL OR LOOP...
|
|
}
|
|
}
|
|
|
|
_counter += __put_char(text_pos.column++, text_pos.line, *__args++, foreground, background, _blink);
|
|
}
|
|
|
|
return _counter;
|
|
}
|
|
|
|
// TODO: Implement later on the (argc, ...) to allow for stuff like printf("%d", number);
|
|
static inline int printf_s(const char *args) {
|
|
// by defeault we dont blink lol
|
|
return __print_string(args, DEFAULT_FG, DEFAULT_BG, 0);
|
|
}
|
|
|
|
static int __printf_internal(const char *fmt, va_list args) {
|
|
int count = 0;
|
|
|
|
while (*fmt) {
|
|
if (*fmt != '%') {
|
|
__put_char(text_pos.column++, text_pos.line, *fmt++, DEFAULT_FG, DEFAULT_BG, 0);
|
|
count++;
|
|
continue;
|
|
}
|
|
|
|
fmt++; // skip %
|
|
|
|
switch (*fmt) {
|
|
case 'c': {
|
|
char c = (char)va_arg(args, int);
|
|
__put_char(text_pos.column++, text_pos.line, c, DEFAULT_FG, DEFAULT_BG, 0);
|
|
count++;
|
|
break;
|
|
}
|
|
|
|
case 's': {
|
|
const char *s = va_arg(args, const char *);
|
|
count += __print_string(s, DEFAULT_FG, DEFAULT_BG, 0);
|
|
break;
|
|
}
|
|
|
|
case 'd': {
|
|
int n = va_arg(args, int);
|
|
char buf[32];
|
|
count += __print_string(itoa(n, buf), DEFAULT_FG, DEFAULT_BG, 0);
|
|
break;
|
|
}
|
|
|
|
case 'u': {
|
|
unsigned n = va_arg(args, unsigned);
|
|
char buf[32];
|
|
count += __print_string(utoa(n, buf), DEFAULT_FG, DEFAULT_BG, 0);
|
|
break;
|
|
}
|
|
|
|
case 'o': {
|
|
unsigned n = va_arg(args, unsigned);
|
|
char buf[32];
|
|
count += __print_string(otoa(n, buf), DEFAULT_FG, DEFAULT_BG, 0);
|
|
break;
|
|
}
|
|
|
|
case 'x': {
|
|
unsigned n = va_arg(args, unsigned);
|
|
char buf[32];
|
|
count += __print_string(__utoa(n, buf, 16), DEFAULT_FG, DEFAULT_BG, 0);
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* TODO: Enable floating point support later
|
|
* This requires enabling FPU in the kernel
|
|
case 'f': {
|
|
double f = va_arg(args, double);
|
|
char buf[64];
|
|
count += __print_string(ftoa(f, buf), DEFAULT_FG, DEFAULT_BG, 0);
|
|
break;
|
|
}
|
|
*/
|
|
|
|
case '%': {
|
|
__put_char(text_pos.column++, text_pos.line, '%', DEFAULT_FG, DEFAULT_BG, 0);
|
|
count++;
|
|
break;
|
|
}
|
|
|
|
default:
|
|
__put_char(text_pos.column++, text_pos.line, *fmt, DEFAULT_FG, DEFAULT_BG, 0);
|
|
count++;
|
|
break;
|
|
}
|
|
|
|
fmt++;
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
int printf(const char *fmt, ...) {
|
|
va_list args;
|
|
va_start(args, fmt);
|
|
int result = __printf_internal(fmt, args);
|
|
va_end(args);
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* END OF OUTPUT FUNCTIONS
|
|
*/
|
|
|
|
|
|
|
|
|
|
/*
|
|
* START OF INPUT FUNCTIONS
|
|
*/
|
|
|
|
static inline void outb(unsigned short port, unsigned char val) {
|
|
__asm__ volatile ("outb %0, %1" : : "a"(val), "Nd"(port));
|
|
}
|
|
|
|
static inline void __VGA_set_cursor_internal(unsigned int column, unsigned int line) {
|
|
if (column >= VGA_WIDTH) column = VGA_WIDTH - 1;
|
|
if (line >= VGA_HEIGHT) line = VGA_HEIGHT - 1;
|
|
|
|
unsigned short pos = line * VGA_WIDTH + column;
|
|
|
|
// Send high byte
|
|
outb(0x3D4, 0x0E);
|
|
outb(0x3D5, (pos >> 8) & 0xFF);
|
|
|
|
// Send low byte
|
|
outb(0x3D4, 0x0F);
|
|
outb(0x3D5, pos & 0xFF);
|
|
|
|
cursor_pos.column = column;
|
|
cursor_pos.line = line;
|
|
|
|
text_pos.column = column;
|
|
text_pos.line = line;
|
|
}
|
|
|
|
static void __VGA_set_cursor_VGA_pos(_VGA_screen_space pos) {
|
|
__VGA_set_cursor_internal(pos.column, pos.line);
|
|
}
|
|
|
|
static _VGA_screen_space get_cursor_pos() {
|
|
_VGA_screen_space __temp = {cursor_pos.column, cursor_pos.line};
|
|
return __temp;
|
|
}
|
|
|
|
void scursor(unsigned int column, unsigned int line) {
|
|
__VGA_set_cursor_internal(column, line);
|
|
}
|
|
|
|
static inline void __keyboard_buffer_push(char __c) {
|
|
_keyboard_buffer[_kb_head] = __c;
|
|
_kb_head = (_kb_head + 1) % KEYBOARD_BUFFER_SIZE;
|
|
}
|
|
|
|
static inline char __keyboard_buffer_pop() {
|
|
if (_kb_tail == _kb_head) {
|
|
return '\0';
|
|
}
|
|
|
|
char __c = _keyboard_buffer[_kb_tail];
|
|
_kb_tail = (_kb_tail + 1) % KEYBOARD_BUFFER_SIZE;
|
|
return __c;
|
|
}
|
|
|
|
static inline char __gets_internal(char *buffer, size_t max_length) {
|
|
size_t index = 0;
|
|
char __c;
|
|
|
|
while (index < max_length - 1) {
|
|
__c = __keyboard_buffer_pop();
|
|
if (__c == '\0') {
|
|
continue;
|
|
}
|
|
|
|
if (__c == '\n' || __c == '\r') {
|
|
buffer[index] = '\0';
|
|
break;
|
|
}
|
|
|
|
buffer[index++] = __c;
|
|
}
|
|
|
|
buffer[index] = '\0';
|
|
return index;
|
|
}
|
|
|
|
void gets(char *buffer, size_t max_length) {
|
|
__gets_internal(buffer, max_length);
|
|
}
|
|
|
|
static inline int __scanf_internal(const char *fmt, va_list args) {
|
|
|
|
char buffer[256];
|
|
__gets_internal(buffer, sizeof(buffer));
|
|
|
|
const char* p = fmt;
|
|
char* in = buffer;
|
|
|
|
int count = 0;
|
|
|
|
while (*p) {
|
|
if (*p == '%') {
|
|
p++;
|
|
|
|
if (*p == 'd') {
|
|
int* out = va_arg(args, int*);
|
|
int sign = 1;
|
|
int value = 0;
|
|
|
|
if (*in == '-') { sign = -1; in++; }
|
|
|
|
while (*in >= '0' && *in <= '9') {
|
|
value = value * 10 + (*in - '0');
|
|
in++;
|
|
}
|
|
|
|
*out = value * sign;
|
|
count++;
|
|
}
|
|
|
|
else if (*p == 's') {
|
|
char* out = va_arg(args, char*);
|
|
while (*in == ' ') in++; // skip spaces
|
|
while (*in && *in != ' ') {
|
|
*out++ = *in++;
|
|
}
|
|
*out = '\0';
|
|
count++;
|
|
}
|
|
|
|
else if (*p == 'c') {
|
|
char* out = va_arg(args, char*);
|
|
*out = *in++;
|
|
count++;
|
|
}
|
|
}
|
|
|
|
p++;
|
|
}
|
|
|
|
va_end(args);
|
|
|
|
return count;
|
|
}
|
|
|
|
int scanf(const char *fmt, ...) {
|
|
va_list args;
|
|
va_start(args, fmt);
|
|
int result = __scanf_internal(fmt, args);
|
|
va_end(args);
|
|
return result;
|
|
}
|
|
|
|
|
|
|
|
#endif
|