Reformat code

Co-authored-by: Ezequiel Bellver <ebellver@itba.edu.ar>
Co-authored-by: Juan Barmasch <jbarmasch@itba.edu.ar>

.gitignore

@@ -5,6 +5,7 @@
 index.html
 .bashrc
 .vscode/*
+.idea/
 
 #Binary Files
 *.bin

Kernel/Makefile

@@ -32,7 +32,7 @@ $(KERNEL_ELF): $(STATICLIBS) $(ALL_OBJECTS)
 	$(LD) $(LDFLAGS) -T kernel.ld --oformat=elf64-x86-64 -o $@ $^
 
 %.o: %.c
-	$(GCC) $(GCCFLAGS) -I./include -I./drivers -I./interruptions -I./utils -I./tests $(MFLAG) -c $< -o $@
+	$(GCC) $(GCCFLAGS) -I./include -I./drivers/include -I./interruptions/include -I./utils/include -I./tests/include $(MFLAG) -c $< -o $@
 
 %.o : %.asm
 	$(ASM) $(ASMFLAGS) $< -o $@

Kernel/drivers/include/keyboard.h

@@ -2,7 +2,9 @@
 #define KEYBOARD_H
 
 #include <stdint.h>
-#include "schedulerLib.h"
+#include "../../utils/include/schedulerLib.h"
+
+#define SIZE 1
 
 void keyboard_handler();
 unsigned char getKeyFromBuffer();

Kernel/drivers/include/time.h

@@ -1,5 +1,5 @@
-#ifndef _TIME_H_
+#ifndef TIME_H
-#define _TIME_H_
+#define TIME_H
 
 void timer_handler();
 int ticks_elapsed();
@@ -14,7 +14,6 @@ int seconds_elapsed();
 
 int getTimeGen(char option);
 int getTime(char option);
-// void wait(long seconds);
 long getTimeOfDay();
 
 #endif

Kernel/drivers/include/video.h

@@ -3,13 +3,11 @@
 
 #include <stdint.h>
 
-void moveToWindowVideo(char window);
 int printStringLen(int color, const char * string, int maxLen);
 void new_line();
 void backspace();
 void clear();
 void increment();
-void changeWindow();
 void scroll();
 
 #endif

Kernel/drivers/keyboard.c

@@ -5,7 +5,6 @@ static unsigned char kbdus_sh[250];
 // static unsigned char kbdsp_sh[250];
 // static unsigned char kbdsp[250];
 
-#define SIZE 1
 unsigned char buffer[SIZE] = {0};
 unsigned char *current = buffer;
 unsigned char *last = buffer;
@@ -24,20 +23,14 @@ void testKeyboardInterrupt(unsigned char c) {
     if (c == 0x2A || c == 0x36) {
         flag = 0;
         return;
-    }
+    } else if (c == 0xAA || c == 0xB6) {
-    else if (c == 0xAA || c == 0xB6) {
         flag = 1;
         return;
-    }
+    } else if (c == 0x3A) {
-  
-    else if (c == 0x3A) {
         flag = ~(flag | 0xFE);
-    }
+    } else if (c == 0x38) {
-
-    else if (c == 0x38) {
         flagChangeAlt = 0;
-    }
+    } else if (c == 0x3B) {
-    else if (c == 0x3B) {
         flagChangeF1 = 0;
     }
 
@@ -46,13 +39,10 @@ void testKeyboardInterrupt(unsigned char c) {
         flagChangeF1 = 1;
         saveChar('\v');
         return;
-    }
+    } else if (c == 0xB8) {
-    
-    else if (c == 0xB8) {
         flagChangeAlt = 1;
         return;
-    }
+    } else if (c == 0xBB) {
-    else if (c == 0xBB) {
         flagChangeF1 = 1;
         return;
     }
@@ -61,8 +51,7 @@ void testKeyboardInterrupt(unsigned char c) {
         c = kbdus_sh[c];
         if (c != 0)
             saveChar(c);
-    }
+    } else {
-    else {
         c = kbdus[c];
         if (c != 0)
             saveChar(c);

Kernel/drivers/naiveConsole.c

@@ -8,82 +8,61 @@ static uint8_t * currentVideo = (uint8_t*)0xB8000;
 static const uint32_t width = 80;
 static const uint32_t height = 25;
 
-void ncPrint(const char * string)
+void ncPrint(const char *string) {
-{
+    for (int i = 0; string[i] != 0; i++)
-	int i;
-
-	for (i = 0; string[i] != 0; i++)
         ncPrintChar(string[i]);
 }
 
-void ncPrintChar(char character)
+void ncPrintChar(char character) {
-{
     *currentVideo = character;
     currentVideo += 2;
 }
 
-void ncNewline()
+void ncNewline() {
-{
+    do {
-	do
-	{
         ncPrintChar(' ');
-	}
+    } while ((uint64_t)(currentVideo - video) % (width * 2) != 0);
-	while((uint64_t)(currentVideo - video) % (width * 2) != 0);
 }
 
-void ncPrintDec(uint64_t value)
+void ncPrintDec(uint64_t value) {
-{
     ncPrintBase(value, 10);
 }
 
-void ncPrintHex(uint64_t value)
+void ncPrintHex(uint64_t value) {
-{
     ncPrintBase(value, 16);
 }
 
-void ncPrintBin(uint64_t value)
+void ncPrintBin(uint64_t value) {
-{
     ncPrintBase(value, 2);
 }
 
-void ncPrintBase(uint64_t value, uint32_t base)
+void ncPrintBase(uint64_t value, uint32_t base) {
-{
     uintToBase(value, buffer, base);
     ncPrint(buffer);
 }
 
-void ncClear()
+void ncClear() {
-{
+    for (int i = 0; i < height * width; i++)
-	int i;
-
-	for (i = 0; i < height * width; i++)
         video[i * 2] = ' ';
     currentVideo = video;
 }
 
-static uint32_t uintToBase(uint64_t value, char * buffer, uint32_t base)
+static uint32_t uintToBase(uint64_t value, char *buffer, uint32_t base) {
-{
     char *p = buffer;
     char *p1, *p2;
     uint32_t digits = 0;
 
-	//Calculate characters for each digit
+    do {
-	do
-	{
         uint32_t remainder = value % base;
         *p++ = (remainder < 10) ? remainder + '0' : remainder + 'A' - 10;
         digits++;
-	}
+    } while (value /= base);
-	while (value /= base);
 
-	// Terminate string in buffer.
     *p = 0;
 
-	//Reverse string in buffer.
     p1 = buffer;
     p2 = p - 1;
-	while (p1 < p2)
+    while (p1 < p2) {
-	{
         char tmp = *p1;
         *p1 = *p2;
         *p2 = tmp;

Kernel/drivers/time.c

@@ -1,4 +1,4 @@
-#include <time.h>
+#include "time.h"
 
 static unsigned long ticks = 0;
 
@@ -11,7 +11,6 @@ int ticks_elapsed() {
 }
 
 int seconds_elapsed() {
-	// return ticks / 18;
     return ticks / 18;
 }
 
@@ -29,41 +28,20 @@ int getTime(char option) {
             return getTimeGen(MONTH);
         case YEAR:
             return getTimeGen(YEAR);
-		default: return -1;
+        default:
+            return -1;
     }
 }
 
-// TODO
-/* void wait(long seconds) {
-	// int initialSeconds = getTimeGen(SECONDS);
-	// int initialMinutes = getTimeGen(MINUTES);
-	// int runSeconds = 0;
-	// if (initialSeconds + seconds >= 60) {
-
-	// }
-	// int newSeconds = 0;
-	// while ((newSeconds = getTimeGen(SECONDS) - initialSeconds) < seconds)
-	// 	haltcpu();
-	// while (initialSeconds - seconds != initialSeconds) {
-
-	// }
-	// while (seconds_elapsed() < seconds);
-} */
-
 static long getTimeFrom2000() {
     long years = 00 * 31557600;
     long months = 1 * 2629800;
     long days = 1 * 86400;
 
-	// long aux = years + months + days;
-
     return years + months + days;
 }
 
 long getTimeOfDay() {
-	// long years = getTimeGen(YEAR) - 1970;
-
-	// obtengo los segundos actuales (sumando todas las variables) y los resto por los de 1970?
     long years = getTimeGen(YEAR) * 31557600;
     long months = getTimeGen(MONTH) * 2629800;
     long days = getTimeGen(DAY) * 86400;

Kernel/drivers/video.c

@@ -1,8 +1,6 @@
-#include <stdint.h>
 #include "video.h"
 
 static uint8_t *const video = (uint8_t *) 0xB8000;
-// static uint8_t * currentVideo = (uint8_t *) 0xB8000;
 static const int width = 80;
 static const int height = 25;
 static int currentX = 0;
@@ -27,7 +25,6 @@ char checkIfEscapeSequence(const char * bufferAux) {
     if (*bufferAux == '\e') {
         bufferAux++;
         if (*bufferAux == '\f') {
-			bufferAux++;
             clear();
         }
         return 1;
@@ -56,12 +53,10 @@ int printStringLen(int color, const char * string, int maxLen) {
             string++;
             i++;
             continue;
-		}
+        } else if (*string == '\b') {
-		else if (*string == '\b') {
             backspace();
             return i;
-		}
+        } else if (checkIfEscapeSequence(string)) {
-		else if (checkIfEscapeSequence(string)) {
             return i;
         }
 

Kernel/include/defs.h

@@ -1,12 +1,6 @@
-/***************************************************
-  Defs.h
-****************************************************/
-
 #ifndef _defs_
 #define _defs_
 
-
-/* Flags para derechos de acceso de los segmentos */
 #define ACS_PRESENT     0x80            /* segmento presente en memoria */
 #define ACS_CSEG        0x18            /* segmento de codigo */
 #define ACS_DSEG        0x10            /* segmento de datos */
@@ -16,7 +10,6 @@
 #define ACS_INT_386 	0x0E		/* Interrupt GATE 32 bits */
 #define ACS_INT         ( ACS_PRESENT | ACS_INT_386 )
 
-
 #define ACS_CODE        (ACS_PRESENT | ACS_CSEG | ACS_READ)
 #define ACS_DATA        (ACS_PRESENT | ACS_DSEG | ACS_WRITE)
 #define ACS_STACK       (ACS_PRESENT | ACS_DSEG | ACS_WRITE)

Kernel/include/idtLoader.h

@@ -1,6 +0,0 @@
-#ifndef __IDT_LOADER_H__
-#define __IDT_LOADER_H__
-
-void load_idt();
-
-#endif

Kernel/include/memManager.h

@@ -1,24 +0,0 @@
-#ifndef MEM_MANAGER_H
-#define MEM_MANAGER_H
-
-#include <stdlib.h>
-
-// typedef struct MemoryManagerCDT * MemoryManagerADT;
-
-// MemoryManagerADT createMemoryManager(void *const restrict memoryForMemoryManager, void *const restrict managedMemory);
-// void *allocMemory(MemoryManagerADT const restrict memoryManager, const size_t memoryToAllocate);
-
-// char initMemoryManager(void *const restrict memoryForMemoryManager, void *const restrict managedMemory);
-void initMemoryManager(void * managedMemory);
-void * memMalloc(unsigned nbytes);
-void memFree(void *ap);
-// void * memMalloc(const size_t memoryToAllocate);
-void * pvPortMalloc(size_t xWantedSize);
-void vPortFree( void *pv );
-size_t xPortGetFreeHeapSize( void );
-
-// SACAR DPS
-char testOne();
-char testTwo();
-
-#endif

Kernel/include/pcb.h

@@ -1,20 +0,0 @@
-#ifndef PCB_H
-#define PCB_H
-
-#include <stdint.h>
-#include <defs.h>
-
-#define MAX_PROCESSES 2
-
-uint64_t loadProcess(uint64_t rsp, void (*fn), uint64_t rbp);
-uint64_t preserveStack(uint64_t rsp);
-void newProcess(void (*fn));
-void newStack(uint64_t rsp);
-void cleanProcesses();
-
-void * _initialize_stack_frame(void * rip, const void * rsp);
-
-void saveSampleRSP(uint64_t rsp);
-uint64_t getSampleRSP();
-
-#endif

Kernel/include/queue.h

@@ -1,8 +0,0 @@
-// #include "scheduler.h"
-
-// typedef struct queueCDT * queueADT;
-
-// void queue(queueADT * my_queue, processADT * process);
-// char isEmpty(queueADT * my_queue);
-// processADT * dequeue(queueADT * my_queue);
-// queueADT createQueue();

Kernel/interruptions/exceptions.c

@@ -1,17 +1,8 @@
-#include "lib.h"
+#include "exceptions.h"
-#include "time.h"
-#include "naiveConsole.h"
-#include "pcb.h"
-#include "video.h"
-#include "keyboard.h"
-#include "interrupts.h"
 
 static void * const sampleCodeAddress = (void *) 0x400000;
 typedef int (* fn)();
 
-#define ZERO_EXCEPTION_ID 0
-#define INVALID_OPCODE_ID 6
-
 static void zero_division();
 static void invalid_opcode();
 
@@ -42,12 +33,6 @@ static char * regsNames[] = {
 
 void printRegs() {
 	uint64_t * regs = stackFrame;
-
-	// 8 bytes = 64 bits = 2^64
-	// máximo: 18.446.744.073.709.551.616 / 2
-	// máximo: 9.223.372.036.854.775.808 entonces de 0 a 18
-	// dejo el primero para un -
-	
 	char buffer[20];
 
 	for (int i = 0; i < 15; i++) {
@@ -95,7 +80,6 @@ static void startOver() {
 }
 
 static void genericException(char * string, int len) {
-	// moveToWindowVideo(-1);
 	clear();
 	printStringLen(15, string, len);
     printRegs();

Kernel/interruptions/idtLoader.c

@@ -1,12 +1,8 @@
-#include <stdint.h>
+#include "idtLoader.h"
-#include <idtLoader.h>
-#include <defs.h>
-#include <interrupts.h>
 
-#pragma pack(push)		/* Push de la alineación actual */
+#pragma pack(push)
-#pragma pack (1) 		/* Alinear las siguiente estructuras a 1 byte */
+#pragma pack (1)
 
-/* Descriptor de interrupcion */
 typedef struct {
     uint16_t offset_l, selector;
     uint8_t cero, access;
@@ -14,26 +10,22 @@ typedef struct {
     uint32_t offset_h, other_cero;
 } DESCR_INT;
 
-#pragma pack(pop)		/* Reestablece la alinceación actual */
+#pragma pack(pop)
 
-DESCR_INT * idt = (DESCR_INT *) 0;	// IDT de 255 entradas
+DESCR_INT *idt = (DESCR_INT *) 0;
 
 static void setup_IDT_entry(int index, uint64_t offset);
 
 void load_idt() {
-
     setup_IDT_entry(0x20, (uint64_t) &_irq00Handler);
     setup_IDT_entry(0x21, (uint64_t) &_irq01Handler);
     setup_IDT_entry(0x00, (uint64_t) &_exception0Handler);
     setup_IDT_entry(0x06, (uint64_t) &_exception6Handler);
 
     setup_IDT_entry(0x80, (uint64_t) &_systemCallsHandler);
-    // setup_IDT_entry (0x81, (uint64_t)&_switchContext);
 
     picMasterMask(0xFC);
     picSlaveMask(0xFF);
-
-	// _sti();
 }
 
 static void setup_IDT_entry(int index, uint64_t offset) {

Kernel/interruptions/include/exceptions.h

@@ -0,0 +1,15 @@
+#ifndef EXCEPTIONS_H
+#define EXCEPTIONS_H
+
+#include "lib.h"
+#include "time.h"
+#include "naiveConsole.h"
+#include "pcb.h"
+#include "video.h"
+#include "keyboard.h"
+#include "interrupts.h"
+
+#define ZERO_EXCEPTION_ID 0
+#define INVALID_OPCODE_ID 6
+
+#endif

Kernel/interruptions/include/idtLoader.h

@@ -0,0 +1,10 @@
+#ifndef IDT_LOADER_H
+#define IDT_LOADER_H
+
+#include <defs.h>
+#include <interrupts.h>
+#include <stdint.h>
+
+void load_idt();
+
+#endif

Kernel/interruptions/include/interrupts.h

@@ -1,7 +1,8 @@
 #ifndef INTERRUPS_H_
 #define INTERRUPS_H_
 
-#include <idtLoader.h>
+#include "idtLoader.h"
+#include <stdint.h>
 
 void _irq00Handler(void);
 void _irq01Handler(void);
@@ -27,4 +28,4 @@ void picSlaveMask(uint8_t mask);
 
 void haltcpu(void);
 
-#endif /* INTERRUPS_H_ */
+#endif

Kernel/interruptions/include/systemCalls.h

@@ -0,0 +1,19 @@
+#ifndef SYSCALLS_H
+#define SYSCALLS_H
+
+#include "video.h"
+#include "keyboard.h"
+#include "time.h"
+#include "pcb.h"
+#include "pipeLib.h"
+#include "schedulerLib.h"
+#include "systemCallsLib.h"
+
+#define STDIN 0
+#define STDOUT 1
+#define STDERR 2
+
+#define STDOUT_COLOR 0x0f
+#define STDERR_COLOR 0x04
+
+#endif

Kernel/interruptions/include/systemCallsLib.h

@@ -1,11 +1,9 @@
-#ifndef SYSCALLS_H
+#ifndef SYSCALLSLIB_H
-#define SYSCALLS_H
+#define SYSCALLSLIB_H
 
 #include <stdint.h>
 
 uint64_t write(uint64_t, uint64_t, uint64_t);
 uint64_t read(uint64_t, uint64_t, uint64_t);
-uint64_t getTime(uint64_t, uint64_t, uint64_t);
-void createProcess();
 
 #endif

Kernel/interruptions/irqDispatcher.c

@@ -1,9 +1,9 @@
-#include <time.h>
 #include <stdint.h>
 
 static void int_20();
 static void int_21();
 void keyboard_handler();
+void timer_handler();
 
 void irqDispatcher(uint64_t irq) {
     switch (irq) {

Kernel/interruptions/systemCalls.c

@@ -1,17 +1,4 @@
-#include <stdint.h>
+#include "systemCalls.h"
-#include "video.h"
-#include "keyboard.h"
-#include "time.h"
-#include "pcb.h"
-#include "pipeLib.h"
-#include "schedulerLib.h"
-
-#define STDIN 0
-#define STDOUT 1
-#define STDERR 2
-
-#define STDOUT_COLOR 0x0f
-#define STDERR_COLOR 0x04 
 
 uint64_t write(uint64_t fd, uint64_t buffer, uint64_t length) {
     char *bufferAux = (char *) buffer;
@@ -56,8 +43,7 @@ uint64_t read(uint64_t fd, uint64_t buffer, uint64_t length) {
             bufferAux++;
             // blockIO();
         }
-    }
+    } else {
-    else {
         while (length-- > 0) {
             *bufferAux = readPipe(fd);
             if (*bufferAux == 0)
@@ -69,7 +55,3 @@ uint64_t read(uint64_t fd, uint64_t buffer, uint64_t length) {
 
     return readBytes;
 }
-
-// void createProcess(void (*fn)) {
-//     newProcess(fn);
-// }

Kernel/interruptions/systemCallsDispatcher.c

@@ -1,13 +1,7 @@
 #include <stdint.h>
 #include "systemCalls.h"
 #include "memManager.h"
-
+#include "pipeLib.h"
-void exitProcess();
-// void setFn(uint64_t, uint64_t, uint64_t);
-char * processes();
-// int enqueueProcess(uint64_t, uint64_t, uint64_t, uint64_t, uint64_t);
-char openPipe(int *, char *);
-char nice(int, char);
 #include "semLib.h"
 #include "schedulerLib.h"
 
@@ -18,7 +12,7 @@ uint64_t systemCallsDispatcher(uint64_t rdi, uint64_t rsi, uint64_t rdx, uint64_
         case 1:
             return read(rsi, rdx, rcx);
         case 2:
-            return getTime(rsi, rdx, rcx);
+            return getTime(rsi);
         case 3:
             return enqueueProcess((void (*)(int, char **)) rsi, rdx, rcx, (char **) r8, (int *) r9);
         case 4:

Kernel/kernel.c

@@ -49,7 +49,9 @@ void * initializeKernelBinary() {
 }
 
 void load_idt();
+
 uint64_t getRSP();
+
 void printBottlerAndWait();
 
 #include "test_util.h"
@@ -145,8 +147,11 @@ void test_mm(){
 void initScheduler();
 
 void _cli();
+
 void _sti();
+
 void haltcpu();
+
 void forceTimer();
 
 int main() {
@@ -174,8 +179,6 @@ int main() {
 
     saveSampleRSP(getRSP());
 
-
-	// ((EntryPoint)sampleCodeModuleAddress)();
     char *argv[] = {"SampleCode"};
     enqueueProcess(sampleCodeModuleAddress, 1, 1, argv, NULL);
     clear();
@@ -183,46 +186,5 @@ int main() {
     _sti();
     forceTimer();
 
-	// printBottlerAndWait();
     return EXIT_SUCCESS;
 }
-
-void printBottlerAndWait() {
-	printStringLen(4, "                                                                             ", 80); new_line();
-    printStringLen(4, "                                   (%(                                     ", 80); new_line();
-	printStringLen(15, "      Welcome to", 17);
-    printStringLen(4, "                  %%%%%                                      ", 80); new_line();
-	printStringLen(15, "        BottlerOS", 18);
-    printStringLen(4, "                  %%%                                      ", 80); new_line();
-    printStringLen(12, "                              %%%%%%%%%%%%%                                 ", 80); new_line();
-    printStringLen(12, "                          %%%%%%%%%%%%%%%%%%%%%                             ", 80); new_line();
-    printStringLen(12, "                        %%%%%%%           %%%%%%%                           ", 80); new_line();
-    printStringLen(12, "                      %%%%%                   %%%%%                         ", 80); new_line();
-    printStringLen(14, "                     %%%%%                     %%%%%                        ", 80); new_line();
-    printStringLen(14, "                    %%%%% ", 27); 
-	printStringLen(14, " %%%%           %%%% ", 22); 
-	printStringLen(14, " %%%%%                       ", 30); new_line();
-    printStringLen(14, "                    %%%%%  ", 28); 
-	printStringLen(14, " (%             %(  ", 21); 
-	printStringLen(14, " %%%%%                       ", 30); new_line();
-    printStringLen(14, "                    %%%%%%%                   %%%%%%%                       ", 80); new_line();
-    printStringLen(2, "                    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                       ", 80); new_line();
-    printStringLen(2, "                 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                    ", 80); new_line();
-    printStringLen(2, "                %%%%%%%%%%%%%%%%%%%%%%% ", 41); 
-	printStringLen(12, " %  %* ", 8); 
-	printStringLen(2, " %%%%%%%%%                   ", 30); new_line();
-    printStringLen(2, "                %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                   ", 80); new_line();
-    printStringLen(9, "                %%**%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/%%                   ", 80); new_line();
-    printStringLen(9, "                %%* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% /%%                   ", 80); new_line();
-    printStringLen(9, "                %%* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% /%%                   ", 80); new_line();
-    printStringLen(9, "                %%%  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  %%%                   ", 80); new_line();
-    printStringLen(13, "              ,%%%%%   %%%%%%%%%%%%%%%%%%%%%%%%%%%   %%%%%.                 ", 80); new_line();
-    printStringLen(13, "                %%.         %%%%%%%%%%%%%%%%%         .%%                   ", 80); new_line();
-    printStringLen(13, "                              %%%%%%%%%%%%%                                 ", 80); new_line();
-    printStringLen(13, "                                 %%%%%%%                                    ", 80); new_line();
-    printStringLen(13, "                                                                            ", 80); new_line();
-	
-	// wait(3);
-	
-	clear();
-}

Kernel/lib.c

@@ -1,7 +1,6 @@
-#include <stdint.h>
+#include "lib.h"
 
-void * memset(void * destination, int32_t c, uint64_t length)
+void *memset(void *destination, int32_t c, uint64_t length) {
-{
     uint8_t chr = (uint8_t) c;
     char *dst = (char *) destination;
 
@@ -11,34 +10,18 @@ void * memset(void * destination, int32_t c, uint64_t length)
     return destination;
 }
 
-void * memcpy(void * destination, const void * source, uint64_t length)
+void *memcpy(void *destination, const void *source, uint64_t length) {
-{
-	/*
-	* memcpy does not support overlapping buffers, so always do it
-	* forwards. (Don't change this without adjusting memmove.)
-	*
-	* For speedy copying, optimize the common case where both pointers
-	* and the length are word-aligned, and copy word-at-a-time instead
-	* of byte-at-a-time. Otherwise, copy by bytes.
-	*
-	* The alignment logic below should be portable. We rely on
-	* the compiler to be reasonably intelligent about optimizing
-	* the divides and modulos out. Fortunately, it is.
-	*/
     uint64_t i;
 
     if ((uint64_t) destination % sizeof(uint32_t) == 0 &&
         (uint64_t) source % sizeof(uint32_t) == 0 &&
-		length % sizeof(uint32_t) == 0)
+        length % sizeof(uint32_t) == 0) {
-	{
         uint32_t *d = (uint32_t *) destination;
         const uint32_t *s = (const uint32_t *) source;
 
         for (i = 0; i < length / sizeof(uint32_t); i++)
             d[i] = s[i];
-	}
+    } else {
-	else
-	{
         uint8_t *d = (uint8_t *) destination;
         const uint8_t *s = (const uint8_t *) source;
 
@@ -87,8 +70,7 @@ char * itoa(int value, char * buffer, int base, int length) {
 
         if (r >= 10) {
             buffer[i++] = 65 + (r - 10);
-        }
+        } else {
-        else {
             buffer[i++] = 48 + r;
         }
 
@@ -107,10 +89,6 @@ char * itoa(int value, char * buffer, int base, int length) {
     return reverse(buffer, 0, i - 1);
 }
 
-void strlen(const char *str, int *len) {
-    for (*len = 0; str[*len]; (*len)++);
-}
-
 int strcpy(char *strDest, const char *strSrc) {
     int i = 0;
     while ((*strDest++ = *strSrc++)) {

Kernel/utils/include/memManager.h

@@ -0,0 +1,14 @@
+#ifndef MEM_MANAGER_H
+#define MEM_MANAGER_H
+
+#include <stdlib.h>
+
+void initMemoryManager(void * managedMemory);
+void * memMalloc(unsigned nbytes);
+void memFree(void *ap);
+// void * memMalloc(const size_t memoryToAllocate);
+void * pvPortMalloc(size_t xWantedSize);
+void vPortFree( void *pv );
+size_t xPortGetFreeHeapSize( void );
+
+#endif

Kernel/utils/include/pcb.h

@@ -0,0 +1,9 @@
+#ifndef PCB_H
+#define PCB_H
+
+#include <stdint.h>
+
+void saveSampleRSP(uint64_t rsp);
+uint64_t getSampleRSP();
+
+#endif

Kernel/utils/include/pipe.h

@@ -4,7 +4,7 @@
 #include <stdint.h>
 #include <stddef.h>
 #include <stdlib.h>
-#include "lib.h"
+#include "../../include/lib.h"
 #include "scheduler.h"
 #include "memManager.h"
 #include "pipeLib.h"

Kernel/utils/include/scheduler.h

@@ -3,8 +3,8 @@
 
 #include "memManager.h"
 #include <stdlib.h>
-#include "lib.h"
+#include "../../include/lib.h"
-#include "time.h"
+#include "../../drivers/include/time.h"
 #include <stddef.h>
 #include "schedulerLib.h"
 
@@ -18,6 +18,7 @@ void haltcpu();
 #define PROCESS_DATA_MAX_SIZE 100
 #define MAX_ATTR_SIZE 6
 #define MAX_NAME_SIZE 10
+#define IDLE_PID 1
 
 typedef struct processCDT * processADT;
 
@@ -27,5 +28,6 @@ uint64_t nextProcess();
 char updateRSP(uint64_t newRsp);
 char getProcessData(char * out, processADT proc);
 processADT searchProcess(processADT * previous, int pid, processADT first);
+uint64_t _initialize_stack_frame(void *, void *, int, char **);
 
 #endif

Kernel/utils/include/sem.h

@@ -4,13 +4,14 @@
 #include <stdint.h>
 #include <stddef.h>
 #include <stdlib.h>
-#include "lib.h"
+#include "../../include/lib.h"
 #include "scheduler.h"
 #include "memManager.h"
 #include "semLib.h"
 
 #define MAX_SEM 100
 #define SEM_DATA_MAX_SIZE 100
+#define MAX_PID 4
 
 void enter_region(uint32_t * lock);
 void leave_region(uint32_t * lock);

Kernel/utils/include/semLib.h

@@ -10,7 +10,6 @@ typedef struct pid_t {
 
 typedef struct sem_t {
     unsigned int value;
-    // char name[MAX_NAME];
     char * name;
     pid_t * entering;
     pid_t * last;

Kernel/utils/memManagerFRT4.c

@@ -39,20 +39,19 @@ typedef unsigned long UBaseType_t;
 
 /* Define the linked list structure.  This is used to link free blocks in order
 of their memory address. */
-typedef struct A_BLOCK_LINK
+typedef struct A_BLOCK_LINK {
-{
     struct A_BLOCK_LINK *pxNextFreeBlock;    /*<< The next free block in the list. */
     size_t xBlockSize;                        /*<< The size of the free block. */
 } BlockLink_t;
 
 static uint8_t *ucHeap;
+
 void initMemoryManager(void *managedMemory) {
     ucHeap = managedMemory;
 }
 
 /* Definition of the Heap_stats_t structure. */
-typedef struct xHeapStats
+typedef struct xHeapStats {
-{
     size_t xAvailableHeapSpaceInBytes;      /* The total heap size currently available - this is the sum of all the free blocks, not the largest block that can be allocated. */
     size_t xSizeOfLargestFreeBlockInBytes;    /* The maximum size, in bytes, of all the free blocks within the heap at the time vPortGetHeapStats() is called. */
     size_t xSizeOfSmallestFreeBlockInBytes; /* The minimum size, in bytes, of all the free blocks within the heap at the time vPortGetHeapStats() is called. */
@@ -85,7 +84,8 @@ static void prvHeapInit( void );
 
 /* The size of the structure placed at the beginning of each allocated memory
 block must by correctly byte aligned. */
-static const size_t xHeapStructSize	= ( sizeof( BlockLink_t ) + ( ( size_t ) ( portBYTE_ALIGNMENT - 1 ) ) ) & ~( ( size_t ) portBYTE_ALIGNMENT_MASK );
+static const size_t xHeapStructSize =
+        (sizeof(BlockLink_t) + ((size_t)(portBYTE_ALIGNMENT - 1))) & ~((size_t)portBYTE_ALIGNMENT_MASK);
 
 /* Create a couple of list links to mark the start and end of the list. */
 static BlockLink_t xStart, *pxEnd = NULL;
@@ -105,15 +105,13 @@ static size_t xBlockAllocatedBit = 0;
 
 /*-----------------------------------------------------------*/
 
-void *pvPortMalloc( size_t xWantedSize )
+void *pvPortMalloc(size_t xWantedSize) {
-{
     BlockLink_t *pxBlock, *pxPreviousBlock, *pxNewBlockLink;
     void *pvReturn = NULL;
 
     /* If this is the first call to malloc then the heap will require
     initialisation to setup the list of free blocks. */
-		if( pxEnd == NULL )
+    if (pxEnd == NULL) {
-		{
         prvHeapInit();
     }
 
@@ -121,40 +119,34 @@ void *pvReturn = NULL;
     set.  The top bit of the block size member of the BlockLink_t structure
     is used to determine who owns the block - the application or the
     kernel, so it must be free. */
-		if( ( xWantedSize & xBlockAllocatedBit ) == 0 )
+    if ((xWantedSize & xBlockAllocatedBit) == 0) {
-		{
         /* The wanted size is increased so it can contain a BlockLink_t
         structure in addition to the requested amount of bytes. */
-			if( xWantedSize > 0 )
+        if (xWantedSize > 0) {
-			{
             xWantedSize += xHeapStructSize;
 
             /* Ensure that blocks are always aligned to the required number
             of bytes. */
-				if( ( xWantedSize & portBYTE_ALIGNMENT_MASK ) != 0x00 )
+            if ((xWantedSize & portBYTE_ALIGNMENT_MASK) != 0x00) {
-				{
                 /* Byte alignment required. */
                 xWantedSize += (portBYTE_ALIGNMENT - (xWantedSize & portBYTE_ALIGNMENT_MASK));
                 // configASSERT( ( xWantedSize & portBYTE_ALIGNMENT_MASK ) == 0 );
             }
         }
 
-			if( ( xWantedSize > 0 ) && ( xWantedSize <= xFreeBytesRemaining ) )
+        if ((xWantedSize > 0) && (xWantedSize <= xFreeBytesRemaining)) {
-			{
             /* Traverse the list from the start	(lowest address) block until
             one	of adequate size is found. */
             pxPreviousBlock = &xStart;
             pxBlock = xStart.pxNextFreeBlock;
-				while( ( pxBlock->xBlockSize < xWantedSize ) && ( pxBlock->pxNextFreeBlock != NULL ) )
+            while ((pxBlock->xBlockSize < xWantedSize) && (pxBlock->pxNextFreeBlock != NULL)) {
-				{
                 pxPreviousBlock = pxBlock;
                 pxBlock = pxBlock->pxNextFreeBlock;
             }
 
             /* If the end marker was reached then a block of adequate size
             was	not found. */
-				if( pxBlock != pxEnd )
+            if (pxBlock != pxEnd) {
-				{
                 /* Return the memory space pointed to - jumping over the
                 BlockLink_t structure at its start. */
                 pvReturn = (void *) (((uint8_t *) pxPreviousBlock->pxNextFreeBlock) + xHeapStructSize);
@@ -165,8 +157,7 @@ void *pvReturn = NULL;
 
                 /* If the block is larger than required it can be split into
                 two. */
-					if( ( pxBlock->xBlockSize - xWantedSize ) > heapMINIMUM_BLOCK_SIZE )
+                if ((pxBlock->xBlockSize - xWantedSize) > heapMINIMUM_BLOCK_SIZE) {
-					{
                     /* This block is to be split into two.  Create a new
                     block following the number of bytes requested. The void
                     cast is used to prevent byte alignment warnings from the
@@ -185,8 +176,7 @@ void *pvReturn = NULL;
 
                 xFreeBytesRemaining -= pxBlock->xBlockSize;
 
-					if( xFreeBytesRemaining < xMinimumEverFreeBytesRemaining )
+                if (xFreeBytesRemaining < xMinimumEverFreeBytesRemaining) {
-					{
                     xMinimumEverFreeBytesRemaining = xFreeBytesRemaining;
                 }
 
@@ -196,8 +186,7 @@ void *pvReturn = NULL;
                 pxBlock->pxNextFreeBlock = NULL;
                 xNumberOfSuccessfulAllocations++;
             }
-			}
+        } else {
-					else {
 
             // ncNewline();
             // ncPrint("MALLOC: ");
@@ -213,15 +202,14 @@ void *pvReturn = NULL;
     // configASSERT( ( ( ( size_t ) pvReturn ) & ( size_t ) portBYTE_ALIGNMENT_MASK ) == 0 );
     return pvReturn;
 }
+
 /*-----------------------------------------------------------*/
 
-void vPortFree( void *pv )
+void vPortFree(void *pv) {
-{
     uint8_t *puc = (uint8_t *) pv;
     BlockLink_t *pxLink;
 
-	if( pv != NULL )
+    if (pv != NULL) {
-	{
         /* The memory being freed will have an BlockLink_t structure immediately
         before it. */
         puc -= xHeapStructSize;
@@ -233,10 +221,8 @@ BlockLink_t *pxLink;
         // configASSERT( ( pxLink->xBlockSize & xBlockAllocatedBit ) != 0 );
         // configASSERT( pxLink->pxNextFreeBlock == NULL );
 
-		if( ( pxLink->xBlockSize & xBlockAllocatedBit ) != 0 )
+        if ((pxLink->xBlockSize & xBlockAllocatedBit) != 0) {
-		{
+            if (pxLink->pxNextFreeBlock == NULL) {
-			if( pxLink->pxNextFreeBlock == NULL )
-			{
                 /* The block is being returned to the heap - it is no longer
                 allocated. */
                 pxLink->xBlockSize &= ~xBlockAllocatedBit;
@@ -251,28 +237,28 @@ BlockLink_t *pxLink;
         }
     }
 }
+
 /*-----------------------------------------------------------*/
 
-size_t xPortGetFreeHeapSize( void )
+size_t xPortGetFreeHeapSize(void) {
-{
     return xFreeBytesRemaining;
 }
+
 /*-----------------------------------------------------------*/
 
-size_t xPortGetMinimumEverFreeHeapSize( void )
+size_t xPortGetMinimumEverFreeHeapSize(void) {
-{
     return xMinimumEverFreeBytesRemaining;
 }
+
 /*-----------------------------------------------------------*/
 
-void vPortInitialiseBlocks( void )
+void vPortInitialiseBlocks(void) {
-{
     /* This just exists to keep the linker quiet. */
 }
+
 /*-----------------------------------------------------------*/
 
-static void prvHeapInit( void )
+static void prvHeapInit(void) {
-{
     BlockLink_t *pxFirstFreeBlock;
     uint8_t *pucAlignedHeap;
     size_t uxAddress;
@@ -281,8 +267,7 @@ size_t xTotalHeapSize = configTOTAL_HEAP_SIZE;
     /* Ensure the heap starts on a correctly aligned boundary. */
     uxAddress = (size_t) ucHeap;
 
-	if( ( uxAddress & portBYTE_ALIGNMENT_MASK ) != 0 )
+    if ((uxAddress & portBYTE_ALIGNMENT_MASK) != 0) {
-	{
         uxAddress += (portBYTE_ALIGNMENT - 1);
         uxAddress &= ~((size_t)portBYTE_ALIGNMENT_MASK);
         xTotalHeapSize -= uxAddress - (size_t) ucHeap;
@@ -317,25 +302,24 @@ size_t xTotalHeapSize = configTOTAL_HEAP_SIZE;
     /* Work out the position of the top bit in a size_t variable. */
     xBlockAllocatedBit = ((size_t) 1) << ((sizeof(size_t) * heapBITS_PER_BYTE) - 1);
 }
+
 /*-----------------------------------------------------------*/
 
-static void prvInsertBlockIntoFreeList( BlockLink_t *pxBlockToInsert )
+static void prvInsertBlockIntoFreeList(BlockLink_t *pxBlockToInsert) {
-{
     BlockLink_t *pxIterator;
     uint8_t *puc;
 
     /* Iterate through the list until a block is found that has a higher address
     than the block being inserted. */
-	for( pxIterator = &xStart; pxIterator->pxNextFreeBlock < pxBlockToInsert; pxIterator = pxIterator->pxNextFreeBlock )
+    for (pxIterator = &xStart;
-	{
+         pxIterator->pxNextFreeBlock < pxBlockToInsert; pxIterator = pxIterator->pxNextFreeBlock) {
         /* Nothing to do here, just iterate to the right position. */
     }
 
     /* Do the block being inserted, and the block it is being inserted after
     make a contiguous block of memory? */
     puc = (uint8_t *) pxIterator;
-	if( ( puc + pxIterator->xBlockSize ) == ( uint8_t * ) pxBlockToInsert )
+    if ((puc + pxIterator->xBlockSize) == (uint8_t *) pxBlockToInsert) {
-	{
         pxIterator->xBlockSize += pxBlockToInsert->xBlockSize;
         pxBlockToInsert = pxIterator;
     }
@@ -343,21 +327,15 @@ uint8_t *puc;
     /* Do the block being inserted, and the block it is being inserted before
     make a contiguous block of memory? */
     puc = (uint8_t *) pxBlockToInsert;
-	if( ( puc + pxBlockToInsert->xBlockSize ) == ( uint8_t * ) pxIterator->pxNextFreeBlock )
+    if ((puc + pxBlockToInsert->xBlockSize) == (uint8_t *) pxIterator->pxNextFreeBlock) {
-	{
+        if (pxIterator->pxNextFreeBlock != pxEnd) {
-		if( pxIterator->pxNextFreeBlock != pxEnd )
-		{
             /* Form one big block from the two blocks. */
             pxBlockToInsert->xBlockSize += pxIterator->pxNextFreeBlock->xBlockSize;
             pxBlockToInsert->pxNextFreeBlock = pxIterator->pxNextFreeBlock->pxNextFreeBlock;
-		}
+        } else {
-		else
-		{
             pxBlockToInsert->pxNextFreeBlock = pxEnd;
         }
-	}
+    } else {
-	else
-	{
         pxBlockToInsert->pxNextFreeBlock = pxIterator->pxNextFreeBlock;
     }
 
@@ -365,37 +343,33 @@ uint8_t *puc;
     before and the block after, then it's pxNextFreeBlock pointer will have
     already been set, and should not be set here as that would make it point
     to itself. */
-	if( pxIterator != pxBlockToInsert )
+    if (pxIterator != pxBlockToInsert) {
-	{
         pxIterator->pxNextFreeBlock = pxBlockToInsert;
     }
 }
+
 /*-----------------------------------------------------------*/
 
-void vPortGetHeapStats( HeapStats_t *pxHeapStats )
+void vPortGetHeapStats(HeapStats_t *pxHeapStats) {
-{
     BlockLink_t *pxBlock;
-size_t xBlocks = 0, xMaxSize = 0, xMinSize = configTOTAL_HEAP_SIZE;//portMAX_DELAY; /* portMAX_DELAY used as a portable way of getting the maximum value. */
+    size_t xBlocks = 0, xMaxSize = 0, xMinSize =
+            configTOTAL_HEAP_SIZE;//portMAX_DELAY; /* portMAX_DELAY used as a portable way of getting the maximum value. */
 
     pxBlock = xStart.pxNextFreeBlock;
 
     /* pxBlock will be NULL if the heap has not been initialised.  The heap
     is initialised automatically when the first allocation is made. */
-		if( pxBlock != NULL )
+    if (pxBlock != NULL) {
-		{
+        do {
-			do
-			{
             /* Increment the number of blocks and record the largest block seen
             so far. */
             xBlocks++;
 
-				if( pxBlock->xBlockSize > xMaxSize )
+            if (pxBlock->xBlockSize > xMaxSize) {
-				{
                 xMaxSize = pxBlock->xBlockSize;
             }
 
-				if( pxBlock->xBlockSize < xMinSize )
+            if (pxBlock->xBlockSize < xMinSize) {
-				{
                 xMinSize = pxBlock->xBlockSize;
             }
 

Kernel/utils/pcb.c

@@ -1,37 +1,5 @@
 #include "pcb.h"
 
-// static const uint8_t * firstProcessAddress = (uint8_t *) 0x18000000;
-// static const long stackSize = 0x4000000; // 2^26
-// static const uint8_t * lastProcessAddress = (uint8_t *) 0x10000001; // 2^29 - 1
-
-// int activeProcesses = 0, currentProcess = -1;
-// uint64_t priority0[MAX_PROCESSES];
-// uint64_t priority1[MAX_PROCESSES];
-// uint64_t priority2[MAX_PROCESSES];
-
-// void cleanProcesses() {
-//     activeProcesses = 0;
-//     currentProcess = -1;
-// }
-
-// void newProcess(void (*fn)) {
-//     if (firstProcessAddress - activeProcesses * stackSize + stackSize <= lastProcessAddress) return;
-//     _initialize_stack_frame(fn, firstProcessAddress - activeProcesses * stackSize);
-// }
-
-// void newStack(uint64_t rsp) {
-//     priority0[activeProcesses++] = rsp;
-// }
-
-// uint64_t preserveStack(uint64_t rsp) {
-//     if (currentProcess != -1) {
-//         priority0[currentProcess] = rsp;
-//     }
-//     if (++currentProcess >= activeProcesses) currentProcess = 0;
-//     if (activeProcesses == 0) return 0;
-//     return priority0[currentProcess];
-// }
-
 static uint64_t sampleRSP;
 
 void saveSampleRSP(uint64_t rsp) {

Kernel/utils/queue.c

@@ -1,51 +0,0 @@
-// #include "queue.h"
-// #include "memManager.h"
-// #include <stdint.h>
-
-// typedef struct nodeT {
-//     processADT * process;
-//     struct nodeT * next;
-// } nodeT;
-
-// typedef struct queueCDT {
-//     nodeT * first;
-//     nodeT * last;
-//     int length;
-// } queueCDT;
-
-// queueADT createQueue() {
-//     queueADT aux = pvPortMalloc(sizeof(queueCDT));
-//     if (aux == NULL)
-//         return NULL;
-//     aux->first = NULL;
-//     aux->last = NULL;
-//     aux->length = 0;
-//     return aux;
-// }
-
-// void queue(queueADT * my_queue, processADT * process) {
-//     if (my_queue == NULL)
-//         return;
-//     nodeT * new_node = pvPortMalloc(sizeof(nodeT));
-//     if (new_node == NULL)
-//         return;
-//     new_node->process = process;
-//     new_node->next = NULL;
-//     (*my_queue)->last->next = new_node;
-//     (*my_queue)->last = new_node;
-//     (*my_queue)->length++;
-// }
-
-// processADT * dequeue(queueADT * my_queue) {
-//     if (my_queue == NULL || isEmpty(my_queue))
-//         return NULL;
-//     nodeT * aux = (*my_queue)->first;
-//     (*my_queue)->first = (*my_queue)->first->next;
-//     processADT * ans = aux->process;
-//     vPortFree(aux);
-//     return ans;
-// }
-
-// char isEmpty(queueADT * my_queue) {
-//     return (*my_queue)->length == 0;
-// }

Kernel/utils/scheduler.c

@@ -1,9 +1,8 @@
 #include "scheduler.h"
-#define IDLE_PID 1
 
-uint64_t _initialize_stack_frame(void *, void *, int, char**);
+enum states {
-
+    READY = 0, DEAD, BLOCKED, BBCHILDREN, WAITING, BLOCKEDIO
-enum states {READY = 0, DEAD, BLOCKED, BBCHILDREN, WAITING, BLOCKEDIO};
+};
 
 typedef struct processCDT {
     struct processCDT *next;
@@ -47,8 +46,7 @@ void removeProcess(processCDT * del, processCDT ** first, processCDT ** last) {
         *first = del->next;
         if (*last == del)
             *last = NULL;
-    }
+    } else {
-    else {
         prev->next = del->next;
         if (*last == del)
             *last = prev;
@@ -59,27 +57,27 @@ uint64_t nextProcess(uint64_t currentRSP) {
     if (currentProcess != NULL)
         currentProcess->rsp = currentRSP;
     processCDT *prev = currentProcess;
-    if (currentProcess != NULL && currentProcess->state == READY && currentProcess->executions == MAX_PRIORITY - currentProcess->priority + 1) {
+    if (currentProcess != NULL && currentProcess->state == READY &&
+        currentProcess->executions == MAX_PRIORITY - currentProcess->priority + 1) {
         currentProcess->executions = 0;
         currentProcess = currentProcess->next;
     }
-    while (currentProcess == NULL || currentProcess->state == BLOCKED || currentProcess->state == DEAD || currentProcess->state == WAITING || currentProcess->state == BLOCKEDIO) {
+    while (currentProcess == NULL || currentProcess->state == BLOCKED || currentProcess->state == DEAD ||
+           currentProcess->state == WAITING || currentProcess->state == BLOCKEDIO) {
         if (currentProcess == NULL) {
             currentProcess = firstProcess;
-        }
+        } else if (currentProcess == firstBlockedIteration) {
-        else if (currentProcess == firstBlockedIteration) {
             idleFlag = 1;
             unblock(IDLE_PID);
             prev = currentProcess;
             currentProcess = currentProcess->next;
-        }
+        } else if (currentProcess->state == DEAD) {
-        else if (currentProcess->state == DEAD) {
             processCDT *del = currentProcess;
             currentProcess = currentProcess->next;
             removeProcess(del, &firstProcess, &lastProcess);
             vPortFree((void *) del);
-        }
+        } else if (currentProcess->state == BLOCKED || currentProcess->state == WAITING ||
-        else if (currentProcess->state == BLOCKED || currentProcess->state == WAITING || currentProcess->state == BLOCKEDIO) {
+                   currentProcess->state == BLOCKEDIO) {
             if (firstBlockedIteration == NULL)
                 firstBlockedIteration = currentProcess;
             prev = currentProcess;
@@ -195,8 +193,7 @@ void checkSleeping() {
         if (getTimeOfDay() >= aux->time + aux->secs) {
             wakeUp(aux, prev);
             aux = prev->next;
-        }
+        } else {
-        else {
             prev = aux;
             aux = aux->next;
         }
@@ -278,8 +275,7 @@ char unblock(int pid) {
     processADT del = searchProcess(&prev, pid, firstProcess);
     if (del == NULL || del->state == DEAD) {
         return EXIT_FAILURE;
-    }
+    } else {
-    else {
         del->state = READY;
     }
 
@@ -347,8 +343,7 @@ char nice(int pid, char offset) {
     processADT del = searchProcess(&prev, pid, firstProcess);
     if (del == NULL) {
         return EXIT_FAILURE;
-    }
+    } else {
-    else {
         del->priority = offset + 20;
     }
     return EXIT_SUCCESS;
@@ -428,7 +423,8 @@ char getProcessData(char * out, processCDT * proc) {
     getGenProcessData(&out, &written, MAX_NAME_SIZE, itoa(proc->rsp, buffer, 16, 10), 0);
     getGenProcessData(&out, &written, MAX_NAME_SIZE, itoa(proc->rbp, buffer, 16, 10), 0);
     getGenProcessData(&out, &written, MAX_ATTR_SIZE, (proc->foreground == 1) ? "F" : "B", 0);
-    getGenProcessData(&out, &written, MAX_ATTR_SIZE, proc->state == BLOCKED ? "Block" : proc->state == DEAD ? "Killed" : "Ready", 1);
+    getGenProcessData(&out, &written, MAX_ATTR_SIZE,
+                      proc->state == BLOCKED ? "Block" : proc->state == DEAD ? "Killed" : "Ready", 1);
 
     return written;
 }

Kernel/utils/sem.c

@@ -39,16 +39,16 @@ char semClose(sem_t * sem) {
     if (firstSem->sem == sem) {
         del = firstSem;
         firstSem = firstSem->next;
-    }
+    } else {
-    else {
         node_t *aux = firstSem;
         while (aux != NULL) {
-            if (aux->next != NULL)
+            if (aux->next != NULL) {
                 if (aux->next->sem == sem) {
                     del = aux->next;
                     aux->next = aux->next->next;
                     break;
                 }
+            }
             aux = aux->next;
         }
     }
@@ -79,8 +79,7 @@ void semWait(sem_t * sem) {
 
     if (sem->value > 0) {
         sem->value--;
-    } 
+    } else {
-    else {
         leave_region(&semLock);
 
         pid_t *curr = pvPortMalloc(sizeof(pid_t));
@@ -157,8 +156,6 @@ char getSemaphoresData(char * out, node_t * node) {
     return written;
 }
 
-#define MAX_PID 4
-
 char *getEntering(sem_t *sem) {
     char *ans = pvPortMalloc(sizeof(pid_t * ));
     pid_t *aux = sem->entering;

Userland/SampleCodeModule/Makefile

@@ -17,10 +17,7 @@ ALL_OBJECTS= $(OBJECTS) $(OBJECTS_ASM) $(OBJECTS_SHELL) $(OBJECTS_COMMANDS) $(OB
 
 STATICLIBS=
 
-all: $(MODULE) $(MODULE_ELF) #shellModule
+all: $(MODULE) $(MODULE_ELF)
-
-#shellModule:
-#	cd shell; make
 
 $(MODULE): $(STATICLIBS) $(ALL_OBJECTS)
 	$(LD) $(LDFLAGS) -T sampleCodeModule.ld $(OBJECTS) $(OBJECTS_SHELL) $(OBJECTS_ASM) $(OBJECTS_PROMPT) $(OBJECTS_BOTTLER) -o ../$(MODULE)
@@ -35,24 +32,6 @@ $(MODULE_ELF): $(STATICLIBS) $(ALL_OBJECTS)
 	$(ASM) $(ASMFLAGS) $< -o $@
 
 clean:
-#	cd shell; make clean
+	rm -rf $(ALL_OBJECTS)
-	rm -rf *.o
-	cd shell; rm -rf *.o
-	cd shell/commands; rm -rf *.o
 
 .PHONY: all clean print
-
-# include ../Makefile.inc
-
-# MODULE=0000-sampleCodeModule.bin
-# SOURCES=$(wildcard [^_]*.c)
-
-# all: $(MODULE)
-
-# $(MODULE): $(SOURCES)
-# 	$(GCC) $(GCCFLAGS) -T sampleCodeModule.ld _loader.c $(SOURCES) -I./include -o ../$(MODULE)
-
-# clean:
-# 	rm -rf *.o
-
-# .PHONY: all clean print

Userland/SampleCodeModule/_loader.c

@@ -1,4 +1,3 @@
-/* _loader.c */
 #include <stdint.h>
 
 extern char bss;
@@ -9,13 +8,11 @@ int main(int argc, char *argv[]);
 void *memset(void *destiny, int32_t c, uint64_t length);
 
 int _start(int argc, char *argv[]) {
-	//Clean BSS
     memset(&bss, 0, &endOfBinary - &bss);
 
     return main(argc, argv);
 }
 
-
 void *memset(void *destination, int32_t c, uint64_t length) {
     uint8_t chr = (uint8_t) c;
     char *dst = (char *) destination;

Userland/SampleCodeModule/bottler/bottler.c

@@ -1,39 +1,64 @@
 #include "bottler.h"
 
 void bottler(int argc, char **argv) {
-	printStringLen("                                                                             ", 80); new_line();
+    printStringLen("                                                                             ", 80);
-    printStringLen("                                   (%(                                     ", 80); new_line();
+    new_line();
+    printStringLen("                                   (%(                                     ", 80);
+    new_line();
     printStringLen("      Welcome to", 17);
-    printStringLen("                  %%%%%                                      ", 80); new_line();
+    printStringLen("                  %%%%%                                      ", 80);
+    new_line();
     printStringLen("        BottlerOS", 18);
-    printStringLen("                  %%%                                      ", 80); new_line();
+    printStringLen("                  %%%                                      ", 80);
-    printStringLen( "                              %%%%%%%%%%%%%                                 ", 80); new_line();
+    new_line();
-    printStringLen( "                          %%%%%%%%%%%%%%%%%%%%%                             ", 80); new_line();
+    printStringLen("                              %%%%%%%%%%%%%                                 ", 80);
-    printStringLen( "                        %%%%%%%           %%%%%%%                           ", 80); new_line();
+    new_line();
-    printStringLen( "                      %%%%%                   %%%%%                         ", 80); new_line();
+    printStringLen("                          %%%%%%%%%%%%%%%%%%%%%                             ", 80);
-    printStringLen( "                     %%%%%                     %%%%%                        ", 80); new_line();
+    new_line();
+    printStringLen("                        %%%%%%%           %%%%%%%                           ", 80);
+    new_line();
+    printStringLen("                      %%%%%                   %%%%%                         ", 80);
+    new_line();
+    printStringLen("                     %%%%%                     %%%%%                        ", 80);
+    new_line();
     printStringLen("                    %%%%% ", 27);
     printStringLen(" %%%%           %%%% ", 22);
-	printStringLen( " %%%%%                       ", 30); new_line();
+    printStringLen(" %%%%%                       ", 30);
+    new_line();
     printStringLen("                    %%%%%  ", 28);
     printStringLen(" (%             %(  ", 21);
-	printStringLen( " %%%%%                       ", 30); new_line();
+    printStringLen(" %%%%%                       ", 30);
-    printStringLen( "                    %%%%%%%                   %%%%%%%                       ", 80); new_line();
+    new_line();
-    printStringLen("                    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                       ", 80); new_line();
+    printStringLen("                    %%%%%%%                   %%%%%%%                       ", 80);
-    printStringLen("                 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                    ", 80); new_line();
+    new_line();
+    printStringLen("                    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                       ", 80);
+    new_line();
+    printStringLen("                 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                    ", 80);
+    new_line();
     printStringLen("                %%%%%%%%%%%%%%%%%%%%%%% ", 41);
     printStringLen(" %  %* ", 8);
-	printStringLen(" %%%%%%%%%                   ", 30); new_line();
+    printStringLen(" %%%%%%%%%                   ", 30);
-    printStringLen("                %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                   ", 80); new_line();
+    new_line();
-    printStringLen("                %%**%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/%%                   ", 80); new_line();
+    printStringLen("                %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%                   ", 80);
-    printStringLen("                %%* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% /%%                   ", 80); new_line();
+    new_line();
-    printStringLen("                %%* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% /%%                   ", 80); new_line();
+    printStringLen("                %%**%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/%%                   ", 80);
-    printStringLen("                %%%  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  %%%                   ", 80); new_line();
+    new_line();
-    printStringLen( "              ,%%%%%   %%%%%%%%%%%%%%%%%%%%%%%%%%%   %%%%%.                 ", 80); new_line();
+    printStringLen("                %%* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% /%%                   ", 80);
-    printStringLen( "                %%.         %%%%%%%%%%%%%%%%%         .%%                   ", 80); new_line();
+    new_line();
-    printStringLen( "                              %%%%%%%%%%%%%                                 ", 80); new_line();
+    printStringLen("                %%* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% /%%                   ", 80);
-    printStringLen( "                                 %%%%%%%                                    ", 80); new_line();
+    new_line();
-    printStringLen( "                                                                            ", 80); new_line();
+    printStringLen("                %%%  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  %%%                   ", 80);
+    new_line();
+    printStringLen("              ,%%%%%   %%%%%%%%%%%%%%%%%%%%%%%%%%%   %%%%%.                 ", 80);
+    new_line();
+    printStringLen("                %%.         %%%%%%%%%%%%%%%%%         .%%                   ", 80);
+    new_line();
+    printStringLen("                              %%%%%%%%%%%%%                                 ", 80);
+    new_line();
+    printStringLen("                                 %%%%%%%                                    ", 80);
+    new_line();
+    printStringLen("                                                                            ", 80);
+    new_line();
     sys_sleep(3);
 
     winClear();

Userland/SampleCodeModule/include/system.h

@@ -8,13 +8,11 @@ typedef struct pid_t {
 
 typedef struct sem_t {
     unsigned int value;
-    // char name[MAX_NAME];
     char * name;
     pid_t * entering;
     pid_t * last;
 } sem_t;
 
-// void sys_switchContext();
 int sys_loadProcess(void (*fn) (int, char **), char foreground, int argc, char *argv[], int * fd);
 int sys_time(char);
 void sys_exit();
@@ -27,10 +25,8 @@ void * sys_free(void *);
 void * sys_openPipe(int *, char *);
 char sys_nice(int, char);
 void sys_sleep(int);
-// void sys_semWait(void *);
 void sys_semWait(sem_t *);
 void sys_semPost(sem_t *);
-// void * sys_semOpen(char *, unsigned int);
 sem_t * sys_semOpen(char *, unsigned int);
 int sys_getPid();
 char sys_semClose(void *);

Userland/SampleCodeModule/libc.c

@@ -74,8 +74,7 @@ char* gtoa(int value, char* buffer, int base, int length) {
         int r = n % base;
         if (r >= 10) {
             buffer[i++] = 65 + (r - 10);
-        }
+        } else {
-        else {
             buffer[i++] = 48 + r;
         }
         n = n / base;
@@ -102,7 +101,9 @@ char getChar() {
 }
 
 void swap(char *x, char *y) {
-    char t = *x; *x = *y; *y = t;
+    char t = *x;
+    *x = *y;
+    *y = t;
 }
 
 char *reverse(char *buffer, int i, int j) {
@@ -129,8 +130,7 @@ char* itoa(int value, char* buffer, int base) {
         int r = n % base;
         if (r >= 10) {
             buffer[i++] = 65 + (r - 10);
-        }
+        } else {
-        else {
             buffer[i++] = 48 + r;
         }
         n = n / base;
@@ -149,14 +149,6 @@ char* itoa(int value, char* buffer, int base) {
     return reverse(buffer, 0, i - 1);
 }
 
-// int atoi(char * string, int length) {
-//     int res = 0, i = 0;
-//     while (string[i] != 0 && i < length) {
-//         res = res * 10 + string[i++] - '0';
-//     }
-//     return res;
-// }
-
 int atoi(char *str, int length) {
     int i = 0, sign = 1, val = 0, nbr = 0;
     while (str[i] != '\0') {
@@ -246,8 +238,7 @@ char *strtok(char * s, char delim) {
         if (*ptr == delim) {
             flag = 1;
             *ptr = 0;
-        }
+        } else if (flag == 1)
-        else if (flag == 1)
             return ptr;
         ptr++;
     }

Userland/SampleCodeModule/sampleCodeModule.c

@@ -1,11 +1,8 @@
-/* sampleCodeModule.c */
 #include "libc.h"
 #include "shell/include/shell.h"
 #include "bottler/include/bottler.h"
 #include <stddef.h>
-
+#include "system.h"
-int sys_loadProcess(void (*fn) (int, char **), char foreground, int argc, char *argv[], int * fd);
-void sys_exit();
 
 int main(int argc, char *argv[]) {
     winClear();

Userland/SampleCodeModule/shell/Makefile

@@ -1,20 +0,0 @@
-# include ../../Makefile.inc
-
-# SOURCES=$(wildcard *.c)
-# SOURCES_COMMANDS=$(wildcard prompt_commands/*.c)
-# OBJECTS=$(SOURCES:.c=.o)
-# OBJECTS_COMMANDS=$(SOURCES_COMMANDS:.c=.o)
-
-# ALL_OBJECTS= $(OBJECTS) $(OBJECTS_COMMANDS)
-
-# STATICLIBS=
-
-# all: $(OBJECTS)
-
-# %.o:%.c
-# 	$(GCC) $(GCCFLAGS) -I./include -c $< -o $@
-
-# clean:
-# 	rm -rf *.o
-
-# .PHONY: all clean print

Userland/SampleCodeModule/shell/shell.c

@@ -34,8 +34,7 @@ int scanfNoPrint(char * buffer) {
             if (c == '\b' && i > 0) {
                 buffer[--i] = ' ';
                 backspace();
-            }
+            } else if (c != 0 && c != '\b') {
-            else if (c != 0 && c != '\b') { 
                 buffer[i++] = c;
                 putChar(c);
             }
@@ -98,8 +97,7 @@ void processInput(char * input) {
         argv1 = sys_malloc(sizeof(char *) * (end - pipe - 1));
         for (int i = pipe + 1; i < end; i++)
             argv1[i - pipe - 1] = tokens[i];
-    }
+    } else {
-    else {
         argv0 = sys_malloc(sizeof(char *) * end);
         for (int i = 0; i < end; i++)
             argv0[i] = tokens[i];
@@ -125,8 +123,7 @@ void processInput(char * input) {
         if (pipe != -1) {
             sys_loadProcess(commands[comm0].func, commands[comm0].isForeground, pipe, argv0, fd1);
             sys_loadProcess(commands[comm1].func, commands[comm0].isForeground, end - pipe - 1, argv1, fd2);
-        }
+        } else {
-        else {
             if (commands[comm0].isBuiltIn)
                 commands[comm0].func(end, argv0);
             else {
@@ -143,8 +140,7 @@ void processInput(char * input) {
     if (!comm_flag0) {
         if (*tokens[0] != 0)
             incorrect_comm(tokens[0]);
-    }
+    } else if (!comm_flag1 && pipe != -1) {
-    else if (!comm_flag1 && pipe != -1) {
         if (*tokens[pipe + 1] != 0)
             incorrect_comm(tokens[pipe + 1]);
     }
@@ -154,13 +150,11 @@ void shell(int argc, char *argv[]) {
     printStringLen("$> ", 3);
     char buffer[SIZE] = {0};
 
-    // while (1) {
     while (scanfNoPrint(buffer) != 0) {
         new_line();
         processInput(buffer);
         printStringLen("$> ", 3);
     }
-    // }
 }
 
 void incorrect_comm(char *buffer) {