Sync.

headers/zivuos.h

@@ -1,13 +0,0 @@
-#ifndef CX_ZIVU_H_INCLUDED
-#define CX_ZIVU_H_INCLUDED
-
-#include "zivuos/kernel.h"
-#include "zivuos/models.h"
-#include "zivuos/process.h"
-#include "zivuos/result.h"
-#include "zivuos/scheduler.h"
-#include "zivuos/alloc.h"
-#include "zivuos/vector.h"
-#include "zivuos/vector_helpers.h"
-
-#endif

headers/zivuos/alloc.h

@@ -1,14 +0,0 @@
-#ifndef CX_ZIVUOS_ALLOC_H_INCLUDED
-#define CX_ZIVUOS_ALLOC_H_INCLUDED
-
-#include <stddef.h>
-#include <stdint.h>
-#include <stdbool.h>
-
-void * zv_alloc(size_t);
-void * zv_alloc_zero(size_t);
-void zv_free(void *);
-
-#define ZV_ALLOC_USE_STDLIB
-
-#endif

headers/zivuos/kernel.h

@@ -1,58 +0,0 @@
-#ifndef CX_ZIVUOS_KERNEL_H_INCLUDED
-#define CX_ZIVUOS_KERNEL_H_INCLUDED
-
-#include <stdint.h>
-#include <stddef.h>
-#include <stdbool.h>
-
-#include "models.h"
-#include "process.h"
-#include "scheduler.h"
-#include "result.h"
-
-typedef struct zv_kernel_s {
-    size_t processes_count;
-    zv_process_t *processes;
-    zv_pid_t last;
-    zv_scheduler_mode_t mode;
-    zv_pid_t interrupts;
-    zv_priority_t lowest_priority;
-} zv_kernel_t;
-
-void zv_kernel_init(
-    zv_kernel_t *,
-    zv_process_t *,
-    zv_pid_t
-);
-
-zv_pid_t zv_kernel_add_process(
-    zv_kernel_t *,
-    zv_worker_t,
-    zv_universal_t,
-    zv_priority_t
-);
-
-void __zv_kernel_clean_balance(zv_kernel_t *);
-void zv_kernel_idle_task();
-bool zv_kernel_set_scheduler(zv_kernel_t *, zv_scheduler_mode_t);
-zv_result_t zv_kernel_trigger_process(zv_kernel_t *, zv_pid_t);
-
-static inline zv_process_t * __zv_kernel_get_process(
-    zv_kernel_t *self, 
-    zv_pid_t target
-) {
-    if (self->processes_count <= target) {
-        return NULL;
-    }
-
-    return self->processes + target;
-}
-
-static inline zv_pid_t zv_kernel_get_pid(
-    zv_kernel_t *self, 
-    zv_process_t *target
-) {
-    return (zv_pid_t) (target - self->processes);
-}
-
-#endif

headers/zivuos/models.h

@@ -1,38 +0,0 @@
-#ifndef CX_ZIVUOS_MODELS_H_INCLUDED
-#define CX_ZIVUOS_MODELS_H_INCLUDED
-
-#include <stdint.h>
-#include <stdbool.h>
-
-typedef uint16_t zv_pid_t;
-typedef uint8_t zv_priority_t;
-
-typedef enum zv_state_e {
-    ZV_EMPTY,
-    ZV_WORKING,
-    ZV_READY,
-    ZV_INTERRUPTED,
-    ZV_INTERRUPT_WAITING,
-    ZV_WAITING
-} zv_state_t;
-
-typedef union zv_universal_u {
-    uintptr_t unumber;
-    intptr_t number;
-    void *pointer;
-    char *cstring;
-} zv_universal_t;
-
-struct zv_kernel_s;
-struct zv_process_s;
-
-typedef zv_state_t (*zv_worker_t) (
-    struct zv_kernel_s *, 
-    struct zv_process_s *
-);
-
-#define ZV_LOWEST_PRIORITY UINT8_MAX
-#define ZV_ERROR_PID UINT16_MAX
-#define ZV_NULL_PARAM ((zv_universal_t) NULL)
-
-#endif

headers/zivuos/process.h

