summaryrefslogtreecommitdiff
path: root/src/util
diff options
context:
space:
mode:
Diffstat (limited to 'src/util')
-rw-r--r--src/util/buffer.c38
-rw-r--r--src/util/buffer.h22
-rw-r--r--src/util/error.c2
-rw-r--r--src/util/error.h12
-rw-r--r--src/util/file/file.h71
-rw-r--r--src/util/file/file_linux.c130
-rw-r--r--src/util/file/file_stdio.c48
-rw-r--r--src/util/file/util.c16
-rw-r--r--src/util/packet.c84
-rw-r--r--src/util/packet.h94
-rw-r--r--src/util/thread/thread.h58
-rw-r--r--src/util/thread/thread_linux.c35
-rw-r--r--src/util/thread/thread_windows.c35
-rw-r--r--src/util/timer/timer.h4
-rw-r--r--src/util/timer/timer_linux.c4
-rw-r--r--src/util/timer/timer_windows.c4
16 files changed, 329 insertions, 328 deletions
diff --git a/src/util/buffer.c b/src/util/buffer.c
index 32a8230..1d343e3 100644
--- a/src/util/buffer.c
+++ b/src/util/buffer.c
@@ -1,58 +1,62 @@
+#include <al/macros.h>
+
#include "buffer.h"
-#define BUFFER_INITIAL_SIZE 128
+#define NNWT_BUFFER_SIZE KB(1)
+#define NNWT_BUFFER_GROW ((size_t)al_grow_step)
-void aki_buffer_ensure_space(struct aki_buffer *buf, size_t size)
+void nn_buffer_ensure_space(struct nn_buffer *buf, size_t size)
{
if (size > buf->alloc) {
- if (size < BUFFER_INITIAL_SIZE) buf->alloc = BUFFER_INITIAL_SIZE;
- else buf->alloc = al_next_power_of_two(size);
- buf->data = buf->data ? al_realloc(buf->data, buf->alloc) : al_malloc(buf->alloc);
+ buf->alloc = size < NNWT_BUFFER_SIZE ? NNWT_BUFFER_SIZE :
+ (size + NNWT_BUFFER_GROW) & ~NNWT_BUFFER_GROW;
+ buf->data = (u8 *)(buf->data ? al_realloc(buf->data, buf->alloc) : al_malloc(buf->alloc));
}
}
-void aki_buffer_init(struct aki_buffer *buf)
+void nn_buffer_init(struct nn_buffer *buf)
{
- buf->data = NULL;
buf->size = 0;
buf->alloc = 0;
+ buf->data = NULL;
}
-size_t aki_buffer_get_size(struct aki_buffer *buf)
+size_t nn_buffer_get_size(struct nn_buffer *buf)
{
return buf->size;
}
-void aki_buffer_set_size(struct aki_buffer *buf, size_t size)
+void nn_buffer_set_size(struct nn_buffer *buf, size_t size)
{
buf->size = size;
}
-void aki_buffer_write(struct aki_buffer *buf, void *data, size_t index, size_t size)
+void nn_buffer_write(struct nn_buffer *buf, void *data, size_t index, size_t size)
{
size_t reach = index + size;
- aki_buffer_ensure_space(buf, reach);
- if (reach > buf->size) buf->size = reach;
+ nn_buffer_ensure_space(buf, reach);
+ if (reach > buf->size)
+ buf->size = reach;
al_memcpy(&buf->data[index], data, size);
}
-void aki_buffer_append(struct aki_buffer *buf, void *data, size_t size)
+void nn_buffer_append(struct nn_buffer *buf, void *data, size_t size)
{
- aki_buffer_write(buf, data, buf->size, size);
+ nn_buffer_write(buf, data, buf->size, size);
}
-u8 *aki_buffer_get_ptr(struct aki_buffer *buf, size_t index)
+u8 *nn_buffer_get_ptr(struct nn_buffer *buf, size_t index)
{
return &buf->data[index];
}
-void aki_buffer_read(struct aki_buffer *buf, void *ptr, size_t index, size_t size)
+void nn_buffer_read(struct nn_buffer *buf, void *ptr, size_t index, size_t size)
{
al_assert(index + size <= buf->size);
al_memcpy(ptr, &buf->data[index], size);
}
-void aki_buffer_free(struct aki_buffer *buf)
+void nn_buffer_free(struct nn_buffer *buf)
{
if (buf->data && buf->alloc > 0) al_free(buf->data);
}
diff --git a/src/util/buffer.h b/src/util/buffer.h
index 78d32d5..612aae4 100644
--- a/src/util/buffer.h
+++ b/src/util/buffer.h
@@ -3,18 +3,18 @@
#include <al/types.h>
#include <al/lib.h>
-struct aki_buffer {
- u8 *data;
+struct nn_buffer {
size_t size;
size_t alloc;
+ u8 *data;
};
-void aki_buffer_init(struct aki_buffer *buf);
-void aki_buffer_ensure_space(struct aki_buffer *buf, size_t size);
-size_t aki_buffer_get_size(struct aki_buffer *buf);
-void aki_buffer_set_size(struct aki_buffer *buf, size_t size);
-void aki_buffer_write(struct aki_buffer *buf, void *data, size_t index, size_t size);
-void aki_buffer_append(struct aki_buffer *buf, void *data, size_t size);
-u8 *aki_buffer_get_ptr(struct aki_buffer *buf, size_t index);
-void aki_buffer_read(struct aki_buffer *buf, void *ptr, size_t index, size_t size);
-void aki_buffer_free(struct aki_buffer *buf);
+void nn_buffer_init(struct nn_buffer *buf);
+void nn_buffer_ensure_space(struct nn_buffer *buf, size_t size);
+size_t nn_buffer_get_size(struct nn_buffer *buf);
+void nn_buffer_set_size(struct nn_buffer *buf, size_t size);
+void nn_buffer_write(struct nn_buffer *buf, void *data, size_t index, size_t size);
+void nn_buffer_append(struct nn_buffer *buf, void *data, size_t size);
+u8 *nn_buffer_get_ptr(struct nn_buffer *buf, size_t index);
+void nn_buffer_read(struct nn_buffer *buf, void *ptr, size_t index, size_t size);
+void nn_buffer_free(struct nn_buffer *buf);
diff --git a/src/util/error.c b/src/util/error.c
index c75696d..928e083 100644
--- a/src/util/error.c
+++ b/src/util/error.c
@@ -1,3 +1,3 @@
#include "error.h"
-__thread char errorbuf[AKI_ERROR_STR_MAXLEN];
+__thread char errorbuf[NNWT_ERROR_STR_MAXLEN];
diff --git a/src/util/error.h b/src/util/error.h
index 7f63aee..898119c 100644
--- a/src/util/error.h
+++ b/src/util/error.h
@@ -4,20 +4,20 @@
#include <errno.h>
-#define AKI_ERROR_STR_MAXLEN 94
+#define NNWT_ERROR_STR_MAXLEN 94
-extern __thread char errorbuf[AKI_ERROR_STR_MAXLEN];
+extern __thread char errorbuf[NNWT_ERROR_STR_MAXLEN];
-static inline char *aki_strerror(s32 errnum)
+static inline char *nn_strerror(s32 errnum)
{
#ifndef _WIN32
#if (_POSIX_C_SOURCE >= 200112L) && ! _GNU_SOURCE
- if (strerror_r(errnum, errorbuf, AKI_ERROR_STR_MAXLEN) != 0) errorbuf[0] = '\0';
+ if (strerror_r(errnum, errorbuf, NNWT_ERROR_STR_MAXLEN) != 0) errorbuf[0] = '\0';
#else
- return strerror_r(errnum, errorbuf, AKI_ERROR_STR_MAXLEN);
+ return strerror_r(errnum, errorbuf, NNWT_ERROR_STR_MAXLEN);
#endif
#else
- strerror_s(errorbuf, AKI_ERROR_STR_MAXLEN, errnum);
+ strerror_s(errorbuf, NNWT_ERROR_STR_MAXLEN, errnum);
#endif
return errorbuf;
}
diff --git a/src/util/file/file.h b/src/util/file/file.h
index 0544d3c..30b44b6 100644
--- a/src/util/file/file.h
+++ b/src/util/file/file.h
@@ -3,7 +3,7 @@
#include <al/str.h>
#include <al/lib.h>
-#ifdef AKIYO_FILE_STDIO_COMPAT
+#ifdef NAUNET_NEEDS_STDIO_ASSIST
#include <stdio.h>
#else
#ifndef _WIN32
@@ -16,76 +16,73 @@
#endif
enum {
- AKI_FILE_READONLY = 1,
- AKI_FILE_CREATE = 1 << 1,
- AKI_FILE_LOCK = 1 << 2
+ NNWT_FILE_READONLY = 1,
+ NNWT_FILE_CREATE = 1 << 1,
+ NNWT_FILE_LOCK = 1 << 2
};
enum {
- AKI_ENTRY_FILE = 0,
- AKI_ENTRY_DIR,
- AKI_ENTRY_OTHER
+ NNWT_ENTRY_FILE = 0,
+ NNWT_ENTRY_DIR,
+ NNWT_ENTRY_OTHER
};
-struct aki_file {
-#ifdef AKIYO_FILE_STDIO_COMPAT
+struct nn_file {
+#ifdef NAUNET_NEEDS_STDIO_ASSIST
FILE *file;
#else
#ifndef _WIN32
s32 fd;
#else
- // WINDOWS
#endif
bool locked;
#endif
size_t filesize;
};
-struct aki_dir {
-#ifdef AKIYO_FILE_STDIO_COMPAT
+struct nn_dir {
+#ifdef NAUNET_NEEDS_STDIO_ASSIST
#else
#ifndef _WIN32
DIR *dir;
#else
- // WINDOWS
#endif
#endif
str path;
};
-struct aki_dir_entry {
+struct nn_dir_entry {
u8 type;
-#ifdef AKIYO_FILE_STDIO_COMPAT
+#ifdef NAUNET_NEEDS_STDIO_ASSIST
#else
#ifndef _WIN32
struct dirent *entry;
#else
- // WINDOWS
#endif
#endif
str name;
str path;
};
-bool aki_file_open(struct aki_file *file, str *path, s32 flags);
-bool aki_file_exists(str *path);
-bool aki_file_create(str *path);
-bool aki_file_truncate(struct aki_file *file, off_t size);
-off_t aki_file_seek(struct aki_file *file, off_t offset, s32 whence);
-size_t aki_file_get_filesize(struct aki_file *file);
-bool aki_file_write(struct aki_file *file, void *buf, size_t size);
-bool aki_file_read(struct aki_file *file, void *buf, size_t size);
-s32 aki_file_read_as_str(struct aki_file *file, str *out);
-s32 aki_file_read_as_c_str(struct aki_file *file, char **out);
-s32 aki_file_replace(struct aki_file *file, str *buf);
-void *aki_file_mmap(struct aki_file *file);
-void *aki_file_mremap(struct aki_file *file, size_t size, void *old_map);
-void aki_file_munmap(struct aki_file *file, void *map);
-void aki_file_close(struct aki_file *file);
+bool nn_file_open(struct nn_file *file, str *path, s32 flags);
+bool nn_file_exists(str *path);
+bool nn_file_create(str *path);
+bool nn_file_truncate(struct nn_file *file, off_t size);
+off_t nn_file_seek(struct nn_file *file, off_t offset, s32 whence);
+size_t nn_file_get_filesize(struct nn_file *file);
+bool nn_file_write(struct nn_file *file, void *buf, size_t size);
+bool nn_file_read(struct nn_file *file, void *buf, size_t size);
+s32 nn_file_read_as_str(struct nn_file *file, str *out);
+s32 nn_file_read_as_c_str(struct nn_file *file, char **out);
+s32 nn_file_replace(struct nn_file *file, str *buf);
+void *nn_file_mmap(struct nn_file *file);
+void *nn_file_mremap(struct nn_file *file, size_t size, void *old_map);
+void nn_file_munmap(struct nn_file *file, void *map);
+void nn_file_close(struct nn_file *file);
-bool aki_dir_open(struct aki_dir *dir, str *path);
-void aki_dir_close(struct aki_dir *dir);
-bool aki_dir_exists(str *path);
-bool aki_dir_create(str *path);
-bool aki_dir_read(struct aki_dir *dir, struct aki_dir_entry *entry);
-void aki_dir_entry_free(struct aki_dir_entry *entry);
+bool nn_dir_open(struct nn_dir *dir, str *path);
+void nn_dir_close(struct nn_dir *dir);
+bool nn_dir_exists(str *path);
+bool nn_dir_create(str *path);
+bool nn_dir_read(struct nn_dir *dir, struct nn_dir_entry *entry);
+void nn_dir_entry_free(struct nn_dir_entry *entry);
diff --git a/src/util/file/file_linux.c b/src/util/file/file_linux.c
index 977853c..9c6b1ce 100644
--- a/src/util/file/file_linux.c
+++ b/src/util/file/file_linux.c
@@ -9,7 +9,7 @@ static bool lock_file_internal(s32 fd, size_t size)
{
struct flock l = { .l_type = F_WRLCK, .l_whence = SEEK_SET, .l_start = 0, .l_len = size };
if (fcntl(fd, F_SETLKW, &l) == -1) {
- al_log_error("file", "fcntl(F_SETLKW, F_WRLCK) failed (%s).", aki_strerror(errno));
+ al_log_error("file", "fcntl(F_SETLKW, F_WRLCK) failed (%s).", nn_strerror(errno));
close(fd);
return false;
}
@@ -20,41 +20,46 @@ static bool unlock_file_internal(s32 fd, size_t size)
{
struct flock l = { .l_type = F_ULOCK, .l_whence = SEEK_SET, .l_start = 0, .l_len = size };
if (fcntl(fd, F_SETLKW, &l) == -1) {
- al_log_error("file", "fcntl(F_SETLKW, F_ULOCK) failed (%s).", aki_strerror(errno));
+ al_log_error("file", "fcntl(F_SETLKW, F_ULOCK) failed (%s).", nn_strerror(errno));
return false;
}
return true;
}
-bool aki_file_open(struct aki_file *file, str *path, s32 flags)
+bool nn_file_open(struct nn_file *file, str *path, s32 flags)
{
- al_assert(!((flags & AKI_FILE_READONLY) && (flags & AKI_FILE_LOCK)));
+ al_assert(!((flags & NNWT_FILE_READONLY) && (flags & NNWT_FILE_LOCK)));
+ s32 oflags = flags & NNWT_FILE_READONLY ? O_RDONLY : O_RDWR;
+ if (flags & NNWT_FILE_CREATE)
+ oflags |= O_CREAT;
+
char *c_str = al_str_to_c_str(path);
- s32 oflags = (flags & AKI_FILE_READONLY) ? O_RDONLY : O_RDWR;
- if (flags & AKI_FILE_CREATE) oflags |= O_CREAT;
file->fd = open(c_str, oflags, 0644);
al_free(c_str);
if (file->fd == -1) {
- al_log_error("file", "open(%.*s) failed (%d: %s).", AL_STR_PRINTF(path), errno, aki_strerror(errno));
+ al_log_error("file", "open(%.*s) failed (%d: %s).", AL_STR_PRINTF(path), errno, nn_strerror(errno));
return false;
}
+
struct stat sb;
s32 res = fstat(file->fd, &sb);
if (res == -1) {
- al_log_error("file", "fstat() failed (%s).", aki_strerror(errno));
+ al_log_error("file", "fstat() failed (%s).", nn_strerror(errno));
close(file->fd);
return false;
}
file->filesize = sb.st_size;
- if (flags & AKI_FILE_LOCK) {
- file->locked = lock_file_internal(file->fd, file->filesize);
- } else {
- file->locked = false;
+
+ file->locked = flags & NNWT_FILE_LOCK;
+ if (file->locked && !lock_file_internal(file->fd, file->filesize)) {
+ close(file->fd);
+ return false;
}
+
return true;
}
-bool aki_file_exists(str *path)
+bool nn_file_exists(str *path)
{
char *c_str = al_str_to_c_str(path);
s32 ret = access(c_str, F_OK);
@@ -62,37 +67,36 @@ bool aki_file_exists(str *path)
return ret == 0;
}
-bool aki_file_create(str *path)
+bool nn_file_create(str *path)
{
- struct aki_file file;
- if (aki_file_open(&file, path, AKI_FILE_CREATE)) {
- aki_file_close(&file);
+ struct nn_file file;
+ if (nn_file_open(&file, path, NNWT_FILE_CREATE)) {
+ nn_file_close(&file);
return true;
}
return false;
}
-off_t aki_file_seek(struct aki_file *file, off_t offset, s32 whence)
+off_t nn_file_seek(struct nn_file *file, off_t offset, s32 whence)
{
off_t res = lseek(file->fd, offset, whence);
- if (res == (off_t)-1) {
- al_log_error("file", "lseek(%jd, %d) failed (%s).", (intmax_t)offset, whence, aki_strerror(errno));
- }
+ if (res == (off_t)-1)
+ al_log_error("file", "lseek(%jd, %d) failed (%s).", (intmax_t)offset, whence, nn_strerror(errno));
return res;
}
-bool aki_file_truncate(struct aki_file *file, off_t size)
+bool nn_file_truncate(struct nn_file *file, off_t size)
{
s32 ret = ftruncate(file->fd, size);
if (ret != 0) {
- al_log_error("file", "ftruncate(%jd) failed (%s).", (intmax_t)size, aki_strerror(errno));
+ al_log_error("file", "ftruncate(%jd) failed (%s).", (intmax_t)size, nn_strerror(errno));
return false;
}
file->filesize = size;
return true;
}
-size_t aki_file_get_filesize(struct aki_file *file)
+size_t nn_file_get_filesize(struct nn_file *file)
{
return file->filesize;
}
@@ -100,140 +104,136 @@ size_t aki_file_get_filesize(struct aki_file *file)
#define file_io_loop(call, fail_case) \
size_t bc = 0; \
ssize_t res; \
- do { \
+ for (;;) { \
res = call(file->fd, buf, size - bc); \
if (fail_case) { \
- al_log_error("file", ""#call"() failed (%s).", aki_strerror(errno)); \
+ al_log_error("file", ""#call"() failed (%s).", nn_strerror(errno)); \
return false; \
} \
- bc += res; \
- } while (bc < size); \
+ if ((bc += res) >= size) break; \
+ } \
return true
-bool aki_file_write(struct aki_file *file, void *buf, size_t size)
+bool nn_file_write(struct nn_file *file, void *buf, size_t size)
{
file_io_loop(write, (res == -1));
}
-bool aki_file_read(struct aki_file *file, void *buf, size_t size)
+bool nn_file_read(struct nn_file *file, void *buf, size_t size)
{
file_io_loop(read, (res == -1));
}
-void *aki_file_mmap(struct aki_file *file)
+void *nn_file_mmap(struct nn_file *file)
{
void *map = mmap(NULL, file->filesize, PROT_READ | PROT_WRITE, MAP_SHARED, file->fd, 0L);
if (map == MAP_FAILED) {
- al_log_error("file", "mmap() failed (%s).", aki_strerror(errno));
+ al_log_error("file", "mmap() failed (%s).", nn_strerror(errno));
return NULL;
}
return map;
}
-void *aki_file_mremap(struct aki_file *file, size_t size, void *old_map)
+void *nn_file_mremap(struct nn_file *file, size_t size, void *old_map)
{
void *map = mremap(old_map, file->filesize, size, MREMAP_MAYMOVE);
if (map == MAP_FAILED) {
- al_log_error("file", "mremap(%p, %zu, %zu) failed (%s).", old_map,
- file->filesize, size, aki_strerror(errno));
+ al_log_error("file", "mremap(%p, %zu, %zu) failed (%s).",
+ old_map, file->filesize, size, nn_strerror(errno));
return NULL;
}
return map;
}
-void aki_file_munmap(struct aki_file *file, void *map)
+void nn_file_munmap(struct nn_file *file, void *map)
{
s32 ret = munmap(map, file->filesize);
- if (ret != 0) {
- al_log_error("file", "munmap(%p, %zu) failed (%s).", map, file->filesize, aki_strerror(errno));
- }
+ if (ret != 0)
+ al_log_error("file", "munmap(%p, %zu) failed (%s).", map, file->filesize, nn_strerror(errno));
}
-void aki_file_close(struct aki_file *file)
+void nn_file_close(struct nn_file *file)
{
- if (file->locked) {
- unlock_file_internal(file->fd, file->filesize);
- }
+ if (file->locked) unlock_file_internal(file->fd, file->filesize);
close(file->fd);
}
-bool aki_dir_open(struct aki_dir *dir, str *path)
+bool nn_dir_open(struct nn_dir *dir, str *path)
{
char *c_str = al_str_to_c_str(path);
dir->dir = opendir(c_str);
al_free(c_str);
if (!dir->dir) {
- al_log_error("file", "opendir(%.*s) failed (%s).", AL_STR_PRINTF(path), aki_strerror(errno));
+ al_log_error("file", "opendir(%.*s) failed (%s).", AL_STR_PRINTF(path), nn_strerror(errno));
return false;
}
al_str_clone(&dir->path, path);
return true;
}
-void aki_dir_close(struct aki_dir *dir)
+void nn_dir_close(struct nn_dir *dir)
{
al_str_free(&dir->path);
closedir(dir->dir);
}
-bool aki_dir_exists(str *path)
+bool nn_dir_exists(str *path)
{
- struct aki_dir dir;
+ struct nn_dir dir;
char *c_str = al_str_to_c_str(path);
dir.dir = opendir(c_str);
al_free(c_str);
if (!dir.dir) {
- if (errno != ENOENT) {
- al_log_error("file", "opendir(%.*s) failed (%s).", AL_STR_PRINTF(path), aki_strerror(errno));
- }
+ if (errno != ENOENT)
+ al_log_error("file", "opendir(%.*s) failed (%s).", AL_STR_PRINTF(path), nn_strerror(errno));
return false;
}
closedir(dir.dir);
return true;
}
-bool aki_dir_create(str *path)
+bool nn_dir_create(str *path)
{
char *c_str = al_str_to_c_str(path);
s32 ret = mkdir(c_str, 0755);
al_free(c_str);
if (ret == -1) {
- al_log_error("file", "mkdir(%.*s) failed (%s).", AL_STR_PRINTF(path), aki_strerror(errno));
+ al_log_error("file", "mkdir(%.*s) failed (%s).", AL_STR_PRINTF(path), nn_strerror(errno));
return false;
}
return true;
}
-bool aki_dir_read(struct aki_dir *dir, struct aki_dir_entry *entry)
+bool nn_dir_read(struct nn_dir *dir, struct nn_dir_entry *entry)
{
- errno = 0;
- entry->entry = readdir(dir->dir);
- if (!entry->entry) {
- if (errno) {
- al_log_error("file", "readdir() failed (%s).", aki_strerror(errno));
- }
+ if (!(entry->entry = readdir(dir->dir))) {
+ if (errno)
+ al_log_error("file", "readdir() failed (%s).", nn_strerror(errno));
return false;
}
+
switch (entry->entry->d_type) {
- case DT_REG:
case DT_UNKNOWN:
- entry->type = AKI_ENTRY_FILE;
+ entry->type = NNWT_ENTRY_FILE;
break;
+ case DT_REG:
case DT_DIR:
- entry->type = AKI_ENTRY_DIR;
+ entry->type = NNWT_ENTRY_DIR;
break;
default:
- entry->type = AKI_ENTRY_OTHER;
+ entry->type = NNWT_ENTRY_OTHER;
break;
}
+
al_str_clone(&entry->name, al_str_cr(entry->entry->d_name));
al_str_clone(&entry->path, &dir->path);
al_str_cat(&entry->path, al_str_c("/"));
al_str_cat(&entry->path, &entry->name);
+
return true;
}
-void aki_dir_entry_free(struct aki_dir_entry *entry)
+void nn_dir_entry_free(struct nn_dir_entry *entry)
{
al_str_free(&entry->name);
al_str_free(&entry->path);
diff --git a/src/util/file/file_stdio.c b/src/util/file/file_stdio.c
index fa1e4ff..8f6d7ae 100644
--- a/src/util/file/file_stdio.c
+++ b/src/util/file/file_stdio.c
@@ -4,10 +4,10 @@
#include "file.h"
-bool aki_file_open(struct aki_file *file, str *path, s32 flags)
+bool nn_file_open(struct nn_file *file, str *path, s32 flags)
{
+ const char *mode = flags & NNWT_FILE_CREATE ? "wb+" : "rb+";
char *c_str = al_str_to_c_str(path);
- const char *mode = (flags & AKI_FILE_CREATE) ? "wb+" : "rb+";
#ifndef _WIN32
file->file = fopen(c_str, mode);
#else
@@ -19,82 +19,84 @@ bool aki_file_open(struct aki_file *file, str *path, s32 flags)
#else
if (ret != 0) {
#endif
- al_log_error("file_stdio", "fopen(%.*s) failed (%s).", AL_STR_PRINTF(path), aki_strerror(errno));
+ al_log_error("file_stdio", "fopen(%.*s) failed (%s).", AL_STR_PRINTF(path), nn_strerror(errno));
return false;
}
- off_t pos = aki_file_seek(file, 0, SEEK_END);
+
+ off_t pos = nn_file_seek(file, 0, SEEK_END);
if (pos == -1) {
- aki_file_close(file);
+ nn_file_close(file);
return false;
}
file->filesize = pos;
rewind(file->file);
+
return true;
}
-bool aki_file_exists(str *path)
+bool nn_file_exists(str *path)
{
(void)path;
return false;
}
-off_t aki_file_seek(struct aki_file *file, off_t offset, s32 whence)
+off_t nn_file_seek(struct nn_file *file, off_t offset, s32 whence)
{
if (fseek(file->file, offset, whence) != 0) {
- al_log_error("file_stdio", "fseek(%jd, %d) failed (%s).", (intmax_t)offset,
- whence, aki_strerror(errno));
+ al_log_error("file_stdio", "fseek(%jd, %d) failed (%s).",
+ (intmax_t)offset, whence, nn_strerror(errno));
return -1;
}
return ftell(file->file);
}
-bool aki_file_truncate(struct aki_file *file, off_t size)
+bool nn_file_truncate(struct nn_file *file, off_t size)
{
(void)file;
(void)size;
return true;
}
-size_t aki_file_get_filesize(struct aki_file *file)
+size_t nn_file_get_filesize(struct nn_file *file)
{
return file->filesize;
}
-bool aki_file_write(struct aki_file *file, void *buf, size_t size)
+bool nn_file_write(struct nn_file *file, void *buf, size_t size)
{
size_t ret = fwrite(buf, size, 1, file->file);
if (ret == 0) {
- al_log_error("file_stdio", "fwrite(%zu) failed (%s).", size, aki_strerror(errno));
+ al_log_error("file_stdio", "fwrite(%zu) failed (%s).", size, nn_strerror(errno));
return false;
}
return true;
}
-bool aki_file_read(struct aki_file *file, void *buf, size_t size)
+bool nn_file_read(struct nn_file *file, void *buf, size_t size)
{
size_t ret = fread(buf, size, 1, file->file);
if (ret == 0) {
- al_log_error("file_stdio", "fread(%zu) failed (%s).", size, aki_strerror(errno));
+ al_log_error("file_stdio", "fread(%zu) failed (%s).", size, nn_strerror(errno));
return false;
}
return true;
}
-void *aki_file_mmap(struct aki_file *file)
+void *nn_file_mmap(struct nn_file *file)
{
(void)file;
al_assert(false);
return NULL;
}
-void aki_file_close(struct aki_file *file)
+void nn_file_close(struct nn_file *file)
{
fclose(file->file);
}
-bool aki_dir_open(struct aki_dir *dir, str *path) { (void)dir; (void)path; return false; }
-void aki_dir_close(struct aki_dir *dir) { (void)dir; }
-bool aki_dir_exists(str *path) { (void)path; return false; }
-bool aki_dir_create(str *path) { (void)path; return false; }
-bool aki_dir_read(struct aki_dir *dir, struct aki_dir_entry *entry) { (void)dir; (void)entry; return false; }
-void aki_dir_entry_free(struct aki_dir_entry *entry) { (void)entry; }
+bool nn_dir_open(struct nn_dir *dir, str *path) { (void)dir; (void)path; return false; }
+void nn_dir_close(struct nn_dir *dir) { (void)dir; }
+bool nn_dir_exists(str *path) { (void)path; return false; }
+bool nn_dir_create(str *path) { (void)path; return false; }
+bool nn_dir_read(struct nn_dir *dir, struct nn_dir_entry *entry) { (void)dir; (void)entry; return false; }
+void nn_dir_entry_free(struct nn_dir_entry *entry) { (void)entry; }
diff --git a/src/util/file/util.c b/src/util/file/util.c
index fe7785f..50e2c4a 100644
--- a/src/util/file/util.c
+++ b/src/util/file/util.c
@@ -1,10 +1,10 @@
#include "file.h"
-s32 aki_file_read_as_str(struct aki_file *file, str *out)
+s32 nn_file_read_as_str(struct nn_file *file, str *out)
{
size_t size = file->filesize;
al_str_sized(out, size);
- if (!aki_file_read(file, (void *)out->data, size)) {
+ if (!nn_file_read(file, (void *)out->data, size)) {
al_str_free(out);
return -1;
}
@@ -12,11 +12,11 @@ s32 aki_file_read_as_str(struct aki_file *file, str *out)
return size;
}
-s32 aki_file_read_as_c_str(struct aki_file *file, char **out)
+s32 nn_file_read_as_c_str(struct nn_file *file, char **out)
{
size_t size = file->filesize;
*out = al_malloc(size + 1);
- if (!aki_file_read(file, (void *)*out, size)) {
+ if (!nn_file_read(file, (void *)*out, size)) {
al_free(*out);
return -1;
}
@@ -24,11 +24,11 @@ s32 aki_file_read_as_c_str(struct aki_file *file, char **out)
return size;
}
-s32 aki_file_replace(struct aki_file *file, str *buf)
+s32 nn_file_replace(struct nn_file *file, str *buf)
{
- if (aki_file_seek(file, 0, SEEK_SET) == (off_t)-1 ||
- !aki_file_write(file, buf->data, buf->len) ||
- !aki_file_truncate(file, buf->len)) {
+ if (nn_file_seek(file, 0, SEEK_SET) == (off_t)-1 ||
+ !nn_file_write(file, buf->data, buf->len) ||
+ !nn_file_truncate(file, buf->len)) {
return -1;
}
return buf->len;
diff --git a/src/util/packet.c b/src/util/packet.c
index 2658d38..900016c 100644
--- a/src/util/packet.c
+++ b/src/util/packet.c
@@ -1,44 +1,44 @@
#include "packet.h"
-struct aki_packet *aki_packet_create(void)
+struct nn_packet *nn_packet_create(void)
{
- struct aki_packet *packet = (struct aki_packet *)al_malloc(sizeof(struct aki_packet));
- aki_buffer_init(&packet->buffer);
- aki_packet_reset(packet);
+ struct nn_packet *packet = (struct nn_packet *)al_malloc(sizeof(struct nn_packet));
+ nn_buffer_init(&packet->buffer);
+ nn_packet_reset(packet);
return packet;
}
-struct aki_packet *aki_packet_clone(struct aki_packet *packet)
+struct nn_packet *nn_packet_clone(struct nn_packet *packet)
{
- struct aki_packet *c = aki_packet_create();
- aki_buffer_ensure_space(&c->buffer, packet->buffer.size);
- al_memcpy(aki_buffer_get_ptr(&c->buffer, 0), aki_buffer_get_ptr(&packet->buffer, 0), packet->buffer.size);
+ struct nn_packet *c = nn_packet_create();
+ nn_buffer_ensure_space(&c->buffer, packet->buffer.size);
+ al_memcpy(nn_buffer_get_ptr(&c->buffer, 0), nn_buffer_get_ptr(&packet->buffer, 0), packet->buffer.size);
c->windex = packet->windex;
c->rindex = packet->rindex;
return c;
}
-void aki_packet_reset(struct aki_packet *packet)
+void nn_packet_reset(struct nn_packet *packet)
{
- aki_buffer_ensure_space(&packet->buffer, AKI_PACKET_HEADER_LENGTH);
- packet->rindex = AKI_PACKET_HEADER_LENGTH;
- packet->windex = AKI_PACKET_HEADER_LENGTH;
+ nn_buffer_ensure_space(&packet->buffer, NNWT_PACKET_HEADER_LENGTH);
+ packet->rindex = NNWT_PACKET_HEADER_LENGTH;
+ packet->windex = NNWT_PACKET_HEADER_LENGTH;
}
-void aki_packet_write_size(struct aki_packet *packet)
+void nn_packet_write_size(struct nn_packet *packet)
{
- *((u32 *)aki_buffer_get_ptr(&packet->buffer, 0)) = packet->windex;
+ *((u32 *)nn_buffer_get_ptr(&packet->buffer, 0)) = packet->windex;
}
-u32 aki_packet_get_size(struct aki_packet *packet)
+u32 nn_packet_get_size(struct nn_packet *packet)
{
- return *((u32 *)aki_buffer_get_ptr(&packet->buffer, 0));
+ return *((u32 *)nn_buffer_get_ptr(&packet->buffer, 0));
}
#define DEFINE_PACKET_WRITE_FUNC(type) \
- void aki_packet_write_##type(struct aki_packet *packet, type v) \
+ void nn_packet_write_##type(struct nn_packet *packet, type v) \
{ \
- AKI_PACKET_WRITE_TYPE(packet, type, v); \
+ NNWT_PACKET_WRITE_TYPE(packet, type, v); \
}
DEFINE_PACKET_WRITE_FUNC(bool)
@@ -53,25 +53,25 @@ DEFINE_PACKET_WRITE_FUNC(s64)
DEFINE_PACKET_WRITE_FUNC(f32)
DEFINE_PACKET_WRITE_FUNC(f64)
-void aki_packet_write_str(struct aki_packet *packet, str *s)
+void nn_packet_write_str(struct nn_packet *packet, str *s)
{
- AKI_PACKET_WRITE_TYPE(packet, u32, s->len);
- AKI_PACKET_WRITE_DATA(packet, s->data, s->len);
+ NNWT_PACKET_WRITE_TYPE(packet, u32, s->len);
+ NNWT_PACKET_WRITE_DATA(packet, s->data, s->len);
}
-void aki_packet_write_buffer(struct aki_packet *packet, struct aki_buffer *buf)
+void nn_packet_write_buffer(struct nn_packet *packet, struct nn_buffer *buf)
{
u64 size = (u64)buf->size;
- AKI_PACKET_WRITE_TYPE(packet, u64, size);
- AKI_PACKET_WRITE_DATA(packet, aki_buffer_get_ptr(buf, 0), buf->size);
+ NNWT_PACKET_WRITE_TYPE(packet, u64, size);
+ NNWT_PACKET_WRITE_DATA(packet, nn_buffer_get_ptr(buf, 0), buf->size);
}
#define DEFINE_PACKET_READ_FUNC(type) \
- type aki_packet_read_##type(struct aki_packet *packet) \
+ type nn_packet_read_##type(struct nn_packet *packet) \
{ \
- type r; \
- AKI_PACKET_READ_TYPE(packet, type, r); \
- return r; \
+ type r; \
+ NNWT_PACKET_READ_TYPE(packet, type, r); \
+ return r; \
}
DEFINE_PACKET_READ_FUNC(bool)
@@ -86,38 +86,38 @@ DEFINE_PACKET_READ_FUNC(s64)
DEFINE_PACKET_READ_FUNC(f32)
DEFINE_PACKET_READ_FUNC(f64)
-void aki_packet_read_str(struct aki_packet *packet, str *s)
+void nn_packet_read_str(struct nn_packet *packet, str *s)
{
- AKI_PACKET_READ_TYPE(packet, u32, s->len);
- AKI_PACKET_READ_DATA(packet, s->len, s->data);
+ NNWT_PACKET_READ_TYPE(packet, u32, s->len);
+ NNWT_PACKET_READ_DATA(packet, s->len, s->data);
s->alloc = 0;
}
-void aki_packet_read_buffer(struct aki_packet *packet, struct aki_buffer *buf)
+void nn_packet_read_buffer(struct nn_packet *packet, struct nn_buffer *buf)
{
u64 size;
- AKI_PACKET_READ_TYPE(packet, u64, size);
+ NNWT_PACKET_READ_TYPE(packet, u64, size);
al_assert((sizeof(size_t) > 4 || size <= INT32_MAX));
buf->size = (size_t)size;
- AKI_PACKET_READ_DATA(packet, buf->size, buf->data);
+ NNWT_PACKET_READ_DATA(packet, buf->size, buf->data);
buf->alloc = 0;
}
-void aki_packet_write_wstr(struct aki_packet *packet, wstr *w)
+void nn_packet_write_wstr(struct nn_packet *packet, wstr *w)
{
- AKI_PACKET_WRITE_TYPE(packet, u32, w->len);
- AKI_PACKET_WRITE_DATA(packet, w->data, w->len * sizeof(wchar_t));
+ NNWT_PACKET_WRITE_TYPE(packet, u32, w->len);
+ NNWT_PACKET_WRITE_DATA(packet, w->data, w->len * sizeof(wchar_t));
}
-void aki_packet_read_wstr(struct aki_packet *packet, wstr *w)
+void nn_packet_read_wstr(struct nn_packet *packet, wstr *w)
{
- AKI_PACKET_READ_TYPE(packet, u32, w->len);
- AKI_PACKET_READ_DATA(packet, w->len * sizeof(wchar_t), w->data);
+ NNWT_PACKET_READ_TYPE(packet, u32, w->len);
+ NNWT_PACKET_READ_DATA(packet, w->len * sizeof(wchar_t), w->data);
w->alloc = 0;
}
-void aki_packet_free(struct aki_packet *packet)
+void nn_packet_free(struct nn_packet *packet)
{
- aki_buffer_free(&packet->buffer);
+ nn_buffer_free(&packet->buffer);
al_free(packet);
}
diff --git a/src/util/packet.h b/src/util/packet.h
index 72543a6..41f0a77 100644
--- a/src/util/packet.h
+++ b/src/util/packet.h
@@ -7,69 +7,69 @@
#include "../util/buffer.h"
-#define AKI_PACKET_HEADER_LENGTH (u32)(sizeof(u32))
+#define NNWT_PACKET_HEADER_LENGTH (u32)(sizeof(u32))
-struct aki_packet {
- struct aki_buffer buffer;
+struct nn_packet {
+ struct nn_buffer buffer;
u32 rindex;
u32 windex;
};
-#define AKI_PACKET_GET_ID(p) \
- *((u32 *)aki_buffer_get_ptr(&p->buffer, AKI_PACKET_HEADER_LENGTH + sizeof(s8)))
+#define NNWT_PACKET_GET_ID(p) \
+ *((u32 *)nn_buffer_get_ptr(&p->buffer, NNWT_PACKET_HEADER_LENGTH + sizeof(s8)))
-#define AKI_PACKET_WRITE_TYPE(p, type, v) \
- aki_buffer_write(&(p)->buffer, &(v), (p)->windex, sizeof(type)); \
+#define NNWT_PACKET_WRITE_TYPE(p, type, v) \
+ nn_buffer_write(&(p)->buffer, &(v), (p)->windex, sizeof(type)); \
(p)->windex += (u32)sizeof(type)
-#define AKI_PACKET_WRITE_DATA(p, data, len) \
- aki_buffer_write(&(p)->buffer, (data), (p)->windex, (len)); \
+#define NNWT_PACKET_WRITE_DATA(p, data, len) \
+ nn_buffer_write(&(p)->buffer, (data), (p)->windex, (len)); \
(p)->windex += (u32)len
-#define AKI_PACKET_READ_TYPE(p, type, r) \
- r = *((type *)aki_buffer_get_ptr(&(p)->buffer, (p)->rindex)); \
+#define NNWT_PACKET_READ_TYPE(p, type, r) \
+ r = *((type *)nn_buffer_get_ptr(&(p)->buffer, (p)->rindex)); \
(p)->rindex += (u32)sizeof(type);
-#define AKI_PACKET_READ_DATA(p, len, r) \
- r = (void *)aki_buffer_get_ptr(&(p)->buffer, (p)->rindex); \
+#define NNWT_PACKET_READ_DATA(p, len, r) \
+ r = (void *)nn_buffer_get_ptr(&(p)->buffer, (p)->rindex); \
(p)->rindex += (u32)len;
-struct aki_packet *aki_packet_create(void);
-struct aki_packet *aki_packet_clone(struct aki_packet *packet);
-void aki_packet_reset(struct aki_packet *packet);
+struct nn_packet *nn_packet_create(void);
+struct nn_packet *nn_packet_clone(struct nn_packet *packet);
+void nn_packet_reset(struct nn_packet *packet);
-void aki_packet_write_size(struct aki_packet *packet);
-u32 aki_packet_get_size(struct aki_packet *packet);
+void nn_packet_write_size(struct nn_packet *packet);
+u32 nn_packet_get_size(struct nn_packet *packet);
-void aki_packet_write_bool(struct aki_packet *packet, bool v);
-void aki_packet_write_s8(struct aki_packet *packet, s8 v);
-void aki_packet_write_u8(struct aki_packet *packet, u8 v);
-void aki_packet_write_s16(struct aki_packet *packet, s16 v);
-void aki_packet_write_u16(struct aki_packet *packet, u16 v);
-void aki_packet_write_s32(struct aki_packet *packet, s32 v);
-void aki_packet_write_u32(struct aki_packet *packet, u32 v);
-void aki_packet_write_s64(struct aki_packet *packet, s64 v);
-void aki_packet_write_u64(struct aki_packet *packet, u64 v);
-void aki_packet_write_f32(struct aki_packet *packet, f32 v);
-void aki_packet_write_f64(struct aki_packet *packet, f64 v);
-void aki_packet_write_str(struct aki_packet *packet, str *s);
-void aki_packet_write_buffer(struct aki_packet *packet, struct aki_buffer *buf);
+void nn_packet_write_bool(struct nn_packet *packet, bool v);
+void nn_packet_write_s8(struct nn_packet *packet, s8 v);
+void nn_packet_write_u8(struct nn_packet *packet, u8 v);
+void nn_packet_write_s16(struct nn_packet *packet, s16 v);
+void nn_packet_write_u16(struct nn_packet *packet, u16 v);
+void nn_packet_write_s32(struct nn_packet *packet, s32 v);
+void nn_packet_write_u32(struct nn_packet *packet, u32 v);
+void nn_packet_write_s64(struct nn_packet *packet, s64 v);
+void nn_packet_write_u64(struct nn_packet *packet, u64 v);
+void nn_packet_write_f32(struct nn_packet *packet, f32 v);
+void nn_packet_write_f64(struct nn_packet *packet, f64 v);
+void nn_packet_write_str(struct nn_packet *packet, str *s);
+void nn_packet_write_buffer(struct nn_packet *packet, struct nn_buffer *buf);
-bool aki_packet_read_bool(struct aki_packet *packet);
-s8 aki_packet_read_s8(struct aki_packet *packet);
-u8 aki_packet_read_u8(struct aki_packet *packet);
-s16 aki_packet_read_s16(struct aki_packet *packet);
-u16 aki_packet_read_u16(struct aki_packet *packet);
-s32 aki_packet_read_s32(struct aki_packet *packet);
-u32 aki_packet_read_u32(struct aki_packet *packet);
-s64 aki_packet_read_s64(struct aki_packet *packet);
-u64 aki_packet_read_u64(struct aki_packet *packet);
-f32 aki_packet_read_f32(struct aki_packet *packet);
-f64 aki_packet_read_f64(struct aki_packet *packet);
-void aki_packet_read_str(struct aki_packet *packet, str *s);
-void aki_packet_read_buffer(struct aki_packet *packet, struct aki_buffer *buf);
+bool nn_packet_read_bool(struct nn_packet *packet);
+s8 nn_packet_read_s8(struct nn_packet *packet);
+u8 nn_packet_read_u8(struct nn_packet *packet);
+s16 nn_packet_read_s16(struct nn_packet *packet);
+u16 nn_packet_read_u16(struct nn_packet *packet);
+s32 nn_packet_read_s32(struct nn_packet *packet);
+u32 nn_packet_read_u32(struct nn_packet *packet);
+s64 nn_packet_read_s64(struct nn_packet *packet);
+u64 nn_packet_read_u64(struct nn_packet *packet);
+f32 nn_packet_read_f32(struct nn_packet *packet);
+f64 nn_packet_read_f64(struct nn_packet *packet);
+void nn_packet_read_str(struct nn_packet *packet, str *s);
+void nn_packet_read_buffer(struct nn_packet *packet, struct nn_buffer *buf);
-void aki_packet_write_wstr(struct aki_packet *packet, wstr *w);
-void aki_packet_read_wstr(struct aki_packet *packet, wstr *w);
+void nn_packet_write_wstr(struct nn_packet *packet, wstr *w);
+void nn_packet_read_wstr(struct nn_packet *packet, wstr *w);
-void aki_packet_free(struct aki_packet *packet);
+void nn_packet_free(struct nn_packet *packet);
diff --git a/src/util/thread/thread.h b/src/util/thread/thread.h
index 5975c84..921de23 100644
--- a/src/util/thread/thread.h
+++ b/src/util/thread/thread.h
@@ -8,14 +8,14 @@
#include "../../winwrap.h"
#endif
-#ifdef AKIYO_HAS_THREAD_CANCEL
+#ifdef NAUNET_HAS_THREAD_CANCEL
enum {
- AKI_THREAD_CANCEL_DEFERRED = PTHREAD_CANCEL_DEFERRED,
- AKI_THREAD_CANCEL_ASYNCHRONOUS = PTHREAD_CANCEL_ASYNCHRONOUS
+ NNWT_THREAD_CANCEL_DEFERRED = PTHREAD_CANCEL_DEFERRED,
+ NNWT_THREAD_CANCEL_ASYNCHRONOUS = PTHREAD_CANCEL_ASYNCHRONOUS
};
#endif
-struct aki_thread {
+struct nn_thread {
#ifndef _WIN32
pthread_t thread;
#else
@@ -23,7 +23,7 @@ struct aki_thread {
#endif
};
-struct aki_mutex {
+struct nn_mutex {
#ifndef _WIN32
pthread_mutex_t mutex;
#else
@@ -31,7 +31,7 @@ struct aki_mutex {
#endif
};
-struct aki_cond {
+struct nn_cond {
#ifndef _WIN32
pthread_cond_t cond;
#else
@@ -40,37 +40,37 @@ struct aki_cond {
bool condition;
};
-typedef f64 aki_os_tstamp;
+typedef f64 nn_os_tstamp;
-#define AKI_TS_FROM_USEC(usec) ((usec) * 1e-6)
+#define NNWT_TS_FROM_USEC(usec) ((usec) * 1e-6)
#ifndef _WIN32
-#define AKI_THREADCALL
-typedef void * aki_thread_result;
+#define NNWT_THREADCALL
+typedef void * nn_thread_result;
#else
-#define AKI_THREADCALL __stdcall
-typedef unsigned long aki_thread_result;
+#define NNWT_THREADCALL __stdcall
+typedef unsigned long nn_thread_result;
#endif
-typedef aki_thread_result (AKI_THREADCALL * aki_thread_func)(void *);
+typedef nn_thread_result (NNWT_THREADCALL * nn_thread_func)(void *);
-void aki_thread_sleep(aki_os_tstamp delay);
+void nn_thread_sleep(nn_os_tstamp delay);
-void aki_thread_create(struct aki_thread *thread, aki_thread_func func, void *userdata);
-void aki_thread_join(struct aki_thread *thread);
-#ifdef AKIYO_HAS_THREAD_CANCEL
-void aki_thread_cancel(struct aki_thread *thread);
-void aki_thread_setcanceltype(s32 type);
+void nn_thread_create(struct nn_thread *thread, nn_thread_func func, void *userdata);
+void nn_thread_join(struct nn_thread *thread);
+#ifdef NAUNET_HAS_THREAD_CANCEL
+void nn_thread_cancel(struct nn_thread *thread);
+void nn_thread_setcanceltype(s32 type);
#endif
-//void aki_thread_detach(struct aki_thread *thread);
+//void nn_thread_detach(struct nn_thread *thread);
-void aki_mutex_init(struct aki_mutex *mutex);
-void aki_mutex_lock(struct aki_mutex *mutex);
-void aki_mutex_unlock(struct aki_mutex *mutex);
-void aki_mutex_destroy(struct aki_mutex *mutex);
+void nn_mutex_init(struct nn_mutex *mutex);
+void nn_mutex_lock(struct nn_mutex *mutex);
+void nn_mutex_unlock(struct nn_mutex *mutex);
+void nn_mutex_destroy(struct nn_mutex *mutex);
-void aki_cond_init(struct aki_cond *cond);
-void aki_cond_wait(struct aki_cond *cond, struct aki_mutex *mutex);
-bool aki_cond_is_waiting(struct aki_cond *cond);
-void aki_cond_signal(struct aki_cond *cond);
-void aki_cond_destroy(struct aki_cond *cond);
+void nn_cond_init(struct nn_cond *cond);
+void nn_cond_wait(struct nn_cond *cond, struct nn_mutex *mutex);
+bool nn_cond_is_waiting(struct nn_cond *cond);
+void nn_cond_signal(struct nn_cond *cond);
+void nn_cond_destroy(struct nn_cond *cond);
diff --git a/src/util/thread/thread_linux.c b/src/util/thread/thread_linux.c
index 26c3e18..bb5bcbc 100644
--- a/src/util/thread/thread_linux.c
+++ b/src/util/thread/thread_linux.c
@@ -4,7 +4,7 @@
#include "thread.h"
-void aki_thread_sleep(aki_os_tstamp delay)
+void nn_thread_sleep(nn_os_tstamp delay)
{
struct timespec tv;
tv.tv_sec = (s64)delay;
@@ -12,81 +12,80 @@ void aki_thread_sleep(aki_os_tstamp delay)
while (nanosleep(&tv, &tv) == -1 && errno == EINTR) {}
}
-void aki_thread_create(struct aki_thread *thread, aki_thread_func func, void *userdata)
+void nn_thread_create(struct nn_thread *thread, nn_thread_func func, void *userdata)
{
pthread_create(&thread->thread, NULL, func, userdata);
}
-void aki_thread_join(struct aki_thread *thread)
+void nn_thread_join(struct nn_thread *thread)
{
pthread_join(thread->thread, NULL);
}
-#ifdef AKIYO_HAS_THREAD_CANCEL
-void aki_thread_cancel(struct aki_thread *thread)
+#ifdef NAUNET_HAS_THREAD_CANCEL
+void nn_thread_cancel(struct nn_thread *thread)
{
pthread_cancel(thread->thread);
}
-void aki_thread_setcanceltype(s32 type)
+void nn_thread_setcanceltype(s32 type)
{
pthread_setcanceltype(type, NULL);
}
#endif
/*
-void aki_thread_detach(struct aki_thread *thread)
+void nn_thread_detach(struct nn_thread *thread)
{
pthread_detach(thread->thread);
}
*/
-void aki_mutex_init(struct aki_mutex *mutex)
+void nn_mutex_init(struct nn_mutex *mutex)
{
pthread_mutex_init(&mutex->mutex, NULL);
}
-void aki_mutex_lock(struct aki_mutex *mutex)
+void nn_mutex_lock(struct nn_mutex *mutex)
{
pthread_mutex_lock(&mutex->mutex);
}
-void aki_mutex_unlock(struct aki_mutex *mutex)
+void nn_mutex_unlock(struct nn_mutex *mutex)
{
pthread_mutex_unlock(&mutex->mutex);
}
-void aki_mutex_destroy(struct aki_mutex *mutex)
+void nn_mutex_destroy(struct nn_mutex *mutex)
{
pthread_mutex_destroy(&mutex->mutex);
}
-void aki_cond_init(struct aki_cond *cond)
+void nn_cond_init(struct nn_cond *cond)
{
cond->condition = true;
pthread_cond_init(&cond->cond, NULL);
}
-void aki_cond_wait(struct aki_cond *cond, struct aki_mutex *mutex)
+void nn_cond_wait(struct nn_cond *cond, struct nn_mutex *mutex)
{
cond->condition = false;
- while (!cond->condition) {
+ while (!cond->condition)
pthread_cond_wait(&cond->cond, &mutex->mutex);
- }
}
-bool aki_cond_is_waiting(struct aki_cond *cond)
+bool nn_cond_is_waiting(struct nn_cond *cond)
{
return !cond->condition;
}
-void aki_cond_signal(struct aki_cond *cond)
+void nn_cond_signal(struct nn_cond *cond)
{
cond->condition = true;
pthread_cond_signal(&cond->cond);
}
-void aki_cond_destroy(struct aki_cond *cond)
+void nn_cond_destroy(struct nn_cond *cond)
{
pthread_cond_destroy(&cond->cond);
}
diff --git a/src/util/thread/thread_windows.c b/src/util/thread/thread_windows.c
index c7fdd62..ded3b6c 100644
--- a/src/util/thread/thread_windows.c
+++ b/src/util/thread/thread_windows.c
@@ -2,86 +2,85 @@
NTSTATUS(__stdcall *NtDelayExecution)(BOOL Alertable, PLARGE_INTEGER DelayInterval);
-void aki_thread_sleep(aki_os_tstamp delay)
+void nn_thread_sleep(nn_os_tstamp delay)
{
NtDelayExecution(false, &((LARGE_INTEGER){ .QuadPart = -(s64)(delay * 1e7L) }));
}
-void aki_thread_create(struct aki_thread *thread, aki_thread_func func, void *userdata)
+void nn_thread_create(struct nn_thread *thread, nn_thread_func func, void *userdata)
{
thread->thread = CreateThread(NULL, 0, func, userdata, 0, NULL);
}
-void aki_thread_join(struct aki_thread *thread)
+void nn_thread_join(struct nn_thread *thread)
{
WaitForSingleObject(thread->thread, INFINITE);
CloseHandle(thread->thread);
}
-#ifdef AKIYO_HAS_THREAD_CANCEL
-void aki_thread_cancel(struct aki_thread *thread)
+#ifdef NAUNET_HAS_THREAD_CANCEL
+void nn_thread_cancel(struct nn_thread *thread)
{
(void)thread;
}
-void aki_thread_setcanceltype(s32 type)
+void nn_thread_setcanceltype(s32 type)
{
(void)type;
}
#endif
/*
-void aki_thread_detach(struct aki_thread *thread)
+void nn_thread_detach(struct nn_thread *thread)
{
}
*/
-void aki_mutex_init(struct aki_mutex *mutex)
+void nn_mutex_init(struct nn_mutex *mutex)
{
InitializeCriticalSection(&mutex->mutex);
}
-void aki_mutex_lock(struct aki_mutex *mutex)
+void nn_mutex_lock(struct nn_mutex *mutex)
{
EnterCriticalSection(&mutex->mutex);
}
-void aki_mutex_unlock(struct aki_mutex *mutex)
+void nn_mutex_unlock(struct nn_mutex *mutex)
{
LeaveCriticalSection(&mutex->mutex);
}
-void aki_mutex_destroy(struct aki_mutex *mutex)
+void nn_mutex_destroy(struct nn_mutex *mutex)
{
DeleteCriticalSection(&mutex->mutex);
}
-void aki_cond_init(struct aki_cond *cond)
+void nn_cond_init(struct nn_cond *cond)
{
cond->condition = true;
InitializeConditionVariable(&cond->cond);
}
-void aki_cond_wait(struct aki_cond *cond, struct aki_mutex *mutex)
+void nn_cond_wait(struct nn_cond *cond, struct nn_mutex *mutex)
{
cond->condition = false;
- while (!cond->condition) {
+ while (!cond->condition)
SleepConditionVariableCS(&cond->cond, &mutex->mutex, INFINITE);
- }
}
-bool aki_cond_is_waiting(struct aki_cond *cond)
+bool nn_cond_is_waiting(struct nn_cond *cond)
{
return !cond->condition;
}
-void aki_cond_signal(struct aki_cond *cond)
+void nn_cond_signal(struct nn_cond *cond)
{
cond->condition = true;
WakeConditionVariable(&cond->cond);
}
-void aki_cond_destroy(struct aki_cond *cond)
+void nn_cond_destroy(struct nn_cond *cond)
{
(void)cond;
}
diff --git a/src/util/timer/timer.h b/src/util/timer/timer.h
index 2bf6b95..cd2daf7 100644
--- a/src/util/timer/timer.h
+++ b/src/util/timer/timer.h
@@ -2,5 +2,5 @@
#include <al/types.h>
-u64 aki_get_timestamp(void);
-f64 aki_get_tick(void);
+u64 nn_get_timestamp(void);
+f64 nn_get_tick(void);
diff --git a/src/util/timer/timer_linux.c b/src/util/timer/timer_linux.c
index d93bfdc..6585f10 100644
--- a/src/util/timer/timer_linux.c
+++ b/src/util/timer/timer_linux.c
@@ -2,14 +2,14 @@
#include "timer.h"
-u64 aki_get_timestamp(void)
+u64 nn_get_timestamp(void)
{
struct timespec spec;
clock_gettime(CLOCK_REALTIME, &spec);
return 1e6 * spec.tv_sec + spec.tv_nsec * 1e-3;
}
-f64 aki_get_tick(void)
+f64 nn_get_tick(void)
{
struct timespec spec;
clock_gettime(CLOCK_MONOTONIC, &spec);
diff --git a/src/util/timer/timer_windows.c b/src/util/timer/timer_windows.c
index edd1297..198cb32 100644
--- a/src/util/timer/timer_windows.c
+++ b/src/util/timer/timer_windows.c
@@ -2,7 +2,7 @@
#include "timer.h"
-f64 aki_get_tick(void)
+f64 nn_get_tick(void)
{
LARGE_INTEGER result;
QueryPerformanceCounter(&result);
@@ -12,7 +12,7 @@ f64 aki_get_tick(void)
// https://stackoverflow.com/a/46024468
static const s64 UNIX_TIME_START = 0x019DB1DED53E8000; // January 1st, 1970 in "ticks"
-u64 aki_get_timestamp(void)
+u64 nn_get_timestamp(void)
{
FILETIME ft;
GetSystemTimePreciseAsFileTime(&ft);
generated by cgit v1.2.3-101-g0448 (git 2.54.0) at 2026-07-25 20:51:35 +0000