Bring in line with dependency changes

Signed-off-by: Andrew Opalach <andrew@akon.city>

6 files changed, 55 insertions, 55 deletions

diff --git a/src/cache/backings/file.c b/src/cache/backings/file.c
index a09d535..bf62190 100644
--- a/src/cache/backings/file.c
+++ b/src/cache/backings/file.c
@@ -6,64 +6,64 @@
 static void file_backing_lock(struct cch_backing *backing)
 {
     struct cch_backing_file *file = (struct cch_backing_file *)backing;
-    aki_mutex_lock(&file->mutex);
+    nn_mutex_lock(&file->mutex);
 }
 
 static void file_backing_write(struct cch_backing *backing, u8 *buf, off_t index, size_t *size)
 {
     struct cch_backing_file *file = (struct cch_backing_file *)backing;
-    aki_mutex_lock(&file->mutex);
+    nn_mutex_lock(&file->mutex);
     if (file->u.pointer != index) {
-        file->u.pointer = aki_file_seek(&file->file, index, SEEK_SET);
+        file->u.pointer = nn_file_seek(&file->file, index, SEEK_SET);
         al_assert(file->u.pointer == index);
     }
     if (file->size >= 0 && index + ((off_t)*size) >= file->size) {
         *size = MAX(file->size - index, 0L);
     }
-    aki_file_write(&file->file, buf, *size);
+    nn_file_write(&file->file, buf, *size);
     file->u.pointer += *size;
     cch_backing_fill_range(&file->backing, index, *size);
-    aki_mutex_unlock(&file->mutex);
+    nn_mutex_unlock(&file->mutex);
 }
 
 static void file_backing_read(struct cch_backing *backing, u8 *buf, off_t index, size_t *size)
 {
     struct cch_backing_file *file = (struct cch_backing_file *)backing;
-    aki_mutex_lock(&file->mutex);
+    nn_mutex_lock(&file->mutex);
     if (file->u.pointer != index) {
-        file->u.pointer = aki_file_seek(&file->file, index, SEEK_SET);
+        file->u.pointer = nn_file_seek(&file->file, index, SEEK_SET);
         al_assert(file->u.pointer == index);
     }
     if (file->size >= 0 && index + ((off_t)*size) >= file->size) {
         *size = MAX(file->size - index, 0L);
     }
-    aki_file_read(&file->file, buf, *size);
+    nn_file_read(&file->file, buf, *size);
     file->u.pointer += *size;
-    aki_mutex_unlock(&file->mutex);
+    nn_mutex_unlock(&file->mutex);
 }
 
 static void file_backing_unlock(struct cch_backing *backing)
 {
     struct cch_backing_file *file = (struct cch_backing_file *)backing;
-    aki_mutex_unlock(&file->mutex);
+    nn_mutex_unlock(&file->mutex);
 }
 
 static void file_backing_resize(struct cch_backing *backing, size_t size)
 {
     struct cch_backing_file *file = (struct cch_backing_file *)backing;
-    aki_mutex_lock(&file->mutex);
+    nn_mutex_lock(&file->mutex);
     file->size = size;
     if ((off_t)size > file->filesize) {
-        aki_file_truncate(&file->file, size);
+        nn_file_truncate(&file->file, size);
         file->filesize = size;
     }
-    aki_mutex_unlock(&file->mutex);
+    nn_mutex_unlock(&file->mutex);
 }
 
 static void file_backing_free(struct cch_backing **backing)
 {
     struct cch_backing_file *file = (struct cch_backing_file *)*backing;
-    aki_file_close(&file->file);
+    nn_file_close(&file->file);
     al_array_free(file->backing.available);
     al_free(file);
     *backing = NULL;
@@ -87,6 +87,6 @@ struct cch_backing *cch_backing_file_create(str *path, size_t size)
         return NULL;
     }
     file->u.pointer = 0;
-    aki_mutex_init(&file->mutex);
+    nn_mutex_init(&file->mutex);
     return (struct cch_backing *)file;
 }
diff --git a/src/cache/backings/file.h b/src/cache/backings/file.h
index 3f8437b..8a2bf7a 100644
--- a/src/cache/backings/file.h
+++ b/src/cache/backings/file.h
@@ -1,22 +1,22 @@
 #pragma once
 
 #include <al/str.h>
-#include <aki/thread.h>
-#include <aki/common.h>
-#include <aki/file.h>
+#include <nnwt/thread.h>
+#include <nnwt/common.h>
+#include <nnwt/file.h>
 
 #include "../backing.h"
 
 struct cch_backing_file {
     struct cch_backing backing;
-    struct aki_file file;
+    struct nn_file file;
     off_t size;
     off_t filesize;
     union {
         void *map; // CACHE_BACKING_MAPPED
         off_t pointer; // CACHE_BACKING_READ
     } u;
-    struct aki_mutex mutex;
+    struct nn_mutex mutex;
 };
 
 struct cch_backing *cch_backing_file_create(str *path, size_t filesize);
