Fix merge conflicts

.clang-format

@@ -0,0 +1,10 @@
+---
+DerivePointerAlignment: 'true'
+SpaceBeforeParens: ControlStatements
+UseTab: ForIndentation
+IndentWidth: 2
+TabWidth: 2
+ColumnLimit: 120
+BreakBeforeBraces: Attach
+
+...

.gitignore

@@ -0,0 +1,59 @@
+
+# Created by https://www.gitignore.io/api/c
+# Edit at https://www.gitignore.io/?templates=c
+
+### C ###
+# Prerequisites
+*.d
+
+# Object files
+*.o
+*.ko
+*.obj
+*.elf
+
+# Linker output
+*.ilk
+*.map
+*.exp
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Libraries
+*.lib
+*.a
+*.la
+*.lo
+
+# Shared objects (inc. Windows DLLs)
+*.dll
+*.so
+*.so.*
+*.dylib
+
+# Executables
+*.exe
+*.out
+*.app
+*.i*86
+*.x86_64
+*.hex
+
+# Debug files
+*.dSYM/
+*.su
+*.idb
+*.pdb
+
+# Kernel Module Compile Results
+*.mod*
+*.cmd
+.tmp_versions/
+modules.order
+Module.symvers
+Mkfile.old
+dkms.conf
+
+# End of https://www.gitignore.io/api/c

arch/i386/tty.c

@@ -3,8 +3,8 @@
 #include <stdint.h>
 #include <string.h>
 
-#include <kernel/tty.h>
-#include <kernel/utils.h>
+#include "kernel/tty.h"
+#include "kernel/utils.h"
 
 static const size_t TERM_WIDTH = 80;
 static const size_t TERM_HEIGHT = 25;
@@ -31,9 +31,7 @@ void screen_initialize(void) {
 	}
 }
 