@@ -1,36 +0,0 @@
-#ifndef CX_ZIVUOS_PROCESS_H_INCLUDED
-#define CX_ZIVUOS_PROCESS_H_INCLUDED
-
-#include <stdint.h>
-#include <stdbool.h>
-
-#include "result.h"
-#include "models.h"
-
-typedef struct zv_process_s {
-    zv_state_t state;
-    zv_priority_t priority;
-    zv_priority_t balance;
-    zv_worker_t worker;
-    zv_universal_t param;
-} zv_process_t;
-
-static inline bool zv_process_is_ready(zv_process_t *self) {
-    return self->state == ZV_READY || self->state == ZV_INTERRUPTED;
-}
-
-static inline zv_priority_t _zv_process_calc_priority(zv_process_t *self) {
-    if (ZV_LOWEST_PRIORITY - self->priority < self->balance) {
-        return ZV_LOWEST_PRIORITY;
-    }
-
-    return self->priority + self->balance;
-}
-
-zv_result_t zv_process_set_param(zv_process_t *, zv_universal_t);
-zv_result_t zv_process_set_worker(zv_process_t *, zv_worker_t);
-zv_result_t zv_process_set_priority(zv_process_t *, zv_priority_t);
-
-#define ZV_COUNT_PROCESSES(X) ((sizeof(X) / sizeof(zv_process_t)))
-
-#endif

headers/zivuos/result.h

@@ -1,14 +0,0 @@
-#ifndef CX_ZIVUOS_RESULT_H_INCLUDED
-#define CX_ZIVUOS_RESULT_H_INCLUDED
-
-typedef enum zv_result_e {
-    ZV_SUCCESS = 0,
-    ZV_ERROR = 1,
-    ZV_ALREADY_TRIGGERED = 2,
-    ZV_IN_USE = 3,
-    ZV_NOT_EXISTS = 4,
-    ZV_NOT_READY = 6,
-    ZV_BAD_STATE
-} zv_result_t;
-
-#endif

headers/zivuos/scheduler.h

@@ -1,22 +0,0 @@
-#ifndef CX_ZIVUOS_SCHEDULER_H_INCLUDED
-#define CX_ZIVUOS_SCHEDULER_H_INCLUDED
-
-#include "models.h"
-#include "process.h"
-
-typedef enum zv_scheduler_mode_e {
-    ZV_FIRST_MATCH,
-    ZV_ROUND_ROBIN_FIRST_MATCH,
-    ZV_BALANCED_PRIORITY,
-    ZV_NON_BALANCED_PRIORITY
-} zv_scheduler_mode_t;
-
-void zv_kernel_scheduler(struct zv_kernel_s *);
-zv_process_t * zv_kernel_round_first_match(struct zv_kernel_s *);
-zv_process_t * zv_kernel_balanced_priority(struct zv_kernel_s *);
-zv_process_t * zv_kernel_non_balanced_priority(struct zv_kernel_s *);
-zv_process_t * zv_kernel_basic_scheduler(struct zv_kernel_s *);
-zv_process_t * zv_kernel_scheduler_mode_selector(struct zv_kernel_s *);
-zv_process_t * zv_kernel_scheduler_select_interrupted(struct zv_kernel_s *);
-
-#endif

headers/zivuos/systypes.h

@@ -0,0 +1,20 @@
+#ifndef CX_ZIVUOS_SYSTYPES_H_INCLUDED
+#define CX_ZIVUOS_SYSTYPES_H_INCLUDED
+
+#include <stdint.h>
+#include <stddef.h>
+#include <stdbool.h>
+
+typedef uint16_t zv_pid_t;
+typedef uint16_t zv_priority_t;
+
+typedef size_t zv_size_t;
+
+typedef union zv_universal_u {
+    char *string;
+    void *pointer;
+    intptr_t integer;
+    uintptr_t uinteger;
+} zv_universal_t;
+
+#endif

headers/zivuos/task.h

@@ -0,0 +1,10 @@
+#ifndef CX_ZIVUOS_TASK_H_INCLUDED
+#define CX_ZIVUOS_TASK_H_INCLUDED
+
+#include "models.h"
+
+typedef struct zv_task_s {
+    
+} zv_task_t;
+
+#endif

headers/zivuos/vector.h

@@ -1,35 +1,50 @@
 #ifndef CX_ZIVUOS_VECTOR_H_INCLUDED
 #define CX_ZIVUOS_VECTOR_H_INCLUDED
 
-#include <stdint.h>
-#include <stddef.h>
 #include <stdbool.h>
 
-#include "result.h"
-#include "models.h"
-
-struct zv_vector_s;
-struct zv_vector_container_s;
-
-typedef struct zv_vector_s {
-    size_t lenght;
-    struct zv_vectos_container_s *first;
-    struct zv_vector_container_s *last;
-} zv_vector_t;
+#include "systypes.h"
+#include "memory.h"
 
 typedef struct zv_vector_container_s {
     struct zv_vector_container_s *previous;
     struct zv_vector_container_s *next;
+
     zv_universal_t content;
 } zv_vector_container_t;
 
