SoraOS/stdio.h

#ifndef COLORS_H
#define COLORS_H

#include "types.h"
#include <stdarg.h>
#include <stddef.h>
#include <stdint.h>

#define VGA_WIDTH 80
#define VGA_HEIGHT 25

#define VGA_MEMORY_ADDRESS 0xB8000

/*
 * FOR INPUT
 */

#define KEYBOARD_BUFFER_SIZE 256

#define SCANCODE_LSHIFT 0x2A
#define SCANCODE_RSHIFT 0x36
#define SCANCODE_CAPSLOCK 0x3A
#define RELEASE_MASK 0x80

static volatile unsigned char _keyboard_buffer[KEYBOARD_BUFFER_SIZE];
static volatile uint16_t _kb_head = 0;
static volatile uint16_t _kb_tail = 0;

static char __g_shift_pressed = 0;
static char __g_caps_lock_active = 0;

// C99 Designated Initializers for Unshifted ASCII Characters
static const char scancode_ascii_unshifted[128] = {
	[0x01] = 27, // ESC
	[0x02] = '1',  [0x03] = '2',  [0x04] = '3', [0x05] = '4', [0x06] = '5', [0x07] = '6', [0x08] = '7', [0x09] = '8', [0x0A] = '9', [0x0B] = '0', [0x0C] = '-',
	[0x0D] = '=',  [0x0E] = '\b', // Backspace
	[0x0F] = '\t',				  // Tab
	[0x10] = 'q',  [0x11] = 'w',  [0x12] = 'e', [0x13] = 'r', [0x14] = 't', [0x15] = 'y', [0x16] = 'u', [0x17] = 'i', [0x18] = 'o', [0x19] = 'p', [0x1A] = '[',
	[0x1B] = ']',  [0x1C] = '\n', // Enter
	[0x1E] = 'a',  [0x1F] = 's',  [0x20] = 'd', [0x21] = 'f', [0x22] = 'g', [0x23] = 'h', [0x24] = 'j', [0x25] = 'k', [0x26] = 'l', [0x27] = ';', [0x28] = '\'',
	[0x29] = '`',  [0x2C] = 'z',  [0x2D] = 'x', [0x2E] = 'c', [0x2F] = 'v', [0x30] = 'b', [0x31] = 'n', [0x32] = 'm', [0x33] = ',', [0x34] = '.', [0x35] = '/',
	[0x39] = ' ' // Spacebar
};

// C99 Designated Initializers for Shifted ASCII Characters
static const char scancode_ascii_shifted[128] = {
	[0x01] = 27, // ESC
	[0x02] = '!', [0x03] = '@', [0x04] = '#',  [0x05] = '$',  [0x06] = '%', [0x07] = '^', [0x08] = '&',	 [0x09] = '*', [0x0A] = '(', [0x0B] = ')',
	[0x0C] = '_', [0x0D] = '+', [0x0E] = '\b', [0x0F] = '\t', [0x10] = 'Q', [0x11] = 'W', [0x12] = 'E',	 [0x13] = 'R', [0x14] = 'T', [0x15] = 'Y',
	[0x16] = 'U', [0x17] = 'I', [0x18] = 'O',  [0x19] = 'P',  [0x1A] = '{', [0x1B] = '}', [0x1C] = '\n', [0x1E] = 'A', [0x1F] = 'S', [0x20] = 'D',
	[0x21] = 'F', [0x22] = 'G', [0x23] = 'H',  [0x24] = 'J',  [0x25] = 'K', [0x26] = 'L', [0x27] = ':',	 [0x28] = '"', [0x29] = '~', [0x2C] = 'Z',
	[0x2D] = 'X', [0x2E] = 'C', [0x2F] = 'V',  [0x30] = 'B',  [0x31] = 'N', [0x32] = 'M', [0x33] = '<',	 [0x34] = '>', [0x35] = '?', [0x39] = ' '};

/* 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 __convert_ascii(uint8_t __scancode) {
	unsigned char __code = __scancode & ~RELEASE_MASK;
	if (__scancode & 0x80) {
		// Key-released
		if (__code == SCANCODE_LSHIFT || __code == SCANCODE_RSHIFT) {
			__g_shift_pressed = 0;
		}
		return '\0';
	}

	if (__code == SCANCODE_LSHIFT || __code == SCANCODE_RSHIFT) {
		__g_shift_pressed = 1;
		return '\0';
	}
	if (__code == SCANCODE_CAPSLOCK) {
		__g_caps_lock_active = !__g_caps_lock_active; // Toggle Caps Lock
		return '\0';
	}

	if ((unsigned char)__scancode >= 128) {
		// Unknown scancodes or Out-of-Bounds
		return '\0';
	}

	char __char = scancode_ascii_unshifted[__code];
	if (__char == '\0') {
		return '\0'; // Key has no ASCII mapping (e.g., F1, Arrow keys)
	}

	if (__char >= 'a' && __char <= 'z') {
		char __make_uppercase = __g_shift_pressed ^ __g_caps_lock_active;
		return __make_uppercase ? scancode_ascii_shifted[__code] : __char;
	} else {
		return __g_shift_pressed ? scancode_ascii_shifted[__code] : __char;
	}

	return __char;
}

uint8_t __scancode_h[128] = {0};
static uint32_t __total_isr_calls = 0;

void __keyboard_handle_scancode(uint8_t __scancode) {
	__total_isr_calls++;

	char __temp = __convert_ascii(__scancode);
	static uint8_t __index = 0;

	if (__index < sizeof(__scancode_h)) {
		__scancode_h[__index++] = __scancode;
	}

	if (__temp == '\0') {
		return;
	}
	__keyboard_buffer_push(__temp);
}

void __dump_scancode_history() {
	printf("Scancode History: \n");
    printf("Total ISR Calls: %u\n", __total_isr_calls);
	for (size_t i = 0; i < sizeof(__scancode_h); i++) {
		if (__scancode_h[i] != 0) {
			printf("[%x] = %c\n", __scancode_h[i], __convert_ascii(__scancode_h[i]));
		}
	}
	printf("\n");
}

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