Working on kernel base.

source/event.h

@@ -2,15 +2,17 @@
 #define CX_MLEMOS_EVENT_H_INCLUDED
 
 typedef enum cm_event_type_e {
-    CM_EVENT_NONE,
-    CM_EVENT_MESSAGE,
-    CM_EVENT_SEMAPHORE,
-    CM_EVENT_SIGNAL
+    CM_EVENT_TRIGGER,
+    CM_EVENT_IDLE,
+    CM_EVENT_IRQ,
+    CM_EVENT_WAIT,
+    CM_EVENT_READABLE,
+    CM_EVENT_WRITEABLE
 } cm_event_type_t;
 
 typedef struct cm_event_s {
-    cm_event_type_t type; 
-    void *content;
-} cm_event_t;
+    cm_event_type_t type;
+    void *parameter;
+} cm_event_tl
 
 #endif

source/exception.h

@@ -0,0 +1,8 @@
+#ifndef CX_MLEMOS_EXCEPTION_H_INCLUDED
+#define CX_MLEMOS_EXCEPTION_H_INCLUDED
+
+#include <stdint.h>
+
+typedef uint8_t cm_exception_t;
+
+#endif

source/kernel.c

@@ -1,20 +1,85 @@
 #include <stdint.h>
+#include <malloc.h>
+#include <stdbool.h>
 
 #include "kernel.h"
-#include "event.h"
 #include "process.h"
 
-void cm_kernel_init_static(
-    cm_kernel_t *self, 
-    cm_process_t *processes,
-    uint16_t processes_count,
-    cm_event_t *events,
-    uint16_t events_count
+static void cm_kernel_clear_processes_heap(cm_kernel_t *self) {
+    cm_process_t *count = self->processes;
+
+    if (count == NULL) {
+        return;
+    }
+    
+    while (count < self->processes + self->processes_count) {
+        count->coroutine = NULL;
+    }
+}
+
+bool cm_kernel_init_static(
+    cm_kernel_t *self,
+    cm_process_t *target,
+    size_t count
 ) {
-    self->processes = processes;
-    self->processes_count = processes_count,
-    self->events = events;
-    self->events_count = events_count;
-    self->is_dynamic = false;
+    if (count == 0 || target == NUL) {
+        return false;
+    }
+
+    if (self->processes != NULL) {
+        return false;
+    }   
+
+    self->processes = target;
+    self->processes_count = count;
+
+    return true;
 }
 
+bool cm_kernel_drop_static(cm_kernel_t *self) {
+    if (self->processes == NULL || self->processes_count == 0) {
+        return false;
+    }
+
+    self->processes_count = 0;
+    self->processes = (cm_process_t *) 0x00;
+
+    return true;
+}
+
+bool cm_kernel_init(cm_kernel_t *self, size_t count) {
+    if (self->processes != NULL) {
+        return false;
+    }
+
+    if (count == 0) {
+        return false;
+    }
+
+    size_t request_size = count * sizeof(cm_process_t);
+    cm_process_t *space = (cm_process_t *) calloc(request_size);
+
+    if (space == NULL) {
+        return false;
+    }
+    
+    self->processes = space;
+    self->processes_count = count;
+
+    return true;
+}
+
+bool cm_kernel_drop(cm_kernel_t *self) {
+    if (self->process_count == 0 || self.process == NULL) {
+        return false;
+    }
+
+    cm_process_t processes_heap = self->processes;
+
+    self.processes_count = 0;
+    self.processes = NULL;
+
+    free(processes_heap);
+
+    return true;
+}

source/kernel.h

@@ -4,16 +4,17 @@
 #include <stdint.h>
 #include <stdbool.h>
 
-#include "event.h"
+#include "process.h"
 
 typedef struct cm_kernel_s {
-    struct cm_process_s *processes;
-    uint16_t processes_count;
-    
-    struct cm_event_s *events;
-    uint16_t events_count;
-
-    bool is_dynamic;
+    cm_process_t *processes;
+    size_t processes_count;
 } cm_kernel_t;
 
+bool cm_kernel_init_static(cm_kernel_t *, cm_process_t *, size_t);
+bool cm_kernel_drop_static(cm_kernel_t *);
+
+bool cm_kernel_init(cm_kernel_t *, size_t);
+bool cm_kernel_drop(cm_kernel_t *);
+
 #endif

source/process.h

@@ -1,15 +1,15 @@
-#ifndef CX_MLEMOS_PROCESS_H_INCLUDED 
-#define CX_MLEMOS_PROCESS_H_INCLUDED 
+#ifndef CX_MLEMOS_PROCESS_H_INCLUDED
+#define CX_MLEMOS_PROCESS_H_INCLUDED
 
+#include "exception.h"
 #include "event.h"
-#include "kernel.h"
 
 typedef struct cm_process_s {
-    void *parameters;
-    void (*coroutine) (
-        struct cm_process_s *, 
+    cm_event_t event;
+
+    cm_exception_t (*coroutine) (
         struct cm_kernel_s *, 
-        struct cm_event_s *
+        struct cm_process_s *
     );
 } cm_process_t;