-zv_vector_t * zv_vector_create();
-zv_universal_t zv_vector_get(zv_vector_t *, size_t);
-size_t zv_vector_push(zv_vector_t *, zv_universal_t);
-size_t zv_vector_count(zv_vector_t *);
-zv_universal_t zv_vector_pop(zv_vector_t *, size_t);
-bool zv_vector_insert(zv_vector_t *, zv_universal_t, size_t);
-void zv_vector_remove(zv_vector_t *);
-zv_universal_t * zv_vector_to_array(zv_vector_t *);
+typedef struct zv_vector_s {
+    zv_vector_container_t *first;
+    zv_vector_container_t *last;
+
+    zv_size_t size;
+} zv_vector_t;
+
+zv_vector_t * zv_vector_create(void);
+void zv_vector_delete(zv_vector_t *self);
+bool zv_vector_avairable(void);
+
+bool zv_vector_push(zv_vector_t *self, zv_universal_t content);
+zv_universal_t zv_vector_pop(zv_vector_t *self);
+
+zv_universal_t * zv_vector_get_pointer(zv_vector_t *self, zv_size_t target);
+zv_universal_t zv_vector_get(zv_vector_t *self, zv_size_t target);
+
+bool zv_vector_insert(
+    zv_vector_t *self, 
+    zv_universal_t content, 
+    zv_size_t after
+);
+
+zv_universal_t zv_vector_remove(
+    zv_vector_t *self,
+    zv_size_t target
+);
+
+zv_universal_t zv_vector_set(
+    zv_vector_t *self, 
+    zv_universal_t content, 
+    zv_size_t target
+);
 
 #endif

headers/zivuos/vector_helpers.h

@@ -1,152 +0,0 @@
-#ifndef CX_ZIVUOS_VECTOR_HELPERS_H_INCLUDED
-#define CX_ZIVUOS_VECTOR_HELPERS_H_INCLUDED
-
-#include <stdint.h>
-#include <stddef.h>
-#include <stdbool.h>
-
-#include "models.h"
-#include "vector.h"
-
-static inline uintptr_t zv_vector_get_unumber(
-    zv_vector_t *self, 
-    size_t count
-) {
-    return zv_vector_get(self, count).unumber;
-}
-
-static inline intptr_t zv_vector_get_number(
-    zv_vector_t *self,
-    size_t count
-) {
-    return zv_vector_get(self, count).number;
-}
-
-static inline void * zv_vector_get_pointer(
-    zv_vector_t *self,
-    size_t count
-) {
-    return zv_vector_get(self, count).pointer;
-}
-
-static inline char * zv_vector_get_cstring(
-    zv_vector_t *self,
-    size_t count
-) {
-    return zv_vector_get(self, count).cstring;
-}
-
-static inline size_t zv_vector_push_unumber(
-    zv_vector_t *self, 
-    uintptr_t unumber
-) {
-    zv_universal_t target;
-    target.unumber = unumber;
-
-    return zv_vector_push(self, target);
-}
-
-static inline size_t zv_vector_push_number(
-    zv_vector_t *self, 
-    intptr_t number
-) {
-    zv_universal_t target;
-    target.number = number;
-
-    return zv_vector_push(self, target);
-}
-
-static inline size_t zv_vector_push_pointer(
-    zv_vector_t *self, 
-    void *pointer
-) {
-    zv_universal_t target;
-    target.pointer = pointer;
-
-    return zv_vector_push(self, target);
-}
-
-static inline size_t zv_vector_push_cstring(
-    zv_vector_t *self, 
-    char *cstring
-) {
-    zv_universal_t target;
-    target.cstring = cstring;
-
-    return zv_vector_push(self, target);
-}
-
-static inline uintptr_t zv_vector_pop_unumber(
-    zv_vector_t *self, 
-    size_t count
-) {
-    return zv_vector_pop(self, count).unumber;
-}
-
-static inline intptr_t zv_vector_pop_number(
-    zv_vector_t *self, 
-    size_t count
-) {
-    return zv_vector_pop(self, count).number;
-}
-
-static inline void * zv_vector_pop_pointer(
-    zv_vector_t *self, 
-    size_t count
-) {
-    return zv_vector_pop(self, count).pointer;
-}
-
-static inline char * zv_vector_pop_cstring(
-    zv_vector_t *self, 
-    size_t count
-) {
-    return zv_vector_pop(self, count).cstring;
-}
-
-static inline bool zv_vector_insert_unumber(
-    zv_vector_t *self,
-    uintptr_t target,
-    size_t count
-) {
-    zv_universal_t translator;
-    translator.unumber = target;
-
-    return zv_vector_insert(self, translator, count);
-}
-
-static inline bool zv_vector_insert_number(
-    zv_vector_t *self,
-    intptr_t target,
-    size_t count
-) {
-    zv_universal_t translator;
-    translator.number = target;
-
-    return zv_vector_insert(self, translator, count);
-}
-
-static inline bool zv_vector_insert_pointer(
-    zv_vector_t *self,
-    void *target,
-    size_t count
-) {
-    zv_universal_t translator;
-    translator.pointer = target;
-
-    return zv_vector_insert(self, translator, count);
-}
-
-static inline bool zv_vector_insert_cstring(
-    zv_vector_t *self,
-    char *target,
-    size_t count
-) {
-    zv_universal_t translator;
-    translator.cstring = target;
-
-    return zv_vector_insert(self, translator, count);
-}
-
-#endif
-