diff --git a/src/cache/backings/file_common.c b/src/cache/backings/file_common.c
index 35322fd..3914f95 100644
--- a/src/cache/backings/file_common.c
+++ b/src/cache/backings/file_common.c
@@ -1,24 +1,24 @@
 static off_t file_backing_get_size_estimate(struct cch_backing *backing)
 {
     struct cch_backing_file *file = (struct cch_backing_file *)backing;
-    aki_mutex_lock(&file->mutex);
+    nn_mutex_lock(&file->mutex);
     off_t size = file->size;
-    aki_mutex_unlock(&file->mutex);
+    nn_mutex_unlock(&file->mutex);
     return size;
 }
 
 static bool file_open_internal(struct cch_backing_file *file, str *path, size_t size)
 {
-    s32 flags = size != 0 ? AKI_FILE_CREATE : 0;
-    if (!aki_file_open(&file->file, path, flags)) return false;
-    file->filesize = aki_file_get_filesize(&file->file);
+    s32 flags = size != 0 ? NNWT_FILE_CREATE : 0;
+    if (!nn_file_open(&file->file, path, flags)) return false;
+    file->filesize = nn_file_get_filesize(&file->file);
     if (!size) {
         file->size = file->filesize;
         cch_backing_fill_range(&file->backing, 0, file->size);
     } else {
         file->size = -1;
         if (file->filesize < (off_t)size) {
-            aki_file_truncate(&file->file, size);
+            nn_file_truncate(&file->file, size);
         }
     }
     return true;
diff --git a/src/cache/backings/file_mapped.c b/src/cache/backings/file_mapped.c
index 22f9ae5..35ab267 100644
--- a/src/cache/backings/file_mapped.c
+++ b/src/cache/backings/file_mapped.c
@@ -6,25 +6,25 @@
 static void file_backing_lock(struct cch_backing *backing)
 {
     struct cch_backing_file *file = (struct cch_backing_file *)backing;
-    aki_mutex_lock(&file->mutex);
+    nn_mutex_lock(&file->mutex);
 }
 
 static void file_backing_write(struct cch_backing *backing, u8 *buf, off_t index, size_t *size)
 {
     struct cch_backing_file *file = (struct cch_backing_file *)backing;
-    aki_mutex_lock(&file->mutex);
+    nn_mutex_lock(&file->mutex);
     if (file->size >= 0 && index + (off_t)*size >= file->size) {
         *size = MAX(file->size - index, 0L);
     }
     al_memcpy(file->u.map + index, buf, *size);
     cch_backing_fill_range(&file->backing, index, *size);
-    aki_mutex_unlock(&file->mutex);
+    nn_mutex_unlock(&file->mutex);
 }
 
 static u8 *file_backing_get_ptr(struct cch_backing *backing, off_t index, size_t *size)
 {
     struct cch_backing_file *file = (struct cch_backing_file *)backing;
-    aki_mutex_lock(&file->mutex);
+    nn_mutex_lock(&file->mutex);
     if (file->size >= 0 && index + (off_t)*size >= file->size) {
         *size = MAX(file->size - index, 0L);
     }
@@ -34,28 +34,28 @@ static u8 *file_backing_get_ptr(struct cch_backing *backing, off_t index, size_t
 static void file_backing_unlock(struct cch_backing *backing)
 {
     struct cch_backing_file *file = (struct cch_backing_file *)backing;
-    aki_mutex_unlock(&file->mutex);
+    nn_mutex_unlock(&file->mutex);
 }
 
 static void file_backing_resize(struct cch_backing *backing, size_t size)
 {
     struct cch_backing_file *file = (struct cch_backing_file *)backing;
-    aki_mutex_lock(&file->mutex);
+    nn_mutex_lock(&file->mutex);
     file->size = size;
     if ((off_t)size > file->filesize) {
-        aki_file_munmap(&file->file, file->u.map);
-        aki_file_truncate(&file->file, size);
-        file->u.map = aki_file_mmap(&file->file);
+        nn_file_munmap(&file->file, file->u.map);
+        nn_file_truncate(&file->file, size);
+        file->u.map = nn_file_mmap(&file->file);
         file->filesize = size;
     }
-    aki_mutex_unlock(&file->mutex);
+    nn_mutex_unlock(&file->mutex);
 }
 
 static void file_backing_free(struct cch_backing **backing)
 {
     struct cch_backing_file *file = (struct cch_backing_file *)*backing;
-    aki_file_munmap(&file->file, file->u.map);
-    aki_file_close(&file->file);
+    nn_file_munmap(&file->file, file->u.map);
+    nn_file_close(&file->file);
     al_array_free(file->backing.available);
     al_free(file);
     *backing = NULL;
@@ -74,10 +74,10 @@ struct cch_backing *cch_backing_file_create(str *path, size_t size)
     file->backing.resize = file_backing_resize;
     file->backing.free = file_backing_free;
     al_array_init(file->backing.available);
-    if (!file_open_internal(file, path, size) || !(file->u.map = aki_file_mmap(&file->file))) {
+    if (!file_open_internal(file, path, size) || !(file->u.map = nn_file_mmap(&file->file))) {
         al_free(file);
         return NULL;
     }
-    aki_mutex_init(&file->mutex);
+    nn_mutex_init(&file->mutex);
     return (struct cch_backing *)file;
 }
diff --git a/src/cache/backings/memory.c b/src/cache/backings/memory.c
index 5db2063..aa5c1b4 100644
--- a/src/cache/backings/memory.c
+++ b/src/cache/backings/memory.c
@@ -13,28 +13,28 @@ static void ensure_alloced(struct cch_backing_memory *mem, size_t size)
 static void memory_backing_lock(struct cch_backing *backing)
 {
     struct cch_backing_memory *mem = (struct cch_backing_memory *)backing;
-    aki_mutex_lock(&mem->mutex);
+    nn_mutex_lock(&mem->mutex);
 }
 
 static void memory_backing_write(struct cch_backing *backing, u8 *buf, off_t index, size_t *size)
 {
     struct cch_backing_memory *mem = (struct cch_backing_memory *)backing;
-    aki_mutex_lock(&mem->mutex);
+    nn_mutex_lock(&mem->mutex);
     if (mem->size >= 0 && index + (off_t)*size >= mem->size) {
-        *size = MAX(mem->size - index, 0L);
+        *size = MAX(mem->size - index, (off_t)0L);
     }
     ensure_alloced(mem, index + *size);
     al_memcpy(mem->data + index, buf, *size);
     cch_backing_fill_range(&mem->backing, index, *size);
-    aki_mutex_unlock(&mem->mutex);
+    nn_mutex_unlock(&mem->mutex);
 }
 
 static u8 *memory_backing_get_ptr(struct cch_backing *backing, off_t index, size_t *size)
 {
     struct cch_backing_memory *mem = (struct cch_backing_memory *)backing;
-    aki_mutex_lock(&mem->mutex);
+    nn_mutex_lock(&mem->mutex);
     if (mem->size >= 0 && index + (off_t)*size >= mem->size) {
-        *size = MAX(mem->size - index, 0L);
+        *size = MAX(mem->size - index, (off_t)0L);
     }
     return (u8 *)(mem->data + index);
 }
@@ -42,32 +42,32 @@ static u8 *memory_backing_get_ptr(struct cch_backing *backing, off_t index, size
 static void memory_backing_unlock(struct cch_backing *backing)
 {
     struct cch_backing_memory *mem = (struct cch_backing_memory *)backing;
-    aki_mutex_unlock(&mem->mutex);
+    nn_mutex_unlock(&mem->mutex);
 }
 
 static off_t memory_backing_get_size_estimate(struct cch_backing *backing)
 {
     struct cch_backing_memory *mem = (struct cch_backing_memory *)backing;
-    aki_mutex_lock(&mem->mutex);
+    nn_mutex_lock(&mem->mutex);
     off_t size = mem->size;
-    aki_mutex_unlock(&mem->mutex);
+    nn_mutex_unlock(&mem->mutex);
     return size;
 }
 
 static void memory_backing_resize(struct cch_backing *backing, size_t size)
 {
     struct cch_backing_memory *mem = (struct cch_backing_memory *)backing;
-    aki_mutex_lock(&mem->mutex);
+    nn_mutex_lock(&mem->mutex);
     ensure_alloced(mem, size);
     mem->size = size;
-    aki_mutex_unlock(&mem->mutex);
+    nn_mutex_unlock(&mem->mutex);
 }
 
 static void memory_backing_free(struct cch_backing **backing)
 {
     struct cch_backing_memory *mem = (struct cch_backing_memory *)*backing;
     al_free(mem->data);
-    aki_mutex_destroy(&mem->mutex);
+    nn_mutex_destroy(&mem->mutex);
     al_array_free(mem->backing.available);
     al_free(mem);
     *backing = NULL;
@@ -87,7 +87,7 @@ struct cch_backing *cch_backing_memory_create(size_t size)
     mem->data = al_malloc(size);
     mem->alloc = size;
     mem->size = -1;
-    aki_mutex_init(&mem->mutex);
+    nn_mutex_init(&mem->mutex);
     al_array_init(mem->backing.available);
     return (struct cch_backing *)mem;
 }
diff --git a/src/cache/backings/memory.h b/src/cache/backings/memory.h
index 107ae4b..e290b48 100644
--- a/src/cache/backings/memory.h
+++ b/src/cache/backings/memory.h
@@ -1,7 +1,7 @@
 #pragma once
 
 #include <al/lib.h>
-#include <aki/thread.h>
+#include <nnwt/thread.h>
 
 #include "../backing.h"
 
@@ -10,7 +10,7 @@ struct cch_backing_memory {
     u8 *data;
     size_t alloc;
     off_t size;
-    struct aki_mutex mutex;
+    struct nn_mutex mutex;
 };
 
 struct cch_backing *cch_backing_memory_create(size_t size);