wash/fx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

meta: rename to fx

Browse Source
This commit is contained in:
max 🍓
2026-03-16 10:35:43 +00:00
parent 84df46489a
commit e9d0e323f0
233 changed files with 12875 additions and 12869 deletions
Download Patch File Download Diff File Expand all files Collapse all files

214
core/ringbuffer.c
View File

@@ -1,4 +1,4 @@
#include <blue/core/ringbuffer.h>
#include <fx/core/ringbuffer.h>
#include <stdlib.h>
#include <string.h>
@@ -14,7 +14,7 @@ enum ringbuffer_flags {
RINGBUFFER_WRITE_LOCKED = 0x08u,
};
struct b_ringbuffer_p {
struct fx_ringbuffer_p {
enum ringbuffer_flags r_flags;
void *r_buf, *r_opened_buf;
unsigned long r_capacity, r_opened_capacity;
@@ -23,18 +23,18 @@ struct b_ringbuffer_p {
/*** PRIVATE FUNCTIONS ********************************************************/
static enum b_status ringbuffer_clear(struct b_ringbuffer_p *buf)
static enum fx_status ringbuffer_clear(struct fx_ringbuffer_p *buf)
{
if (BUF_LOCKED(buf)) {
return B_ERR_BUSY;
return FX_ERR_BUSY;
}
buf->r_read_ptr = buf->r_write_ptr = 0;
return B_SUCCESS;
return FX_SUCCESS;
}
static size_t ringbuffer_write_capacity_remaining(const struct b_ringbuffer_p *buf)
static size_t ringbuffer_write_capacity_remaining(const struct fx_ringbuffer_p *buf)
{
if (buf->r_read_ptr > buf->r_write_ptr) {
return buf->r_read_ptr - buf->r_write_ptr - 1;
@@ -43,7 +43,7 @@ static size_t ringbuffer_write_capacity_remaining(const struct b_ringbuffer_p *b
}
}
static size_t ringbuffer_available_data_remaining(const struct b_ringbuffer_p *buf)
static size_t ringbuffer_available_data_remaining(const struct fx_ringbuffer_p *buf)
{
if (buf->r_read_ptr < buf->r_write_ptr) {
return buf->r_write_ptr - buf->r_read_ptr;
@@ -54,11 +54,11 @@ static size_t ringbuffer_available_data_remaining(const struct b_ringbuffer_p *b
}
}
static enum b_status ringbuffer_open_read_buffer(
struct b_ringbuffer_p *buf, const void **ptr, size_t *length)
static enum fx_status ringbuffer_open_read_buffer(
struct fx_ringbuffer_p *buf, const void **ptr, size_t *length)
{
if (BUF_LOCKED(buf)) {
return B_ERR_BUSY;
return FX_ERR_BUSY;
}
size_t contiguous_capacity = 0;
@@ -69,7 +69,7 @@ static enum b_status ringbuffer_open_read_buffer(
}
if (contiguous_capacity == 0) {
return B_ERR_NO_DATA;
return FX_ERR_NO_DATA;
}
buf->r_opened_buf = (char *)buf->r_buf + buf->r_read_ptr;
@@ -79,22 +79,22 @@ static enum b_status ringbuffer_open_read_buffer(
*ptr = buf->r_opened_buf;
*length = contiguous_capacity;
return B_SUCCESS;
return FX_SUCCESS;
}
static enum b_status ringbuffer_close_read_buffer(
struct b_ringbuffer_p *buf, const void **ptr, size_t nr_read)
static enum fx_status ringbuffer_close_read_buffer(
struct fx_ringbuffer_p *buf, const void **ptr, size_t nr_read)
{
if (!(buf->r_flags & RINGBUFFER_READ_LOCKED)) {
return B_ERR_BAD_STATE;
return FX_ERR_BAD_STATE;
}
if (*ptr != buf->r_opened_buf) {
return B_ERR_INVALID_ARGUMENT;
return FX_ERR_INVALID_ARGUMENT;
}
if (nr_read > buf->r_opened_capacity) {
return B_ERR_INVALID_ARGUMENT;
return FX_ERR_INVALID_ARGUMENT;
}
buf->r_read_ptr += nr_read;
@@ -114,14 +114,14 @@ static enum b_status ringbuffer_close_read_buffer(
buf->r_opened_capacity = 0;
buf->r_flags &= ~RINGBUFFER_READ_LOCKED;
return B_SUCCESS;
return FX_SUCCESS;
}
static enum b_status ringbuffer_open_write_buffer(
struct b_ringbuffer_p *buf, void **ptr, size_t *capacity)
static enum fx_status ringbuffer_open_write_buffer(
struct fx_ringbuffer_p *buf, void **ptr, size_t *capacity)
{
if (BUF_LOCKED(buf)) {
return B_ERR_BUSY;
return FX_ERR_BUSY;
}
size_t contiguous_capacity = 0;
@@ -136,7 +136,7 @@ static enum b_status ringbuffer_open_write_buffer(
}
if (contiguous_capacity == 0) {
return B_ERR_NO_SPACE;
return FX_ERR_NO_SPACE;
}
buf->r_opened_buf = (char *)buf->r_buf + buf->r_write_ptr;
@@ -146,22 +146,22 @@ static enum b_status ringbuffer_open_write_buffer(
*ptr = buf->r_opened_buf;
*capacity = contiguous_capacity;
return B_SUCCESS;
return FX_SUCCESS;
}
static enum b_status ringbuffer_close_write_buffer(
struct b_ringbuffer_p *buf, void **ptr, size_t nr_written)
static enum fx_status ringbuffer_close_write_buffer(
struct fx_ringbuffer_p *buf, void **ptr, size_t nr_written)
{
if (!(buf->r_flags & RINGBUFFER_WRITE_LOCKED)) {
return B_ERR_BAD_STATE;
return FX_ERR_BAD_STATE;
}
if (*ptr != buf->r_opened_buf) {
return B_ERR_INVALID_ARGUMENT;
return FX_ERR_INVALID_ARGUMENT;
}
if (nr_written > buf->r_opened_capacity) {
return B_ERR_INVALID_ARGUMENT;
return FX_ERR_INVALID_ARGUMENT;
}
buf->r_write_ptr += nr_written;
@@ -173,14 +173,14 @@ static enum b_status ringbuffer_close_write_buffer(
buf->r_opened_capacity = 0;
buf->r_flags &= ~RINGBUFFER_WRITE_LOCKED;
return B_SUCCESS;
return FX_SUCCESS;
}
static enum b_status ringbuffer_read(
struct b_ringbuffer_p *buf, void *p, size_t count, size_t *nr_read)
static enum fx_status ringbuffer_read(
struct fx_ringbuffer_p *buf, void *p, size_t count, size_t *nr_read)
{
if (BUF_LOCKED(buf)) {
return B_ERR_BUSY;
return FX_ERR_BUSY;
}
size_t r = 0;
@@ -190,14 +190,14 @@ static enum b_status ringbuffer_read(
while (remaining > 0) {
const void *src;
size_t available;
enum b_status status
enum fx_status status
= ringbuffer_open_read_buffer(buf, &src, &available);
if (status == B_ERR_NO_DATA) {
if (status == FX_ERR_NO_DATA) {
break;
}
if (!B_OK(status)) {
if (!FX_OK(status)) {
return status;
}
@@ -216,14 +216,14 @@ static enum b_status ringbuffer_read(
}
*nr_read = r;
return B_SUCCESS;
return FX_SUCCESS;
}
static enum b_status ringbuffer_write(
struct b_ringbuffer_p *buf, const void *p, size_t count, size_t *nr_written)
static enum fx_status ringbuffer_write(
struct fx_ringbuffer_p *buf, const void *p, size_t count, size_t *nr_written)
{
if (BUF_LOCKED(buf)) {
return B_ERR_BUSY;
return FX_ERR_BUSY;
}
size_t w = 0;
@@ -233,14 +233,14 @@ static enum b_status ringbuffer_write(
while (remaining > 0) {
void *dest;
size_t available;
enum b_status status
enum fx_status status
= ringbuffer_open_write_buffer(buf, &dest, &available);
if (status == B_ERR_NO_SPACE) {
if (status == FX_ERR_NO_SPACE) {
break;
}
if (!B_OK(status)) {
if (!FX_OK(status)) {
return status;
}
@@ -259,10 +259,10 @@ static enum b_status ringbuffer_write(
}
*nr_written = w;
return B_SUCCESS;
return FX_SUCCESS;
}
static int ringbuffer_getc(struct b_ringbuffer_p *buf)
static int ringbuffer_getc(struct fx_ringbuffer_p *buf)
{
size_t available = ringbuffer_available_data_remaining(buf);
if (available == 0) {
@@ -279,11 +279,11 @@ static int ringbuffer_getc(struct b_ringbuffer_p *buf)
return c;
}
static enum b_status ringbuffer_putc(struct b_ringbuffer_p *buf, int c)
static enum fx_status ringbuffer_putc(struct fx_ringbuffer_p *buf, int c)
{
size_t available = ringbuffer_write_capacity_remaining(buf);
if (available == 0) {
return B_ERR_NO_SPACE;
return FX_ERR_NO_SPACE;
}
char *p = buf->r_buf;
@@ -298,19 +298,19 @@ static enum b_status ringbuffer_putc(struct b_ringbuffer_p *buf, int c)
/*** PUBLIC FUNCTIONS *********************************************************/
b_ringbuffer *b_ringbuffer_create(size_t capacity)
fx_ringbuffer *fx_ringbuffer_create(size_t capacity)
{
b_ringbuffer *ringbuf = b_object_create(B_TYPE_RINGBUFFER);
fx_ringbuffer *ringbuf = fx_object_create(FX_TYPE_RINGBUFFER);
if (!ringbuf) {
return NULL;
}
struct b_ringbuffer_p *p
= b_object_get_private(ringbuf, B_TYPE_RINGBUFFER);
struct fx_ringbuffer_p *p
= fx_object_get_private(ringbuf, FX_TYPE_RINGBUFFER);
void *buffer = malloc(capacity);
if (!buffer) {
b_ringbuffer_unref(ringbuf);
fx_ringbuffer_unref(ringbuf);
return NULL;
}
@@ -321,15 +321,15 @@ b_ringbuffer *b_ringbuffer_create(size_t capacity)
return ringbuf;
}
b_ringbuffer *b_ringbuffer_create_with_buffer(void *ptr, size_t capacity)
fx_ringbuffer *fx_ringbuffer_create_with_buffer(void *ptr, size_t capacity)
{
b_ringbuffer *ringbuf = b_object_create(B_TYPE_RINGBUFFER);
fx_ringbuffer *ringbuf = fx_object_create(FX_TYPE_RINGBUFFER);
if (!ringbuf) {
return NULL;
}
struct b_ringbuffer_p *p
= b_object_get_private(ringbuf, B_TYPE_RINGBUFFER);
struct fx_ringbuffer_p *p
= fx_object_get_private(ringbuf, FX_TYPE_RINGBUFFER);
p->r_flags = 0;
p->r_buf = ptr;
@@ -338,87 +338,87 @@ b_ringbuffer *b_ringbuffer_create_with_buffer(void *ptr, size_t capacity)
return ringbuf;
}
enum b_status b_ringbuffer_clear(b_ringbuffer *buf)
enum fx_status fx_ringbuffer_clear(fx_ringbuffer *buf)
{
B_CLASS_DISPATCH_STATIC_0(B_TYPE_RINGBUFFER, ringbuffer_clear, buf);
FX_CLASS_DISPATCH_STATIC_0(FX_TYPE_RINGBUFFER, ringbuffer_clear, buf);
}
enum b_status b_ringbuffer_read(
b_ringbuffer *buf, void *p, size_t count, size_t *nr_read)
enum fx_status fx_ringbuffer_read(
fx_ringbuffer *buf, void *p, size_t count, size_t *nr_read)
{
B_CLASS_DISPATCH_STATIC(
B_TYPE_RINGBUFFER, ringbuffer_read, buf, p, count, nr_read);
FX_CLASS_DISPATCH_STATIC(
FX_TYPE_RINGBUFFER, ringbuffer_read, buf, p, count, nr_read);
}
enum b_status b_ringbuffer_write(
b_ringbuffer *buf, const void *p, size_t count, size_t *nr_written)
enum fx_status fx_ringbuffer_write(
fx_ringbuffer *buf, const void *p, size_t count, size_t *nr_written)
{
B_CLASS_DISPATCH_STATIC(
B_TYPE_RINGBUFFER, ringbuffer_write, buf, p, count, nr_written);
FX_CLASS_DISPATCH_STATIC(
FX_TYPE_RINGBUFFER, ringbuffer_write, buf, p, count, nr_written);
}
int b_ringbuffer_getc(b_ringbuffer *buf)
int fx_ringbuffer_getc(fx_ringbuffer *buf)
{
B_CLASS_DISPATCH_STATIC_0(B_TYPE_RINGBUFFER, ringbuffer_getc, buf);
FX_CLASS_DISPATCH_STATIC_0(FX_TYPE_RINGBUFFER, ringbuffer_getc, buf);
}
enum b_status b_ringbuffer_putc(b_ringbuffer *buf, int c)
enum fx_status fx_ringbuffer_putc(fx_ringbuffer *buf, int c)
{
B_CLASS_DISPATCH_STATIC(B_TYPE_RINGBUFFER, ringbuffer_putc, buf, c);
FX_CLASS_DISPATCH_STATIC(FX_TYPE_RINGBUFFER, ringbuffer_putc, buf, c);
}
size_t b_ringbuffer_write_capacity_remaining(const b_ringbuffer *buf)
size_t fx_ringbuffer_write_capacity_remaining(const fx_ringbuffer *buf)
{
B_CLASS_DISPATCH_STATIC_0(
B_TYPE_RINGBUFFER, ringbuffer_write_capacity_remaining, buf);
FX_CLASS_DISPATCH_STATIC_0(
FX_TYPE_RINGBUFFER, ringbuffer_write_capacity_remaining, buf);
}
size_t b_ringbuffer_available_data_remaining(const b_ringbuffer *buf)
size_t fx_ringbuffer_available_data_remaining(const fx_ringbuffer *buf)
{
B_CLASS_DISPATCH_STATIC_0(
B_TYPE_RINGBUFFER, ringbuffer_available_data_remaining, buf);
FX_CLASS_DISPATCH_STATIC_0(
FX_TYPE_RINGBUFFER, ringbuffer_available_data_remaining, buf);
}
enum b_status b_ringbuffer_open_read_buffer(
b_ringbuffer *buf, const void **ptr, size_t *length)
enum fx_status fx_ringbuffer_open_read_buffer(
fx_ringbuffer *buf, const void **ptr, size_t *length)
{
B_CLASS_DISPATCH_STATIC(
B_TYPE_RINGBUFFER, ringbuffer_open_read_buffer, buf, ptr, length);
FX_CLASS_DISPATCH_STATIC(
FX_TYPE_RINGBUFFER, ringbuffer_open_read_buffer, buf, ptr, length);
}
enum b_status b_ringbuffer_close_read_buffer(
b_ringbuffer *buf, const void **ptr, size_t nr_read)
enum fx_status fx_ringbuffer_close_read_buffer(
fx_ringbuffer *buf, const void **ptr, size_t nr_read)
{
B_CLASS_DISPATCH_STATIC(
B_TYPE_RINGBUFFER, ringbuffer_close_read_buffer, buf, ptr, nr_read);
FX_CLASS_DISPATCH_STATIC(
FX_TYPE_RINGBUFFER, ringbuffer_close_read_buffer, buf, ptr, nr_read);
}
enum b_status b_ringbuffer_open_write_buffer(
b_ringbuffer *buf, void **ptr, size_t *capacity)
enum fx_status fx_ringbuffer_open_write_buffer(
fx_ringbuffer *buf, void **ptr, size_t *capacity)
{
B_CLASS_DISPATCH_STATIC(
B_TYPE_RINGBUFFER, ringbuffer_open_write_buffer, buf, ptr,
FX_CLASS_DISPATCH_STATIC(
FX_TYPE_RINGBUFFER, ringbuffer_open_write_buffer, buf, ptr,
capacity);
}
enum b_status b_ringbuffer_close_write_buffer(
b_ringbuffer *buf, void **ptr, size_t nr_written)
enum fx_status fx_ringbuffer_close_write_buffer(
fx_ringbuffer *buf, void **ptr, size_t nr_written)
{
B_CLASS_DISPATCH_STATIC(
B_TYPE_RINGBUFFER, ringbuffer_close_write_buffer, buf, ptr,
FX_CLASS_DISPATCH_STATIC(
FX_TYPE_RINGBUFFER, ringbuffer_close_write_buffer, buf, ptr,
nr_written);
}
/*** VIRTUAL FUNCTIONS ********************************************************/
static void ringbuffer_init(b_object *obj, void *priv)
static void ringbuffer_init(fx_object *obj, void *priv)
{
struct b_ringbuffer_p *buf = priv;
struct fx_ringbuffer_p *buf = priv;
}
static void ringbuffer_fini(b_object *obj, void *priv)
static void ringbuffer_fini(fx_object *obj, void *priv)
{
struct b_ringbuffer_p *buf = priv;
struct fx_ringbuffer_p *buf = priv;
if (buf->r_flags & RINGBUFFER_BUFFER_MALLOC) {
free(buf->r_buf);
@@ -427,16 +427,16 @@ static void ringbuffer_fini(b_object *obj, void *priv)
/*** CLASS DEFINITION *********************************************************/
B_TYPE_CLASS_DEFINITION_BEGIN(b_ringbuffer)
B_TYPE_CLASS_INTERFACE_BEGIN(b_object, B_TYPE_OBJECT)
B_INTERFACE_ENTRY(to_string) = NULL;
B_TYPE_CLASS_INTERFACE_END(b_object, B_TYPE_OBJECT)
B_TYPE_CLASS_DEFINITION_END(b_ringbuffer)
FX_TYPE_CLASS_DEFINITION_BEGIN(fx_ringbuffer)
FX_TYPE_CLASS_INTERFACE_BEGIN(fx_object, FX_TYPE_OBJECT)
FX_INTERFACE_ENTRY(to_string) = NULL;
FX_TYPE_CLASS_INTERFACE_END(fx_object, FX_TYPE_OBJECT)
FX_TYPE_CLASS_DEFINITION_END(fx_ringbuffer)
B_TYPE_DEFINITION_BEGIN(b_ringbuffer)
B_TYPE_ID(0xb0493774, 0xef13, 0x4905, 0xa865, 0x1595607ccad9);
B_TYPE_CLASS(b_ringbuffer_class);
B_TYPE_INSTANCE_PRIVATE(struct b_ringbuffer_p);
B_TYPE_INSTANCE_INIT(ringbuffer_init);
B_TYPE_INSTANCE_FINI(ringbuffer_fini);
B_TYPE_DEFINITION_END(b_ringbuffer)
FX_TYPE_DEFINITION_BEGIN(fx_ringbuffer)
FX_TYPE_ID(0xb0493774, 0xef13, 0x4905, 0xa865, 0x1595607ccad9);
FX_TYPE_CLASS(fx_ringbuffer_class);
FX_TYPE_INSTANCE_PRIVATE(struct fx_ringbuffer_p);
FX_TYPE_INSTANCE_INIT(ringbuffer_init);
FX_TYPE_INSTANCE_FINI(ringbuffer_fini);
FX_TYPE_DEFINITION_END(fx_ringbuffer)