headers/zivuos/zalloc.h

@@ -0,0 +1,12 @@
+#ifndef CX_ZIVUOS_ZALLOC_H_INCLUDED
+#define CX_ZIVUOS_ZALLOC_H_INCLUDED
+
+#include <stdbool.h>
+
+#include "systypes.h"
+
+void * zv_malloc(zv_size_t size);
+void zv_free(void *pointer);
+bool zv_malloc_avairable(void);
+
+#endif

sources/alloc.c

@@ -1,31 +0,0 @@
-#include <stdint.h>
-#include <stddef.h>
-#include <stdbool.h>
-
-#include "alloc.h"
-
-#ifdef ZV_ALLOC_USE_STDLIB
-#include <stdlib.h>
-#include <malloc.h>
-#endif
-
-
-void * zv_alloc(size_t count) {
-    #ifdef ZV_ALLOC_USE_STDLIB
-    return malloc(count);   
-    #endif
-}
-
-void * zv_alloc_zero(size_t count) {
-    #ifdef ZV_ALLOC_USE_STDLIB
-    return calloc(count, 0);
-    #endif
-}
-
-void zv_free(void *target) {
-    #ifdef ZV_ALLOC_USE_STDLIB
-    free(target);
-    #endif
-}
-
-

sources/balanced_priority_scheduler.c

@@ -1,69 +0,0 @@
-#include "kernel.h"
-#include "scheduler.h"
-
-#ifndef ZV_FULL_DISABLE_BALANCED_PRIORITY
-
-zv_process_t * zv_kernel_balanced_priority(zv_kernel_t *self) {
-    zv_process_t *selected = NULL;
-    zv_process_t *last = self->processes + self->last;
-    zv_priority_t selected_priority = 0;
-    bool full_round = true;
-    
-    for (
-        zv_process_t *current = self->processes;
-        current != (self->processes + self->processes_count);
-        ++current
-    ) {
-        if (current->priority > self->lowest_priority) {
-            self->lowest_priority = current->priority;
-        }
-
-        if (current->priority == self->lowest_priority) {
-            full_round = full_round && current->balance > 0; 
-        }
-
-        if (!zv_process_is_ready(current)) {
-            continue;
-        }
-        
-        zv_priority_t current_priority = _zv_process_calc_priority(current);
-
-        if (current != last && current_priority > self->lowest_priority) {
-            if (current->balance > 0) {
-                --current->balance;
-            }
-        }
-
-        if (selected == NULL) {
-            selected = current;
-            selected_priority = current_priority;
-            continue;
-        }
-
-        if (current_priority <= selected_priority) {
-            selected = current;
-            selected_priority = current_priority;
-            continue;
-        }
-    }
-
-    if (full_round) {
-        __zv_kernel_clean_balance(self);
-        return zv_kernel_balanced_priority(self);
-    }
-
-    if (selected->balance < 255) {
-        ++selected->balance;
-    }
-
-    return selected;
-}
-
-#else
-
-zv_process_t * zv_kernel_balanced_priority(zv_kernel_t *self) {
-    return NULL;
-}
-
-#endif
-

sources/basic_scheduler.c

@@ -1,24 +0,0 @@
-#include "kernel.h"
-#include "scheduler.h"
-
-#ifndef ZV_BASIC_SCHEDULER_UNUSED
-
-zv_process_t * zv_kernel_basic_scheduler(zv_kernel_t *self) {
-    for (zv_pid_t count = 0; count < self->processes_count; ++count) {
-        zv_process_t *current = self->processes + count;
-        
-        if (zv_process_is_ready(current)) {
-            return current;
-        }
-    }
-
-    return NULL;
-}
-
-#else
-
-zv_process_t * zv_kernel_basic_scheduler(zv_kernel_t *self) {
-    return NULL;
-}
-
-#endif

sources/idle_task.c