-void term_setcolor(enum vga_colors color) {
-	current_color = color;
-}
+void term_setcolor(enum vga_colors color) { current_color = color; }
 
 void term_putentryat(char c, uint8_t color, size_t x, size_t y) {
 	const size_t offset = y * TERM_WIDTH + x;
@@ -51,187 +49,228 @@ void term_putchar(char c) {
 		break;
 	default:
 		term_putentryat(uc, current_color, terminal_column, terminal_row);
-			break;
-	}
-	
-	if(++terminal_column == TERM_WIDTH) 
-	{
+		if (++terminal_column == TERM_WIDTH) {
 			terminal_column = 0;
 			if (++terminal_row == TERM_HEIGHT) {
 				term_scroll(false);
 				terminal_row = 0;
 			}
 		}
+		break;
+	}
+}
+
+struct csi_sequence parse_csi(const char* data, size_t size) {
+	enum State { PARAMETER, INTERMEDIATE, FINAL, INVALID };
+	enum State state = PARAMETER;
+
+	struct csi_sequence sequence = {.parameter = NULL,
+	                                .parameter_len = 0,
+	                                .intermediate = NULL,
+	                                .intermediate_len = 0,
+	                                .final = NULL,
+	                                .valid = false};
+
+	for (size_t j = 0; j < size; j++) {
+		uint8_t c = data[j];
+		if (state == PARAMETER && (c >= 0x30 && c <= 0x3F)) {
+			if (!sequence.parameter)
+				sequence.parameter = data + j;
+			sequence.parameter_len++;
+		} else if (c >= 0x20 && c <= 0x2F) {
+			if (!sequence.intermediate)
+				sequence.intermediate = data + j;
+			sequence.intermediate_len++;
+			state = INTERMEDIATE;
+		} else if (c >= 0x40 && c <= 0x7F) {
+			sequence.final = data + j;
+			sequence.valid = true;
+			state = FINAL;
+			break;
+		} else {
+			// Parameter found in intermediate byte location, or byte out of
+			// range
+			state = INVALID;
+			break;
+		}
+	}
+	return sequence;
 }
 
 void term_write(const char* data, size_t size) {
 	for (size_t i = 0; i < size; i++) {
 		// Begin handling ANSI escape codes.
-		if(data[i] == 0x1B) { //The current character is ESC - the start of ANSI codes.
-			term_writes("ANSI Code encountered: ");
+		if (data[i] == 0x1b) { // The current character is ESC - the start of ANSI codes.
+			// term_writes("ANSI Code encountered: ");
 
 			bool string_terminated = false; // Flag used in some of the escape codes
-			switch(data[i+1]) {
-				case 0x9b/*[*/: //CSI - Control Sequence Introducer (The most common one, hence it comes first)
-					char* controlSequence;
-					if(data[i+2] == NULL) {
-						controlSequence = '\0';
-					for(size_t j = 0; j < (strlen(data) - (i+2); j++) {
-						if(data[j] == ' ') 
-							break;
-						controlSequence += data[j];
-					}
-					handleControlSequence(controlSequence); //Send it off to our handler function to keep this part clean
-					break;
 
+			// TODO: Should only progress if we have at least 2 more bytes
+
+			switch ((uint8_t)data[i + 1]) {
+			case '[': // CSI - Control Sequence Introducer (The most common one, hence it comes first)
+			{
+				struct csi_sequence sequence = parse_csi(data + i + 2, size - (i + 2));
+				if (sequence.valid) {
+					// Send it off to our handler function to keep this part clean
+					handleControlSequence(sequence);
+					i += sequence.parameter_len + sequence.intermediate_len + 2; // Move past sequence
+				}
+			} break;
 			// Single shifts are not handled, so just print them and exit
-				case 0x8e/*N*/: //SS2 - Single Shift Two
+			case 'N': // SS2 - Single Shift Two
 				term_writes("Single Shift Two\n");
 				break;
-				case 0x8f/*O*/: //SS3 - Single Shift Three
+			case 'O': // SS3 - Single Shift Three
 				term_writes("Single Shift Three\n");
 				break;
 
 			// Control Strings
-				case 0x90/*P*/: //DCS - Device Control String
+			case 'P': // DCS - Device Control String
 				term_writes("Device Control String");
 				string_terminated = false;
 				break;
-				case 0x9c/*\*/: //ST - String Terminator 
+			case '\\': // ST - String Terminator
 				term_writes("String Terminator\n");
 				string_terminated = true;
 				break;
-				case 0x9d/*]*/: //OSC - Operating System Command
+			case ']': // OSC - Operating System Command
 				term_writes("Operating System Command\n");
 				string_terminated = false;
 				break;
-				case 0x98/*X*/: //SOS - Start Of String
+			case 'X': // SOS - Start Of String
 				term_writes("Start of String");
 				string_terminated = false;
 				break;
-				case 0x9e/*^*/: //PM - Privacy Message
+			case '^': // PM - Privacy Message
 				term_writes("Privacy Message\n");
 				break;
-				case 0x9f/*_*/: //APC - Application Program Command
+			case '_': // APC - Application Program Command
 				term_writes("Application Program Command\n");
 				break;
 			}
-			
-		}
-		
+		} else {
 			term_putchar(data[i]);
 		}
 	}
-
-void term_writes(const char* data) {
-	term_write(data, strlen(data));
 }
 
+void term_writes(const char* data) { term_write(data, strlen(data)); }
+
 void puts(const char* string) {
 	term_write(string, strlen(string));
 	term_putchar('\n');
 }
 
-void handleControlSequence(const char* sequence) {
+void handleControlSequence(struct csi_sequence sequence) {
 	// Check for our failsafes
-	if(sequence) {
-		if(sequence != '\0') {
+
+	if (sequence.valid) {
 		int n = 0; // Default of the flag used for a few items
 
-			bool nPresent = false;
-			bool terminated = false;
-			for(size_t i = 0; i < strlen(sequence); i++) {
-				if(isDigit(sequence[i])) {
-						nPresent = true;
-						n = (n*10) + sequence[i];
-					} else if(n > 80) {
-						n = 80;
-						break;
+		// Parse parameters, we only care about a max 2 of number only parameters
+		// for now
+		int params[2] = {0};
+		int param_count = 0;
+		if (sequence.parameter_len) {
+			for (size_t i = 0; i < sequence.parameter_len && param_count < 1; i++) {
+				char c = sequence.parameter[i];
+				if (isDigit(c)) {
+					n = (n * 10) + (sequence.parameter[i] - '0');
+				} else if (c == ';') {
+					params[param_count++] = n;
 				}
 			}
-				
-				if(n == 0)
-					n = 1;
-				
-				switch(sequence[i]) {
-					case ';':
-						terminated = true;
-						int m = 0; 
-						for(size_t j = 0; j < strlen(sequence - i); j++) {
-							if(sequence[j] == 'H' ||sequence[j] == 'f') 
-								break;
-							
-							if(isDigit(sequence[j])) {
-									m = (m*10) + sequence[j];
-							} else if(j > 80) break;
+			params[param_count++] = n;
 		}
 
-						if(m == 0)
-							m = 1;
-						cursor_pos(n, m);
-						
+		switch (*(sequence.final)) {
+		case 'H':
+		case 'f': // CUP - Cursor Position
+			// TODO: Check to see if we have 2 paramaters
+			if (params[0])
+				params[0]--;
+			if (params[1])
+				params[1]--;
+			set_cursor(params[0], params[1]);
 			break;
 		case 'A': // CUU - Cursor Up
-						//cursor_pos(x, y)
-						
-						cursor_pos(terminal_column, terminal_row + n);
+			if (!params[0])
+				params[0] = 1;
+			set_cursor(terminal_column, terminal_row - params[0]);
 			break;
 		case 'B': // CUD - Cursor Down
-						cursor_pos(terminal_column, terminal_row - n);
+			if (!params[0])
+				params[0] = 1;
+			set_cursor(terminal_column, terminal_row + params[0]);
 			break;
 		case 'C': // CUF - Cursor Forward
-						cursor_pos(terminal_column + n, terminal_row);
+			if (!params[0])
+				params[0] = 1;
+			set_cursor(terminal_column + params[0], terminal_row);
 			break;
 		case 'D': // CUB - Cursor Back
-						cursor_pos(terminal_column - n, terminal_row);
+			if (!params[0])
+				params[0] = 1;
+			set_cursor(terminal_column - params[0], terminal_row);
 			break;
 		case 'E': // CNL - Cursor Next Line
-						cursor_pos(0, terminal_row + n);
+			if (!params[0])
+				params[0] = 1;
+			set_cursor(0, terminal_row + params[0]);
 			break;
 		case 'F': // CPL - Cursor Previous Line
-						cursor_pos(0, terminal_row - n);
+			if (!params[0])
+				params[0] = 1;
+			set_cursor(0, terminal_row - params[0]);
 			break;
 		case 'G': // CHA - Cursor Horizontal Absolute
-						cursor_pos(n, terminal_row);
+			if (params[0])
+				params[0]--;
+			set_cursor(params[0], terminal_row);
+			break;
 		case 'J': // ED - Erase in Display
+		{
 			// current cursor pos = y * width + x
 			int pos = terminal_row * 80 + terminal_column;
-						if(!nPresent) {
-							for(pos < (25 * 80); pos++) {
+			if (params[0] == 0) { // Clear from cursor to end of screen
+				for (; pos < (25 * 80); pos++) {
 					vga_buffer[pos] = '\0';
 				}
-							n = 0;
-						} else if(nPresent && n == 1) {
-							for(pos > 0; pos--) {
+			} else if (params[0] == 1) { // Clear from cursor to beginning
+				for (; pos > 0; pos--) {
 					vga_buffer[pos] = '\0';
 				}
-						} else if(n == 2 || n == 3) {
+			} else if (params[0] == 2 || params[0] == 3) { // Clear entire screen
+				// TODO: Support scrollback buffer? (n = 3)
 				for (int i = 0; i < (25 * 80); i++) {
 					vga_buffer[0] = '\0';
 				}
 			}
 			break;
+		}
 		case 'K': // EL - Erase in Line
-					
+		{
 			int pos = terminal_row * 80 + terminal_column;
-						if(!nPresent) { //From cursor to end of line
+			if (params[0] == 0) {                       // From cursor to end of line
 				int endPos = (terminal_row + 1) * 80 - 1; // End of line = current row + 25 columns = current row + 1
-							for(pos < endPos; pos++) {
+				for (; pos < endPos; pos++) {
 					vga_buffer[pos] = '\0';
 				}
-						} else if(nPresent && n == 1) { //From cursor to start of line
+			} else if (params[0] == 1) {      // From cursor to start of line
 				int endPos = terminal_row * 80; // Start of line = end of previous line + 1 == current line
-							for(pos > endPos; pos--) {
+				for (; pos > endPos; pos--) {
 					vga_buffer[pos] = '\0';
 				}
-						} else if(nPresent && n == 2) { //Entire current line
+			} else if (params[0] == 2) { // Entire current line
 				pos = terminal_row * 80;
 				int endPos = (terminal_row + 1) * 80 - 1;
-							for(pos < endPos; pos++) {
+				for (; pos < endPos; pos++) {
 					vga_buffer[pos] = '\0';
 				}
 			}
 			break;
+		}
 		case 'S': // SU - Scroll Up
 			term_scroll(true);
 			break;
@@ -241,14 +280,12 @@ void handleControlSequence(const char* sequence) {
 		}
 	}
 }
-	}
 
-}
+bool isDigit(char c) { return c >= '0' && c <= '9'; }
 
-bool isDigit(const char c) {
-	return c == '0' || c == '1' || c == '2' || c == '3' ||
-			c == '4' || c == '5' || c == '6' || c == '7' ||
-			c == '8' || c == '9';
+void set_cursor(int n, int m) {
+	terminal_column = n;
+	terminal_row = m;
 }
 
 void term_scroll(bool down) {
@@ -267,28 +304,30 @@ void term_scroll(bool down) {
 			term_buffer[current_pos + 160] = vga_buffer[current_pos];
 			term_buffer[current_pos + 159] = vga_buffer[current_pos - 1];
 			current_pos -= 2;
+		}
 	} else {
 		while (current_pos <= 4000) {
-			term_buffer[current_pos - 160 /*The character immediately below it*/] = vga_buffer[current_pos];      //Move each character up a line
-			term_buffer[current_pos - 159 /*The color of the character below*/] = vga_buffer[current_pos + 1];    //As well as its color
+			term_buffer[current_pos - 160 /*The character immediately below it*/] =
+			    vga_buffer[current_pos]; // Move each character up a line
+			term_buffer[current_pos - 159 /*The color of the character below*/] =
+			    vga_buffer[current_pos + 1]; // As well as its color
 			current_pos += 2;                // Move to next char
 		}
 	}
 
 	if (down) {
 		current_pos = 0; // Start of first line
-		for(current_pos < 80; current_pos++) {
+		for (; current_pos < 80; current_pos++) {
 			term_buffer[current_pos] = '\0';
 			current_pos += 2;
+		}
 	} else {
 		; // Start of the last line
 		// Wipe out the bottom line
-		for(current_pos = 3840; current_pos <= 3920; i++) {
+		for (current_pos = 3840; current_pos <= 3920; current_pos += 2) {
 			term_buffer[current_pos] = 0;
-			current_pos += 2;
 		}
 	}
-	
 	terminal_row = 24; // Start writing on the last line
 	terminal_column = 0;
 }

include/arch/i386/vga.h

@@ -3,7 +3,6 @@
 
 #include <stdint.h>
 
-
 enum vga_colors {
 	BLACK = 0,
 	BLUE = 1,
@@ -23,12 +22,8 @@ enum vga_colors {
 	WHITE = 15
 };
 
-static inline uint8_t vga_color_set(enum vga_colors fg, enum vga_colors bg) {
-	return fg | bg << 4;
-}
+static inline uint8_t vga_color_set(enum vga_colors fg, enum vga_colors bg) { return fg | bg << 4; }
 
-static inline uint16_t vga_entry(unsigned char uc, uint8_t color) {
-	return (uint16_t) uc | (uint16_t) color << 8;
-}
+static inline uint16_t vga_entry(unsigned char uc, uint8_t color) { return (uint16_t)uc | (uint16_t)color << 8; }
 
 #endif

include/kernel/tty.h

@@ -1,8 +1,19 @@
 #pragma once
 
+#include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
-#include <vga.h>
+
+#include "vga.h"
+
+struct csi_sequence {
+	const char* parameter;
+	size_t parameter_len;
+	const char* intermediate;
+	size_t intermediate_len;
+	const char* final;
+	bool valid;
+};
 
 void term_setcolor(enum vga_colors);
 void screen_initialize(void);
@@ -11,8 +22,11 @@ void term_putchar(char);
 void term_write(const char*, size_t);
 void term_writes(const char*);
 void puts(const char*);
+void handleControlSequence(struct csi_sequence);
 void set_cursor(int, int);
-void term_scroll(void);
+void term_scroll(bool);
 void int_to_ascii(int, char*);
 void int_to_hex(int, char*);
 void empty_string(char*);
+
+bool isDigit(char c);

include/kernel/utils.h

@@ -1,3 +1,4 @@
+
 #pragma once
 #include <stddef.h>
 

include/vga.h

@@ -2,7 +2,6 @@
 
 #include <stdint.h>
 
-
 enum vga_colors {
 	BLACK = 0,
 	BLUE = 1,
@@ -22,10 +21,6 @@ enum vga_colors {
 	WHITE = 15
 };
 
-static inline uint8_t vga_color_set(enum vga_colors fg, enum vga_colors bg) {
-	return fg | bg << 4;
-}
+static inline uint8_t vga_color_set(enum vga_colors fg, enum vga_colors bg) { return fg | bg << 4; }
 
-static inline uint16_t vga_entry(unsigned char uc, uint8_t color) {
-	return (uint16_t) uc | (uint16_t) color << 8;
-}
+static inline uint16_t vga_entry(unsigned char uc, uint8_t color) { return (uint16_t)uc | (uint16_t)color << 8; }

kernel/kernel.c

@@ -1,3 +1,4 @@
+
 //#include <stdio.h>
 
 #include <kernel/tty.h>

kernel/syscalls.c

@@ -1,10 +1,10 @@
 /*#include <sys/stat.h>
-#include <sys/types.h>
-#include <sys/fcntl.h>
-#include <sys/times.h>
-#include <sys/errno.h>
-#include <sys/time.h>
 #include <stdio.h>
+#include <sys/errno.h>
+#include <sys/fcntl.h>
+#include <sys/time.h>
+#include <sys/times.h>
+#include <sys/types.h>
 
 //prototypes; these are the bare minimum for newlib to compile.
 

libc/include/stdlib.h

@@ -3,8 +3,7 @@
 
 #include <sys/cdefs.h>
 
-__attribute__((__noreturn__))
-void abort(void);
+__attribute__((__noreturn__)) void abort(void);
 
 /*
   Default header file for malloc-2.8.x, written by Doug Lea
@@ -202,7 +201,6 @@ int mallopt(int, int);
 #define M_GRANULARITY (-2)
 #define M_MMAP_THRESHOLD (-3)
 
-
 /*
   malloc_footprint();
   Returns the number of bytes obtained from the system.  The total
@@ -280,8 +278,7 @@ size_t malloc_set_footprint_limit(size_t bytes);
 
   malloc_inspect_all is compiled only if MALLOC_INSPECT_ALL is defined.
 */
-void malloc_inspect_all(void(*handler)(void*, void *, size_t, void*),
-                           void* arg);
+void malloc_inspect_all(void (*handler)(void*, void*, size_t, void*), void* arg);
 
 #if !NO_MALLINFO
 /*
@@ -577,10 +574,8 @@ void* mspace_calloc(mspace msp, size_t n_elements, size_t elem_size);
 void* mspace_realloc(mspace msp, void* mem, size_t newsize);
 void* mspace_realloc_in_place(mspace msp, void* mem, size_t newsize);
 void* mspace_memalign(mspace msp, size_t alignment, size_t bytes);
-void** mspace_independent_calloc(mspace msp, size_t n_elements,
-                                 size_t elem_size, void* chunks[]);
-void** mspace_independent_comalloc(mspace msp, size_t n_elements,
-                                   size_t sizes[], void* chunks[]);
+void** mspace_independent_calloc(mspace msp, size_t n_elements, size_t elem_size, void* chunks[]);
+void** mspace_independent_comalloc(mspace msp, size_t n_elements, size_t sizes[], void* chunks[]);
 size_t mspace_bulk_free(mspace msp, void**, size_t n_elements);
 size_t mspace_usable_size(const void* mem);
 void mspace_malloc_stats(mspace msp);
@@ -589,9 +584,7 @@ size_t mspace_footprint(mspace msp);
 size_t mspace_max_footprint(mspace msp);
 size_t mspace_footprint_limit(mspace msp);
 size_t mspace_set_footprint_limit(mspace msp, size_t bytes);
-void mspace_inspect_all(mspace msp, 
-                        void(*handler)(void *, void *, size_t, void*),
-                        void* arg);
+void mspace_inspect_all(mspace msp, void (*handler)(void*, void*, size_t, void*), void* arg);
 #endif /* MSPACES */
 
 #ifdef __cplusplus

libc/include/string.h

@@ -1,8 +1,8 @@
 #ifndef _STRING_H
 #define _STRING_H 1
 
-#include <sys/cdefs.h>
 #include <stddef.h>
+#include <sys/cdefs.h>
 
 int memcmp(const void*, const void*, size_t);
 void* memcpy(void* __restrict, const void* __restrict, size_t);

libc/stdio/printf.c

@@ -1,6 +1,6 @@
 #include <limits.h>
-#include <stdbool.h>
 #include <stdarg.h>
+#include <stdbool.h>
 #include <stdio.h>
 #include <string.h>
 
@@ -8,8 +8,7 @@ static bool print(const char* data, size_t length) {
 	const unsigned char* bytes = (const unsigned char*)data;
 	for (size_t i = 0; i < length; i++)
 		if (putchar(bytes[i]) == EOF)
-			return false'
-	return true;
+			return false' return true;
 }
 
 int printf(const char* restrict format, ...) {

libc/stdlib/abort.c

@@ -1,8 +1,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-__attribute__((__noreturn__))
-void abort(void) {
+__attribute__((__noreturn__)) void abort(void) {
 
 #if defined(__is_libk)
 	// TODO: Kernel panic.
@@ -10,6 +9,7 @@ void abort(void) {
 #else
 	printf("abort() called\n");
 #endif
-		while(1) {}
+	while (1) {
+	}
 	__builtin_unreachable();
 }

libc/string/strlen.c

@@ -3,6 +3,5 @@
 size_t strlen(const char* str) {
 	size_t len = 0;
 	while (str[len])
-		len++
-	return len;
+		len++ return len;
 }