@@ -1,7 +0,0 @@
-#ifndef ZV_OVERRIDE_IDLE_TASK
-
-void zv_kernel_idle_task() {
-    return;   
-}
-
-#endif

sources/interrupt_scheduler.c

@@ -1,19 +0,0 @@
-#include "kernel.h"
-#include "process.h"
-#include "scheduler.h"
-
-zv_process_t * zv_kernel_scheduler_select_interrupted(zv_kernel_t *self) {
-    zv_process_t *selected = self->processes;
-
-    while (selected != (self->processes + self->processes_count)) {
-        if (selected->state == ZV_INTERRUPTED) {
-            return selected;
-        }
-
-        ++selected;
-    }
-
-    return NULL;
-}
-
-

sources/kernel.c

@@ -1,98 +0,0 @@
-#include "kernel.h"
-
-void zv_kernel_init(
-    zv_kernel_t *self,
-    zv_process_t *processes,
-    zv_pid_t size
-) {
-    self->processes = processes;
-    self->processes_count = size;
-    self->last = 0;
-    self->interrupts = 0;
-    self->mode = ZV_FIRST_MATCH;
-    self->lowest_priority = 0;
-
-    for (zv_pid_t count = 0; count < size; ++count) {
-        zv_process_t *current = self->processes + count;
-        
-        current->state = ZV_EMPTY;
-        current->worker = (zv_worker_t) NULL;
-        current->param = ZV_NULL_PARAM;
-        current->priority = 0;
-    }
-}
-
-zv_pid_t zv_kernel_add_process(
-    zv_kernel_t *self,
-    zv_worker_t worker,
-    zv_universal_t param,
-    zv_priority_t priority
-) {
-    for (zv_pid_t count = 0; count < self->processes_count; ++count) {
-        zv_process_t *current = self->processes + count;
-
-        if (current->state != ZV_EMPTY) {
-            continue;
-        }
-
-        current->worker = worker;
-        current->param = param;
-        current->priority = priority;
-        current->balance = 0;
-        current->state = ZV_READY;
-
-        return count;
-    }
-
-    return ZV_ERROR_PID;
-}
-
-bool zv_kernel_set_scheduler(zv_kernel_t *self, zv_scheduler_mode_t target) {
-#ifdef ZV_KERNEL_SCHEDULER_SINGLE_MODE
-    return false;
-#else
-    self->mode = target;
-    return true;
-#endif
-}
-
-void __zv_kernel_clean_balance(zv_kernel_t *self) {
-    for (zv_pid_t count = 0; count < self->processes_count; ++count) {
-        zv_process_t *current = self->processes + count;
-        current->balance = 0;
-    }
-}
-
-zv_result_t zv_kernel_trigger_process(zv_kernel_t *self, zv_pid_t target) {
-    zv_process_t *current = __zv_kernel_get_process(self, target);
-    
-    if (current == NULL || current->state == ZV_EMPTY) {
-        return ZV_NOT_EXISTS;
-    }
-
-    if (current->state != ZV_INTERRUPT_WAITING) {
-        return ZV_BAD_STATE;
-    }
-
-    ++self->interrupts;
-    self->processes->state = ZV_INTERRUPTED;
-
-    return ZV_SUCCESS;
-}  
-
-zv_result_t zv_kernel_awake_process(zv_kernel_t *self, zv_pid_t target) {
-    zv_process_t *current = __zv_kernel_get_process(self, target);
-    
-    if (current == NULL || current->state == ZV_EMPTY) {
-        return ZV_NOT_EXISTS;
-    }
-    
-    if (current->state != ZV_WAITING) {
-        return ZV_BAD_STATE;
-    }
-
-    current->state = ZV_READY;
-    return ZV_SUCCESS;
-}
-
-

sources/non_balanced_priority_scheduler.c

@@ -1,38 +0,0 @@
-#include "kernel.h"
-#include "scheduler.h"
-
-#ifndef ZV_FULL_DISABLE_NON_BALANCED_PRIORITY
-
-zv_process_t * zv_kernel_non_balanced_priority(zv_kernel_t *self) {
-    zv_process_t *selected = NULL;
-
-    for (
-        zv_process_t *current = self->processes;
-        current != (self->processes + self->processes_count);
-        ++current
-    ) {
-        if (!zv_process_is_ready(current)) {
-            continue;
-        }
-        
-        if (selected == NULL) {
-            selected = current;
-            continue;
-        }
-
-        if (current->priority < selected->priority) {
-            selected = current;
-            continue;
-        }
-    }
-
-    return selected;
-}
-
-#else
-
-zv_process_t * zv_kernel_non_balanced_priority(zv_kernel_t *self) {
-    return NULL;
-}
-
-#endif

sources/process.c

@@ -1,17 +0,0 @@
-#include "process.h"
-#include "result.h"
-
-zv_result_t zv_process_set_worker(zv_process_t *self, zv_worker_t target) {
-    self->worker = target;
-    return ZV_SUCCESS;
-}
-
-zv_result_t zv_process_set_param(zv_process_t *self, zv_universal_t target) {
-    self->param = target;
-    return ZV_SUCCESS;
-}
-
-zv_result_t zv_process_set_state(zv_process_t *self, zv_priority_t target) {
-    self->priority = target;
-    return ZV_SUCCESS;
-}

sources/round_roubin_first_match_scheduler.c

@@ -1,29 +0,0 @@
-#include "kernel.h"
-#include "scheduler.h"
-
-#ifndef ZV_FULL_DISABLE_ROUND_ROUBIN_FIRST_MATCH
-
-zv_process_t * zv_kernel_round_first_match(zv_kernel_t *self) {
-    zv_pid_t size = self->processes_count;
-    zv_pid_t count = (self->last + 1) % size;
-
-    while (count != self->last) {
-        zv_process_t *current = self->processes + count;
-        
-        if (zv_process_is_ready(current)) {
-            return current;
-        }
-
-        count = (count + 1) % size;
-    }
-
-    return NULL;
-}
-
-#else
-
-zv_process_t * zv_kernel_round_first_match(zv_kernel_t *self) {
-    return NULL;
-}
-
-#endif

sources/scheduler.c

@@ -1,60 +0,0 @@
-#include "kernel.h"
-#include "scheduler.h"
-
-static inline void zv_kernel_exec_process(
-    zv_kernel_t *self,
-    zv_process_t *target
-) {
-    bool was_interrupted = (target->state == ZV_INTERRUPTED);
-
-    if (was_interrupted && self->interrupts > 0) {
-        --self->interrupts;
-    }
-
-    target->state = ZV_WORKING;
-    zv_state_t result = target->worker(self, target);
-
-    if (result == ZV_WORKING || result == ZV_INTERRUPTED) {
-        result = ZV_READY;
-    }
-
-    if (was_interrupted) {
-        result = ZV_INTERRUPT_WAITING;
-    }
-
-    target->state = result;
-}
-
-static inline zv_process_t * zv_kernel_select_process(zv_kernel_t *self) {
-    if (self->interrupts > 0) {
-        zv_process_t *selected = zv_kernel_scheduler_select_interrupted(self);
-
-        if (selected != NULL) {
-            return selected;
-        }       
-
-        self->interrupts = 0;
-    }
-
-    return zv_kernel_scheduler_mode_selector(self);
-}
-
-void zv_kernel_scheduler_single_loop(zv_kernel_t *self) {
-    zv_process_t *selected = zv_kernel_select_process(self);
-
-    if (selected == NULL) {
-        zv_kernel_idle_task();
-        return;
-    }
-
-    zv_kernel_exec_process(self, selected);
-    self->last = zv_kernel_get_pid(self, selected);
-}
-
-void zv_kernel_scheduler(zv_kernel_t *self) {
-    while (true) {
-        zv_kernel_scheduler_single_loop(self);
-    }
-}
-
-

sources/scheduler_mode_selector.c

@@ -1,62 +0,0 @@
-#include "process.h"
-#include "kernel.h"
-#include "scheduler.h"
-
-#ifndef ZV_ONLY_BALANCED_PRIORITY_SCHEDULER_MODE
-#ifndef ZV_ONLY_NON_BALANCED_PRIORITY_SCHEDULER_MODE
-#ifndef ZV_ONLY_ROUND_ROUBIN_FIRST_MATCH_SCHEDULER_MODE
-
-zv_process_t * zv_kernel_scheduler_mode_selector(zv_kernel_t *self) {
-    switch (self->mode) {
-
-        #ifndef ZV_FULL_DISABLE_ROUND_ROUBIN_FIRST_MATCH
-        case ZV_FIRST_MATCH:
-        case ZV_ROUND_ROBIN_FIRST_MATCH:
-            return zv_kernel_round_first_match(self);
-        #endif
-
-        #ifndef ZV_FULL_DISABLE_BALANCED_PRIORITY
-        case ZV_BALANCED_PRIORITY:
-            return zv_kernel_balanced_priority(self);
-        #endif
-    
-        #ifndef ZV_FULL_DISABLE_NON_BALANCED_PRIORITY
-        case ZV_NON_BALANCED_PRIORITY:
-            return zv_kernel_non_balanced_priority(self);
-        #endif
-
-        default:
-            break;
-
-    }
-
-    return zv_kernel_basic_scheduler(self);
-}
-
-#endif
-#endif
-#endif
-
-#ifdef ZV_ONLY_BALANCED_PRIORITY_SCHEDULER_MODE
-
-zv_process_t * zv_kernel_scheduler_mode_selector(zv_kernel_t *self) {
-    return zv_kernel_balanced_priority(self);
-}
-
-#endif
-
-#ifdef ZV_ONLY_NON_BALANCED_PRIORITY_SCHEDULER_MODE
-
-zv_process_t * zv_kernel_scheduler_mode_selector(zv_kernel_t *self) {
-    return zv_kernel_non_balanced_priority(self);
-}
-
-#endif
-
-#ifdef ZV_ONLY_ROUND_ROUBIN_FIRST_MATCH_SCHEDULER_MODE
-
-zv_process_t * zv_kernel_scheduler_mode_selector(zv_kernel_t *self) {
-    return zv_kernel_round_first_match(self);
-}
-
-#endif

sources/vector.c

@@ -1,89 +1,96 @@
-#include <stdint.h>
 #include <stddef.h>
+#include <stdint.h>
 #include <stdbool.h>
 
+#include "zalloc.h"
 #include "vector.h"
-#include "alloc.h"
+#include "systypes.h"
+
+
+zv_vector_t * zv_vector_create(void) {
+    if (!zv_malloc_avairable()) {
+        return NULL
+    }
 
-zv_vector_t * zv_vector_create() {
-    zv_vector_t *result = (zv_vector_t *) zv_alloc(sizeof(zv_vector_t));
-    
-    if (result == NULL) {
+    zv_vector_t *self = (zv_vector_t *) zv_malloc(sizeof(zv_vector_t));
+   
+    if (self == NULL) {
         return NULL;
     }
 
-    result->lenght = 0;
-    result->first = NULL;
-    result->last = NULL;
+    self->first = NULL;
+    self->last = NULL;
+    self->size = 0;
 
-    return result;    
+    return self;
 }
 
-static inline zv_vector_container_t * __zv_vector_count_right(
-    zv_vector_t *self,
-    size_t count
-) {
-    zv_vector_container_t *current = self->last;
-    count = self->lenght - count;
-    
-    while (count-- > 0) {
-        current = current->previous;
-
-        if (current == NULL) {
-            return NULL;
-        }
+void zv_vector_delete(zv_vector_t *self) {
+    zv_vector_container_t *current = self->first;
+
+    while (current != NULL) {
+        zv_vector_container_t *next = current->next;
+        zv_free(current);
+        current = next;
     }
 
-    return current;
+    zv_free(self);
 }
 
-static inline zv_vector_container_t * __zv_vector_count_lefr(
-    zv_vector_t *self,
-    size_t count
-) {
-    zv_vector_container_t *current = self->first;
+bool zv_vector_avairable(void) {
+    return zv_zalloc_avairable();
+
+}
 
-    while (count-- > 0) {
-        current = current->next;
+bool zv_vector_push(zv_vector_t *self, zv_universal_t content) {
+    zv_vector_container_t *target = zv_malloc(sizeof(zv_vector_container_t));
 
-        if (current == NULL) {
-            return NULL;
-        }
+    if (target == NULL) {
+        return false;
     }
 
-    return current;
+    target->next = NULL;
+    target->content = content;
+    target->previous = self->last;
+    self->last = target;
+
+    return true;
+}
+
+zv_universal_t zv_vector_pop(zv_vector_t *self) {
+    zv_universal_t result = self->last->
+    return result; 
 }
 
-static zv_vector_container_t * __zv_vector_get_container(
+zv_universal_t * zv_vector_get_pointer(zv_vector_t *self, zv_size_t target) {
+
+}
+
+zv_universal_t zv_vector_get(zv_vector_t *self, zv_size_t target) {
+
+}
+
+bool zv_vector_insert(
     zv_vector_t *self, 
-    size_t count
+    zv_universal_t content, 
+    zv_size_t after
 ) {
-    if (self->lenght <= count) {
-        return NULL;
-    }
-
-    if (self->lenght / 2 > count) {
-        return __zv_vector_count_right(self, count);
-    } 
 
-    return __zv_vector_count_left(self, count);
 }
 
-zv_universal_t zv_vector_get(zv_vector_t *self, size_t count) {
-    zv_vector_container_t *current = __zv_vector_get_container(self, count);
-    
-    if (current == NULL) {
-        return NULL;
-    }
+zv_universal_t zv_vector_remove(
+    zv_vector_t *self,
+    zv_size_t target
+) {
 
-    return current->content;
 }
 
-size_t zv_vector_push(zv_vector_t *, zv_universal_t);
-size_t zv_vector_count(zv_vector_t *);
-zv_universal_t zv_vector_pop(zv_vector_t *, size_t);
-bool zv_vector_insert(zv_vector_t *, zv_universal_t, size_t);
-void zv_vector_remove(zv_vector_t *);
-zv_universal_t * zv_vector_to_array(zv_vector_t *);
+zv_universal_t zv_vector_set(
+    zv_vector_t *self, 
+    zv_universal_t content, 
+    zv_size_t target
+) {
+
+}
 
 

sources/zalloc.c

@@ -0,0 +1,42 @@
+#include <stddef.h>
+#include <stdbool.h>
+
+#include "zalloc.h"
+#include "systypes.h"
+
+#ifndef ZV_DISABLE_DYNAMIC
+#define ZV_USE_STD_MALLOC
+#endif
+
+#ifdef ZV_USE_STD_MALLOC
+
+#include <malloc.h>
+
+void * zv_malloc(zv_size_t size) {
+    return malloc(size);
+}
+
+void zv_free(void *pointer) {
+    free(pointer);
+}
+
+bool zv_malloc_avairable(void) {
+    return true;
+}
+
+#endif
+
+#ifdef ZV_DISABLE_DYNAMIC
+
+bool zv_malloc_avairable(void) {
+    return false;
+}
+
+void * zv_malloc(zv_size_t size) {
+    return NULL;
+}
+
+void zv_free(void *pointer) {
+}
+
+#endif

tests/001-base_scheduler/run.sh

@@ -1,24 +0,0 @@
-#!/bin/bash
-
-CC=gcc
-CC_FLAGS="-O2"
-
-OWN=$(dirname $(realpath $0))
-TEST_SOURCE=$OWN/testing.c
-TEST_OUTPUT=$OWN/testing.app
-HEADERS=$OWN/../../headers
-LIBRARY=$OWN/../../build-generic
-LIBRARY_MAKE=$OWN/../../build-generic/make.sh
-
-rm -f $TEST_OUTPUT
-
-echo "Rebuilding..."
-$LIBRARY_MAKE
-
-echo ""
-echo "Build test..."
-$CC $CC_FLAGS $TEST_SOURCE -o $TEST_OUTPUT -I$HEADERS -L$LIBRARY -lzivuos 
-
-echo "Running..."
-echo ""
-$TEST_OUTPUT

tests/001-base_scheduler/testing.c

@@ -1,73 +0,0 @@
-#include <stdio.h>
-#include <zivuos.h>
-
-zv_state_t process_first_worker(zv_kernel_t *kernel, zv_process_t *self) {
-    puts("Hello from process 1!");
-    printf("My balance is: %i\n\n", (int) self->balance);
-
-    return ZV_READY;
-}
-
-zv_state_t process_second_worker(zv_kernel_t *kernel, zv_process_t *self) {
-    puts("Hello from process 2!");
-    printf("My balance is: %i\n\n", (int) self->balance);
-
-    return ZV_READY;
-}
-
-zv_state_t process_third_worker(zv_kernel_t *kernel, zv_process_t *self) {
-    puts("Hello from process 3!");
-    printf("My balance is: %i\n\n", (int) self->balance);
-
-    return ZV_READY;
-}
-
-zv_state_t process_fourth_worker(zv_kernel_t *kernel, zv_process_t *self) {
-    puts("Hello from process 4!");
-    printf("My balance is: %i\n\n", (int) self->balance);
-
-    return ZV_READY;
-}
-
-int main() {
-    puts("ZivuOS scheduler test unit.");
-    puts("Creating scheduler and two processes.");
-
-    zv_kernel_t kernel[1];
-    zv_process_t processes[10];
-
-    zv_kernel_init(kernel, processes, ZV_COUNT_PROCESSES(processes));
-    kernel->mode = ZV_BALANCED_PRIORITY;
-
-    zv_pid_t first = zv_kernel_add_process(
-        kernel,
-        process_first_worker,
-        ZV_NULL_PARAM,
-        1
-    );
-
-    zv_pid_t second = zv_kernel_add_process(
-        kernel,
-        process_second_worker,
-        ZV_NULL_PARAM,
-        4
-    );
-
-    zv_pid_t third = zv_kernel_add_process(
-        kernel,
-        process_third_worker,
-        ZV_NULL_PARAM,
-        10
-    );
-
-    zv_pid_t four = zv_kernel_add_process(
-        kernel,
-        process_fourth_worker,
-        ZV_NULL_PARAM,
-        4
-    );
-
-    zv_kernel_scheduler(kernel);
-
-    return 0;
-}