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

2
core/CMakeLists.txt
View File

@@ -1,5 +1,5 @@
include(../cmake/Templates.cmake)
add_bluelib_module(
add_fx_module(
NAME core
SUBDIRS hash)

138
core/bstr.c
View File

@@ -1,37 +1,37 @@
#include "printf.h"
#include <blue/core/bstr.h>
#include <blue/core/rope.h>
#include <fx/core/bstr.h>
#include <fx/core/rope.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define CHECK_FLAG(str, f) ((((str)->bstr_flags) & (f)) == (f))
#define IS_DYNAMIC(p) (CHECK_FLAG(p, B_BSTR_F_ALLOC))
#define IS_DYNAMIC(p) (CHECK_FLAG(p, FX_BSTR_F_ALLOC))
/* number of bytes that bstr_buf is extended by when required */
#define CAPACITY_STEP 32
void b_bstr_begin(struct b_bstr *str, char *buf, size_t max)
void fx_bstr_begin(struct fx_bstr *str, char *buf, size_t max)
{
memset(str, 0x0, sizeof *str);
str->bstr_magic = B_BSTR_MAGIC;
str->bstr_magic = FX_BSTR_MAGIC;
str->bstr_buf = buf;
str->bstr_capacity = max;
str->bstr_len = 0;
str->bstr_flags = B_BSTR_F_NONE;
str->bstr_flags = FX_BSTR_F_NONE;
}
void b_bstr_begin_dynamic(struct b_bstr *str)
void fx_bstr_begin_dynamic(struct fx_bstr *str)
{
memset(str, 0x0, sizeof *str);
str->bstr_magic = B_BSTR_MAGIC;
str->bstr_magic = FX_BSTR_MAGIC;
str->bstr_buf = NULL;
str->bstr_capacity = 0;
str->bstr_len = 0;
str->bstr_flags = B_BSTR_F_ALLOC;
str->bstr_flags = FX_BSTR_F_ALLOC;
}
static char *truncate_buffer(char *s, size_t len)
@@ -50,7 +50,7 @@ static char *truncate_buffer(char *s, size_t len)
return final;
}
char *b_bstr_end(struct b_bstr *str)
char *fx_bstr_end(struct fx_bstr *str)
{
char *out = str->bstr_buf;
size_t len = str->bstr_len;
@@ -70,29 +70,29 @@ char *b_bstr_end(struct b_bstr *str)
return out;
}
enum b_status b_bstr_reserve(struct b_bstr *strv, size_t len)
enum fx_status fx_bstr_reserve(struct fx_bstr *strv, size_t len)
{
if (!IS_DYNAMIC(strv)) {
return B_SUCCESS;
return FX_SUCCESS;
}
if (strv->bstr_capacity > 0 && strv->bstr_capacity - 1 >= len) {
return B_SUCCESS;
return FX_SUCCESS;
}
char *new_buf = realloc(strv->bstr_buf, len + 1);
if (!new_buf) {
return B_ERR_NO_MEMORY;
return FX_ERR_NO_MEMORY;
}
strv->bstr_buf = new_buf;
strv->bstr_capacity = len + 1;
strv->bstr_buf[strv->bstr_len] = '\0';
return B_SUCCESS;
return FX_SUCCESS;
}
static int current_indent(struct b_bstr *str)
static int current_indent(struct fx_bstr *str)
{
if (!str->bstr_istack || !str->bstr_istack_size) {
return 0;
@@ -101,7 +101,7 @@ static int current_indent(struct b_bstr *str)
return str->bstr_istack[str->bstr_istack_ptr];
}
static void __formatter_putchar(struct b_bstr *str, char c)
static void __formatter_putchar(struct fx_bstr *str, char c)
{
if (str->bstr_capacity > 0 && str->bstr_len < str->bstr_capacity - 1) {
str->bstr_buf[str->bstr_len++] = c;
@@ -109,7 +109,7 @@ static void __formatter_putchar(struct b_bstr *str, char c)
return;
}
if (!CHECK_FLAG(str, B_BSTR_F_ALLOC)) {
if (!CHECK_FLAG(str, FX_BSTR_F_ALLOC)) {
return;
}
@@ -127,7 +127,7 @@ static void __formatter_putchar(struct b_bstr *str, char c)
str->bstr_buf[str->bstr_len] = '\0';
}
static void formatter_putchar(struct b_bstr *f, char c)
static void formatter_putchar(struct fx_bstr *f, char c)
{
if (f->bstr_add_indent && c != '\n') {
int indent = current_indent(f);
@@ -148,12 +148,12 @@ static void formatter_putchar(struct b_bstr *f, char c)
static void bstr_fctprintf(char c, void *arg)
{
struct b_bstr *str = arg;
struct fx_bstr *str = arg;
formatter_putchar(str, c);
}
static enum b_status bstr_putcs(
struct b_bstr *str, const char *s, size_t len, size_t *nr_written)
static enum fx_status bstr_putcs(
struct fx_bstr *str, const char *s, size_t len, size_t *nr_written)
{
for (size_t i = 0; i < len; i++) {
formatter_putchar(str, s[i]);
@@ -163,10 +163,10 @@ static enum b_status bstr_putcs(
*nr_written = len;
}
return B_SUCCESS;
return FX_SUCCESS;
}
static enum b_status bstr_puts(struct b_bstr *str, const char *s, size_t *nr_written)
static enum fx_status bstr_puts(struct fx_bstr *str, const char *s, size_t *nr_written)
{
size_t i;
for (i = 0; s[i]; i++) {
@@ -177,10 +177,10 @@ static enum b_status bstr_puts(struct b_bstr *str, const char *s, size_t *nr_wri
*nr_written = i;
}
return B_SUCCESS;
return FX_SUCCESS;
}
enum b_status b_bstr_push_indent(struct b_bstr *str, int indent)
enum fx_status fx_bstr_push_indent(struct fx_bstr *str, int indent)
{
if (!str->bstr_istack) {
str->bstr_istack = calloc(4, sizeof(int));
@@ -193,7 +193,7 @@ enum b_status b_bstr_push_indent(struct b_bstr *str, int indent)
str->bstr_istack,
(str->bstr_istack_size + 4) * sizeof(int));
if (!buf) {
return B_ERR_NO_MEMORY;
return FX_ERR_NO_MEMORY;
}
str->bstr_istack = buf;
@@ -203,47 +203,47 @@ enum b_status b_bstr_push_indent(struct b_bstr *str, int indent)
int cur_indent = str->bstr_istack[str->bstr_istack_ptr];
str->bstr_istack[++str->bstr_istack_ptr] = cur_indent + indent;
return B_SUCCESS;
return FX_SUCCESS;
}
enum b_status b_bstr_pop_indent(struct b_bstr *strv)
enum fx_status fx_bstr_pop_indent(struct fx_bstr *strv)
{
if (strv->bstr_istack_ptr > 0) {
strv->bstr_istack_ptr--;
}
return B_SUCCESS;
return FX_SUCCESS;
}
enum b_status b_bstr_write_char(struct b_bstr *str, char c)
enum fx_status fx_bstr_write_char(struct fx_bstr *str, char c)
{
formatter_putchar(str, c);
return B_SUCCESS;
return FX_SUCCESS;
}
enum b_status b_bstr_write_chars(
struct b_bstr *str, const char *s, size_t len, size_t *nr_written)
enum fx_status fx_bstr_write_chars(
struct fx_bstr *str, const char *s, size_t len, size_t *nr_written)
{
return bstr_putcs(str, s, len, nr_written);
}
enum b_status b_bstr_write_cstr(struct b_bstr *str, const char *s, size_t *nr_written)
enum fx_status fx_bstr_write_cstr(struct fx_bstr *str, const char *s, size_t *nr_written)
{
return bstr_puts(str, s, nr_written);
}
enum b_status b_bstr_write_cstr_list(
struct b_bstr *str, const char **strs, size_t *nr_written)
enum fx_status fx_bstr_write_cstr_list(
struct fx_bstr *str, const char **strs, size_t *nr_written)
{
size_t w = 0;
enum b_status status = B_SUCCESS;
enum fx_status status = FX_SUCCESS;
for (size_t i = 0; strs[i]; i++) {
size_t tmp = 0;
status = bstr_puts(str, strs[i], &tmp);
w += tmp;
if (B_ERR(status)) {
if (FX_ERR(status)) {
break;
}
}
@@ -255,10 +255,10 @@ enum b_status b_bstr_write_cstr_list(
return status;
}
enum b_status b_bstr_write_cstr_array(
struct b_bstr *str, const char **strs, size_t count, size_t *nr_written)
enum fx_status fx_bstr_write_cstr_array(
struct fx_bstr *str, const char **strs, size_t count, size_t *nr_written)
{
enum b_status status = B_SUCCESS;
enum fx_status status = FX_SUCCESS;
size_t w = 0;
for (size_t i = 0; i < count; i++) {
@@ -270,7 +270,7 @@ enum b_status b_bstr_write_cstr_array(
status = bstr_puts(str, strs[i], &tmp);
w += tmp;
if (B_ERR(status)) {
if (FX_ERR(status)) {
break;
}
}
@@ -282,20 +282,20 @@ enum b_status b_bstr_write_cstr_array(
return status;
}
enum b_status b_bstr_add_many(struct b_bstr *str, size_t *nr_written, ...)
enum fx_status fx_bstr_add_many(struct fx_bstr *str, size_t *nr_written, ...)
{
va_list arg;
va_start(arg, nr_written);
const char *s = NULL;
size_t w = 0;
enum b_status status = B_SUCCESS;
enum fx_status status = FX_SUCCESS;
while ((s = va_arg(arg, const char *))) {
size_t tmp = 0;
status = bstr_puts(str, s, &tmp);
w += tmp;
if (B_ERR(status)) {
if (FX_ERR(status)) {
break;
}
}
@@ -307,11 +307,11 @@ enum b_status b_bstr_add_many(struct b_bstr *str, size_t *nr_written, ...)
return status;
}
enum b_status b_bstr_write_rope(
b_bstr *strv, const struct b_rope *rope, size_t *nr_written)
enum fx_status fx_bstr_write_rope(
fx_bstr *strv, const struct fx_rope *rope, size_t *nr_written)
{
size_t start = strv->bstr_len;
enum b_status status = b_rope_to_bstr(rope, strv);
enum fx_status status = fx_rope_to_bstr(rope, strv);
size_t end = strv->bstr_len;
if (nr_written) {
@@ -321,55 +321,55 @@ enum b_status b_bstr_write_rope(
return status;
}
enum b_status b_bstr_write_fmt(
struct b_bstr *str, size_t *nr_written, const char *format, ...)
enum fx_status fx_bstr_write_fmt(
struct fx_bstr *str, size_t *nr_written, const char *format, ...)
{
va_list arg;
va_start(arg, format);
enum b_status result = b_bstr_write_vfmt(str, nr_written, format, arg);
enum fx_status result = fx_bstr_write_vfmt(str, nr_written, format, arg);
va_end(arg);
return result;
}
enum b_status b_bstr_write_vfmt(
struct b_bstr *str, size_t *nr_written, const char *format, va_list arg)
enum fx_status fx_bstr_write_vfmt(
struct fx_bstr *str, size_t *nr_written, const char *format, va_list arg)
{
size_t start = str->bstr_len;
z__b_fctprintf(bstr_fctprintf, str, format, arg);
z__fx_fctprintf(bstr_fctprintf, str, format, arg);
size_t end = str->bstr_len;
if (nr_written) {
*nr_written = end - start;
}
/* TODO update z__b_fctprintf to support propagating error codes */
return B_SUCCESS;
/* TODO update z__fx_fctprintf to support propagating error codes */
return FX_SUCCESS;
}
char *b_bstr_rope(const struct b_rope *rope, size_t *nr_written)
char *fx_bstr_rope(const struct fx_rope *rope, size_t *nr_written)
{
struct b_bstr str;
b_bstr_begin_dynamic(&str);
b_bstr_write_rope(&str, rope, nr_written);
struct fx_bstr str;
fx_bstr_begin_dynamic(&str);
fx_bstr_write_rope(&str, rope, nr_written);
return b_bstr_end(&str);
return fx_bstr_end(&str);
}
char *b_bstr_fmt(size_t *nr_written, const char *format, ...)
char *fx_bstr_fmt(size_t *nr_written, const char *format, ...)
{
va_list arg;
va_start(arg, format);
char *s = b_bstr_vfmt(nr_written, format, arg);
char *s = fx_bstr_vfmt(nr_written, format, arg);
va_end(arg);
return s;
}
char *b_bstr_vfmt(size_t *nr_written, const char *format, va_list arg)
char *fx_bstr_vfmt(size_t *nr_written, const char *format, va_list arg)
{
struct b_bstr str;
b_bstr_begin_dynamic(&str);
b_bstr_write_vfmt(&str, nr_written, format, arg);
struct fx_bstr str;
fx_bstr_begin_dynamic(&str);
fx_bstr_write_vfmt(&str, nr_written, format, arg);
return b_bstr_end(&str);
return fx_bstr_end(&str);
}

440
core/btree.c
View File

@@ -50,45 +50,45 @@
this file intentionally excludes any kind of search function implementation.
it is up to the programmer to implement their own tree node type
using b_btree_node, and their own search function using b_btree.
using fx_bst_node, and their own search function using fx_bst.
this allows the programmer to define their own node types with complex
non-integer key types. btree.h contains a number of macros to help
define these functions. the macros do all the work, you just have to
provide a comparator function.
*/
#include <blue/core/btree.h>
#include <fx/core/btree.h>
#include <stddef.h>
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define IS_LEFT_CHILD(p, c) ((p) && (c) && ((p)->b_left == (c)))
#define IS_RIGHT_CHILD(p, c) ((p) && (c) && ((p)->b_right == (c)))
#define IS_LEFT_CHILD(p, c) ((p) && (c) && ((p)->n_left == (c)))
#define IS_RIGHT_CHILD(p, c) ((p) && (c) && ((p)->n_right == (c)))
#define HAS_LEFT_CHILD(x) ((x) && ((x)->b_left))
#define HAS_RIGHT_CHILD(x) ((x) && ((x)->b_right))
#define HAS_LEFT_CHILD(x) ((x) && ((x)->n_left))
#define HAS_RIGHT_CHILD(x) ((x) && ((x)->n_right))
#define HAS_NO_CHILDREN(x) ((x) && (!(x)->b_left) && (!(x)->b_right))
#define HAS_NO_CHILDREN(x) ((x) && (!(x)->n_left) && (!(x)->n_right))
#define HAS_ONE_CHILD(x) \
((HAS_LEFT_CHILD(x) && !HAS_RIGHT_CHILD(x)) \
|| (!HAS_LEFT_CHILD(x) && HAS_RIGHT_CHILD(x)))
#define HAS_TWO_CHILDREN(x) (HAS_LEFT_CHILD(x) && HAS_RIGHT_CHILD(x))
#define HEIGHT(x) ((x) ? (x)->b_height : 0)
#define HEIGHT(x) ((x) ? (x)->n_height : 0)
struct b_btree_iterator_p {
struct fx_bst_iterator_p {
size_t i, depth;
b_btree_node *node;
b_btree *_b;
fx_bst_node *node;
fx_bst *_b;
};
static inline void update_height(struct b_btree_node *x)
static inline void update_height(struct fx_bst_node *x)
{
x->b_height = MAX(HEIGHT(x->b_left), HEIGHT((x->b_right))) + 1;
x->n_height = MAX(HEIGHT(x->n_left), HEIGHT((x->n_right))) + 1;
}
static inline int bf(struct b_btree_node *x)
static inline int bf(struct fx_bst_node *x)
{
int bf = 0;
@@ -96,12 +96,12 @@ static inline int bf(struct b_btree_node *x)
return bf;
}
if (x->b_right) {
bf += x->b_right->b_height;
if (x->n_right) {
bf += x->n_right->n_height;
}
if (x->b_left) {
bf -= x->b_left->b_height;
if (x->n_left) {
bf -= x->n_left->n_height;
}
return bf;
@@ -130,38 +130,38 @@ static inline int bf(struct b_btree_node *x)
/ \
. .
note that this function does NOT update b_height for the rotated
note that this function does NOT update fx_height for the rotated
nodes. it is up to you to call update_height_to_root().
*/
static void rotate_left(struct b_btree *tree, struct b_btree_node *x)
static void rotate_left(struct fx_bst *tree, struct fx_bst_node *x)
{
struct b_btree_node *y = x->b_right;
struct b_btree_node *p = x->b_parent;
struct fx_bst_node *y = x->n_right;
struct fx_bst_node *p = x->n_parent;
if (y->b_left) {
y->b_left->b_parent = x;
if (y->n_left) {
y->n_left->n_parent = x;
}
x->b_right = y->b_left;
x->n_right = y->n_left;
if (!p) {
tree->b_root = y;
} else if (x == p->b_left) {
p->b_left = y;
tree->bst_root = y;
} else if (x == p->n_left) {
p->n_left = y;
} else {
p->b_right = y;
p->n_right = y;
}
x->b_parent = y;
y->b_left = x;
y->b_parent = p;
x->n_parent = y;
y->n_left = x;
y->n_parent = p;
}
static void update_height_to_root(struct b_btree_node *x)
static void update_height_to_root(struct fx_bst_node *x)
{
while (x) {
update_height(x);
x = x->b_parent;
x = x->n_parent;
}
}
@@ -188,31 +188,31 @@ static void update_height_to_root(struct b_btree_node *x)
/ \
. .
note that this function does NOT update b_height for the rotated
note that this function does NOT update fx_height for the rotated
nodes. it is up to you to call update_height_to_root().
*/
static void rotate_right(struct b_btree *tree, struct b_btree_node *y)
static void rotate_right(struct fx_bst *tree, struct fx_bst_node *y)
{
struct b_btree_node *x = y->b_left;
struct b_btree_node *p = y->b_parent;
struct fx_bst_node *x = y->n_left;
struct fx_bst_node *p = y->n_parent;
if (x->b_right) {
x->b_right->b_parent = y;
if (x->n_right) {
x->n_right->n_parent = y;
}
y->b_left = x->b_right;
y->n_left = x->n_right;
if (!p) {
tree->b_root = x;
} else if (y == p->b_left) {
p->b_left = x;
tree->bst_root = x;
} else if (y == p->n_left) {
p->n_left = x;
} else {
p->b_right = x;
p->n_right = x;
}
y->b_parent = x;
x->b_right = y;
x->b_parent = p;
y->n_parent = x;
x->n_right = y;
x->n_parent = p;
}
/* for a given node Z, perform a right rotation on Z's right child,
@@ -239,13 +239,13 @@ static void rotate_right(struct b_btree *tree, struct b_btree_node *y)
. . . .
note that, unlike rotate_left and rotate_right, this function
DOES update b_height for the rotated nodes (since it needs to be
DOES update fx_height for the rotated nodes (since it needs to be
done in a certain order).
*/
static void rotate_double_left(struct b_btree *tree, struct b_btree_node *z)
static void rotate_double_left(struct fx_bst *tree, struct fx_bst_node *z)
{
struct b_btree_node *x = z->b_right;
struct b_btree_node *y = x->b_left;
struct fx_bst_node *x = z->n_right;
struct fx_bst_node *y = x->n_left;
rotate_right(tree, x);
rotate_left(tree, z);
@@ -255,7 +255,7 @@ static void rotate_double_left(struct b_btree *tree, struct b_btree_node *z)
while (y) {
update_height(y);
y = y->b_parent;
y = y->n_parent;
}
}
@@ -283,13 +283,13 @@ static void rotate_double_left(struct b_btree *tree, struct b_btree_node *z)
. . . .
note that, unlike rotate_left and rotate_right, this function
DOES update b_height for the rotated nodes (since it needs to be
DOES update fx_height for the rotated nodes (since it needs to be
done in a certain order).
*/
static void rotate_double_right(struct b_btree *tree, struct b_btree_node *z)
static void rotate_double_right(struct fx_bst *tree, struct fx_bst_node *z)
{
struct b_btree_node *x = z->b_left;
struct b_btree_node *y = x->b_right;
struct fx_bst_node *x = z->n_left;
struct fx_bst_node *y = x->n_right;
rotate_left(tree, x);
rotate_right(tree, z);
@@ -299,7 +299,7 @@ static void rotate_double_right(struct b_btree *tree, struct b_btree_node *z)
while (y) {
update_height(y);
y = y->b_parent;
y = y->n_parent;
}
}
@@ -311,13 +311,13 @@ static void rotate_double_right(struct b_btree *tree, struct b_btree_node *z)
is inserted into the tree.
this function depends on all nodes in the tree having
correct b_height values.
correct fx_height values.
@param w the node that was just inserted into the tree
*/
static void insert_fixup(struct b_btree *tree, struct b_btree_node *w)
static void insert_fixup(struct fx_bst *tree, struct fx_bst_node *w)
{
struct b_btree_node *z = NULL, *y = NULL, *x = NULL;
struct fx_bst_node *z = NULL, *y = NULL, *x = NULL;
z = w;
while (z) {
@@ -344,7 +344,7 @@ static void insert_fixup(struct b_btree *tree, struct b_btree_node *w)
next_ancestor:
x = y;
y = z;
z = z->b_parent;
z = z->n_parent;
}
}
@@ -356,7 +356,7 @@ static void insert_fixup(struct b_btree *tree, struct b_btree_node *w)
to restore balance after a node is deleted.
this function depends on all nodes in the tree having
correct b_height values.
correct fx_height values.
@param w one of the following:
- the parent of the node that was deleted if the node
@@ -366,20 +366,20 @@ static void insert_fixup(struct b_btree *tree, struct b_btree_node *w)
- the node that replaced the node that was deleted, if
the node that was deleted had one child.
*/
static void delete_fixup(struct b_btree *tree, struct b_btree_node *w)
static void delete_fixup(struct fx_bst *tree, struct fx_bst_node *w)
{
struct b_btree_node *z = w;
struct fx_bst_node *z = w;
while (z) {
if (bf(z) > 1) {
if (bf(z->b_right) >= 0) {
if (bf(z->n_right) >= 0) {
rotate_left(tree, z);
update_height_to_root(z);
} else {
rotate_double_left(tree, z);
}
} else if (bf(z) < -1) {
if (bf(z->b_left) <= 0) {
if (bf(z->n_left) <= 0) {
rotate_right(tree, z);
update_height_to_root(z);
} else {
@@ -387,23 +387,23 @@ static void delete_fixup(struct b_btree *tree, struct b_btree_node *w)
}
}
z = z->b_parent;
z = z->n_parent;
}
}
/* updates b_height for all nodes between the inserted node and the root
/* updates fx_height for all nodes between the inserted node and the root
of the tree, and calls insert_fixup.
@param node the node that was just inserted into the tree.
*/
void b_btree_insert_fixup(struct b_btree *tree, struct b_btree_node *node)
void fx_bst_insert_fixup(struct fx_bst *tree, struct fx_bst_node *node)
{
node->b_height = 0;
node->n_height = 0;
struct b_btree_node *cur = node;
struct fx_bst_node *cur = node;
while (cur) {
update_height(cur);
cur = cur->b_parent;
cur = cur->n_parent;
}
insert_fixup(tree, node);
@@ -414,28 +414,28 @@ void b_btree_insert_fixup(struct b_btree *tree, struct b_btree_node *node)
this function assumes that `node` has no children, and therefore
doesn't need to be replaced.
updates b_height for all nodes between `node` and the tree root.
updates fx_height for all nodes between `node` and the tree root.
@param node the node to delete.
*/
static struct b_btree_node *remove_node_with_no_children(
struct b_btree *tree, struct b_btree_node *node)
static struct fx_bst_node *remove_node_with_no_children(
struct fx_bst *tree, struct fx_bst_node *node)
{
struct b_btree_node *w = node->b_parent;
struct b_btree_node *p = node->b_parent;
node->b_parent = NULL;
struct fx_bst_node *w = node->n_parent;
struct fx_bst_node *p = node->n_parent;
node->n_parent = NULL;
if (!p) {
tree->b_root = NULL;
tree->bst_root = NULL;
} else if (IS_LEFT_CHILD(p, node)) {
p->b_left = NULL;
p->n_left = NULL;
} else {
p->b_right = NULL;
p->n_right = NULL;
}
while (p) {
update_height(p);
p = p->b_parent;
p = p->n_parent;
}
return w;
@@ -446,40 +446,40 @@ static struct b_btree_node *remove_node_with_no_children(
this function assumes that `node` has one child.
the child of `node` is inherited by `node`'s parent, and `node` is removed.
updates b_height for all nodes between the node that replaced
updates fx_height for all nodes between the node that replaced
`node` and the tree root.
@param node the node to delete.
*/
static struct b_btree_node *replace_node_with_one_subtree(
struct b_btree *tree, struct b_btree_node *node)
static struct fx_bst_node *replace_node_with_one_subtree(
struct fx_bst *tree, struct fx_bst_node *node)
{
struct b_btree_node *p = node->b_parent;
struct b_btree_node *z = NULL;
struct fx_bst_node *p = node->n_parent;
struct fx_bst_node *z = NULL;
if (HAS_LEFT_CHILD(node)) {
z = node->b_left;
z = node->n_left;
} else {
z = node->b_right;
z = node->n_right;
}
struct b_btree_node *w = z;
struct fx_bst_node *w = z;
if (!p) {
tree->b_root = z;
tree->bst_root = z;
} else if (IS_LEFT_CHILD(p, node)) {
p->b_left = z;
p->n_left = z;
} else if (IS_RIGHT_CHILD(p, node)) {
p->b_right = z;
p->n_right = z;
}
z->b_parent = p;
z->n_parent = p;
node->b_parent = NULL;
node->b_left = node->b_right = NULL;
node->n_parent = NULL;
node->n_left = node->n_right = NULL;
while (z) {
update_height(z);
z = z->b_parent;
z = z->n_parent;
}
return w;
@@ -495,79 +495,79 @@ static struct b_btree_node *replace_node_with_one_subtree(
if Y has a child (it will never have more than one), have Y's parent inherit
Y's child.
updates b_height for all nodes between the deepest node that was modified
updates fx_height for all nodes between the deepest node that was modified
and the tree root.
@param z the node to delete.
*/
static struct b_btree_node *replace_node_with_two_subtrees(
struct b_btree *tree, struct b_btree_node *z)
static struct fx_bst_node *replace_node_with_two_subtrees(
struct fx_bst *tree, struct fx_bst_node *z)
{
/* x will replace z */
struct b_btree_node *x = z->b_left;
struct fx_bst_node *x = z->n_left;
while (x->b_right) {
x = x->b_right;
while (x->n_right) {
x = x->n_right;
}
/* y is the node that will replace x (if x has a left child) */
struct b_btree_node *y = x->b_left;
struct fx_bst_node *y = x->n_left;
/* w is the starting point for the height update and fixup */
struct b_btree_node *w = x;
if (w->b_parent != z) {
w = w->b_parent;
struct fx_bst_node *w = x;
if (w->n_parent != z) {
w = w->n_parent;
}
if (y) {
w = y;
}
if (IS_LEFT_CHILD(x->b_parent, x)) {
x->b_parent->b_left = y;
} else if (IS_RIGHT_CHILD(x->b_parent, x)) {
x->b_parent->b_right = y;
if (IS_LEFT_CHILD(x->n_parent, x)) {
x->n_parent->n_left = y;
} else if (IS_RIGHT_CHILD(x->n_parent, x)) {
x->n_parent->n_right = y;
}
if (y) {
y->b_parent = x->b_parent;
y->n_parent = x->n_parent;
}
if (IS_LEFT_CHILD(z->b_parent, z)) {
z->b_parent->b_left = x;
} else if (IS_RIGHT_CHILD(z->b_parent, z)) {
z->b_parent->b_right = x;
if (IS_LEFT_CHILD(z->n_parent, z)) {
z->n_parent->n_left = x;
} else if (IS_RIGHT_CHILD(z->n_parent, z)) {
z->n_parent->n_right = x;
}
x->b_parent = z->b_parent;
x->b_left = z->b_left;
x->b_right = z->b_right;
x->n_parent = z->n_parent;
x->n_left = z->n_left;
x->n_right = z->n_right;
if (x->b_left) {
x->b_left->b_parent = x;
if (x->n_left) {
x->n_left->n_parent = x;
}
if (x->b_right) {
x->b_right->b_parent = x;
if (x->n_right) {
x->n_right->n_parent = x;
}
if (!x->b_parent) {
tree->b_root = x;
if (!x->n_parent) {
tree->bst_root = x;
}
struct b_btree_node *cur = w;
struct fx_bst_node *cur = w;
while (cur) {
update_height(cur);
cur = cur->b_parent;
cur = cur->n_parent;
}
return w;
}
/* delete a node from the tree and re-balance it afterwards */
void b_btree_delete(struct b_btree *tree, struct b_btree_node *node)
void fx_bst_delete(struct fx_bst *tree, struct fx_bst_node *node)
{
struct b_btree_node *w = NULL;
struct fx_bst_node *w = NULL;
if (HAS_NO_CHILDREN(node)) {
w = remove_node_with_no_children(tree, node);
@@ -581,14 +581,14 @@ void b_btree_delete(struct b_btree *tree, struct b_btree_node *node)
delete_fixup(tree, w);
}
node->b_left = node->b_right = node->b_parent = NULL;
node->n_left = node->n_right = node->n_parent = NULL;
}
static struct b_btree_node *first_node(const struct b_btree *tree, int *depth)
static struct fx_bst_node *first_node(const struct fx_bst *tree, int *depth)
{
/* the first node in the tree is the node with the smallest key.
we keep moving left until we can't go any further */
struct b_btree_node *cur = tree->b_root;
struct fx_bst_node *cur = tree->bst_root;
int d = 0;
if (!cur) {
@@ -596,47 +596,47 @@ static struct b_btree_node *first_node(const struct b_btree *tree, int *depth)
return NULL;
}
while (cur->b_left) {
while (cur->n_left) {
d++;
cur = cur->b_left;
cur = cur->n_left;
}
*depth = d;
return cur;
}
struct b_btree_node *b_btree_first(const struct b_btree *tree)
struct fx_bst_node *fx_bst_first(const struct fx_bst *tree)
{
int d;
return first_node(tree, &d);
}
static struct b_btree_node *last_node(const struct b_btree *tree, int *depth)
static struct fx_bst_node *last_node(const struct fx_bst *tree, int *depth)
{
/* the first node in the tree is the node with the largest key.
we keep moving right until we can't go any further */
struct b_btree_node *cur = tree->b_root;
struct fx_bst_node *cur = tree->bst_root;
int d = 0;
if (!cur) {
return NULL;
}
while (cur->b_right) {
while (cur->n_right) {
d++;
cur = cur->b_right;
cur = cur->n_right;
}
*depth = d;
return cur;
}
b_btree_node *b_btree_last(const struct b_btree *tree)
fx_bst_node *fx_bst_last(const struct fx_bst *tree)
{
int d;
return last_node(tree, &d);
}
static b_btree_node *next_node(const struct b_btree_node *node, int *depth_diff)
static fx_bst_node *next_node(const struct fx_bst_node *node, int *depth_diff)
{
if (!node) {
return NULL;
@@ -653,13 +653,13 @@ static b_btree_node *next_node(const struct b_btree_node *node, int *depth_diff)
the sub-tree rooted at `node`. we need to go back to our parent
and continue the search elsewhere.
*/
if (node->b_right) {
if (node->n_right) {
/* case 1: step into `node`'s right sub-tree and keep going
left to find the smallest node */
struct b_btree_node *cur = node->b_right;
struct fx_bst_node *cur = node->n_right;
depth++;
while (cur->b_left) {
cur = cur->b_left;
while (cur->n_left) {
cur = cur->n_left;
depth++;
}
@@ -671,16 +671,16 @@ static b_btree_node *next_node(const struct b_btree_node *node, int *depth_diff)
if we encounter a step where we are our parent's left child,
we've found a parent with a value larger than us. this parent
is the in-order successor of `node` */
while (node->b_parent && node->b_parent->b_left != node) {
node = node->b_parent;
while (node->n_parent && node->n_parent->n_left != node) {
node = node->n_parent;
depth--;
}
*depth_diff = depth - 1;
return node->b_parent;
return node->n_parent;
}
static b_btree_node *prev_node(const struct b_btree_node *node, int *depth_diff)
static fx_bst_node *prev_node(const struct fx_bst_node *node, int *depth_diff)
{
if (!node) {
return NULL;
@@ -697,13 +697,13 @@ static b_btree_node *prev_node(const struct b_btree_node *node, int *depth_diff)
the sub-tree rooted at `node`. we need to go back to our parent
and continue the search elsewhere.
*/
if (node->b_left) {
if (node->n_left) {
/* case 1: step into `node`'s left sub-tree and keep going
right to find the largest node */
b_btree_node *cur = node->b_left;
fx_bst_node *cur = node->n_left;
depth++;
while (cur->b_right) {
cur = cur->b_right;
while (cur->n_right) {
cur = cur->n_right;
depth++;
}
@@ -715,65 +715,65 @@ static b_btree_node *prev_node(const struct b_btree_node *node, int *depth_diff)
if we encounter a step where we are our parent's right child,
we've found a parent with a value smaller than us. this parent
is the in-order predecessor of `node`. */
while (node->b_parent && node->b_parent->b_right != node) {
node = node->b_parent;
while (node->n_parent && node->n_parent->n_right != node) {
node = node->n_parent;
depth--;
}
*depth_diff = depth - 1;
return node->b_parent;
return node->n_parent;
}
b_btree_node *b_btree_next(const struct b_btree_node *node)
fx_bst_node *fx_bst_next(const struct fx_bst_node *node)
{
int d;
return next_node(node, &d);
}
b_btree_node *b_btree_prev(const struct b_btree_node *node)
fx_bst_node *fx_bst_prev(const struct fx_bst_node *node)
{
int d;
return prev_node(node, &d);
}
void b_btree_move(
struct b_btree *tree, struct b_btree_node *dest, struct b_btree_node *src)
void fx_bst_move(
struct fx_bst *tree, struct fx_bst_node *dest, struct fx_bst_node *src)
{
if (src->b_parent) {
if (src->b_parent->b_left == src) {
src->b_parent->b_left = dest;
if (src->n_parent) {
if (src->n_parent->n_left == src) {
src->n_parent->n_left = dest;
} else {
src->b_parent->b_right = dest;
src->n_parent->n_right = dest;
}
}
if (src->b_left) {
src->b_left->b_parent = dest;
if (src->n_left) {
src->n_left->n_parent = dest;
}
if (src->b_right) {
src->b_right->b_parent = dest;
if (src->n_right) {
src->n_right->n_parent = dest;
}
if (tree->b_root == src) {
tree->b_root = dest;
if (tree->bst_root == src) {
tree->bst_root = dest;
}
memmove(dest, src, sizeof *src);
}
b_iterator *b_btree_begin(struct b_btree *tree)
fx_iterator *fx_bst_begin(struct fx_bst *tree)
{
b_iterator *it_obj = b_object_create(B_TYPE_BTREE_ITERATOR);
fx_iterator *it_obj = fx_object_create(FX_TYPE_BTREE_ITERATOR);
if (!it_obj) {
return NULL;
}
struct b_btree_iterator_p *it
= b_object_get_private(it_obj, B_TYPE_BTREE_ITERATOR);
struct fx_bst_iterator_p *it
= fx_object_get_private(it_obj, FX_TYPE_BTREE_ITERATOR);
int depth = 0;
it->_b = (struct b_btree *)tree;
it->_b = (struct fx_bst *)tree;
it->i = 0;
it->node = first_node(tree, &depth);
it->depth = depth;
@@ -781,18 +781,18 @@ b_iterator *b_btree_begin(struct b_btree *tree)
return it_obj;
}
const b_iterator *b_btree_cbegin(const struct b_btree *tree)
const fx_iterator *fx_bst_cbegin(const struct fx_bst *tree)
{
b_iterator *it_obj = b_object_create(B_TYPE_BTREE_ITERATOR);
fx_iterator *it_obj = fx_object_create(FX_TYPE_BTREE_ITERATOR);
if (!it_obj) {
return NULL;
}
struct b_btree_iterator_p *it
= b_object_get_private(it_obj, B_TYPE_BTREE_ITERATOR);
struct fx_bst_iterator_p *it
= fx_object_get_private(it_obj, FX_TYPE_BTREE_ITERATOR);
int depth = 0;
it->_b = (struct b_btree *)tree;
it->_b = (struct fx_bst *)tree;
it->i = 0;
it->node = first_node(tree, &depth);
it->depth = depth;
@@ -800,13 +800,13 @@ const b_iterator *b_btree_cbegin(const struct b_btree *tree)
return it_obj;
}
static enum b_status iterator_move_next(const b_iterator *obj)
static enum fx_status iterator_move_next(const fx_iterator *obj)
{
struct b_btree_iterator_p *it
= b_object_get_private(obj, B_TYPE_BTREE_ITERATOR);
struct fx_bst_iterator_p *it
= fx_object_get_private(obj, FX_TYPE_BTREE_ITERATOR);
int depth_diff = 0;
struct b_btree_node *next = next_node(it->node, &depth_diff);
struct fx_bst_node *next = next_node(it->node, &depth_diff);
if (!next) {
it->node = NULL;
@@ -821,19 +821,19 @@ static enum b_status iterator_move_next(const b_iterator *obj)
return true;
}
static enum b_status iterator_erase(b_iterator *obj)
static enum fx_status iterator_erase(fx_iterator *obj)
{
struct b_btree_iterator_p *it
= b_object_get_private(obj, B_TYPE_BTREE_ITERATOR);
struct fx_bst_iterator_p *it
= fx_object_get_private(obj, FX_TYPE_BTREE_ITERATOR);
if (!it->node) {
return B_ERR_OUT_OF_BOUNDS;
return FX_ERR_OUT_OF_BOUNDS;
}
int depth_diff = 0;
struct b_btree_node *next = next_node(it->node, &depth_diff);
struct fx_bst_node *next = next_node(it->node, &depth_diff);
b_btree_delete(it->_b, it->node);
fx_bst_delete(it->_b, it->node);
if (!next) {
it->node = NULL;
it->depth = 0;
@@ -841,51 +841,51 @@ static enum b_status iterator_erase(b_iterator *obj)
it->node = next;
it->depth = 0;
struct b_btree_node *cur = next->b_parent;
struct fx_bst_node *cur = next->n_parent;
while (cur) {
it->depth++;
cur = cur->b_parent;
cur = cur->n_parent;
}
}
return B_SUCCESS;
return FX_SUCCESS;
}
static b_iterator_value iterator_get_value(b_iterator *obj)
static fx_iterator_value iterator_get_value(fx_iterator *obj)
{
struct b_btree_iterator_p *it
= b_object_get_private(obj, B_TYPE_BTREE_ITERATOR);
struct fx_bst_iterator_p *it
= fx_object_get_private(obj, FX_TYPE_BTREE_ITERATOR);
return B_ITERATOR_VALUE_PTR(it->node);
return FX_ITERATOR_VALUE_PTR(it->node);
}
static const b_iterator_value iterator_get_cvalue(const b_iterator *obj)
static const fx_iterator_value iterator_get_cvalue(const fx_iterator *obj)
{
struct b_btree_iterator_p *it
= b_object_get_private(obj, B_TYPE_BTREE_ITERATOR);
struct fx_bst_iterator_p *it
= fx_object_get_private(obj, FX_TYPE_BTREE_ITERATOR);
return B_ITERATOR_VALUE_CPTR(it->node);
return FX_ITERATOR_VALUE_CPTR(it->node);
}
/*** CLASS DEFINITION *********************************************************/
// ---- b_btree_iterator DEFINITION
B_TYPE_CLASS_DEFINITION_BEGIN(b_btree_iterator)
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)
// ---- fx_bst_iterator DEFINITION
FX_TYPE_CLASS_DEFINITION_BEGIN(fx_bst_iterator)
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)
B_TYPE_CLASS_INTERFACE_BEGIN(b_iterator, B_TYPE_ITERATOR)
B_INTERFACE_ENTRY(it_move_next) = iterator_move_next;
B_INTERFACE_ENTRY(it_erase) = iterator_erase;
B_INTERFACE_ENTRY(it_get_value) = iterator_get_value;
B_INTERFACE_ENTRY(it_get_cvalue) = iterator_get_cvalue;
B_TYPE_CLASS_INTERFACE_END(b_iterator, B_TYPE_ITERATOR)
B_TYPE_CLASS_DEFINITION_END(b_btree_iterator)
FX_TYPE_CLASS_INTERFACE_BEGIN(fx_iterator, FX_TYPE_ITERATOR)
FX_INTERFACE_ENTRY(it_move_next) = iterator_move_next;
FX_INTERFACE_ENTRY(it_erase) = iterator_erase;
FX_INTERFACE_ENTRY(it_get_value) = iterator_get_value;
FX_INTERFACE_ENTRY(it_get_cvalue) = iterator_get_cvalue;
FX_TYPE_CLASS_INTERFACE_END(fx_iterator, FX_TYPE_ITERATOR)
FX_TYPE_CLASS_DEFINITION_END(fx_bst_iterator)
B_TYPE_DEFINITION_BEGIN(b_btree_iterator)
B_TYPE_ID(0x432779d7, 0xc03a, 0x48ea, 0xae8f, 0x12c666c767ae);
B_TYPE_EXTENDS(B_TYPE_ITERATOR);
B_TYPE_CLASS(b_btree_iterator_class);
B_TYPE_INSTANCE_PRIVATE(struct b_btree_iterator_p);
B_TYPE_DEFINITION_END(b_btree_iterator)
FX_TYPE_DEFINITION_BEGIN(fx_bst_iterator)
FX_TYPE_ID(0x432779d7, 0xc03a, 0x48ea, 0xae8f, 0x12c666c767ae);
FX_TYPE_EXTENDS(FX_TYPE_ITERATOR);
FX_TYPE_CLASS(fx_bst_iterator_class);
FX_TYPE_INSTANCE_PRIVATE(struct fx_bst_iterator_p);
FX_TYPE_DEFINITION_END(fx_bst_iterator)

42
core/class.c
View File

@@ -3,13 +3,13 @@
#include "type.h"
#include <assert.h>
#include <blue/core/class.h>
#include <fx/core/class.h>
#include <stdlib.h>
#include <string.h>
void *b_class_get(b_type id)
void *fx_class_get(fx_type id)
{
struct b_type_registration *r = b_type_get_registration(id);
struct fx_type_registration *r = fx_type_get_registration(id);
if (!r) {
return NULL;
}
@@ -17,28 +17,28 @@ void *b_class_get(b_type id)
return r->r_class;
}
const char *b_class_get_name(const struct _b_class *c)
const char *fx_class_get_name(const struct _fx_class *c)
{
if (!c) {
return NULL;
}
assert(c->c_magic == B_CLASS_MAGIC);
assert(c->c_magic == FX_CLASS_MAGIC);
return c->c_type->r_info->t_name;
}
void *b_class_get_interface(const struct _b_class *c, const union b_type *id)
void *fx_class_get_interface(const struct _fx_class *c, const union fx_type *id)
{
if (!c) {
return NULL;
}
assert(c->c_magic == B_CLASS_MAGIC);
assert(c->c_magic == FX_CLASS_MAGIC);
const struct b_type_registration *type_reg = c->c_type;
struct b_type_component *comp
= b_type_get_component(&type_reg->r_components, id);
const struct fx_type_registration *type_reg = c->c_type;
struct fx_type_component *comp
= fx_type_get_component(&type_reg->r_components, id);
if (!comp) {
return NULL;
@@ -47,33 +47,33 @@ void *b_class_get_interface(const struct _b_class *c, const union b_type *id)
return (char *)c + comp->c_class_data_offset;
}
b_result b_class_instantiate(
struct b_type_registration *type, struct _b_class **out_class)
fx_result fx_class_instantiate(
struct fx_type_registration *type, struct _fx_class **out_class)
{
struct _b_class *out = malloc(type->r_class_size);
struct _fx_class *out = malloc(type->r_class_size);
if (!out) {
return B_RESULT_ERR(NO_MEMORY);
return FX_RESULT_ERR(NO_MEMORY);
}
memset(out, 0x0, type->r_class_size);
out->c_magic = B_CLASS_MAGIC;
out->c_magic = FX_CLASS_MAGIC;
out->c_type = type;
struct b_queue_entry *entry = b_queue_first(&type->r_class_hierarchy);
struct fx_queue_entry *entry = fx_queue_first(&type->r_class_hierarchy);
while (entry) {
struct b_type_component *comp
= b_unbox(struct b_type_component, entry, c_entry);
const struct b_type_info *class_info = comp->c_type->r_info;
struct fx_type_component *comp
= fx_unbox(struct fx_type_component, entry, c_entry);
const struct fx_type_info *class_info = comp->c_type->r_info;
void *class_data = (char *)out + comp->c_class_data_offset;
if (class_info->t_class_init) {
class_info->t_class_init(out, class_data);
}
entry = b_queue_next(entry);
entry = fx_queue_next(entry);
}
*out_class = out;
return B_RESULT_SUCCESS;
return FX_RESULT_SUCCESS;
}

14
core/class.h
View File

@@ -1,18 +1,18 @@
#ifndef _CLASS_H_
#define _CLASS_H_
#include <blue/core/error.h>
#include <blue/core/misc.h>
#include <fx/core/error.h>
#include <fx/core/misc.h>
#include <stdint.h>
struct b_type_registration;
struct fx_type_registration;
struct _b_class {
struct _fx_class {
uint64_t c_magic;
const struct b_type_registration *c_type;
const struct fx_type_registration *c_type;
};
extern b_result b_class_instantiate(
struct b_type_registration *type, struct _b_class **out);
extern fx_result fx_class_instantiate(
struct fx_type_registration *type, struct _fx_class **out);
#endif

46
core/encoding.c
View File

@@ -1,12 +1,12 @@
#include <blue/core/encoding.h>
#include <fx/core/encoding.h>
#include <wctype.h>
bool b_wchar_is_number(b_wchar c)
bool fx_wchar_is_number(fx_wchar c)
{
return iswnumber((wchar_t)c);
}
bool b_wchar_is_alpha(b_wchar c)
bool fx_wchar_is_alpha(fx_wchar c)
{
if (c == 0) {
return false;
@@ -1177,28 +1177,28 @@ bool b_wchar_is_alpha(b_wchar c)
}
}
bool b_wchar_is_hex_digit(b_wchar c)
bool fx_wchar_is_hex_digit(fx_wchar c)
{
return isxdigit(c);
}
bool b_wchar_is_space(b_wchar c)
bool fx_wchar_is_space(fx_wchar c)
{
return iswspace((wchar_t)c);
}
bool b_wchar_is_punct(b_wchar c)
bool fx_wchar_is_punct(fx_wchar c)
{
return iswpunct((wchar_t)c);
}
bool b_wchar_utf8_is_valid_scalar(b_wchar c)
bool fx_wchar_utf8_is_valid_scalar(fx_wchar c)
{
return (((c) >= 0x0000 && (c) <= 0xD7FF)
|| ((c) >= 0xE000 && (c) <= 0x10FFFF));
}
unsigned int b_wchar_utf8_header_decode(char c)
unsigned int fx_wchar_utf8_header_decode(char c)
{
unsigned int len = 0;
@@ -1217,9 +1217,9 @@ unsigned int b_wchar_utf8_header_decode(char c)
return len;
}
unsigned int b_wchar_utf8_codepoint_size(b_wchar c)
unsigned int fx_wchar_utf8_codepoint_size(fx_wchar c)
{
if (!b_wchar_utf8_is_valid_scalar(c)) {
if (!fx_wchar_utf8_is_valid_scalar(c)) {
return 0;
}
@@ -1251,9 +1251,9 @@ static int32_t decode_utf8_trailer_byte(char c)
return c & 0x3F;
}
b_wchar b_wchar_utf8_codepoint_decode(const char *s)
fx_wchar fx_wchar_utf8_codepoint_decode(const char *s)
{
b_wchar result = 0;
fx_wchar result = 0;
int len = 0;
if (!(s[0] & 0x80)) {
@@ -1272,29 +1272,29 @@ b_wchar b_wchar_utf8_codepoint_decode(const char *s)
result = s[0] & 0x07;
result <<= 18;
} else {
return B_WCHAR_INVALID;
return FX_WCHAR_INVALID;
}
for (int i = 1; i < len; i++) {
int32_t c = decode_utf8_trailer_byte(s[i]);
if (c == -1) {
return B_WCHAR_INVALID;
return FX_WCHAR_INVALID;
}
c <<= 6 * (len - i - 1);
result |= c;
}
if (!b_wchar_utf8_is_valid_scalar(result)) {
return B_WCHAR_INVALID;
if (!fx_wchar_utf8_is_valid_scalar(result)) {
return FX_WCHAR_INVALID;
}
return result;
}
unsigned int b_wchar_utf8_codepoint_encode(b_wchar c, char s[4])
unsigned int fx_wchar_utf8_codepoint_encode(fx_wchar c, char s[4])
{
unsigned int len = b_wchar_utf8_codepoint_size(c);
unsigned int len = fx_wchar_utf8_codepoint_size(c);
switch (len) {
case 1:
@@ -1322,7 +1322,7 @@ unsigned int b_wchar_utf8_codepoint_encode(b_wchar c, char s[4])
return len;
}
unsigned int b_wchar_utf8_codepoint_stride(const char *s)
unsigned int fx_wchar_utf8_codepoint_stride(const char *s)
{
char c = *s;
@@ -1345,13 +1345,13 @@ unsigned int b_wchar_utf8_codepoint_stride(const char *s)
return 0;
}
size_t b_wchar_utf8_codepoint_count(const char *s, size_t nr_bytes)
size_t fx_wchar_utf8_codepoint_count(const char *s, size_t nr_bytes)
{
size_t nr_codepoints = 0;
const char *end = s + nr_bytes;
while (*s && s < end) {
size_t stride = b_wchar_utf8_codepoint_stride(s);
size_t stride = fx_wchar_utf8_codepoint_stride(s);
if (stride == 0) {
/* invalid codepoint */
return 0;
@@ -1364,11 +1364,11 @@ size_t b_wchar_utf8_codepoint_count(const char *s, size_t nr_bytes)
return nr_codepoints;
}
size_t b_wchar_utf8_string_encoded_size(const b_wchar *s, size_t nr_codepoints)
size_t fx_wchar_utf8_string_encoded_size(const fx_wchar *s, size_t nr_codepoints)
{
size_t len = 0;
for (size_t i = 0; i < nr_codepoints; i++) {
size_t l = b_wchar_utf8_codepoint_size(s[i]);
size_t l = fx_wchar_utf8_codepoint_size(s[i]);
if (l == 0) {
/* invalid codepoint */
return 0;

38
core/endian.c
View File

@@ -1,8 +1,8 @@
#include <blue/core/endian.h>
#include <fx/core/endian.h>
b_i16 b_i16_htob(uint16_t v)
fx_i16 fx_i16_htob(uint16_t v)
{
b_i16 x;
fx_i16 x;
#ifdef BIG_ENDIAN
x.i_uval = v;
@@ -15,9 +15,9 @@ b_i16 b_i16_htob(uint16_t v)
return x;
}
b_i16 b_i16_htos(uint16_t v)
fx_i16 fx_i16_htos(uint16_t v)
{
b_i16 x;
fx_i16 x;
#ifdef LITTLE_ENDIAN
x.i_uval = v;
@@ -30,7 +30,7 @@ b_i16 b_i16_htos(uint16_t v)
return x;
}
uint16_t b_i16_btoh(b_i16 v)
uint16_t fx_i16_btoh(fx_i16 v)
{
uint16_t x;
@@ -45,7 +45,7 @@ uint16_t b_i16_btoh(b_i16 v)
return x;
}
uint16_t b_i16_stoh(b_i16 v)
uint16_t fx_i16_stoh(fx_i16 v)
{
uint16_t x;
@@ -60,9 +60,9 @@ uint16_t b_i16_stoh(b_i16 v)
return x;
}
b_i32 b_i32_htob(uint32_t v)
fx_i32 fx_i32_htob(uint32_t v)
{
b_i32 x;
fx_i32 x;
#ifdef BIG_ENDIAN
x.i_uval = v;
@@ -77,9 +77,9 @@ b_i32 b_i32_htob(uint32_t v)
return x;
}
b_i32 b_i32_htos(uint32_t v)
fx_i32 fx_i32_htos(uint32_t v)
{
b_i32 x;
fx_i32 x;
#ifdef LITTLE_ENDIAN
x.i_uval = v;
@@ -94,7 +94,7 @@ b_i32 b_i32_htos(uint32_t v)
return x;
}
uint32_t b_i32_btoh(b_i32 v)
uint32_t fx_i32_btoh(fx_i32 v)
{
uint32_t x;
@@ -111,7 +111,7 @@ uint32_t b_i32_btoh(b_i32 v)
return x;
}
uint32_t b_i32_stoh(b_i32 v)
uint32_t fx_i32_stoh(fx_i32 v)
{
uint32_t x;
@@ -128,9 +128,9 @@ uint32_t b_i32_stoh(b_i32 v)
return x;
}
b_i64 b_i64_htob(uint64_t v)
fx_i64 fx_i64_htob(uint64_t v)
{
b_i64 x;
fx_i64 x;
#ifdef BIG_ENDIAN
x.i_uval = v;
@@ -149,9 +149,9 @@ b_i64 b_i64_htob(uint64_t v)
return x;
}
b_i64 b_i64_htos(uint64_t v)
fx_i64 fx_i64_htos(uint64_t v)
{
b_i64 x;
fx_i64 x;
#ifdef LITTLE_ENDIAN
x.i_uval = v;
@@ -170,7 +170,7 @@ b_i64 b_i64_htos(uint64_t v)
return x;
}
uint64_t b_i64_btoh(b_i64 v)
uint64_t fx_i64_btoh(fx_i64 v)
{
uint64_t x;
@@ -191,7 +191,7 @@ uint64_t b_i64_btoh(b_i64 v)
return x;
}
uint64_t b_i64_stoh(b_i64 v)
uint64_t fx_i64_stoh(fx_i64 v)
{
uint64_t x;

516
core/error.c
View File

File diff suppressed because it is too large Load Diff

42
core/error.h
View File

@@ -1,37 +1,37 @@
#ifndef _BLUELIB_ERROR_H_
#define _BLUELIB_ERROR_H_
#ifndef _FX_ERROR_H_
#define _FX_ERROR_H_
#include <blue/core/error.h>
#include <blue/core/queue.h>
#include <fx/core/error.h>
#include <fx/core/queue.h>
struct b_error_stack_frame {
b_queue_entry f_entry;
struct fx_error_stack_frame {
fx_queue_entry f_entry;
const char *f_file;
unsigned int f_line_number;
const char *f_function;
};
struct b_error_submsg {
b_queue_entry msg_entry;
b_error_submsg_type msg_type;
struct fx_error_submsg {
fx_queue_entry msg_entry;
fx_error_submsg_type msg_type;
char *msg_content;
const struct b_error_msg *msg_msg;
struct b_error_template_parameter msg_params[B_ERROR_TEMPLATE_PARAMETER_MAX];
const struct fx_error_msg *msg_msg;
struct fx_error_template_parameter msg_params[FX_ERROR_TEMPLATE_PARAMETER_MAX];
};
struct b_error {
const struct b_error_vendor *err_vendor;
b_error_status_code err_code;
struct fx_error {
const struct fx_error_vendor *err_vendor;
fx_error_status_code err_code;
const struct b_error_definition *err_def;
const struct b_error_msg *err_msg;
const struct fx_error_definition *err_def;
const struct fx_error_msg *err_msg;
char *err_description;
struct b_error_template_parameter err_params[B_ERROR_TEMPLATE_PARAMETER_MAX];
struct fx_error_template_parameter err_params[FX_ERROR_TEMPLATE_PARAMETER_MAX];
struct b_queue err_submsg;
struct b_queue err_stack;
b_queue_entry err_entry;
struct b_error *err_caused_by;
struct fx_queue err_submsg;
struct fx_queue err_stack;
fx_queue_entry err_entry;
struct fx_error *err_caused_by;
};
#endif

136
core/hash/hash.c
View File

@@ -1,7 +1,7 @@
#include "hash.h"
#include <blue/core/hash.h>
#include <blue/core/rope.h>
#include <fx/core/hash.h>
#include <fx/core/rope.h>
#include <inttypes.h>
#include <stddef.h>
#include <stdint.h>
@@ -10,46 +10,46 @@
#define FNV1_OFFSET_BASIS 0xcbf29ce484222325
#define FNV1_PRIME 0x100000001b3
extern struct b_hash_function_ops z__b_md4_ops;
extern struct b_hash_function_ops z__b_md5_ops;
extern struct b_hash_function_ops z__b_sha1_ops;
extern struct b_hash_function_ops z__b_sha2_224_ops;
extern struct b_hash_function_ops z__b_sha2_256_ops;
extern struct b_hash_function_ops z__b_sha2_384_ops;
extern struct b_hash_function_ops z__b_sha2_512_ops;
extern struct b_hash_function_ops z__b_sha3_224_ops;
extern struct b_hash_function_ops z__b_sha3_256_ops;
extern struct b_hash_function_ops z__b_sha3_384_ops;
extern struct b_hash_function_ops z__b_sha3_512_ops;
extern struct b_hash_function_ops z__b_shake128_ops;
extern struct b_hash_function_ops z__b_shake256_ops;
extern struct fx_hash_function_ops z__fx_md4_ops;
extern struct fx_hash_function_ops z__fx_md5_ops;
extern struct fx_hash_function_ops z__fx_sha1_ops;
extern struct fx_hash_function_ops z__fx_sha2_224_ops;
extern struct fx_hash_function_ops z__fx_sha2_256_ops;
extern struct fx_hash_function_ops z__fx_sha2_384_ops;
extern struct fx_hash_function_ops z__fx_sha2_512_ops;
extern struct fx_hash_function_ops z__fx_sha3_224_ops;
extern struct fx_hash_function_ops z__fx_sha3_256_ops;
extern struct fx_hash_function_ops z__fx_sha3_384_ops;
extern struct fx_hash_function_ops z__fx_sha3_512_ops;
extern struct fx_hash_function_ops z__fx_shake128_ops;
extern struct fx_hash_function_ops z__fx_shake256_ops;
static const struct b_hash_function_ops *hash_functions[] = {
[B_HASH_NONE] = NULL,
[B_HASH_MD4] = &z__b_md4_ops,
[B_HASH_MD5] = &z__b_md5_ops,
[B_HASH_SHA1] = &z__b_sha1_ops,
[B_HASH_SHA2_224] = &z__b_sha2_224_ops,
[B_HASH_SHA2_256] = &z__b_sha2_256_ops,
[B_HASH_SHA2_384] = &z__b_sha2_384_ops,
[B_HASH_SHA2_512] = &z__b_sha2_512_ops,
[B_HASH_SHA3_224] = &z__b_sha3_224_ops,
[B_HASH_SHA3_256] = &z__b_sha3_256_ops,
[B_HASH_SHA3_384] = &z__b_sha3_384_ops,
[B_HASH_SHA3_512] = &z__b_sha3_512_ops,
[B_HASH_SHAKE128] = &z__b_shake128_ops,
[B_HASH_SHAKE256] = &z__b_shake256_ops,
static const struct fx_hash_function_ops *hash_functions[] = {
[FX_HASH_NONE] = NULL,
[FX_HASH_MD4] = &z__fx_md4_ops,
[FX_HASH_MD5] = &z__fx_md5_ops,
[FX_HASH_SHA1] = &z__fx_sha1_ops,
[FX_HASH_SHA2_224] = &z__fx_sha2_224_ops,
[FX_HASH_SHA2_256] = &z__fx_sha2_256_ops,
[FX_HASH_SHA2_384] = &z__fx_sha2_384_ops,
[FX_HASH_SHA2_512] = &z__fx_sha2_512_ops,
[FX_HASH_SHA3_224] = &z__fx_sha3_224_ops,
[FX_HASH_SHA3_256] = &z__fx_sha3_256_ops,
[FX_HASH_SHA3_384] = &z__fx_sha3_384_ops,
[FX_HASH_SHA3_512] = &z__fx_sha3_512_ops,
[FX_HASH_SHAKE128] = &z__fx_shake128_ops,
[FX_HASH_SHAKE256] = &z__fx_shake256_ops,
};
static const size_t nr_hash_functions
= sizeof hash_functions / sizeof hash_functions[0];
uint64_t b_hash_cstr(const char *s)
uint64_t fx_hash_cstr(const char *s)
{
size_t x = 0;
return b_hash_cstr_ex(s, &x);
return fx_hash_cstr_ex(s, &x);
}
uint64_t b_hash_cstr_ex(const char *s, size_t *len)
uint64_t fx_hash_cstr_ex(const char *s, size_t *len)
{
uint64_t hash = FNV1_OFFSET_BASIS;
size_t i = 0;
@@ -66,15 +66,15 @@ uint64_t b_hash_cstr_ex(const char *s, size_t *len)
return hash;
}
enum b_status b_hash_ctx_init(struct b_hash_ctx *ctx, enum b_hash_function func)
enum fx_status fx_hash_ctx_init(struct fx_hash_ctx *ctx, enum fx_hash_function func)
{
if (func < 0 || func >= nr_hash_functions) {
return B_ERR_NOT_SUPPORTED;
return FX_ERR_NOT_SUPPORTED;
}
const struct b_hash_function_ops *hash_function = hash_functions[func];
const struct fx_hash_function_ops *hash_function = hash_functions[func];
if (!hash_function) {
return B_ERR_NOT_SUPPORTED;
return FX_ERR_NOT_SUPPORTED;
}
memset(ctx, 0x0, sizeof *ctx);
@@ -86,13 +86,13 @@ enum b_status b_hash_ctx_init(struct b_hash_ctx *ctx, enum b_hash_function func)
hash_function->hash_init(ctx);
}
return B_SUCCESS;
return FX_SUCCESS;
}
enum b_status b_hash_ctx_reset(struct b_hash_ctx *ctx)
enum fx_status fx_hash_ctx_reset(struct fx_hash_ctx *ctx)
{
if (ctx->ctx_func == B_HASH_NONE || !ctx->ctx_ops) {
return B_ERR_BAD_STATE;
if (ctx->ctx_func == FX_HASH_NONE || !ctx->ctx_ops) {
return FX_ERR_BAD_STATE;
}
memset(&ctx->ctx_state, 0x0, sizeof ctx->ctx_state);
@@ -101,69 +101,69 @@ enum b_status b_hash_ctx_reset(struct b_hash_ctx *ctx)
ctx->ctx_ops->hash_init(ctx);
}
return B_SUCCESS;
return FX_SUCCESS;
}
enum b_status b_hash_ctx_update(struct b_hash_ctx *ctx, const void *p, size_t len)
enum fx_status fx_hash_ctx_update(struct fx_hash_ctx *ctx, const void *p, size_t len)
{
if (!ctx->ctx_ops) {
return B_ERR_BAD_STATE;
return FX_ERR_BAD_STATE;
}
if (!ctx->ctx_ops->hash_update) {
return B_ERR_NOT_SUPPORTED;
return FX_ERR_NOT_SUPPORTED;
}
ctx->ctx_ops->hash_update(ctx, p, len);
return B_SUCCESS;
return FX_SUCCESS;
}
static void update_rope(const b_rope *rope, void *arg)
static void update_rope(const fx_rope *rope, void *arg)
{
struct b_hash_ctx *ctx = arg;
unsigned int type = B_ROPE_TYPE(rope->r_flags);
struct fx_hash_ctx *ctx = arg;
unsigned int type = FX_ROPE_TYPE(rope->r_flags);
char tmp[64];
size_t len = 0;
switch (type) {
case B_ROPE_F_CHAR:
b_hash_ctx_update(ctx, &rope->r_v.v_char, sizeof rope->r_v.v_char);
case FX_ROPE_F_CHAR:
fx_hash_ctx_update(ctx, &rope->r_v.v_char, sizeof rope->r_v.v_char);
break;
case B_ROPE_F_CSTR:
case B_ROPE_F_CSTR_BORROWED:
case B_ROPE_F_CSTR_STATIC:
b_hash_ctx_update(
case FX_ROPE_F_CSTR:
case FX_ROPE_F_CSTR_BORROWED:
case FX_ROPE_F_CSTR_STATIC:
fx_hash_ctx_update(
ctx, rope->r_v.v_cstr.s, strlen(rope->r_v.v_cstr.s));
break;
case B_ROPE_F_INT:
case FX_ROPE_F_INT:
len = snprintf(tmp, sizeof tmp, "%" PRIdPTR, rope->r_v.v_int);
b_hash_ctx_update(ctx, tmp, len);
fx_hash_ctx_update(ctx, tmp, len);
break;
case B_ROPE_F_UINT:
case FX_ROPE_F_UINT:
len = snprintf(tmp, sizeof tmp, "%" PRIuPTR, rope->r_v.v_uint);
b_hash_ctx_update(ctx, tmp, len);
fx_hash_ctx_update(ctx, tmp, len);
break;
default:
break;
}
}
enum b_status b_hash_ctx_update_rope(
struct b_hash_ctx *ctx, const struct b_rope *rope)
enum fx_status fx_hash_ctx_update_rope(
struct fx_hash_ctx *ctx, const struct fx_rope *rope)
{
b_rope_iterate(rope, update_rope, ctx);
return B_SUCCESS;
fx_rope_iterate(rope, update_rope, ctx);
return FX_SUCCESS;
}
enum b_status b_hash_ctx_finish(
struct b_hash_ctx *ctx, void *out_digest, size_t out_max)
enum fx_status fx_hash_ctx_finish(
struct fx_hash_ctx *ctx, void *out_digest, size_t out_max)
{
if (!ctx->ctx_ops) {
return B_ERR_BAD_STATE;
return FX_ERR_BAD_STATE;
}
if (!ctx->ctx_ops->hash_finish) {
return B_ERR_NOT_SUPPORTED;
return FX_ERR_NOT_SUPPORTED;
}
ctx->ctx_ops->hash_finish(ctx, out_digest, out_max);
@@ -174,5 +174,5 @@ enum b_status b_hash_ctx_finish(
ctx->ctx_ops->hash_init(ctx);
}
return B_SUCCESS;
return FX_SUCCESS;
}

10
core/hash/hash.h
View File

@@ -3,12 +3,12 @@
#include <stddef.h>
struct b_hash_ctx;
struct fx_hash_ctx;
struct b_hash_function_ops {
void (*hash_init)(struct b_hash_ctx *);
void (*hash_update)(struct b_hash_ctx *, const void *, size_t);
void (*hash_finish)(struct b_hash_ctx *, void *, size_t);
struct fx_hash_function_ops {
void (*hash_init)(struct fx_hash_ctx *);
void (*hash_update)(struct fx_hash_ctx *, const void *, size_t);
void (*hash_finish)(struct fx_hash_ctx *, void *, size_t);
};
#endif

12
core/hash/md4.c
View File

@@ -36,7 +36,7 @@
*/
#include "hash.h"
#include <blue/core/hash.h>
#include <fx/core/hash.h>
#include <stdint.h>
#include <string.h>
@@ -88,7 +88,7 @@
* This processes one or more 64-byte data blocks, but does NOT update the bit
* counters. There are no alignment requirements.
*/
static const void *body(struct b_hash_ctx *ctx, const void *data, unsigned long size)
static const void *body(struct fx_hash_ctx *ctx, const void *data, unsigned long size)
{
const unsigned char *ptr;
uint32_t a, b, c, d;
@@ -178,7 +178,7 @@ static const void *body(struct b_hash_ctx *ctx, const void *data, unsigned long
return ptr;
}
void md4_init(struct b_hash_ctx *ctx)
void md4_init(struct fx_hash_ctx *ctx)
{
ctx->ctx_state.md4.a = 0x67452301;
ctx->ctx_state.md4.b = 0xefcdab89;
@@ -189,7 +189,7 @@ void md4_init(struct b_hash_ctx *ctx)
ctx->ctx_state.md4.hi = 0;
}
void md4_update(struct b_hash_ctx *ctx, const void *data, unsigned long size)
void md4_update(struct fx_hash_ctx *ctx, const void *data, unsigned long size)
{
uint32_t saved_lo;
unsigned long used, available;
@@ -229,7 +229,7 @@ void md4_update(struct b_hash_ctx *ctx, const void *data, unsigned long size)
(dst)[2] = (unsigned char)((src) >> 16); \
(dst)[3] = (unsigned char)((src) >> 24);
void md4_finish(struct b_hash_ctx *ctx, void *out, size_t max)
void md4_finish(struct fx_hash_ctx *ctx, void *out, size_t max)
{
unsigned char *result = out;
unsigned long used, available;
@@ -261,7 +261,7 @@ void md4_finish(struct b_hash_ctx *ctx, void *out, size_t max)
OUT(&result[12], ctx->ctx_state.md4.d)
}
struct b_hash_function_ops z__b_md4_ops = {
struct fx_hash_function_ops z__fx_md4_ops = {
.hash_init = md4_init,
.hash_update = md4_update,
.hash_finish = md4_finish,

16
core/hash/md5.c
View File

@@ -3,7 +3,7 @@
* and is in the public domain. */
#include "hash.h"
#include <blue/core/hash.h>
#include <fx/core/hash.h>
#include <memory.h>
#include <stdint.h>
#include <stdio.h>
@@ -19,7 +19,7 @@
#define STEP(f, a, b, c, d, x, t, s) \
(a += f(b, c, d) + x + t, a = ROTATE_LEFT(a, s), a += b)
void md5_init(struct b_hash_ctx *ctx)
void md5_init(struct fx_hash_ctx *ctx)
{
ctx->ctx_state.md5.a = 0x67452301;
ctx->ctx_state.md5.b = 0xefcdab89;
@@ -30,7 +30,7 @@ void md5_init(struct b_hash_ctx *ctx)
ctx->ctx_state.md5.count[1] = 0;
}
uint8_t *md5_transform(struct b_hash_ctx *ctx, const void *data, uintmax_t size)
uint8_t *md5_transform(struct fx_hash_ctx *ctx, const void *data, uintmax_t size)
{
uint8_t *ptr = (uint8_t *)data;
uint32_t a, b, c, d, aa, bb, cc, dd;
@@ -140,7 +140,7 @@ uint8_t *md5_transform(struct b_hash_ctx *ctx, const void *data, uintmax_t size)
return ptr;
}
void md5_update(struct b_hash_ctx *ctx, const void *buffer, size_t buffer_size)
void md5_update(struct fx_hash_ctx *ctx, const void *buffer, size_t buffer_size)
{
uint32_t saved_low = ctx->ctx_state.md5.count[0];
uint32_t used;
@@ -178,7 +178,7 @@ void md5_update(struct b_hash_ctx *ctx, const void *buffer, size_t buffer_size)
memcpy(ctx->ctx_state.md5.input, buffer, buffer_size);
}
void md5_finish(struct b_hash_ctx *ctx, void *out, size_t max)
void md5_finish(struct fx_hash_ctx *ctx, void *out, size_t max)
{
uint32_t used = ctx->ctx_state.md5.count[0] & 0x3f;
ctx->ctx_state.md5.input[used++] = 0x80;
@@ -193,7 +193,7 @@ void md5_finish(struct b_hash_ctx *ctx, void *out, size_t max)
memset(&ctx->ctx_state.md5.input[used], 0, free - 8);
unsigned char digest[B_DIGEST_LENGTH_MD5];
unsigned char digest[FX_DIGEST_LENGTH_MD5];
ctx->ctx_state.md5.count[0] <<= 3;
ctx->ctx_state.md5.input[56] = (uint8_t)(ctx->ctx_state.md5.count[0]);
@@ -228,10 +228,10 @@ void md5_finish(struct b_hash_ctx *ctx, void *out, size_t max)
digest[14] = (uint8_t)(ctx->ctx_state.md5.d >> 16);
digest[15] = (uint8_t)(ctx->ctx_state.md5.d >> 24);
memcpy(out, digest, b_min(size_t, sizeof digest, max));
memcpy(out, digest, fx_min(size_t, sizeof digest, max));
}
struct b_hash_function_ops z__b_md5_ops = {
struct fx_hash_function_ops z__fx_md5_ops = {
.hash_init = md5_init,
.hash_update = md5_update,
.hash_finish = md5_finish,

14
core/hash/sha1.c
View File

@@ -19,7 +19,7 @@ A million repetitions of "a"
#include "hash.h"
#include <blue/core/hash.h>
#include <fx/core/hash.h>
#include <stdio.h>
#include <string.h>
@@ -187,7 +187,7 @@ void SHA1Transform(uint32_t state[5], const unsigned char buffer[64])
/* sha_init - Initialize new context */
static void sha_init(struct b_hash_ctx *context)
static void sha_init(struct fx_hash_ctx *context)
{
/* SHA1 initialization constants */
context->ctx_state.sha1.state[0] = 0x67452301;
@@ -200,7 +200,7 @@ static void sha_init(struct b_hash_ctx *context)
/* Run your data through this. */
static void sha_update(struct b_hash_ctx *context, const void *p, size_t len)
static void sha_update(struct fx_hash_ctx *context, const void *p, size_t len)
{
const unsigned char *data = p;
uint32_t i, j;
@@ -226,7 +226,7 @@ static void sha_update(struct b_hash_ctx *context, const void *p, size_t len)
/* Add padding and return the message digest. */
static void sha_finish(struct b_hash_ctx *context, void *out, size_t max)
static void sha_finish(struct fx_hash_ctx *context, void *out, size_t max)
{
unsigned i;
@@ -241,7 +241,7 @@ static void sha_finish(struct b_hash_ctx *context, void *out, size_t max)
& 255); /* Endian independent */
}
char digest[B_DIGEST_LENGTH_SHA1];
char digest[FX_DIGEST_LENGTH_SHA1];
c = 0200;
sha_update(context, &c, 1);
while ((context->ctx_state.sha1.count[0] & 504) != 448) {
@@ -255,12 +255,12 @@ static void sha_finish(struct b_hash_ctx *context, void *out, size_t max)
& 255);
}
memcpy(out, digest, b_min(size_t, sizeof digest, max));
memcpy(out, digest, fx_min(size_t, sizeof digest, max));
/* Wipe variables */
memset(&finalcount, '\0', sizeof(finalcount));
}
struct b_hash_function_ops z__b_sha1_ops = {
struct fx_hash_function_ops z__fx_sha1_ops = {
.hash_init = sha_init,
.hash_update = sha_update,
.hash_finish = sha_finish,

24
core/hash/sha2_224.c
View File

@@ -1,14 +1,14 @@
// SHA-224. Adapted from LibTomCrypt. This code is Public Domain
#include "hash.h"
#include <blue/core/hash.h>
#include <fx/core/hash.h>
#include <string.h>
extern void z__b_sha2_256_update(
struct b_hash_ctx *md, const void *src, size_t inlen);
extern void z__b_sha2_256_finish(struct b_hash_ctx *md, void *out, size_t max);
extern void z__fx_sha2_256_update(
struct fx_hash_ctx *md, const void *src, size_t inlen);
extern void z__fx_sha2_256_finish(struct fx_hash_ctx *md, void *out, size_t max);
static void sha_init(struct b_hash_ctx *md)
static void sha_init(struct fx_hash_ctx *md)
{
md->ctx_state.sha2_256.curlen = 0;
md->ctx_state.sha2_256.length = 0;
@@ -22,20 +22,20 @@ static void sha_init(struct b_hash_ctx *md)
md->ctx_state.sha2_256.state[7] = 0xbefa4fa4UL;
}
static void sha_update(struct b_hash_ctx *md, const void *in, size_t inlen)
static void sha_update(struct fx_hash_ctx *md, const void *in, size_t inlen)
{
z__b_sha2_256_update(md, in, inlen);
z__fx_sha2_256_update(md, in, inlen);
}
static void sha_finish(struct b_hash_ctx *md, void *out, size_t max)
static void sha_finish(struct fx_hash_ctx *md, void *out, size_t max)
{
unsigned char res[B_DIGEST_LENGTH_SHA2_256];
z__b_sha2_256_finish(md, res, max);
unsigned char res[FX_DIGEST_LENGTH_SHA2_256];
z__fx_sha2_256_finish(md, res, max);
/* truncate the digest to 224 bits */
memcpy(out, res, b_min(size_t, max, B_DIGEST_LENGTH_224));
memcpy(out, res, fx_min(size_t, max, FX_DIGEST_LENGTH_224));
}
struct b_hash_function_ops z__b_sha2_224_ops = {
struct fx_hash_function_ops z__fx_sha2_224_ops = {
.hash_init = sha_init,
.hash_update = sha_update,
.hash_finish = sha_finish,

20
core/hash/sha2_256.c
View File

@@ -1,7 +1,7 @@
// SHA-256. Adapted from LibTomCrypt. This code is Public Domain
#include "hash.h"
#include <blue/core/hash.h>
#include <fx/core/hash.h>
#include <string.h>
static const uint32_t K[64] = {
@@ -87,7 +87,7 @@ static void RND(
(*h) = *t0 + *t1;
}
static void sha_compress(struct b_hash_ctx *md, const unsigned char *buf)
static void sha_compress(struct fx_hash_ctx *md, const unsigned char *buf)
{
uint32_t S[8], W[64], t0, t1, t;
@@ -127,7 +127,7 @@ static void sha_compress(struct b_hash_ctx *md, const unsigned char *buf)
// Public interface
static void sha_init(struct b_hash_ctx *md)
static void sha_init(struct fx_hash_ctx *md)
{
md->ctx_state.sha2_256.curlen = 0;
md->ctx_state.sha2_256.length = 0;
@@ -141,7 +141,7 @@ static void sha_init(struct b_hash_ctx *md)
md->ctx_state.sha2_256.state[7] = 0x5BE0CD19UL;
}
void z__b_sha2_256_update(struct b_hash_ctx *md, const void *src, size_t inlen)
void z__fx_sha2_256_update(struct fx_hash_ctx *md, const void *src, size_t inlen)
{
const uint32_t block_size = sizeof md->ctx_state.sha2_256.buf;
const unsigned char *in = (const unsigned char *)(src);
@@ -171,7 +171,7 @@ void z__b_sha2_256_update(struct b_hash_ctx *md, const void *src, size_t inlen)
}
}
}
void z__b_sha2_256_finish(struct b_hash_ctx *md, void *out, size_t max)
void z__fx_sha2_256_finish(struct fx_hash_ctx *md, void *out, size_t max)
{
// Increase the length of the message
md->ctx_state.sha2_256.length += md->ctx_state.sha2_256.curlen * 8;
@@ -198,18 +198,18 @@ void z__b_sha2_256_finish(struct b_hash_ctx *md, void *out, size_t max)
store64(md->ctx_state.sha2_256.length, md->ctx_state.sha2_256.buf + 56);
sha_compress(md, md->ctx_state.sha2_256.buf);
unsigned char digest[B_DIGEST_LENGTH_SHA2_256];
unsigned char digest[FX_DIGEST_LENGTH_SHA2_256];
// Copy output
for (int i = 0; i < 8; i++)
store32(md->ctx_state.sha2_256.state[i],
(unsigned char *)&digest[(4 * i)]);
memcpy(out, digest, b_min(size_t, sizeof digest, max));
memcpy(out, digest, fx_min(size_t, sizeof digest, max));
}
struct b_hash_function_ops z__b_sha2_256_ops = {
struct fx_hash_function_ops z__fx_sha2_256_ops = {
.hash_init = sha_init,
.hash_update = z__b_sha2_256_update,
.hash_finish = z__b_sha2_256_finish,
.hash_update = z__fx_sha2_256_update,
.hash_finish = z__fx_sha2_256_finish,
};

24
core/hash/sha2_384.c
View File

@@ -1,14 +1,14 @@
// SHA-384. Adapted from LibTomCrypt. This code is Public Domain
#include "hash.h"
#include <blue/core/hash.h>
#include <fx/core/hash.h>
#include <string.h>
extern void z__b_sha2_512_update(
struct b_hash_ctx *md, const void *src, size_t inlen);
extern void z__b_sha2_512_finish(struct b_hash_ctx *md, void *out, size_t max);
extern void z__fx_sha2_512_update(
struct fx_hash_ctx *md, const void *src, size_t inlen);
extern void z__fx_sha2_512_finish(struct fx_hash_ctx *md, void *out, size_t max);
void sha_init(struct b_hash_ctx *md)
void sha_init(struct fx_hash_ctx *md)
{
md->ctx_state.sha2_512.curlen = 0;
md->ctx_state.sha2_512.length = 0;
@@ -22,20 +22,20 @@ void sha_init(struct b_hash_ctx *md)
md->ctx_state.sha2_512.state[7] = 0x47b5481dbefa4fa4ULL;
}
static void sha_update(struct b_hash_ctx *md, const void *in, size_t inlen)
static void sha_update(struct fx_hash_ctx *md, const void *in, size_t inlen)
{
z__b_sha2_512_update(md, in, inlen);
z__fx_sha2_512_update(md, in, inlen);
}
static void sha_finish(struct b_hash_ctx *md, void *out, size_t max)
static void sha_finish(struct fx_hash_ctx *md, void *out, size_t max)
{
unsigned char res[B_DIGEST_LENGTH_SHA2_512];
z__b_sha2_512_finish(md, res, max);
unsigned char res[FX_DIGEST_LENGTH_SHA2_512];
z__fx_sha2_512_finish(md, res, max);
/* truncate the digest to 384 bits */
memcpy(out, res, b_min(size_t, max, B_DIGEST_LENGTH_384));
memcpy(out, res, fx_min(size_t, max, FX_DIGEST_LENGTH_384));
}
struct b_hash_function_ops z__b_sha2_384_ops = {
struct fx_hash_function_ops z__fx_sha2_384_ops = {
.hash_init = sha_init,
.hash_update = sha_update,
.hash_finish = sha_finish,

20
core/hash/sha2_512.c
View File

@@ -1,7 +1,7 @@
// SHA-512. Adapted from LibTomCrypt. This code is Public Domain
#include "hash.h"
#include <blue/core/hash.h>
#include <fx/core/hash.h>
#include <stdint.h>
#include <string.h>
@@ -96,7 +96,7 @@ static void RND(
*h = *t0 + *t1;
}
static void sha_compress(struct b_hash_ctx *md, const unsigned char *buf)
static void sha_compress(struct fx_hash_ctx *md, const unsigned char *buf)
{
uint64_t S[8], W[80], t0, t1;
@@ -144,7 +144,7 @@ static void sha_compress(struct b_hash_ctx *md, const unsigned char *buf)
// Public interface
static void sha_init(struct b_hash_ctx *md)
static void sha_init(struct fx_hash_ctx *md)
{
md->ctx_state.sha2_512.curlen = 0;
md->ctx_state.sha2_512.length = 0;
@@ -158,7 +158,7 @@ static void sha_init(struct b_hash_ctx *md)
md->ctx_state.sha2_512.state[7] = 0x5be0cd19137e2179ULL;
}
void z__b_sha2_512_update(struct b_hash_ctx *md, const void *src, size_t inlen)
void z__fx_sha2_512_update(struct fx_hash_ctx *md, const void *src, size_t inlen)
{
const uint32_t block_size = sizeof md->ctx_state.sha2_512.block;
const unsigned char *in = (const unsigned char *)src;
@@ -189,7 +189,7 @@ void z__b_sha2_512_update(struct b_hash_ctx *md, const void *src, size_t inlen)
}
}
void z__b_sha2_512_finish(struct b_hash_ctx *md, void *out, size_t max)
void z__fx_sha2_512_finish(struct fx_hash_ctx *md, void *out, size_t max)
{
// Increase the length of the message
md->ctx_state.sha2_512.length += md->ctx_state.sha2_512.curlen * 8ULL;
@@ -218,7 +218,7 @@ void z__b_sha2_512_finish(struct b_hash_ctx *md, void *out, size_t max)
store64(md->ctx_state.sha2_512.length, md->ctx_state.sha2_512.block + 120);
sha_compress(md, md->ctx_state.sha2_512.block);
unsigned char digest[B_DIGEST_LENGTH_SHA2_512];
unsigned char digest[FX_DIGEST_LENGTH_SHA2_512];
// Copy output
for (int i = 0; i < 8; i++) {
@@ -226,11 +226,11 @@ void z__b_sha2_512_finish(struct b_hash_ctx *md, void *out, size_t max)
(unsigned char *)&digest[(8 * i)]);
}
memcpy(out, digest, b_min(size_t, sizeof digest, max));
memcpy(out, digest, fx_min(size_t, sizeof digest, max));
}
struct b_hash_function_ops z__b_sha2_512_ops = {
struct fx_hash_function_ops z__fx_sha2_512_ops = {
.hash_init = sha_init,
.hash_update = z__b_sha2_512_update,
.hash_finish = z__b_sha2_512_finish,
.hash_update = z__fx_sha2_512_update,
.hash_finish = z__fx_sha2_512_finish,
};

88
core/hash/sha3.c
View File

@@ -30,8 +30,8 @@
#include "hash.h"
#include <blue/core/hash.h>
#include <blue/core/misc.h>
#include <fx/core/hash.h>
#include <fx/core/misc.h>
#include <string.h>
#ifndef KECCAKF_ROUNDS
@@ -134,7 +134,7 @@ void sha3_keccakf(uint64_t st[25])
// Initialize the context for SHA3
int sha3_init(struct b_hash_ctx *c, int mdlen)
int sha3_init(struct fx_hash_ctx *c, int mdlen)
{
int i;
@@ -149,7 +149,7 @@ int sha3_init(struct b_hash_ctx *c, int mdlen)
// update state with more data
void sha3_update(struct b_hash_ctx *c, const void *data, size_t len)
void sha3_update(struct fx_hash_ctx *c, const void *data, size_t len)
{
size_t i;
int j;
@@ -168,7 +168,7 @@ void sha3_update(struct b_hash_ctx *c, const void *data, size_t len)
// finalize and output a hash
int sha3_final(void *md, struct b_hash_ctx *c)
int sha3_final(void *md, struct fx_hash_ctx *c)
{
int i;
@@ -187,7 +187,7 @@ int sha3_final(void *md, struct b_hash_ctx *c)
void *sha3(const void *in, size_t inlen, void *md, int mdlen)
{
struct b_hash_ctx sha3;
struct fx_hash_ctx sha3;
sha3_init(&sha3, mdlen);
sha3_update(&sha3, in, inlen);
@@ -198,7 +198,7 @@ void *sha3(const void *in, size_t inlen, void *md, int mdlen)
// SHAKE128 and SHAKE256 extensible-output functionality
void shake_xof(struct b_hash_ctx *c)
void shake_xof(struct fx_hash_ctx *c)
{
c->ctx_state.sha3.st.b[c->ctx_state.sha3.pt] ^= 0x1F;
c->ctx_state.sha3.st.b[c->ctx_state.sha3.rsiz - 1] ^= 0x80;
@@ -206,7 +206,7 @@ void shake_xof(struct b_hash_ctx *c)
c->ctx_state.sha3.pt = 0;
}
void shake_out(struct b_hash_ctx *c, void *out, size_t len)
void shake_out(struct fx_hash_ctx *c, void *out, size_t len)
{
size_t i;
int j;
@@ -222,111 +222,111 @@ void shake_out(struct b_hash_ctx *c, void *out, size_t len)
c->ctx_state.sha3.pt = j;
}
static void sha3_224_init(struct b_hash_ctx *ctx)
static void sha3_224_init(struct fx_hash_ctx *ctx)
{
sha3_init(ctx, B_DIGEST_LENGTH_SHA3_224);
sha3_init(ctx, FX_DIGEST_LENGTH_SHA3_224);
}
static void sha3_224_finish(struct b_hash_ctx *ctx, void *out, size_t max)
static void sha3_224_finish(struct fx_hash_ctx *ctx, void *out, size_t max)
{
unsigned char md[B_DIGEST_LENGTH_SHA3_224];
unsigned char md[FX_DIGEST_LENGTH_SHA3_224];
sha3_final(md, ctx);
memcpy(out, md, b_min(size_t, sizeof md, max));
memcpy(out, md, fx_min(size_t, sizeof md, max));
}
static void sha3_256_init(struct b_hash_ctx *ctx)
static void sha3_256_init(struct fx_hash_ctx *ctx)
{
sha3_init(ctx, B_DIGEST_LENGTH_SHA3_256);
sha3_init(ctx, FX_DIGEST_LENGTH_SHA3_256);
}
static void sha3_256_finish(struct b_hash_ctx *ctx, void *out, size_t max)
static void sha3_256_finish(struct fx_hash_ctx *ctx, void *out, size_t max)
{
unsigned char md[B_DIGEST_LENGTH_SHA3_256];
unsigned char md[FX_DIGEST_LENGTH_SHA3_256];
sha3_final(md, ctx);
memcpy(out, md, b_min(size_t, sizeof md, max));
memcpy(out, md, fx_min(size_t, sizeof md, max));
}
static void sha3_384_init(struct b_hash_ctx *ctx)
static void sha3_384_init(struct fx_hash_ctx *ctx)
{
sha3_init(ctx, B_DIGEST_LENGTH_SHA3_384);
sha3_init(ctx, FX_DIGEST_LENGTH_SHA3_384);
}
static void sha3_384_finish(struct b_hash_ctx *ctx, void *out, size_t max)
static void sha3_384_finish(struct fx_hash_ctx *ctx, void *out, size_t max)
{
unsigned char md[B_DIGEST_LENGTH_SHA3_384];
unsigned char md[FX_DIGEST_LENGTH_SHA3_384];
sha3_final(md, ctx);
memcpy(out, md, b_min(size_t, sizeof md, max));
memcpy(out, md, fx_min(size_t, sizeof md, max));
}
static void sha3_512_init(struct b_hash_ctx *ctx)
static void sha3_512_init(struct fx_hash_ctx *ctx)
{
sha3_init(ctx, B_DIGEST_LENGTH_SHA3_512);
sha3_init(ctx, FX_DIGEST_LENGTH_SHA3_512);
}
static void sha3_512_finish(struct b_hash_ctx *ctx, void *out, size_t max)
static void sha3_512_finish(struct fx_hash_ctx *ctx, void *out, size_t max)
{
unsigned char md[B_DIGEST_LENGTH_SHA3_512];
unsigned char md[FX_DIGEST_LENGTH_SHA3_512];
sha3_final(md, ctx);
memcpy(out, md, b_min(size_t, sizeof md, max));
memcpy(out, md, fx_min(size_t, sizeof md, max));
}
static void shake128_init(struct b_hash_ctx *ctx)
static void shake128_init(struct fx_hash_ctx *ctx)
{
sha3_init(ctx, B_DIGEST_LENGTH_SHAKE128);
sha3_init(ctx, FX_DIGEST_LENGTH_SHAKE128);
}
static void shake128_finish(struct b_hash_ctx *ctx, void *out, size_t max)
static void shake128_finish(struct fx_hash_ctx *ctx, void *out, size_t max)
{
unsigned char md[B_DIGEST_LENGTH_SHAKE128];
unsigned char md[FX_DIGEST_LENGTH_SHAKE128];
shake_xof(ctx);
shake_out(ctx, md, sizeof md);
memcpy(out, md, b_min(size_t, sizeof md, max));
memcpy(out, md, fx_min(size_t, sizeof md, max));
}
static void shake256_init(struct b_hash_ctx *ctx)
static void shake256_init(struct fx_hash_ctx *ctx)
{
sha3_init(ctx, B_DIGEST_LENGTH_SHAKE256);
sha3_init(ctx, FX_DIGEST_LENGTH_SHAKE256);
}
static void shake256_finish(struct b_hash_ctx *ctx, void *out, size_t max)
static void shake256_finish(struct fx_hash_ctx *ctx, void *out, size_t max)
{
unsigned char md[B_DIGEST_LENGTH_SHAKE256];
unsigned char md[FX_DIGEST_LENGTH_SHAKE256];
shake_xof(ctx);
shake_out(ctx, md, sizeof md);
memcpy(out, md, b_min(size_t, sizeof md, max));
memcpy(out, md, fx_min(size_t, sizeof md, max));
}
struct b_hash_function_ops z__b_sha3_224_ops = {
struct fx_hash_function_ops z__fx_sha3_224_ops = {
.hash_init = sha3_224_init,
.hash_update = sha3_update,
.hash_finish = sha3_224_finish,
};
struct b_hash_function_ops z__b_sha3_256_ops = {
struct fx_hash_function_ops z__fx_sha3_256_ops = {
.hash_init = sha3_256_init,
.hash_update = sha3_update,
.hash_finish = sha3_256_finish,
};
struct b_hash_function_ops z__b_sha3_384_ops = {
struct fx_hash_function_ops z__fx_sha3_384_ops = {
.hash_init = sha3_384_init,
.hash_update = sha3_update,
.hash_finish = sha3_384_finish,
};
struct b_hash_function_ops z__b_sha3_512_ops = {
struct fx_hash_function_ops z__fx_sha3_512_ops = {
.hash_init = sha3_512_init,
.hash_update = sha3_update,
.hash_finish = sha3_512_finish,
};
struct b_hash_function_ops z__b_shake128_ops = {
struct fx_hash_function_ops z__fx_shake128_ops = {
.hash_init = shake128_init,
.hash_update = sha3_update,
.hash_finish = shake128_finish,
};
struct b_hash_function_ops z__b_shake256_ops = {
struct fx_hash_function_ops z__fx_shake256_ops = {
.hash_init = shake256_init,
.hash_update = sha3_update,
.hash_finish = shake256_finish,

71
core/include/blue/core/bstr.h
View File

@@ -1,71 +0,0 @@
#ifndef BLUE_CORE_BSTR_H_
#define BLUE_CORE_BSTR_H_
#include <blue/core/misc.h>
#include <blue/core/status.h>
#include <stdarg.h>
#include <stddef.h>
#define B_BSTR_MAGIC 0x5005500550055005ULL
struct b_rope;
enum b_bstr_flags {
B_BSTR_F_NONE = 0x00u,
B_BSTR_F_ALLOC = 0x01u,
};
typedef struct b_bstr {
uint64_t bstr_magic;
enum b_bstr_flags bstr_flags;
char *bstr_buf;
/* total number of characters in bstr_buf, not including null terminator */
size_t bstr_len;
/* number of bytes allocated for bstr_buf (includes space for the null
* terminator) */
size_t bstr_capacity;
int *bstr_istack;
int bstr_add_indent;
size_t bstr_istack_ptr, bstr_istack_size;
} b_bstr;
BLUE_API void b_bstr_begin(b_bstr *strv, char *buf, size_t max);
BLUE_API void b_bstr_begin_dynamic(b_bstr *strv);
BLUE_API char *b_bstr_end(b_bstr *strv);
BLUE_API b_status b_bstr_reserve(b_bstr *strv, size_t len);
static inline size_t b_bstr_get_size(const b_bstr *str)
{
return str->bstr_len;
}
static inline size_t b_bstr_get_capacity(const b_bstr *str)
{
return str->bstr_capacity;
}
BLUE_API b_status b_bstr_push_indent(b_bstr *strv, int indent);
BLUE_API b_status b_bstr_pop_indent(b_bstr *strv);
BLUE_API b_status b_bstr_write_char(b_bstr *strv, char c);
BLUE_API b_status b_bstr_write_chars(
b_bstr *strv, const char *cs, size_t len, size_t *nr_written);
BLUE_API b_status b_bstr_write_cstr(
b_bstr *strv, const char *str, size_t *nr_written);
BLUE_API b_status b_bstr_write_cstr_list(
b_bstr *strv, const char **strs, size_t *nr_written);
BLUE_API b_status b_bstr_write_cstr_array(
b_bstr *strv, const char **strs, size_t count, size_t *nr_written);
BLUE_API b_status b_bstr_write_cstr_varg(b_bstr *strv, size_t *nr_written, ...);
BLUE_API b_status b_bstr_write_rope(
b_bstr *strv, const struct b_rope *rope, size_t *nr_written);
BLUE_API b_status b_bstr_write_fmt(
b_bstr *strv, size_t *nr_written, const char *format, ...);
BLUE_API b_status b_bstr_write_vfmt(
b_bstr *strv, size_t *nr_written, const char *format, va_list arg);
BLUE_API char *b_bstr_rope(const struct b_rope *rope, size_t *nr_written);
BLUE_API char *b_bstr_fmt(size_t *nr_written, const char *format, ...);
BLUE_API char *b_bstr_vfmt(size_t *nr_written, const char *format, va_list arg);
#endif

359
core/include/blue/core/btree.h
View File

@@ -1,359 +0,0 @@
#ifndef BLUELIB_CORE_BTREE_H_
#define BLUELIB_CORE_BTREE_H_
#include <blue/core/iterator.h>
#include <blue/core/macros.h>
#include <blue/core/misc.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
B_DECLS_BEGIN;
#define B_BTREE_INIT {0}
#define B_TYPE_BTREE_ITERATOR (b_btree_iterator_get_type())
B_DECLARE_TYPE(b_btree_iterator);
B_TYPE_CLASS_DECLARATION_BEGIN(b_btree_iterator)
B_TYPE_CLASS_DECLARATION_END(b_btree_iterator)
/* defines a simple node insertion function.
this function assumes that your nodes have simple integer keys that can be
compared with the usual operators.
EXAMPLE:
if you have a tree node type like this:
struct my_tree_node {
int key;
b_btree_node base;
}
You would use the following call to generate an insert function for a tree
with this node type:
BTREE_DEFINE_SIMPLE_INSERT(
struct my_tree_node,
base,
key,
my_tree_node_insert);
Which would emit a function defined like:
static void my_tree_node_insert(b_btree *tree, struct my_tree_node *node);
@param node_type your custom tree node type. usually a structure that
contains a b_btree_node member.
@param container_node_member the name of the b_btree_node member variable
within your custom type.
@param container_key_member the name of the key member variable within your
custom type.
@param function_name the name of the function to generate.
*/
#define B_BTREE_DEFINE_SIMPLE_INSERT( \
node_type, container_node_member, container_key_member, function_name) \
void function_name(b_btree *tree, node_type *node) \
{ \
if (!tree->b_root) { \
tree->b_root = &node->container_node_member; \
b_btree_insert_fixup(tree, &node->container_node_member); \
return; \
} \
\
b_btree_node *cur = tree->b_root; \
while (1) { \
node_type *cur_node = b_unbox( \
node_type, cur, container_node_member); \
b_btree_node *next = NULL; \
\
if (node->container_key_member \
>= cur_node->container_key_member) { \
next = b_btree_right(cur); \
\
if (!next) { \
b_btree_put_right( \
cur, \
&node->container_node_member); \
break; \
} \
} else if ( \
node->container_key_member \
< cur_node->container_key_member) { \
next = b_btree_left(cur); \
\
if (!next) { \
b_btree_put_left( \
cur, \
&node->container_node_member); \
break; \
} \
} \
\
cur = next; \
} \
\
b_btree_insert_fixup(tree, &node->container_node_member); \
}
/* defines a node insertion function.
this function should be used for trees with complex node keys that cannot be
directly compared. a comparator for your keys must be supplied.
EXAMPLE:
if you have a tree node type like this:
struct my_tree_node {
complex_key_t key;
b_btree_node base;
}
You would need to define a comparator function or macro with the following
signature:
int my_comparator(struct my_tree_node *a, struct my_tree_node *b);
Which implements the following:
return -1 if a < b
return 0 if a == b
return 1 if a > b
You would use the following call to generate an insert function for a tree
with this node type:
BTREE_DEFINE_INSERT(struct my_tree_node, base, key, my_tree_node_insert,
my_comparator);
Which would emit a function defined like:
static void my_tree_node_insert(b_btree *tree, struct my_tree_node *node);
@param node_type your custom tree node type. usually a structure that
contains a b_btree_node member.
@param container_node_member the name of the b_btree_node member variable
within your custom type.
@param container_key_member the name of the key member variable within your
custom type.
@param function_name the name of the function to generate.
@param comparator the name of a comparator function or functional-macro that
conforms to the requirements listed above.
*/
#define B_BTREE_DEFINE_INSERT( \
node_type, container_node_member, container_key_member, function_name, \
comparator) \
void function_name(b_btree *tree, node_type *node) \
{ \
if (!tree->b_root) { \
tree->b_root = &node->container_node_member; \
b_btree_insert_fixup(tree, &node->container_node_member); \
return; \
} \
\
b_btree_node *cur = tree->b_root; \
while (1) { \
node_type *cur_node = b_unbox( \
node_type, cur, container_node_member); \
b_btree_node *next = NULL; \
int cmp = comparator(node, cur_node); \
\
if (cmp >= 0) { \
next = b_btree_right(cur); \
\
if (!next) { \
b_btree_put_right( \
cur, \
&node->container_node_member); \
break; \
} \
} else if (cmp < 0) { \
next = b_btree_left(cur); \
\
if (!next) { \
b_btree_put_left( \
cur, \
&node->container_node_member); \
break; \
} \
} else { \
return; \
} \
\
cur = next; \
} \
\
b_btree_insert_fixup(tree, &node->container_node_member); \
}
/* defines a simple tree search function.
this function assumes that your nodes have simple integer keys that can be
compared with the usual operators.
EXAMPLE:
if you have a tree node type like this:
struct my_tree_node {
int key;
b_btree_node base;
}
You would use the following call to generate a search function for a tree
with this node type:
BTREE_DEFINE_SIMPLE_GET(struct my_tree_node, int, base, key,
my_tree_node_get);
Which would emit a function defined like:
static struct my_tree_node *my_tree_node_get(b_btree *tree, int key);
@param node_type your custom tree node type. usually a structure that
contains a b_btree_node member.
@param key_type the type name of the key embedded in your custom tree node
type. this type must be compatible with the builtin comparison operators.
@param container_node_member the name of the b_btree_node member variable
within your custom type.
@param container_key_member the name of the key member variable within your
custom type.
@param function_name the name of the function to generate.
*/
#define B_BTREE_DEFINE_SIMPLE_GET( \
node_type, key_type, container_node_member, container_key_member, \
function_name) \
node_type *function_name(const b_btree *tree, key_type key) \
{ \
b_btree_node *cur = tree->b_root; \
while (cur) { \
node_type *cur_node = b_unbox( \
node_type, cur, container_node_member); \
if (key > cur_node->container_key_member) { \
cur = b_btree_right(cur); \
} else if (key < cur_node->container_key_member) { \
cur = b_btree_left(cur); \
} else { \
return cur_node; \
} \
} \
\
return NULL; \
}
#define b_btree_foreach(it, btree) \
for (int z__b_unique_name() = b_btree_iterator_begin(btree, it); \
(it)->node != NULL; b_btree_iterator_next(it))
/* binary tree nodes. this *cannot* be used directly. you need to define a
custom node type that contains a member variable of type b_btree_node.
you would then use the supplied macros to define functions to manipulate your
custom binary tree.
*/
typedef struct b_btree_node {
struct b_btree_node *b_parent, *b_left, *b_right;
unsigned short b_height;
} b_btree_node;
/* binary tree. unlike b_btree_node, you can define variables of type b_btree.
*/
typedef struct b_btree {
b_btree_node *b_root;
} b_btree;
BLUE_API b_type b_btree_iterator_get_type(void);
/* re-balance a binary tree after an insertion operation.
NOTE that, if you define an insertion function using BTREE_DEFINE_INSERT or
similar, this function will automatically called for you.
@param tree the tree to re-balance.
@param node the node that was just inserted into the tree.
*/
BLUE_API void b_btree_insert_fixup(b_btree *tree, b_btree_node *node);
/* delete a node from a binary tree and re-balance the tree afterwards.
@param tree the tree to delete from
@param node the node to delete.
*/
BLUE_API void b_btree_delete(b_btree *tree, b_btree_node *node);
/* get the first node in a binary tree.
this will be the node with the smallest key (i.e. the node that is
furthest-left from the root)
*/
BLUE_API b_btree_node *b_btree_first(const b_btree *tree);
/* get the last node in a binary tree.
this will be the node with the largest key (i.e. the node that is
furthest-right from the root)
*/
BLUE_API b_btree_node *b_btree_last(const b_btree *tree);
/* for any binary tree node, this function returns the node with the
* next-largest key value */
BLUE_API b_btree_node *b_btree_next(const b_btree_node *node);
/* for any binary tree node, this function returns the node with the
* next-smallest key value */
BLUE_API b_btree_node *b_btree_prev(const b_btree_node *node);
/* return true if the btree is empty, false otherwise */
static inline bool b_btree_empty(const b_btree *tree)
{
return tree->b_root == NULL;
}
/* sets `child` as the immediate left-child of `parent` */
static inline void b_btree_put_left(b_btree_node *parent, b_btree_node *child)
{
parent->b_left = child;
child->b_parent = parent;
}
/* sets `child` as the immediate right-child of `parent` */
static inline void b_btree_put_right(b_btree_node *parent, b_btree_node *child)
{
parent->b_right = child;
child->b_parent = parent;
}
/* get the immediate left-child of `node` */
static inline b_btree_node *b_btree_left(b_btree_node *node)
{
return node->b_left;
}
/* get the immediate right-child of `node` */
static inline b_btree_node *b_btree_right(b_btree_node *node)
{
return node->b_right;
}
/* get the immediate parent of `node` */
static inline b_btree_node *b_btree_parent(b_btree_node *node)
{
return node->b_parent;
}
BLUE_API void b_btree_move(b_btree *tree, b_btree_node *dest, b_btree_node *src);
/* get the height of `node`.
the height of a node is defined as the length of the longest path
between the node and a leaf node.
this count includes the node itself, so the height of a leaf node will be 1.
*/
static inline unsigned short b_btree_height(b_btree_node *node)
{
return node->b_height;
}
BLUE_API b_iterator *b_btree_begin(b_btree *tree);
BLUE_API const b_iterator *b_btree_cbegin(const b_btree *tree);
#ifdef __cplusplus
}
#endif
#endif

15
core/include/blue/core/class.h
View File

@@ -1,15 +0,0 @@
#ifndef BLUE_OBJECT_CLASS_H_
#define BLUE_OBJECT_CLASS_H_
#include <blue/core/type.h>
#define B_CLASS_MAGIC 0xDEADFACEDCAFEBEDULL
#define B_CLASS(p) ((b_class *)(p))
typedef struct _b_class b_class;
BLUE_API void *b_class_get(b_type id);
BLUE_API const char *b_class_get_name(const b_class *c);
BLUE_API void *b_class_get_interface(const b_class *c, b_type id);
#endif

41
core/include/blue/core/encoding.h
View File

@@ -1,41 +0,0 @@
#ifndef BLUE_CORE_ENCODING_H_
#define BLUE_CORE_ENCODING_H_
#include <blue/core/misc.h>
#include <stdbool.h>
#include <stdint.h>
#define B_WCHAR_INVALID ((b_wchar) - 1)
typedef int32_t b_wchar;
BLUE_API bool b_wchar_is_alpha(b_wchar c);
BLUE_API bool b_wchar_is_number(b_wchar c);
static inline bool b_wchar_is_bin_digit(b_wchar c)
{
return c >= '0' && c <= '1';
}
static inline bool b_wchar_is_oct_digit(b_wchar c)
{
return c >= '0' && c <= '7';
}
BLUE_API bool b_wchar_is_hex_digit(b_wchar c);
BLUE_API bool b_wchar_is_space(b_wchar c);
static inline bool b_wchar_is_alnum(b_wchar c)
{
return b_wchar_is_alpha(c) || b_wchar_is_number(c);
}
BLUE_API bool b_wchar_is_punct(b_wchar c);
BLUE_API bool b_wchar_utf8_is_valid_scalar(b_wchar c);
BLUE_API unsigned int b_wchar_utf8_header_decode(char c);
BLUE_API unsigned int b_wchar_utf8_codepoint_size(b_wchar c);
BLUE_API b_wchar b_wchar_utf8_codepoint_decode(const char *s);
BLUE_API unsigned int b_wchar_utf8_codepoint_encode(b_wchar c, char s[4]);
BLUE_API unsigned int b_wchar_utf8_codepoint_stride(const char *s);
BLUE_API size_t b_wchar_utf8_codepoint_count(const char *s, size_t nr_bytes);
BLUE_API size_t b_wchar_utf8_string_encoded_size(
const b_wchar *s, size_t nr_codepoints);
#endif

49
core/include/blue/core/endian.h
View File

@@ -1,49 +0,0 @@
#ifndef BLUELIB_CORE_ENDIAN_H_
#define BLUELIB_CORE_ENDIAN_H_
#include <blue/core/misc.h>
#include <stdint.h>
typedef struct {
union {
unsigned char i_bytes[sizeof(uint16_t)];
int16_t i_val;
uint16_t i_uval;
};
} b_i16;
typedef struct {
union {
unsigned char i_bytes[sizeof(uint32_t)];
int32_t i_val;
uint32_t i_uval;
};
} b_i32;
typedef struct {
union {
unsigned char i_bytes[sizeof(uint64_t)];
int64_t i_val;
uint64_t i_uval;
};
} b_i64;
BLUE_API b_i16 b_i16_htob(uint16_t v);
BLUE_API b_i16 b_i16_htos(uint16_t v);
BLUE_API uint16_t b_i16_btoh(b_i16 v);
BLUE_API uint16_t b_i16_stoh(b_i16 v);
BLUE_API b_i32 b_i32_htob(uint32_t v);
BLUE_API b_i32 b_i32_htos(uint32_t v);
BLUE_API uint32_t b_i32_btoh(b_i32 v);
BLUE_API uint32_t b_i32_stoh(b_i32 v);
BLUE_API b_i64 b_i64_htob(uint64_t v);
BLUE_API b_i64 b_i64_htos(uint64_t v);
BLUE_API uint64_t b_i64_btoh(b_i64 v);
BLUE_API uint64_t b_i64_stoh(b_i64 v);
#endif

418
core/include/blue/core/error.h
View File

@@ -1,418 +0,0 @@
#ifndef BLUE_CORE_ERROR_H_
#define BLUE_CORE_ERROR_H_
#include <blue/core/misc.h>
#include <blue/core/status.h>
#include <stdarg.h>
#include <stdbool.h>
#define B_ERROR_TEMPLATE_PARAMETER_MAX 4
#define B_ERROR_MSG_ID_INVALID ((unsigned long)-1)
#define B_CATCH(err, expr) ((err = (expr)) != NULL)
#define b_result_is_error(result) ((result) != NULL)
#define b_result_is_success(result) ((result) == NULL)
#define B_RESULT_SUCCESS ((b_result)NULL)
#define B_RESULT_ERR(err_name) \
b_error_with_code(b_error_vendor_get_builtin(), B_ERR_##err_name)
#define B_RESULT_ERR_WITH_STRING(err_name, ...) \
b_error_with_string( \
b_error_vendor_get_builtin(), B_ERR_##err_name, __VA_ARGS__)
#define B_RESULT_STATUS(code) \
((code) == B_SUCCESS \
? B_RESULT_SUCCESS \
: (b_error_with_code(b_error_vendor_get_builtin(), code)))
#define B_RESULT_STATUS_WITH_STRING(code, ...) \
((code) == B_SUCCESS \
? B_RESULT_SUCCESS \
: (b_error_with_string( \
b_error_vendor_get_builtin(), code, __VA_ARGS__)))
#define B_ERRORS_BUILTIN (b_error_vendor_get_builtin())
#define B_ERRORS_ERRNO (b_error_vendor_get_errno())
#define B_ERROR_PARAM(name, value) \
(b_error_template_parameter) \
{ \
.param_name = (name), .param_value = (uintptr_t)(value), \
}
#define B_ERROR_TEMPLATE_PARAM(name, type, format) \
(b_error_template_parameter_definition) \
{ \
.param_name = (name), .param_type = (type), \
.param_format = (format), \
}
#define B_ERROR_DEFINITION(code, name, msg) \
[code] = (b_error_definition) \
{ \
.err_name = (name), .err_message = (msg), \
}
#define B_ERROR_DEFINITION_TEMPLATE(code, name, msg, ...) \
[code] = (b_error_definition) \
{ \
.err_name = (name), .err_message = (msg), \
.err_params = __VA_ARGS__, \
}
#define B_ERROR_MSG(id, content) \
[id] = (b_error_msg) \
{ \
.msg_message = (content), \
}
#define B_ERROR_MSG_TEMPLATE(id, content, ...) \
[id] = (b_error_msg) \
{ \
.msg_message = (content), .msg_params = __VA_ARGS__, \
}
#define z__b_error_create_status(status_code) \
(z__b_error_create( \
b_error_vendor_get_builtin(), status_code, NULL, NULL, 0, \
NULL, NULL))
/* Error creation macros */
#define b_error_with_code(vendor, code) \
(z__b_error_create( \
vendor, code, NULL, __FILE__, __LINE__, __FUNCTION__, NULL))
#define b_error_caused_by_error(vendor, code, cause_error) \
(z__b_error_create( \
vendor, code, cause_error, __FILE__, __LINE__, __FUNCTION__, NULL))
#define b_error_caused_by_status(vendor, code, cause_status) \
(z__b_error_create( \
vendor, code, z__b_error_create_status(cause_status), \
__FILE__, __LINE__, __FUNCTION__, NULL))
#define b_error_caused_by_code(vendor, code, cause_vendor, cause_code) \
(z__b_error_create( \
vendor, code, b_error_with_code(cause_vendor, cause_code), \
__FILE__, __LINE__, __FUNCTION__, NULL))
#define b_error_with_string(vendor, code, ...) \
(z__b_error_create( \
vendor, code, NULL, __FILE__, __LINE__, __FUNCTION__, __VA_ARGS__))
#define b_error_with_string_caused_by_error(vendor, code, cause_error, ...) \
(z__b_error_create( \
vendor, code, cause_error, __FILE__, __LINE__, __FUNCTION__, \
__VA_ARGS__))
#define b_error_with_string_caused_by_status(vendor, code, cause_status, ...) \
(z__b_error_create( \
vendor, code, z__b_error_create_status(cause_status), \
__FILE__, __LINE__, __FUNCTION__, __VA_ARGS__))
#define b_error_with_msg(vendor, code, msg_id) \
(z__b_error_create_msg( \
vendor, code, NULL, __FILE__, __LINE__, __FUNCTION__, msg_id, \
(b_error_template_parameter[]) {{}}))
#define b_error_with_msg_caused_by_error(vendor, code, cause_error, msg_id) \
(z__b_error_create_msg( \
vendor, code, cause_error, __FILE__, __LINE__, __FUNCTION__, \
msg_id, (b_error_template_parameter[]) {{}}))
#define b_error_with_msg_caused_by_status(vendor, code, cause_status, msg_id) \
(z__b_error_create_msg( \
vendor, code, z__b_error_create_status(cause_status), \
__FILE__, __LINE__, __FUNCTION__, msg_id, \
(b_error_template_parameter[]) {{}}))
#define b_error_with_msg_template(vendor, code, msg_id, ...) \
(z__b_error_create_msg( \
vendor, code, NULL, __FILE__, __LINE__, __FUNCTION__, msg_id, \
(b_error_template_parameter[]) {__VA_ARGS__, {}}))
#define b_error_with_msg_template_caused_by_error( \
vendor, code, cause_error, msg_id, ...) \
(z__b_error_create_msg( \
vendor, code, cause_error, __FILE__, __LINE__, __FUNCTION__, \
msg_id, (b_error_template_parameter[]) {__VA_ARGS__, {}}))
#define b_error_with_msg_template_caused_by_status( \
vendor, code, cause_status, msg_id, ...) \
(z__b_error_create_msg( \
vendor, code, z__b_error_create_status(cause_status), \
__FILE__, __LINE__, __FUNCTION__, msg_id, \
(b_error_template_parameter[]) {__VA_ARGS__, {}}))
#define b_error_with_template(vendor, code, ...) \
(z__b_error_create_template( \
vendor, code, NULL, __FILE__, __LINE__, __FUNCTION__, \
(b_error_template_parameter[]) {__VA_ARGS__, {}}))
#define b_error_with_template_caused_by_error(vendor, code, cause_error, ...) \
(z__b_error_create_template( \
vendor, code, cause_error, __FILE__, __LINE__, __FUNCTION__, \
(b_error_template_parameter[]) {__VA_ARGS__, {}}))
#define b_error_with_template_caused_by_status(vendor, code, cause_status, ...) \
(z__b_error_create_template( \
vendor, code, z__b_error_create_status(cause_status), \
__FILE__, __LINE__, __FUNCTION__, \
(b_error_template_parameter[]) {__VA_ARGS__, {}}))
/* Error propagation macros */
#define b_result_propagate(err) \
(z__b_error_propagate(err, __FILE__, __LINE__, __FUNCTION__))
#define b_error_caused_by(err, caused_by) (z__b_error_caused_by(err, caused_by))
#define b_error_caused_by_b_status(err, status) \
(z__b_error_caused_by_b_status(err, status))
#define b_error_replace(err, caused_by) \
(z__b_error_propagate(err, __FILE__, __LINE__, __FUNCTION__))
/* Error throw macros */
#define z__b_throw(err) (z__b_error_throw(err, NULL, 0, NULL))
#define b_throw(err) (z__b_error_throw(err, __FILE__, __LINE__, __FUNCTION__))
#define b_throw_status(status) \
(z__b_error_throw( \
z__b_error_create( \
b_error_vendor_get_builtin(), status, NULL, NULL, 0, \
NULL, NULL), \
__FILE__, __LINE__, __FUNCTION__))
#define b_throw_status_string(status, ...) \
(z__b_error_throw( \
z__b_error_create( \
b_error_vendor_get_builtin(), status, NULL, NULL, 0, \
NULL, __VA_ARGS__), \
__FILE__, __LINE__, __FUNCTION__))
#define b_throw_error_code(vendor, code) \
z__b_throw(b_error_with_code(vendor, code))
#define b_throw_error_caused_by_error(vendor, code, cause) \
z__b_throw(b_error_caused_by_error(vendor, code, cause))
#define b_throw_error_caused_by_status(vendor, code, cause) \
z__b_throw(b_error_caused_by_status(vendor, code, cause))
#define b_throw_error_with_string(vendor, code, ...) \
z__b_throw(b_error_with_string(vendor, code, __VA_ARGS__))
#define b_throw_error_with_string_caused_by_error(vendor, code, cause, ...) \
z__b_throw(b_error_with_string_caused_by_error( \
vendor, code, cause, __VA_ARGS__))
#define b_throw_error_with_string_caused_by_status(vendor, code, cause, ...) \
z__b_throw(b_error_with_string_caused_by_status( \
vendor, code, cause, __VA_ARGS__))
#define b_throw_error_with_msg(vendor, code, msg_id) \
z__b_throw(b_error_with_msg(vendor, code, msg_id))
#define b_throw_error_with_msg_caused_by_error(vendor, code, cause, msg_id) \
z__b_throw(b_error_with_msg_caused_by_error(vendor, code, cause, msg_id))
#define b_throw_error_with_msg_caused_by_status(vendor, code, cause, msg_id) \
z__b_throw(b_error_with_msg_caused_by_status(vendor, code, cause, msg_id))
#define b_throw_error_with_msg_template(vendor, code, msg_id, ...) \
z__b_throw(b_error_with_msg_template(vendor, code, msg_id, __VA_ARGS__))
#define b_throw_error_with_msg_template_caused_by_error( \
vendor, code, cause, msg_id, ...) \
z__b_throw(b_error_with_msg_template_caused_by_error( \
vendor, code, cause, msg_id, __VA_ARGS__))
#define b_throw_error_with_msg_template_caused_by_status( \
vendor, code, cause, msg_id, ...) \
z__b_throw(b_error_with_msg_template_caused_by_status( \
vendor, code, cause, msg_id, __VA_ARGS__))
#define b_throw_error_with_template(vendor, code, ...) \
z__b_throw(b_error_with_template(vendor, code, __VA_ARGS__))
#define b_throw_error_with_template_caused_by_error(vendor, code, cause, ...) \
z__b_throw(b_error_with_template_caused_by_error( \
vendor, code, cause, __VA_ARGS__))
#define b_throw_error_with_template_caused_by_status(vendor, code, cause, ...) \
z__b_throw(b_error_with_template_caused_by_status( \
vendor, code, cause, __VA_ARGS__))
#define B_ERR_MSG(s) \
{ \
.msg_type = B_ERROR_MESSAGE_ERROR, \
.msg_content = (s), \
}
#define B_ERR_MSG_WARN(s) \
{ \
.msg_type = B_ERROR_MESSAGE_WARN, \
.msg_content = (s), \
}
#define B_ERR_MSG_INFO(s) \
{ \
.msg_type = B_ERROR_MESSAGE_INFO, \
.msg_content = (s), \
}
#define B_ERR_MSG_END(s) \
{ \
.msg_type = B_ERROR_MESSAGE_NONE, \
.msg_content = NULL, \
}
typedef enum b_error_submsg_type {
B_ERROR_SUBMSG_NONE = 0,
B_ERROR_SUBMSG_ERROR,
B_ERROR_SUBMSG_WARNING,
B_ERROR_SUBMSG_INFO,
} b_error_submsg_type;
typedef enum b_error_report_flags {
B_ERROR_REPORT_NONE = 0,
B_ERROR_REPORT_STATUS = 0x01u,
B_ERROR_REPORT_DESCRIPTION = 0x02u,
B_ERROR_REPORT_SUBMSG = 0x04u,
B_ERROR_REPORT_STACK_TRACE = 0x08u,
B_ERROR_REPORT_CAUSE = 0x10u,
B_ERROR_REPORT_MINIMAL = B_ERROR_REPORT_STATUS | B_ERROR_REPORT_DESCRIPTION,
B_ERROR_REPORT_DEFAULT = B_ERROR_REPORT_MINIMAL | B_ERROR_REPORT_SUBMSG
| B_ERROR_REPORT_CAUSE,
B_ERROR_REPORT_ALL = B_ERROR_REPORT_DEFAULT | B_ERROR_REPORT_STACK_TRACE,
} b_error_report_flags;
typedef enum b_error_template_parameter_type {
B_ERROR_TEMPLATE_PARAM_NONE = 0,
B_ERROR_TEMPLATE_PARAM_STRING,
B_ERROR_TEMPLATE_PARAM_CHAR,
B_ERROR_TEMPLATE_PARAM_INT,
B_ERROR_TEMPLATE_PARAM_UINT,
B_ERROR_TEMPLATE_PARAM_LONG,
B_ERROR_TEMPLATE_PARAM_ULONG,
B_ERROR_TEMPLATE_PARAM_LONGLONG,
B_ERROR_TEMPLATE_PARAM_ULONGLONG,
B_ERROR_TEMPLATE_PARAM_SIZE_T,
B_ERROR_TEMPLATE_PARAM_INTPTR,
B_ERROR_TEMPLATE_PARAM_UINTPTR,
B_ERROR_TEMPLATE_PARAM_PTR,
} b_error_template_parameter_type;
typedef struct b_error_template_parameter_definition {
const char *param_name;
b_error_template_parameter_type param_type;
const char *param_format;
} b_error_template_parameter_definition;
typedef struct b_error_template_parameter {
const char *param_name;
uintptr_t param_value;
const struct b_error_template_parameter_definition *__param_def;
} b_error_template_parameter;
struct b_error_vendor;
typedef struct b_error b_error;
typedef struct b_error *b_result;
typedef struct b_error_submsg b_error_submsg;
typedef struct b_error_stack_frame b_error_stack_frame;
typedef long b_error_status_code;
typedef unsigned long b_error_msg_id;
typedef struct b_error_definition {
const char *err_name;
const char *err_message;
const b_error_template_parameter_definition err_params[B_ERROR_TEMPLATE_PARAMETER_MAX];
} b_error_definition;
typedef struct b_error_msg {
const char *msg_message;
const b_error_template_parameter_definition msg_params[B_ERROR_TEMPLATE_PARAMETER_MAX];
} b_error_msg;
typedef const b_error_definition *(*b_error_status_code_get_definition)(
const struct b_error_vendor *, b_error_status_code);
typedef const b_error_msg *(*b_error_msg_get_definition)(
const struct b_error_vendor *, b_error_msg_id);
typedef void (*b_error_report_function)(
const struct b_error *, b_error_report_flags);
typedef struct b_error_vendor {
const char *v_name;
b_error_status_code_get_definition v_status_get_definition;
b_error_msg_get_definition v_msg_get_definition;
const b_error_definition *v_error_definitions;
size_t v_error_definitions_length;
const b_error_msg *v_msg;
size_t v_msg_length;
} b_error_vendor;
BLUE_API b_error *z__b_error_create_template(
const b_error_vendor *, b_error_status_code, b_error *, const char *,
unsigned int, const char *, const b_error_template_parameter[]);
BLUE_API b_error *z__b_error_create_string(
const b_error_vendor *, b_error_status_code, b_error *, const char *,
unsigned int, const char *, const char *, va_list);
BLUE_API b_error *z__b_error_create_msg(
const b_error_vendor *, b_error_status_code, b_error *, const char *,
unsigned int, const char *, b_error_msg_id,
const b_error_template_parameter[]);
BLUE_API b_error *z__b_error_propagate(
b_error *, const char *, unsigned int, const char *);
BLUE_API b_error *z__b_error_caused_by(b_error *, b_error *);
BLUE_API b_error *z__b_error_caused_by_b_status(b_error *, b_status);
BLUE_API void z__b_error_throw(b_error *, const char *, unsigned int, const char *);
BLUE_API bool b_result_is(
b_result result, const b_error_vendor *vendor, b_error_status_code code);
BLUE_API const b_error_vendor *b_error_vendor_get_builtin(void);
BLUE_API const b_error_vendor *b_error_vendor_get_errno(void);
BLUE_API const b_error_definition *b_error_vendor_get_error_definition(
const b_error_vendor *vendor, b_error_status_code code);
BLUE_API const char *b_error_vendor_get_status_code_name(
const b_error_vendor *vendor, b_error_status_code code);
BLUE_API const char *b_error_vendor_get_status_code_description(
const b_error_vendor *vendor, b_error_status_code code);
BLUE_API const b_error_msg *b_error_vendor_get_msg(
const b_error_vendor *vendor, b_error_msg_id msg_id);
static inline b_error *z__b_error_create(
const b_error_vendor *v, b_error_status_code c, b_error *c2,
const char *f0, unsigned int l, const char *f1, const char *d, ...)
{
va_list arg;
va_start(arg, d);
b_error *err = z__b_error_create_string(v, c, c2, f0, l, f1, d, arg);
va_end(arg);
return err;
}
BLUE_API enum b_status b_error_add_submsg_string(
b_error *error, b_error_submsg_type type, const char *msg, ...);
BLUE_API enum b_status z__b_error_add_submsg_template(
b_error *error, b_error_submsg_type type, b_error_msg_id msg_id,
b_error_template_parameter param[]);
#define b_error_add_submsg(error, type, msg_id) \
(z__b_error_add_submsg_template( \
error, type, msg_id, (b_error_template_parameter[]) {{}}))
#define b_error_add_submsg_template(error, type, msg_id, ...) \
(z__b_error_add_submsg_template( \
error, type, msg_id, \
(b_error_template_parameter[]) {__VA_ARGS__, {}}))
BLUE_API void b_error_discard(b_error *error);
BLUE_API b_error_status_code b_error_get_status_code(const b_error *error);
BLUE_API const b_error_vendor *b_error_get_vendor(const b_error *error);
BLUE_API const b_error_definition *b_error_get_definition(const b_error *error);
BLUE_API const b_error_template_parameter *b_error_get_template_parameter(
const b_error *error, const char *param_name);
BLUE_API const b_error_template_parameter *b_error_get_template_parameters(
const b_error *error);
BLUE_API const char *b_error_get_description(const b_error *error);
BLUE_API const b_error_msg *b_error_get_msg(const b_error *error);
BLUE_API const b_error_submsg *b_error_get_first_submsg(const b_error *error);
BLUE_API const b_error_submsg *b_error_get_next_submsg(
const b_error *error, const b_error_submsg *msg);
BLUE_API const b_error_stack_frame *b_error_get_first_stack_frame(
const b_error *error);
BLUE_API const b_error_stack_frame *b_error_get_next_stack_frame(
const b_error *error, const b_error_stack_frame *frame);
BLUE_API const b_error *b_error_get_caused_by(const b_error *error);
BLUE_API b_error_submsg_type b_error_submsg_get_type(const b_error_submsg *msg);
BLUE_API const char *b_error_submsg_get_content(const b_error_submsg *msg);
BLUE_API const b_error_msg *b_error_submsg_get_msg(const b_error_submsg *msg);
BLUE_API const b_error_template_parameter *b_error_submsg_get_template_parameters(
const b_error_submsg *msg);
BLUE_API const char *b_error_stack_frame_get_filepath(
const b_error_stack_frame *frame);
BLUE_API unsigned int b_error_stack_frame_get_line_number(
const b_error_stack_frame *frame);
BLUE_API const char *b_error_stack_frame_get_function_name(
const b_error_stack_frame *frame);
BLUE_API const b_error_template_parameter_definition *b_error_definition_get_template_parameter(
const b_error_definition *error_def, const char *param_name);
BLUE_API const char *b_error_msg_get_content(const b_error_msg *msg);
BLUE_API const b_error_template_parameter_definition *b_error_msg_get_template_parameter(
const b_error_msg *msg, const char *param_name);
BLUE_API void b_set_error_report_function(
b_error_report_function func, b_error_report_flags flags);
#endif

111
core/include/blue/core/hash.h
View File

@@ -1,111 +0,0 @@
#ifndef BLUELIB_CORE_HASH_H_
#define BLUELIB_CORE_HASH_H_
#include <blue/core/misc.h>
#include <blue/core/status.h>
#include <stddef.h>
#include <stdint.h>
#define B_DIGEST_LENGTH_128 16
#define B_DIGEST_LENGTH_160 20
#define B_DIGEST_LENGTH_192 24
#define B_DIGEST_LENGTH_224 28
#define B_DIGEST_LENGTH_256 32
#define B_DIGEST_LENGTH_384 48
#define B_DIGEST_LENGTH_512 64
#define B_DIGEST_LENGTH_MD4 B_DIGEST_LENGTH_128
#define B_DIGEST_LENGTH_MD5 B_DIGEST_LENGTH_128
#define B_DIGEST_LENGTH_SHA1 B_DIGEST_LENGTH_160
#define B_DIGEST_LENGTH_SHA2_224 B_DIGEST_LENGTH_224
#define B_DIGEST_LENGTH_SHA2_256 B_DIGEST_LENGTH_256
#define B_DIGEST_LENGTH_SHA2_384 B_DIGEST_LENGTH_384
#define B_DIGEST_LENGTH_SHA2_512 B_DIGEST_LENGTH_512
#define B_DIGEST_LENGTH_SHA3_224 B_DIGEST_LENGTH_224
#define B_DIGEST_LENGTH_SHA3_256 B_DIGEST_LENGTH_256
#define B_DIGEST_LENGTH_SHA3_384 B_DIGEST_LENGTH_384
#define B_DIGEST_LENGTH_SHA3_512 B_DIGEST_LENGTH_512
#define B_DIGEST_LENGTH_SHAKE128 B_DIGEST_LENGTH_128
#define B_DIGEST_LENGTH_SHAKE256 B_DIGEST_LENGTH_256
struct b_hash_function_ops;
struct b_rope;
typedef enum b_hash_function {
B_HASH_NONE = 0,
B_HASH_MD4,
B_HASH_MD5,
B_HASH_SHA1,
B_HASH_SHA2_224,
B_HASH_SHA2_256,
B_HASH_SHA2_384,
B_HASH_SHA2_512,
B_HASH_SHA3_224,
B_HASH_SHA3_256,
B_HASH_SHA3_384,
B_HASH_SHA3_512,
B_HASH_SHAKE128,
B_HASH_SHAKE256,
} b_hash_function;
typedef struct b_hash_ctx {
b_hash_function ctx_func;
const struct b_hash_function_ops *ctx_ops;
union {
struct {
uint32_t lo, hi;
uint32_t a, b, c, d;
uint32_t block[16];
unsigned char buffer[64];
} md4;
struct {
unsigned int count[2];
unsigned int a, b, c, d;
unsigned int block[16];
unsigned char input[64];
} md5;
struct {
uint32_t state[5];
uint32_t count[2];
unsigned char buffer[64];
} sha1;
struct {
uint64_t curlen;
uint64_t length;
unsigned char buf[128];
uint32_t state[8];
} sha2_256;
struct {
uint64_t curlen;
uint64_t length;
unsigned char block[256];
uint64_t state[8];
} sha2_512;
struct {
union {
uint8_t b[200];
uint64_t q[25];
} st;
int pt, rsiz, mdlen;
} sha3;
} ctx_state;
} b_hash_ctx;
BLUE_API uint64_t b_hash_cstr(const char *s);
BLUE_API uint64_t b_hash_cstr_ex(const char *s, size_t *len);
BLUE_API b_status b_hash_ctx_init(b_hash_ctx *ctx, b_hash_function func);
BLUE_API b_status b_hash_ctx_reset(b_hash_ctx *ctx);
BLUE_API b_status b_hash_ctx_update(b_hash_ctx *ctx, const void *p, size_t len);
BLUE_API b_status b_hash_ctx_update_rope(b_hash_ctx *ctx, const struct b_rope *rope);
BLUE_API b_status b_hash_ctx_finish(
b_hash_ctx *ctx, void *out_digest, size_t out_max);
#endif

93
core/include/blue/core/iterator.h
View File

@@ -1,93 +0,0 @@
#ifndef BLUE_CORE_ITERATOR_H_
#define BLUE_CORE_ITERATOR_H_
#include <blue/core/macros.h>
#include <blue/core/misc.h>
#include <blue/core/status.h>
#include <stdbool.h>
B_DECLS_BEGIN;
#define b_foreach(type, var, iterator) \
for (type var = (type)b_iterator_get_value(iterator).v_int; \
B_OK(b_iterator_get_status(iterator)); \
b_iterator_move_next(iterator), \
var = (type)b_iterator_get_value(iterator).v_int)
#define b_foreach_ptr(type, var, iterator) \
for (type *var = (type *)b_iterator_get_value(iterator).v_ptr; \
B_OK(b_iterator_get_status(iterator)); \
b_iterator_move_next(iterator), \
var = (type *)b_iterator_get_value(iterator).v_ptr)
#define b_foreach_c(type, var, iterator) \
for (type var = (type)b_iterator_get_cvalue(iterator).v_int; \
B_OK(b_iterator_get_status(iterator)); \
b_iterator_move_next(iterator), \
var = (type)b_iterator_get_cvalue(iterator).v_int)
#define b_foreach_cptr(type, var, iterator) \
for (const type *var \
= (const type *)b_iterator_get_cvalue(iterator).v_cptr; \
B_OK(b_iterator_get_status(iterator)); \
b_iterator_move_next(iterator), \
var = (const type *)b_iterator_get_cvalue(iterator).v_cptr)
#define B_ITERATOR_VALUE_INT(v) ((b_iterator_value) {.v_int = (v)})
#define B_ITERATOR_VALUE_PTR(v) ((b_iterator_value) {.v_ptr = (v)})
#define B_ITERATOR_VALUE_CPTR(v) ((const b_iterator_value) {.v_cptr = (v)})
#define B_ITERATOR_VALUE_NULL ((b_iterator_value) {})
#define B_ITERATOR_VALUE_IS_NULL(v) ((v)->v_ptr == NULL)
#define B_TYPE_ITERATOR (b_iterator_get_type())
#define B_TYPE_ITERABLE (b_iterable_get_type())
typedef union b_iterator_value {
uintptr_t v_int;
void *v_ptr;
const void *v_cptr;
} b_iterator_value;
__B_DECLARE_TYPE(b_iterator);
B_DECLARE_TYPE(b_iterable);
B_TYPE_CLASS_DECLARATION_BEGIN(b_iterator)
b_status (*it_move_next)(const b_iterator *);
b_status (*it_erase)(b_iterator *);
b_iterator_value (*it_get_value)(b_iterator *);
const b_iterator_value (*it_get_cvalue)(const b_iterator *);
B_TYPE_CLASS_DECLARATION_END(b_iterator)
B_TYPE_CLASS_DECLARATION_BEGIN(b_iterable)
b_iterator *(*it_begin)(b_iterable *);
const b_iterator *(*it_cbegin)(const b_iterable *);
B_TYPE_CLASS_DECLARATION_END(b_iterable)
BLUE_API b_type b_iterator_get_type(void);
BLUE_API b_type b_iterable_get_type(void);
static inline const b_iterator *b_iterator_ref(const b_iterator *p)
{
return b_object_ref((b_object *)p);
}
static inline void b_iterator_unref(const b_iterator *p)
{
b_object_unref((b_object *)p);
}
BLUE_API b_iterator *b_iterator_begin(b_iterable *it);
BLUE_API const b_iterator *b_iterator_cbegin(const b_iterable *it);
BLUE_API b_status b_iterator_get_status(const b_iterator *it);
BLUE_API b_status b_iterator_set_status(const b_iterator *it, b_status status);
BLUE_API b_status b_iterator_move_next(const b_iterator *it);
BLUE_API b_iterator_value b_iterator_get_value(b_iterator *it);
BLUE_API const b_iterator_value b_iterator_get_cvalue(const b_iterator *it);
BLUE_API b_status b_iterator_erase(b_iterator *it);
static inline bool b_iterator_is_valid(const b_iterator *it)
{
return B_OK(b_iterator_get_status(it));
}
B_DECLS_END;
#endif

197
core/include/blue/core/macros.h
View File

@@ -1,197 +0,0 @@
#ifndef BLUE_CORE_MACROS_H_
#define BLUE_CORE_MACROS_H_
#include <blue/core/class.h>
#include <blue/core/object.h>
#include <blue/core/thread.h>
#include <blue/core/type.h>
#include <stdlib.h>
#define __B_IFACE_I0(p, x) p##x
#define __B_IFACE_I1(p, x) __B_IFACE_I0(p, x)
/* Type definitions macros (for use in .c source file) */
#define B_TYPE_CLASS_DEFINITION_BEGIN(type_name) \
static void type_name##_class_init(b_class *p, void *d) \
{
#define B_TYPE_CLASS_DEFINITION_END(type_name) }
#define B_TYPE_CLASS_INTERFACE_BEGIN(interface_name, interface_id) \
interface_name##_class *__B_IFACE_I1(iface, __LINE__) \
= b_class_get_interface(p, interface_id); \
if (!__B_IFACE_I1(iface, __LINE__)) { \
b_throw_error_with_msg_template( \
B_ERRORS_BUILTIN, B_ERR_CLASS_INIT_FAILURE, \
B_MSG_CLASS_SPECIFIES_UNKNOWN_INTERFACE, \
B_ERROR_PARAM("class_name", b_class_get_name(p)), \
B_ERROR_PARAM("interface_name", #interface_name)); \
exit(-1); \
} else { \
interface_name##_class *iface = __B_IFACE_I1(iface, __LINE__);
#define B_TYPE_CLASS_INTERFACE_END(interface_name, interface_id) }
#define B_INTERFACE_ENTRY(slot) iface->slot
#define B_TYPE_DEFINITION_BEGIN(name) \
static b_type_info name##_type_info = {0}; \
static void name##_class_init(b_class *, void *); \
static void name##_type_init(void) \
{ \
b_type_info *type_info = &name##_type_info; \
unsigned int nr_vtables = 0; \
type_info->t_name = #name; \
type_info->t_class_init = name##_class_init;
#define B_TYPE_DEFINITION_END(name) \
b_result result = b_type_register(type_info); \
if (b_result_is_error(result)) { \
b_throw_error_caused_by_error( \
B_ERRORS_BUILTIN, B_ERR_TYPE_REGISTRATION_FAILURE, \
result); \
abort(); \
} \
} \
b_type name##_get_type(void) \
{ \
static b_once static_type_init = B_ONCE_INIT; \
\
if (b_init_once(&static_type_init)) { \
name##_type_init(); \
} \
\
return &name##_type_info.t_id; \
}
#define B_TYPE_ID(a, b, c, d, e) b_type_id_init(&type_info->t_id, a, b, c, d, e)
#define B_TYPE_EXTENDS(parent_id) \
b_type_id_copy(parent_id, &type_info->t_parent_id)
#define B_TYPE_IMPLEMENTS(interface_id) \
b_type_id_copy( \
interface_id, \
&type_info->t_interfaces[type_info->t_nr_interfaces++])
#define B_TYPE_CLASS(class_struct) \
type_info->t_class_size = sizeof(class_struct)
#define B_TYPE_FLAGS(flags) type_info->t_flags = (flags)
#define B_TYPE_INSTANCE_INIT(func) type_info->t_instance_init = (func)
#define B_TYPE_INSTANCE_FINI(func) type_info->t_instance_fini = (func)
#if 0
#define B_TYPE_VTABLE_BEGIN(vtable_struct, interface_id) \
vtable_struct __B_IFACE_I1(iface, __LINE__) = {0}; \
{ \
vtable_struct *iface = &__B_IFACE_I1(iface, __LINE__); \
type_info->t_vtables[nr_vtables].v_vtable = iface; \
type_info->t_vtables[nr_vtables].v_interface_id = interface_id; \
nr_vtables++;
#define B_TYPE_VTABLE_END(vtable_struct, interface_id) }
#endif
#define B_TYPE_INSTANCE_PRIVATE(instance_struct) \
type_info->t_instance_private_size = sizeof(instance_struct)
#define B_TYPE_INSTANCE_PROTECTED(instance_struct) \
type_info->t_instance_protected_size = sizeof(instance_struct)
/* Type declaration macros (for use in .h header file) */
#define __B_DECLARE_TYPE(name) \
typedef B_TYPE_FWDREF(name) name; \
typedef struct _##name##_class name##_class;
#define B_DECLARE_TYPE(name) \
__B_DECLARE_TYPE(name); \
static inline name *name##_ref(name *p) \
{ \
return b_object_ref(p); \
} \
static inline void name##_unref(name *p) \
{ \
b_object_unref(p); \
}
#define B_TYPE_CLASS_DECLARATION_BEGIN(name) struct _##name##_class {
#define B_TYPE_CLASS_DECLARATION_END(name) \
} \
;
#define B_TYPE_VIRTUAL_METHOD(return_type, method_name) \
return_type(*method_name)
#define B_TYPE_DEFAULT_CONSTRUCTOR(type_name, type_id) \
static inline type_name *type_name##_create(void) \
{ \
return b_object_create(type_id); \
}
/* Other macros */
#define B_CLASS_DISPATCH_VIRTUAL( \
type_name, type_id, default_value, func, object, ...) \
do { \
type_name##_class *iface \
= b_object_get_interface(object, type_id); \
if (iface && iface->func) { \
return iface->func(object, __VA_ARGS__); \
} else { \
return default_value; \
} \
} while (0)
#define B_CLASS_DISPATCH_VIRTUAL_0(type_name, type_id, default_value, func, object) \
do { \
type_name##_class *iface \
= b_object_get_interface(object, type_id); \
if (iface && iface->func) { \
return iface->func(object); \
} else { \
return default_value; \
} \
} while (0)
#define B_CLASS_DISPATCH_VIRTUAL_V(type_name, type_id, func, object, ...) \
do { \
type_name##_class *iface \
= b_object_get_interface(object, type_id); \
if (iface && iface->func) { \
iface->func(object, __VA_ARGS__); \
return; \
} \
} while (0)
#define B_CLASS_DISPATCH_VIRTUAL_V0(type_name, type_id, func, object) \
do { \
type_name##_class *iface \
= b_object_get_interface(object, type_id); \
if (iface && iface->func) { \
iface->func(object); \
return; \
} \
} while (0)
#define B_CLASS_DISPATCH_STATIC(type_id, func_name, obj, ...) \
do { \
void *priv = b_object_get_private(obj, type_id); \
return func_name(priv, __VA_ARGS__); \
} while (0)
#define B_CLASS_DISPATCH_STATIC_V(type_id, func_name, obj, ...) \
do { \
void *priv = b_object_get_private(obj, type_id); \
func_name(priv, __VA_ARGS__); \
} while (0)
#define B_CLASS_DISPATCH_STATIC_0(type_id, func_name, obj) \
do { \
void *priv = b_object_get_private(obj, type_id); \
return func_name(priv); \
} while (0)
#define B_CLASS_DISPATCH_STATIC_V0(type_id, func_name, obj) \
do { \
void *priv = b_object_get_private(obj, type_id); \
func_name(priv); \
} while (0)
#ifdef __cplusplus
#define B_DECLS_BEGIN extern "C" {
#define B_DECLS_END }
#else
#define B_DECLS_BEGIN
#define B_DECLS_END
#endif
#endif

118
core/include/blue/core/misc.h
View File

@@ -1,118 +0,0 @@
#ifndef BLUE_CORE_MISC_H_
#define BLUE_CORE_MISC_H_
#include <stddef.h>
#include <stdint.h>
#ifndef _Nonnull
#define _Nonnull
#endif
#define B_NPOS ((size_t)-1)
#define b_min(type, x, y) (z__b_min_##type(x, y))
#define b_max(type, x, y) (z__b_max_##type(x, y))
#define b_unbox(type, box, member) \
((type *_Nonnull)((box) ? (uintptr_t)(box) - (offsetof(type, member)) : 0))
#define z__b_merge_(a, b) a##b
#define z__b_label_(a) z__b_merge_(__unique_name_, a)
#define z__b_unique_name() z__b_label_(__LINE__)
#define z__b_numargs(arg_type, ...) \
(sizeof((arg_type[]) {__VA_ARGS__}) / sizeof(arg_type))
#ifdef _MSC_VER
#ifdef BLUELIB_STATIC
#define BLUE_API extern
#else
#ifdef BLUELIB_EXPORT
#define BLUE_API extern __declspec(dllexport)
#else
#define BLUE_API extern __declspec(dllimport)
#endif
#endif
#else
#define BLUE_API extern
#endif
static inline char z__b_min_char(char x, char y)
{
return x < y ? x : y;
}
static inline unsigned char z__b_min_uchar(unsigned char x, unsigned char y)
{
return x < y ? x : y;
}
static inline int z__b_min_int(int x, int y)
{
return x < y ? x : y;
}
static inline unsigned int z__b_min_uint(unsigned int x, unsigned int y)
{
return x < y ? x : y;
}
static inline long z__b_min_long(long x, long y)
{
return x < y ? x : y;
}
static inline unsigned int z__b_min_ulong(unsigned long x, unsigned long y)
{
return x < y ? x : y;
}
static inline long long z__b_min_longlong(long long x, long long y)
{
return x < y ? x : y;
}
static inline unsigned long long z__b_min_ulonglong(
unsigned long long x, unsigned long long y)
{
return x < y ? x : y;
}
static inline size_t z__b_min_size_t(size_t x, size_t y)
{
return x < y ? x : y;
}
static inline char z__b_max_char(char x, char y)
{
return x > y ? x : y;
}
static inline unsigned char z__b_max_uchar(unsigned char x, unsigned char y)
{
return x > y ? x : y;
}
static inline int z__b_max_int(int x, int y)
{
return x > y ? x : y;
}
static inline unsigned int z__b_max_uint(unsigned int x, unsigned int y)
{
return x > y ? x : y;
}
static inline long z__b_max_long(long x, long y)
{
return x > y ? x : y;
}
static inline unsigned int z__b_max_ulong(unsigned long x, unsigned long y)
{
return x > y ? x : y;
}
static inline long long z__b_max_longlong(long long x, long long y)
{
return x > y ? x : y;
}
static inline unsigned long long z__b_max_ulonglong(
unsigned long long x, unsigned long long y)
{
return x > y ? x : y;
}
static inline size_t z__b_max_size_t(size_t x, size_t y)
{
return x > y ? x : y;
}
BLUE_API size_t b_int_length(intptr_t v);
BLUE_API size_t b_uint_length(uintptr_t v);
#endif // BLUE_CORE_MISC_H_

39
core/include/blue/core/object.h
View File

@@ -1,39 +0,0 @@
#ifndef BLUE_CORE_OBJECT_H_
#define BLUE_CORE_OBJECT_H_
#include <blue/core/misc.h>
#include <blue/core/type.h>
#define B_OBJECT_MAGIC 0xDECAFC0C0ABEEF13ULL
#define B_OBJECT(p) ((b_object *)(p))
#define B_TYPE_OBJECT (b_object_get_type())
#define B_TYPE_FWDREF(name) struct _b_object
#define B_RV(p) (b_object_make_rvalue(p))
typedef B_TYPE_FWDREF(b_object) b_object;
typedef struct _b_object_class {
void (*to_string)(const b_object *, B_TYPE_FWDREF(b_stream) *);
} b_object_class;
BLUE_API b_type b_object_get_type(void);
BLUE_API void *b_object_get_private(const b_object *object, b_type type);
BLUE_API void *b_object_get_protected(const b_object *object, b_type type);
BLUE_API void *b_object_get_interface(const b_object *object, b_type type);
BLUE_API b_status b_object_get_data(
const b_object *object, b_type type, void **priv, void **prot,
void **iface);
BLUE_API b_object *b_object_ref(b_object *p);
BLUE_API void b_object_unref(b_object *p);
BLUE_API b_object *b_object_make_rvalue(b_object *p);
BLUE_API b_object *b_object_create(b_type type);
BLUE_API void b_object_to_string(const b_object *p, B_TYPE_FWDREF(b_stream) * out);
BLUE_API bool b_object_is_type(const b_object *p, b_type type);
#endif

82
core/include/blue/core/queue.h
View File

@@ -1,82 +0,0 @@
#ifndef BLUE_CORE_QUEUE_H_
#define BLUE_CORE_QUEUE_H_
#include <blue/core/iterator.h>
#include <blue/core/macros.h>
#include <blue/core/status.h>
#include <stdbool.h>
#include <string.h>
B_DECLS_BEGIN;
#define B_TYPE_QUEUE_ITERATOR (b_queue_iterator_get_type())
B_DECLARE_TYPE(b_queue_iterator);
B_TYPE_CLASS_DECLARATION_BEGIN(b_queue_iterator)
B_TYPE_CLASS_DECLARATION_END(b_queue_iterator)
#define B_QUEUE_INIT ((b_queue) {.q_first = NULL, .q_last = NULL})
#define B_QUEUE_ENTRY_INIT ((b_queue_entry) {.qe_next = NULL, .qe_prev = NULL})
typedef struct b_queue_entry {
struct b_queue_entry *qe_next;
struct b_queue_entry *qe_prev;
} b_queue_entry;
typedef struct b_queue {
b_queue_entry *q_first;
b_queue_entry *q_last;
} b_queue;
static inline void b_queue_init(b_queue *q)
{
memset(q, 0x00, sizeof *q);
}
static inline bool b_queue_empty(const b_queue *q)
{
return q ? (q->q_first == NULL) : true;
}
static inline b_queue_entry *b_queue_first(const b_queue *q)
{
return q ? q->q_first : NULL;
}
static inline b_queue_entry *b_queue_last(const b_queue *q)
{
return q ? q->q_last : NULL;
}
static inline b_queue_entry *b_queue_next(const b_queue_entry *entry)
{
return entry ? entry->qe_next : NULL;
}
static inline b_queue_entry *b_queue_prev(const b_queue_entry *entry)
{
return entry ? entry->qe_prev : NULL;
}
BLUE_API b_type b_queue_iterator_get_type(void);
BLUE_API size_t b_queue_length(const b_queue *q);
BLUE_API void b_queue_insert_before(
b_queue *q, b_queue_entry *entry, b_queue_entry *before);
BLUE_API void b_queue_insert_after(
b_queue *q, b_queue_entry *entry, b_queue_entry *after);
BLUE_API void b_queue_push_front(b_queue *q, b_queue_entry *entry);
BLUE_API void b_queue_push_back(b_queue *q, b_queue_entry *entry);
BLUE_API b_queue_entry *b_queue_pop_front(b_queue *q);
BLUE_API b_queue_entry *b_queue_pop_back(b_queue *q);
BLUE_API void b_queue_move(b_queue *q, b_queue_entry *dest, b_queue_entry *src);
BLUE_API void b_queue_delete(b_queue *q, b_queue_entry *entry);
BLUE_API void b_queue_delete_all(b_queue *q);
BLUE_API b_iterator *b_queue_begin(b_queue *q);
BLUE_API b_iterator *b_queue_cbegin(const b_queue *q);
B_DECLS_END;
#endif

37
core/include/blue/core/random.h
View File

@@ -1,37 +0,0 @@
#ifndef BLUELIB_RANDOM_H_
#define BLUELIB_RANDOM_H_
#include <blue/core/status.h>
#include <stddef.h>
struct b_random_algorithm;
typedef enum b_random_flags {
/* algorithm selection */
B_RANDOM_MT19937 = 0x01u,
/* generation flags */
B_RANDOM_SECURE = 0x100u,
} b_random_flags;
typedef struct b_random_ctx {
b_random_flags __f;
struct b_random_algorithm *__a;
union {
struct {
unsigned long long mt[312];
size_t mti;
} __mt19937;
};
} b_random_ctx;
BLUE_API b_random_ctx *b_random_global_ctx(void);
BLUE_API b_status b_random_init(b_random_ctx *ctx, b_random_flags flags);
BLUE_API unsigned long long b_random_next_int64(b_random_ctx *ctx);
BLUE_API double b_random_next_double(b_random_ctx *ctx);
BLUE_API void b_random_next_bytes(
b_random_ctx *ctx, unsigned char *out, size_t nbytes);
#endif

47
core/include/blue/core/ringbuffer.h
View File

@@ -1,47 +0,0 @@
#ifndef BLUE_CORE_RINGBUFFER_H_
#define BLUE_CORE_RINGBUFFER_H_
#include <blue/core/macros.h>
#include <blue/core/misc.h>
#include <blue/core/status.h>
B_DECLS_BEGIN;
#define B_TYPE_RINGBUFFER (b_ringbuffer_get_type())
B_DECLARE_TYPE(b_ringbuffer);
B_TYPE_CLASS_DECLARATION_BEGIN(b_ringbuffer)
B_TYPE_CLASS_DECLARATION_END(b_ringbuffer)
BLUE_API b_type b_ringbuffer_get_type(void);
BLUE_API b_ringbuffer *b_ringbuffer_create(size_t capacity);
BLUE_API b_ringbuffer *b_ringbuffer_create_with_buffer(void *ptr, size_t capacity);
BLUE_API b_status b_ringbuffer_clear(b_ringbuffer *buf);
BLUE_API b_status b_ringbuffer_read(
b_ringbuffer *buf, void *p, size_t count, size_t *nr_read);
BLUE_API b_status b_ringbuffer_write(
b_ringbuffer *buf, const void *p, size_t count, size_t *nr_written);
BLUE_API int b_ringbuffer_getc(b_ringbuffer *buf);
BLUE_API b_status b_ringbuffer_putc(b_ringbuffer *buf, int c);
BLUE_API size_t b_ringbuffer_write_capacity_remaining(const b_ringbuffer *buf);
BLUE_API size_t b_ringbuffer_available_data_remaining(const b_ringbuffer *buf);
BLUE_API b_status b_ringbuffer_open_read_buffer(
b_ringbuffer *buf, const void **ptr, size_t *length);
BLUE_API b_status b_ringbuffer_close_read_buffer(
b_ringbuffer *buf, const void **ptr, size_t nr_read);
BLUE_API b_status b_ringbuffer_open_write_buffer(
b_ringbuffer *buf, void **ptr, size_t *capacity);
BLUE_API b_status b_ringbuffer_close_write_buffer(
b_ringbuffer *buf, void **ptr, size_t nr_written);
B_DECLS_END;
#endif

109
core/include/blue/core/rope.h
View File

@@ -1,109 +0,0 @@
#ifndef BLUE_CORE_ROPE_H_
#define BLUE_CORE_ROPE_H_
#include <blue/core/hash.h>
#include <blue/core/misc.h>
#include <blue/core/stream.h>
#include <stdint.h>
#include <string.h>
struct b_string;
struct b_bstr;
#define B_ROPE_TYPE(f) ((f) & 0xFF)
#define B_ROPE_CHAR(c) \
\
{ \
.r_flags = B_ROPE_F_CHAR, .r_len_total = 1, \
.r_v = {.v_char = (c) } \
}
#define B_ROPE_CSTR(str) \
{ \
.r_flags = B_ROPE_F_CSTR_BORROWED, \
.r_len_total = strlen(str), \
.r_v = { \
.v_cstr = { \
.s = (str), \
.hash = b_hash_cstr(str), \
}, \
}, \
}
#define B_ROPE_CSTR_STATIC(str) \
{ \
.r_flags = B_ROPE_F_CSTR_STATIC, \
.r_len_total = strlen(str), \
.r_v = { \
.v_cstr = { \
.s = (str), \
.hash = b_hash_cstr(str), \
}, \
}, \
}
#define B_ROPE_INT(v) \
\
{ \
.r_flags = B_ROPE_F_INT, .r_len_total = b_int_length(v), \
.r_v = {.v_int = (v) } \
}
#define B_ROPE_UINT(v) \
\
{ \
.r_flags = B_ROPE_F_UINT, .r_len_total = b_uint_length(v), \
.r_v = {.v_uint = (v) } \
}
typedef enum b_rope_flags {
B_ROPE_F_NONE = 0x0000u,
B_ROPE_F_CHAR = 0x0001u,
B_ROPE_F_CSTR = 0x0002u,
B_ROPE_F_CSTR_BORROWED = 0x0003u,
B_ROPE_F_CSTR_STATIC = 0x0004u,
B_ROPE_F_INT = 0x0005u,
B_ROPE_F_UINT = 0x0006u,
B_ROPE_F_COMPOSITE = 0x0007u,
B_ROPE_F_MALLOC = 0x0100u,
} b_rope_flags;
typedef struct b_rope {
b_rope_flags r_flags;
unsigned long r_len_left, r_len_total;
union {
char v_char;
intptr_t v_int;
uintptr_t v_uint;
struct {
const char *s;
uint64_t hash;
} v_cstr;
struct {
const struct b_rope *r_left, *r_right;
} v_composite;
} r_v;
} b_rope;
BLUE_API void b_rope_init_char(b_rope *rope, char c);
BLUE_API void b_rope_init_cstr(b_rope *rope, const char *s);
BLUE_API void b_rope_init_cstr_borrowed(b_rope *rope, const char *s);
BLUE_API void b_rope_init_cstr_static(b_rope *rope, const char *s);
BLUE_API void b_rope_init_int(b_rope *rope, intptr_t v);
BLUE_API void b_rope_init_uint(b_rope *rope, uintptr_t v);
BLUE_API void b_rope_destroy(b_rope *rope);
BLUE_API void b_rope_iterate(
const b_rope *rope, void (*func)(const b_rope *, void *), void *arg);
BLUE_API size_t b_rope_get_size(const b_rope *rope);
BLUE_API void b_rope_concat(b_rope *result, const b_rope *left, const b_rope *right);
BLUE_API void b_rope_join(b_rope *result, const b_rope **ropes, size_t nr_ropes);
BLUE_API b_status b_rope_to_cstr(const b_rope *rope, char *out, size_t max);
BLUE_API b_status b_rope_to_bstr(const b_rope *rope, struct b_bstr *str);
BLUE_API b_status b_rope_to_string(const b_rope *rope, b_stream *out);
#endif

48
core/include/blue/core/status.h
View File

@@ -1,48 +0,0 @@
#ifndef BLUELIB_CORE_STATUS_H_
#define BLUELIB_CORE_STATUS_H_
#include <blue/core/misc.h>
#define B_OK(status) ((enum b_status)((uintptr_t)(status)) == B_SUCCESS)
#define B_ERR(status) ((status) != B_SUCCESS)
typedef enum b_status {
B_SUCCESS = 0x00u,
B_ERR_NO_MEMORY,
B_ERR_OUT_OF_BOUNDS,
B_ERR_INVALID_ARGUMENT,
B_ERR_NAME_EXISTS,
B_ERR_NOT_SUPPORTED,
B_ERR_BAD_STATE,
B_ERR_NO_ENTRY,
B_ERR_NO_DATA,
B_ERR_NO_SPACE,
B_ERR_UNKNOWN_FUNCTION,
B_ERR_BAD_FORMAT,
B_ERR_IO_FAILURE,
B_ERR_IS_DIRECTORY,
B_ERR_NOT_DIRECTORY,
B_ERR_PERMISSION_DENIED,
B_ERR_BUSY,
/* blue-compress specific code */
B_ERR_COMPRESSION_FAILURE,
/* blue-object specific code */
B_ERR_TYPE_REGISTRATION_FAILURE,
B_ERR_CLASS_INIT_FAILURE,
} b_status;
typedef enum b_status_msg {
B_MSG_SUCCESS = 0,
/* blue-object specific messages */
B_MSG_TYPE_REGISTRATION_FAILURE,
B_MSG_CLASS_INIT_FAILURE,
B_MSG_CLASS_SPECIFIES_UNKNOWN_INTERFACE,
} b_status_msg;
BLUE_API const char *b_status_to_string(b_status status);
BLUE_API const char *b_status_description(b_status status);
#endif

100
core/include/blue/core/stream.h
View File

@@ -1,100 +0,0 @@
#ifndef BLUE_CORE_STREAM_H_
#define BLUE_CORE_STREAM_H_
#include <blue/core/encoding.h>
#include <blue/core/macros.h>
#include <blue/core/misc.h>
#include <blue/core/status.h>
#include <stdarg.h>
#include <stdio.h>
B_DECLS_BEGIN;
#define b_stdin (z__b_stream_get_stdin())
#define b_stdout (z__b_stream_get_stdout())
#define b_stderr (z__b_stream_get_stderr())
#define B_TYPE_STREAM (b_stream_get_type())
#define B_TYPE_STREAM_BUFFER (b_stream_buffer_get_type())
B_DECLARE_TYPE(b_stream);
B_DECLARE_TYPE(b_stream_buffer);
typedef enum b_stream_mode {
B_STREAM_READ = 0x01u,
B_STREAM_WRITE = 0x02u,
B_STREAM_BINARY = 0x10u,
Z__B_STREAM_STATIC = 0x80u,
} b_stream_mode;
typedef enum b_stream_seek_origin {
B_STREAM_SEEK_START = 0x01u,
B_STREAM_SEEK_CURRENT = 0x02u,
B_STREAM_SEEK_END = 0x03u,
} b_stream_seek_origin;
typedef struct b_stream_cfg {
b_stream_mode s_mode;
} b_stream_cfg;
B_TYPE_CLASS_DECLARATION_BEGIN(b_stream)
b_status (*s_close)(b_stream *);
b_status (*s_seek)(b_stream *, long long, b_stream_seek_origin);
b_status (*s_tell)(const b_stream *, size_t *);
b_status (*s_getc)(b_stream *, b_wchar *);
b_status (*s_read)(b_stream *, void *, size_t, size_t *);
b_status (*s_write)(b_stream *, const void *, size_t, size_t *);
b_status (*s_reserve)(b_stream *, size_t);
B_TYPE_CLASS_DECLARATION_END(b_stream)
B_TYPE_CLASS_DECLARATION_BEGIN(b_stream_buffer)
B_TYPE_CLASS_DECLARATION_END(b_stream_buffer)
BLUE_API b_type b_stream_get_type();
BLUE_API b_type b_stream_buffer_get_type();
BLUE_API b_stream *z__b_stream_get_stdin(void);
BLUE_API b_stream *z__b_stream_get_stdout(void);
BLUE_API b_stream *z__b_stream_get_stderr(void);
BLUE_API b_stream_buffer *b_stream_buffer_create(void *p, size_t len);
BLUE_API b_stream_buffer *b_stream_buffer_create_dynamic(size_t buffer_size);
BLUE_API b_stream *b_stream_open_fp(FILE *fp);
BLUE_API b_status b_stream_reserve(b_stream *stream, size_t len);
BLUE_API b_status b_stream_seek(
b_stream *stream, long long offset, b_stream_seek_origin origin);
BLUE_API size_t b_stream_cursor(const b_stream *stream);
BLUE_API b_status b_stream_push_indent(b_stream *stream, int indent);
BLUE_API b_status b_stream_pop_indent(b_stream *stream);
BLUE_API b_status b_stream_read_char(b_stream *stream, b_wchar *c);
BLUE_API b_status b_stream_read_bytes(
b_stream *stream, void *buf, size_t count, size_t *nr_read);
BLUE_API b_status b_stream_read_line(b_stream *stream, char *s, size_t max);
BLUE_API b_status b_stream_read_line_s(b_stream *src, b_stream *dest);
BLUE_API b_status b_stream_read_all_bytes(
b_stream *stream, void *p, size_t max, size_t *nr_read);
BLUE_API b_status b_stream_read_all_bytes_s(
b_stream *src, b_stream *dest, b_stream_buffer *buffer, size_t *nr_read);
BLUE_API b_status b_stream_write_char(b_stream *stream, b_wchar c);
BLUE_API b_status b_stream_write_string(
b_stream *stream, const char *s, size_t *nr_written);
BLUE_API b_status b_stream_write_bytes(
b_stream *stream, const void *buf, size_t count, size_t *nr_written);
BLUE_API b_status b_stream_write_fmt(
b_stream *stream, size_t *nr_written, const char *format, ...);
BLUE_API b_status b_stream_write_vfmt(
b_stream *stream, size_t *nr_written, const char *format, va_list arg);
B_DECLS_END;
#endif

35
core/include/blue/core/stringstream.h
View File

@@ -1,35 +0,0 @@
#ifndef BLUE_CORE_STRINGSTREAM_H_
#define BLUE_CORE_STRINGSTREAM_H_
#include <blue/core/macros.h>
#include <blue/core/misc.h>
#include <blue/core/status.h>
#include <blue/core/stream.h>
#include <stddef.h>
B_DECLS_BEGIN;
#define B_TYPE_STRINGSTREAM (b_stringstream_get_type())
B_DECLARE_TYPE(b_stringstream);
B_TYPE_CLASS_DECLARATION_BEGIN(b_stringstream)
B_TYPE_CLASS_DECLARATION_END(b_stringstream)
BLUE_API b_type b_stringstream_get_type(void);
BLUE_API b_stringstream *b_stringstream_create(void);
BLUE_API b_stringstream *b_stringstream_create_with_buffer(char *buf, size_t max);
BLUE_API b_status b_stringstream_reset(b_stringstream *strv);
BLUE_API b_status b_stringstream_reset_with_buffer(
b_stringstream *strv, char *buf, size_t max);
BLUE_API const char *b_stringstream_ptr(const b_stringstream *strv);
BLUE_API char *b_stringstream_steal(b_stringstream *strv);
BLUE_API size_t b_stringstream_get_length(const b_stringstream *strv);
B_DECLS_END;
#endif

36
core/include/blue/core/thread.h
View File

@@ -1,36 +0,0 @@
#ifndef BLUELIB_CORE_THREAD_H_
#define BLUELIB_CORE_THREAD_H_
#include <blue/core/bitop.h>
#include <blue/core/misc.h>
#include <stdbool.h>
#if defined(__APPLE__) || defined(__linux__)
#include <pthread.h>
#define B_MUTEX_INIT PTHREAD_MUTEX_INITIALIZER
typedef pthread_mutex_t b_mutex;
#else
#error Unsupported compiler/system
#endif
#define B_ONCE_INIT ((b_once)0)
typedef struct b_thread b_thread;
typedef int b_once;
static inline bool b_init_once(b_once *once)
{
int x = 0;
return b_cmpxchg(once, &x, 1);
}
BLUE_API b_thread *b_thread_self(void);
BLUE_API bool b_mutex_lock(b_mutex *mut);
BLUE_API bool b_mutex_trylock(b_mutex *mut);
BLUE_API bool b_mutex_unlock(b_mutex *mut);
#endif

66
core/include/blue/core/type.h
View File

@@ -1,66 +0,0 @@
#ifndef BLUE_CORE_TYPE_H_
#define BLUE_CORE_TYPE_H_
#include <blue/core/error.h>
#include <blue/core/misc.h>
#include <stddef.h>
#include <stdint.h>
#include <string.h>
#define B_TYPE_MAX_INTERFACES 64
struct _b_class;
struct _b_object;
typedef void (*b_class_init_function)(struct _b_class *, void *);
typedef void (*b_instance_init_function)(struct _b_object *, void *);
typedef void (*b_instance_fini_function)(struct _b_object *, void *);
typedef const union b_type {
struct {
uint64_t p00, p01;
} a;
unsigned char b[16];
} *b_type;
typedef enum b_type_flags {
B_TYPE_F_ABSTRACT = 0x01u,
} b_type_flags;
typedef struct b_type_info {
union b_type t_id;
union b_type t_parent_id;
const char *t_name;
b_type_flags t_flags;
union b_type t_interfaces[B_TYPE_MAX_INTERFACES];
size_t t_nr_interfaces;
size_t t_class_size;
b_class_init_function t_class_init;
size_t t_instance_private_size;
size_t t_instance_protected_size;
b_instance_init_function t_instance_init;
b_instance_fini_function t_instance_fini;
} b_type_info;
BLUE_API void b_type_id_init(
union b_type *out, uint32_t a, uint16_t b, uint16_t c, uint16_t d,
uint64_t e);
static inline void b_type_id_copy(b_type src, union b_type *dest)
{
dest->a.p00 = src->a.p00;
dest->a.p01 = src->a.p01;
}
static inline int b_type_id_compare(b_type a, b_type b)
{
if (a == b) {
return 0;
}
return memcmp(a, b, sizeof(union b_type));
}
BLUE_API b_result b_type_register(b_type_info *info);
#endif

0
core/include/blue/core.h → core/include/fx/core.h
View File

14
core/include/blue/core/bitop.h → core/include/fx/core/bitop.h
View File

@@ -1,14 +1,14 @@
#ifndef BLUELIB_CORE_BITOP_H_
#define BLUELIB_CORE_BITOP_H_
#ifndef FX_CORE_BITOP_H_
#define FX_CORE_BITOP_H_
#include <blue/core/misc.h>
#include <fx/core/misc.h>
BLUE_API int b_popcountl(long v);
BLUE_API int b_ctzl(long v);
BLUE_API int b_clzl(long v);
FX_API int fx_popcountl(long v);
FX_API int fx_ctzl(long v);
FX_API int fx_clzl(long v);
#if defined(__GNUC__) || defined(__clang__)
#define b_cmpxchg(v, expected_val, new_val) \
#define fx_cmpxchg(v, expected_val, new_val) \
__atomic_compare_exchange_n( \
v, expected_val, new_val, 0, __ATOMIC_RELAXED, __ATOMIC_RELAXED)
#elif defined(_MSC_VER)

71
core/include/fx/core/bstr.h Normal file
View File

@@ -0,0 +1,71 @@
#ifndef FX_CORE_BSTR_H_
#define FX_CORE_BSTR_H_
#include <fx/core/misc.h>
#include <fx/core/status.h>
#include <stdarg.h>
#include <stddef.h>
#define FX_BSTR_MAGIC 0x5005500550055005ULL
struct fx_rope;
enum fx_bstr_flags {
FX_BSTR_F_NONE = 0x00u,
FX_BSTR_F_ALLOC = 0x01u,
};
typedef struct fx_bstr {
uint64_t bstr_magic;
enum fx_bstr_flags bstr_flags;
char *bstr_buf;
/* total number of characters in bstr_buf, not including null terminator */
size_t bstr_len;
/* number of bytes allocated for bstr_buf (includes space for the null
* terminator) */
size_t bstr_capacity;
int *bstr_istack;
int bstr_add_indent;
size_t bstr_istack_ptr, bstr_istack_size;
} fx_bstr;
FX_API void fx_bstr_begin(fx_bstr *strv, char *buf, size_t max);
FX_API void fx_bstr_begin_dynamic(fx_bstr *strv);
FX_API char *fx_bstr_end(fx_bstr *strv);
FX_API fx_status fx_bstr_reserve(fx_bstr *strv, size_t len);
static inline size_t fx_bstr_get_size(const fx_bstr *str)
{
return str->bstr_len;
}
static inline size_t fx_bstr_get_capacity(const fx_bstr *str)
{
return str->bstr_capacity;
}
FX_API fx_status fx_bstr_push_indent(fx_bstr *strv, int indent);
FX_API fx_status fx_bstr_pop_indent(fx_bstr *strv);
FX_API fx_status fx_bstr_write_char(fx_bstr *strv, char c);
FX_API fx_status fx_bstr_write_chars(
fx_bstr *strv, const char *cs, size_t len, size_t *nr_written);
FX_API fx_status fx_bstr_write_cstr(
fx_bstr *strv, const char *str, size_t *nr_written);
FX_API fx_status fx_bstr_write_cstr_list(
fx_bstr *strv, const char **strs, size_t *nr_written);
FX_API fx_status fx_bstr_write_cstr_array(
fx_bstr *strv, const char **strs, size_t count, size_t *nr_written);
FX_API fx_status fx_bstr_write_cstr_varg(fx_bstr *strv, size_t *nr_written, ...);
FX_API fx_status fx_bstr_write_rope(
fx_bstr *strv, const struct fx_rope *rope, size_t *nr_written);
FX_API fx_status fx_bstr_write_fmt(
fx_bstr *strv, size_t *nr_written, const char *format, ...);
FX_API fx_status fx_bstr_write_vfmt(
fx_bstr *strv, size_t *nr_written, const char *format, va_list arg);
FX_API char *fx_bstr_rope(const struct fx_rope *rope, size_t *nr_written);
FX_API char *fx_bstr_fmt(size_t *nr_written, const char *format, ...);
FX_API char *fx_bstr_vfmt(size_t *nr_written, const char *format, va_list arg);
#endif

359
core/include/fx/core/btree.h Normal file
View File

@@ -0,0 +1,359 @@
#ifndef FX_CORE_BST_H_
#define FX_CORE_BST_H_
#include <fx/core/iterator.h>
#include <fx/core/macros.h>
#include <fx/core/misc.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
FX_DECLS_BEGIN;
#define FX_BTREE_INIT {0}
#define FX_TYPE_BTREE_ITERATOR (fx_bst_iterator_get_type())
FX_DECLARE_TYPE(fx_bst_iterator);
FX_TYPE_CLASS_DECLARATION_BEGIN(fx_bst_iterator)
FX_TYPE_CLASS_DECLARATION_END(fx_bst_iterator)
/* defines a simple node insertion function.
this function assumes that your nodes have simple integer keys that can be
compared with the usual operators.
EXAMPLE:
if you have a tree node type like this:
struct my_tree_node {
int key;
fx_bst_node base;
}
You would use the following call to generate an insert function for a tree
with this node type:
BTREE_DEFINE_SIMPLE_INSERT(
struct my_tree_node,
base,
key,
my_tree_node_insert);
Which would emit a function defined like:
static void my_tree_node_insert(fx_bst *tree, struct my_tree_node *node);
@param node_type your custom tree node type. usually a structure that
contains a fx_bst_node member.
@param container_node_member the name of the fx_bst_node member variable
within your custom type.
@param container_key_member the name of the key member variable within your
custom type.
@param function_name the name of the function to generate.
*/
#define FX_BTREE_DEFINE_SIMPLE_INSERT( \
node_type, container_node_member, container_key_member, function_name) \
void function_name(fx_bst *tree, node_type *node) \
{ \
if (!tree->bst_root) { \
tree->bst_root = &node->container_node_member; \
fx_bst_insert_fixup(tree, &node->container_node_member); \
return; \
} \
\
fx_bst_node *cur = tree->bst_root; \
while (1) { \
node_type *cur_node = fx_unbox( \
node_type, cur, container_node_member); \
fx_bst_node *next = NULL; \
\
if (node->container_key_member \
>= cur_node->container_key_member) { \
next = fx_bst_right(cur); \
\
if (!next) { \
fx_bst_put_right( \
cur, \
&node->container_node_member); \
break; \
} \
} else if ( \
node->container_key_member \
< cur_node->container_key_member) { \
next = fx_bst_left(cur); \
\
if (!next) { \
fx_bst_put_left( \
cur, \
&node->container_node_member); \
break; \
} \
} \
\
cur = next; \
} \
\
fx_bst_insert_fixup(tree, &node->container_node_member); \
}
/* defines a node insertion function.
this function should be used for trees with complex node keys that cannot be
directly compared. a comparator for your keys must be supplied.
EXAMPLE:
if you have a tree node type like this:
struct my_tree_node {
complex_key_t key;
fx_bst_node base;
}
You would need to define a comparator function or macro with the following
signature:
int my_comparator(struct my_tree_node *a, struct my_tree_node *b);
Which implements the following:
return -1 if a < b
return 0 if a == b
return 1 if a > b
You would use the following call to generate an insert function for a tree
with this node type:
BTREE_DEFINE_INSERT(struct my_tree_node, base, key, my_tree_node_insert,
my_comparator);
Which would emit a function defined like:
static void my_tree_node_insert(fx_bst *tree, struct my_tree_node *node);
@param node_type your custom tree node type. usually a structure that
contains a fx_bst_node member.
@param container_node_member the name of the fx_bst_node member variable
within your custom type.
@param container_key_member the name of the key member variable within your
custom type.
@param function_name the name of the function to generate.
@param comparator the name of a comparator function or functional-macro that
conforms to the requirements listed above.
*/
#define FX_BTREE_DEFINE_INSERT( \
node_type, container_node_member, container_key_member, function_name, \
comparator) \
void function_name(fx_bst *tree, node_type *node) \
{ \
if (!tree->bst_root) { \
tree->bst_root = &node->container_node_member; \
fx_bst_insert_fixup(tree, &node->container_node_member); \
return; \
} \
\
fx_bst_node *cur = tree->bst_root; \
while (1) { \
node_type *cur_node = fx_unbox( \
node_type, cur, container_node_member); \
fx_bst_node *next = NULL; \
int cmp = comparator(node, cur_node); \
\
if (cmp >= 0) { \
next = fx_bst_right(cur); \
\
if (!next) { \
fx_bst_put_right( \
cur, \
&node->container_node_member); \
break; \
} \
} else if (cmp < 0) { \
next = fx_bst_left(cur); \
\
if (!next) { \
fx_bst_put_left( \
cur, \
&node->container_node_member); \
break; \
} \
} else { \
return; \
} \
\
cur = next; \
} \
\
fx_bst_insert_fixup(tree, &node->container_node_member); \
}
/* defines a simple tree search function.
this function assumes that your nodes have simple integer keys that can be
compared with the usual operators.
EXAMPLE:
if you have a tree node type like this:
struct my_tree_node {
int key;
fx_bst_node base;
}
You would use the following call to generate a search function for a tree
with this node type:
BTREE_DEFINE_SIMPLE_GET(struct my_tree_node, int, base, key,
my_tree_node_get);
Which would emit a function defined like:
static struct my_tree_node *my_tree_node_get(fx_bst *tree, int key);
@param node_type your custom tree node type. usually a structure that
contains a fx_bst_node member.
@param key_type the type name of the key embedded in your custom tree node
type. this type must be compatible with the builtin comparison operators.
@param container_node_member the name of the fx_bst_node member variable
within your custom type.
@param container_key_member the name of the key member variable within your
custom type.
@param function_name the name of the function to generate.
*/
#define FX_BTREE_DEFINE_SIMPLE_GET( \
node_type, key_type, container_node_member, container_key_member, \
function_name) \
node_type *function_name(const fx_bst *tree, key_type key) \
{ \
fx_bst_node *cur = tree->bst_root; \
while (cur) { \
node_type *cur_node = fx_unbox( \
node_type, cur, container_node_member); \
if (key > cur_node->container_key_member) { \
cur = fx_bst_right(cur); \
} else if (key < cur_node->container_key_member) { \
cur = fx_bst_left(cur); \
} else { \
return cur_node; \
} \
} \
\
return NULL; \
}
#define fx_bst_foreach(it, bst) \
for (int z__fx_unique_name() = fx_bst_iterator_begin(bst, it); \
(it)->node != NULL; fx_bst_iterator_next(it))
/* binary tree nodes. this *cannot* be used directly. you need to define a
custom node type that contains a member variable of type fx_bst_node.
you would then use the supplied macros to define functions to manipulate your
custom binary tree.
*/
typedef struct fx_bst_node {
struct fx_bst_node *n_parent, *n_left, *n_right;
unsigned short n_height;
} fx_bst_node;
/* binary tree. unlike fx_bst_node, you can define variables of type fx_bst.
*/
typedef struct fx_bst {
fx_bst_node *bst_root;
} fx_bst;
FX_API fx_type fx_bst_iterator_get_type(void);
/* re-balance a binary tree after an insertion operation.
NOTE that, if you define an insertion function using BTREE_DEFINE_INSERT or
similar, this function will automatically called for you.
@param tree the tree to re-balance.
@param node the node that was just inserted into the tree.
*/
FX_API void fx_bst_insert_fixup(fx_bst *tree, fx_bst_node *node);
/* delete a node from a binary tree and re-balance the tree afterwards.
@param tree the tree to delete from
@param node the node to delete.
*/
FX_API void fx_bst_delete(fx_bst *tree, fx_bst_node *node);
/* get the first node in a binary tree.
this will be the node with the smallest key (i.e. the node that is
furthest-left from the root)
*/
FX_API fx_bst_node *fx_bst_first(const fx_bst *tree);
/* get the last node in a binary tree.
this will be the node with the largest key (i.e. the node that is
furthest-right from the root)
*/
FX_API fx_bst_node *fx_bst_last(const fx_bst *tree);
/* for any binary tree node, this function returns the node with the
* next-largest key value */
FX_API fx_bst_node *fx_bst_next(const fx_bst_node *node);
/* for any binary tree node, this function returns the node with the
* next-smallest key value */
FX_API fx_bst_node *fx_bst_prev(const fx_bst_node *node);
/* return true if the bst is empty, false otherwise */
static inline bool fx_bst_empty(const fx_bst *tree)
{
return tree->bst_root == NULL;
}
/* sets `child` as the immediate left-child of `parent` */
static inline void fx_bst_put_left(fx_bst_node *parent, fx_bst_node *child)
{
parent->n_left = child;
child->n_parent = parent;
}
/* sets `child` as the immediate right-child of `parent` */
static inline void fx_bst_put_right(fx_bst_node *parent, fx_bst_node *child)
{
parent->n_right = child;
child->n_parent = parent;
}
/* get the immediate left-child of `node` */
static inline fx_bst_node *fx_bst_left(fx_bst_node *node)
{
return node->n_left;
}
/* get the immediate right-child of `node` */
static inline fx_bst_node *fx_bst_right(fx_bst_node *node)
{
return node->n_right;
}
/* get the immediate parent of `node` */
static inline fx_bst_node *fx_bst_parent(fx_bst_node *node)
{
return node->n_parent;
}
FX_API void fx_bst_move(fx_bst *tree, fx_bst_node *dest, fx_bst_node *src);
/* get the height of `node`.
the height of a node is defined as the length of the longest path
between the node and a leaf node.
this count includes the node itself, so the height of a leaf node will be 1.
*/
static inline unsigned short fx_bst_height(fx_bst_node *node)
{
return node->n_height;
}
FX_API fx_iterator *fx_bst_begin(fx_bst *tree);
FX_API const fx_iterator *fx_bst_cbegin(const fx_bst *tree);
#ifdef __cplusplus
}
#endif
#endif

15
core/include/fx/core/class.h Normal file
View File

@@ -0,0 +1,15 @@
#ifndef FX_OBJECT_CLASS_H_
#define FX_OBJECT_CLASS_H_
#include <fx/core/type.h>
#define FX_CLASS_MAGIC 0xDEADFACEDCAFEBEDULL
#define FX_CLASS(p) ((fx_class *)(p))
typedef struct _fx_class fx_class;
FX_API void *fx_class_get(fx_type id);
FX_API const char *fx_class_get_name(const fx_class *c);
FX_API void *fx_class_get_interface(const fx_class *c, fx_type id);
#endif

41
core/include/fx/core/encoding.h Normal file
View File

@@ -0,0 +1,41 @@
#ifndef FX_CORE_ENCODING_H_
#define FX_CORE_ENCODING_H_
#include <fx/core/misc.h>
#include <stdbool.h>
#include <stdint.h>
#define FX_WCHAR_INVALID ((fx_wchar) - 1)
typedef int32_t fx_wchar;
FX_API bool fx_wchar_is_alpha(fx_wchar c);
FX_API bool fx_wchar_is_number(fx_wchar c);
static inline bool fx_wchar_is_bin_digit(fx_wchar c)
{
return c >= '0' && c <= '1';
}
static inline bool fx_wchar_is_oct_digit(fx_wchar c)
{
return c >= '0' && c <= '7';
}
FX_API bool fx_wchar_is_hex_digit(fx_wchar c);
FX_API bool fx_wchar_is_space(fx_wchar c);
static inline bool fx_wchar_is_alnum(fx_wchar c)
{
return fx_wchar_is_alpha(c) || fx_wchar_is_number(c);
}
FX_API bool fx_wchar_is_punct(fx_wchar c);
FX_API bool fx_wchar_utf8_is_valid_scalar(fx_wchar c);
FX_API unsigned int fx_wchar_utf8_header_decode(char c);
FX_API unsigned int fx_wchar_utf8_codepoint_size(fx_wchar c);
FX_API fx_wchar fx_wchar_utf8_codepoint_decode(const char *s);
FX_API unsigned int fx_wchar_utf8_codepoint_encode(fx_wchar c, char s[4]);
FX_API unsigned int fx_wchar_utf8_codepoint_stride(const char *s);
FX_API size_t fx_wchar_utf8_codepoint_count(const char *s, size_t nr_bytes);
FX_API size_t fx_wchar_utf8_string_encoded_size(
const fx_wchar *s, size_t nr_codepoints);
#endif

49
core/include/fx/core/endian.h Normal file
View File

@@ -0,0 +1,49 @@
#ifndef FX_CORE_ENDIAN_H_
#define FX_CORE_ENDIAN_H_
#include <fx/core/misc.h>
#include <stdint.h>
typedef struct {
union {
unsigned char i_bytes[sizeof(uint16_t)];
int16_t i_val;
uint16_t i_uval;
};
} fx_i16;
typedef struct {
union {
unsigned char i_bytes[sizeof(uint32_t)];
int32_t i_val;
uint32_t i_uval;
};
} fx_i32;
typedef struct {
union {
unsigned char i_bytes[sizeof(uint64_t)];
int64_t i_val;
uint64_t i_uval;
};
} fx_i64;
FX_API fx_i16 fx_i16_htob(uint16_t v);
FX_API fx_i16 fx_i16_htos(uint16_t v);
FX_API uint16_t fx_i16_btoh(fx_i16 v);
FX_API uint16_t fx_i16_stoh(fx_i16 v);
FX_API fx_i32 fx_i32_htob(uint32_t v);
FX_API fx_i32 fx_i32_htos(uint32_t v);
FX_API uint32_t fx_i32_btoh(fx_i32 v);
FX_API uint32_t fx_i32_stoh(fx_i32 v);
FX_API fx_i64 fx_i64_htob(uint64_t v);
FX_API fx_i64 fx_i64_htos(uint64_t v);
FX_API uint64_t fx_i64_btoh(fx_i64 v);
FX_API uint64_t fx_i64_stoh(fx_i64 v);
#endif

418
core/include/fx/core/error.h Normal file
View File

@@ -0,0 +1,418 @@
#ifndef FX_CORE_ERROR_H_
#define FX_CORE_ERROR_H_
#include <fx/core/misc.h>
#include <fx/core/status.h>
#include <stdarg.h>
#include <stdbool.h>
#define FX_ERROR_TEMPLATE_PARAMETER_MAX 4
#define FX_ERROR_MSG_ID_INVALID ((unsigned long)-1)
#define FX_CATCH(err, expr) ((err = (expr)) != NULL)
#define fx_result_is_error(result) ((result) != NULL)
#define fx_result_is_success(result) ((result) == NULL)
#define FX_RESULT_SUCCESS ((fx_result)NULL)
#define FX_RESULT_ERR(err_name) \
fx_error_with_code(fx_error_vendor_get_builtin(), FX_ERR_##err_name)
#define FX_RESULT_ERR_WITH_STRING(err_name, ...) \
fx_error_with_string( \
fx_error_vendor_get_builtin(), FX_ERR_##err_name, __VA_ARGS__)
#define FX_RESULT_STATUS(code) \
((code) == FX_SUCCESS \
? FX_RESULT_SUCCESS \
: (fx_error_with_code(fx_error_vendor_get_builtin(), code)))
#define FX_RESULT_STATUS_WITH_STRING(code, ...) \
((code) == FX_SUCCESS \
? FX_RESULT_SUCCESS \
: (fx_error_with_string( \
fx_error_vendor_get_builtin(), code, __VA_ARGS__)))
#define FX_ERRORS_BUILTIN (fx_error_vendor_get_builtin())
#define FX_ERRORS_ERRNO (fx_error_vendor_get_errno())
#define FX_ERROR_PARAM(name, value) \
(fx_error_template_parameter) \
{ \
.param_name = (name), .param_value = (uintptr_t)(value), \
}
#define FX_ERROR_TEMPLATE_PARAM(name, type, format) \
(fx_error_template_parameter_definition) \
{ \
.param_name = (name), .param_type = (type), \
.param_format = (format), \
}
#define FX_ERROR_DEFINITION(code, name, msg) \
[code] = (fx_error_definition) \
{ \
.err_name = (name), .err_message = (msg), \
}
#define FX_ERROR_DEFINITION_TEMPLATE(code, name, msg, ...) \
[code] = (fx_error_definition) \
{ \
.err_name = (name), .err_message = (msg), \
.err_params = __VA_ARGS__, \
}
#define FX_ERROR_MSG(id, content) \
[id] = (fx_error_msg) \
{ \
.msg_message = (content), \
}
#define FX_ERROR_MSG_TEMPLATE(id, content, ...) \
[id] = (fx_error_msg) \
{ \
.msg_message = (content), .msg_params = __VA_ARGS__, \
}
#define z__fx_error_create_status(status_code) \
(z__fx_error_create( \
fx_error_vendor_get_builtin(), status_code, NULL, NULL, 0, \
NULL, NULL))
/* Error creation macros */
#define fx_error_with_code(vendor, code) \
(z__fx_error_create( \
vendor, code, NULL, __FILE__, __LINE__, __FUNCTION__, NULL))
#define fx_error_caused_by_error(vendor, code, cause_error) \
(z__fx_error_create( \
vendor, code, cause_error, __FILE__, __LINE__, __FUNCTION__, NULL))
#define fx_error_caused_by_status(vendor, code, cause_status) \
(z__fx_error_create( \
vendor, code, z__fx_error_create_status(cause_status), \
__FILE__, __LINE__, __FUNCTION__, NULL))
#define fx_error_caused_by_code(vendor, code, cause_vendor, cause_code) \
(z__fx_error_create( \
vendor, code, fx_error_with_code(cause_vendor, cause_code), \
__FILE__, __LINE__, __FUNCTION__, NULL))
#define fx_error_with_string(vendor, code, ...) \
(z__fx_error_create( \
vendor, code, NULL, __FILE__, __LINE__, __FUNCTION__, __VA_ARGS__))
#define fx_error_with_string_caused_by_error(vendor, code, cause_error, ...) \
(z__fx_error_create( \
vendor, code, cause_error, __FILE__, __LINE__, __FUNCTION__, \
__VA_ARGS__))
#define fx_error_with_string_caused_by_status(vendor, code, cause_status, ...) \
(z__fx_error_create( \
vendor, code, z__fx_error_create_status(cause_status), \
__FILE__, __LINE__, __FUNCTION__, __VA_ARGS__))
#define fx_error_with_msg(vendor, code, msg_id) \
(z__fx_error_create_msg( \
vendor, code, NULL, __FILE__, __LINE__, __FUNCTION__, msg_id, \
(fx_error_template_parameter[]) {{}}))
#define fx_error_with_msg_caused_by_error(vendor, code, cause_error, msg_id) \
(z__fx_error_create_msg( \
vendor, code, cause_error, __FILE__, __LINE__, __FUNCTION__, \
msg_id, (fx_error_template_parameter[]) {{}}))
#define fx_error_with_msg_caused_by_status(vendor, code, cause_status, msg_id) \
(z__fx_error_create_msg( \
vendor, code, z__fx_error_create_status(cause_status), \
__FILE__, __LINE__, __FUNCTION__, msg_id, \
(fx_error_template_parameter[]) {{}}))
#define fx_error_with_msg_template(vendor, code, msg_id, ...) \
(z__fx_error_create_msg( \
vendor, code, NULL, __FILE__, __LINE__, __FUNCTION__, msg_id, \
(fx_error_template_parameter[]) {__VA_ARGS__, {}}))
#define fx_error_with_msg_template_caused_by_error( \
vendor, code, cause_error, msg_id, ...) \
(z__fx_error_create_msg( \
vendor, code, cause_error, __FILE__, __LINE__, __FUNCTION__, \
msg_id, (fx_error_template_parameter[]) {__VA_ARGS__, {}}))
#define fx_error_with_msg_template_caused_by_status( \
vendor, code, cause_status, msg_id, ...) \
(z__fx_error_create_msg( \
vendor, code, z__fx_error_create_status(cause_status), \
__FILE__, __LINE__, __FUNCTION__, msg_id, \
(fx_error_template_parameter[]) {__VA_ARGS__, {}}))
#define fx_error_with_template(vendor, code, ...) \
(z__fx_error_create_template( \
vendor, code, NULL, __FILE__, __LINE__, __FUNCTION__, \
(fx_error_template_parameter[]) {__VA_ARGS__, {}}))
#define fx_error_with_template_caused_by_error(vendor, code, cause_error, ...) \
(z__fx_error_create_template( \
vendor, code, cause_error, __FILE__, __LINE__, __FUNCTION__, \
(fx_error_template_parameter[]) {__VA_ARGS__, {}}))
#define fx_error_with_template_caused_by_status(vendor, code, cause_status, ...) \
(z__fx_error_create_template( \
vendor, code, z__fx_error_create_status(cause_status), \
__FILE__, __LINE__, __FUNCTION__, \
(fx_error_template_parameter[]) {__VA_ARGS__, {}}))
/* Error propagation macros */
#define fx_result_propagate(err) \
(z__fx_error_propagate(err, __FILE__, __LINE__, __FUNCTION__))
#define fx_error_caused_by(err, caused_by) (z__fx_error_caused_by(err, caused_by))
#define fx_error_caused_by_fx_status(err, status) \
(z__fx_error_caused_by_fx_status(err, status))
#define fx_error_replace(err, caused_by) \
(z__fx_error_propagate(err, __FILE__, __LINE__, __FUNCTION__))
/* Error throw macros */
#define z__fx_throw(err) (z__fx_error_throw(err, NULL, 0, NULL))
#define fx_throw(err) (z__fx_error_throw(err, __FILE__, __LINE__, __FUNCTION__))
#define fx_throw_status(status) \
(z__fx_error_throw( \
z__fx_error_create( \
fx_error_vendor_get_builtin(), status, NULL, NULL, 0, \
NULL, NULL), \
__FILE__, __LINE__, __FUNCTION__))
#define fx_throw_status_string(status, ...) \
(z__fx_error_throw( \
z__fx_error_create( \
fx_error_vendor_get_builtin(), status, NULL, NULL, 0, \
NULL, __VA_ARGS__), \
__FILE__, __LINE__, __FUNCTION__))
#define fx_throw_error_code(vendor, code) \
z__fx_throw(fx_error_with_code(vendor, code))
#define fx_throw_error_caused_by_error(vendor, code, cause) \
z__fx_throw(fx_error_caused_by_error(vendor, code, cause))
#define fx_throw_error_caused_by_status(vendor, code, cause) \
z__fx_throw(fx_error_caused_by_status(vendor, code, cause))
#define fx_throw_error_with_string(vendor, code, ...) \
z__fx_throw(fx_error_with_string(vendor, code, __VA_ARGS__))
#define fx_throw_error_with_string_caused_by_error(vendor, code, cause, ...) \
z__fx_throw(fx_error_with_string_caused_by_error( \
vendor, code, cause, __VA_ARGS__))
#define fx_throw_error_with_string_caused_by_status(vendor, code, cause, ...) \
z__fx_throw(fx_error_with_string_caused_by_status( \
vendor, code, cause, __VA_ARGS__))
#define fx_throw_error_with_msg(vendor, code, msg_id) \
z__fx_throw(fx_error_with_msg(vendor, code, msg_id))
#define fx_throw_error_with_msg_caused_by_error(vendor, code, cause, msg_id) \
z__fx_throw(fx_error_with_msg_caused_by_error(vendor, code, cause, msg_id))
#define fx_throw_error_with_msg_caused_by_status(vendor, code, cause, msg_id) \
z__fx_throw(fx_error_with_msg_caused_by_status(vendor, code, cause, msg_id))
#define fx_throw_error_with_msg_template(vendor, code, msg_id, ...) \
z__fx_throw(fx_error_with_msg_template(vendor, code, msg_id, __VA_ARGS__))
#define fx_throw_error_with_msg_template_caused_by_error( \
vendor, code, cause, msg_id, ...) \
z__fx_throw(fx_error_with_msg_template_caused_by_error( \
vendor, code, cause, msg_id, __VA_ARGS__))
#define fx_throw_error_with_msg_template_caused_by_status( \
vendor, code, cause, msg_id, ...) \
z__fx_throw(fx_error_with_msg_template_caused_by_status( \
vendor, code, cause, msg_id, __VA_ARGS__))
#define fx_throw_error_with_template(vendor, code, ...) \
z__fx_throw(fx_error_with_template(vendor, code, __VA_ARGS__))
#define fx_throw_error_with_template_caused_by_error(vendor, code, cause, ...) \
z__fx_throw(fx_error_with_template_caused_by_error( \
vendor, code, cause, __VA_ARGS__))
#define fx_throw_error_with_template_caused_by_status(vendor, code, cause, ...) \
z__fx_throw(fx_error_with_template_caused_by_status( \
vendor, code, cause, __VA_ARGS__))
#define FX_ERR_MSG(s) \
{ \
.msg_type = FX_ERROR_MESSAGE_ERROR, \
.msg_content = (s), \
}
#define FX_ERR_MSG_WARN(s) \
{ \
.msg_type = FX_ERROR_MESSAGE_WARN, \
.msg_content = (s), \
}
#define FX_ERR_MSG_INFO(s) \
{ \
.msg_type = FX_ERROR_MESSAGE_INFO, \
.msg_content = (s), \
}
#define FX_ERR_MSG_END(s) \
{ \
.msg_type = FX_ERROR_MESSAGE_NONE, \
.msg_content = NULL, \
}
typedef enum fx_error_submsg_type {
FX_ERROR_SUBMSG_NONE = 0,
FX_ERROR_SUBMSG_ERROR,
FX_ERROR_SUBMSG_WARNING,
FX_ERROR_SUBMSG_INFO,
} fx_error_submsg_type;
typedef enum fx_error_report_flags {
FX_ERROR_REPORT_NONE = 0,
FX_ERROR_REPORT_STATUS = 0x01u,
FX_ERROR_REPORT_DESCRIPTION = 0x02u,
FX_ERROR_REPORT_SUBMSG = 0x04u,
FX_ERROR_REPORT_STACK_TRACE = 0x08u,
FX_ERROR_REPORT_CAUSE = 0x10u,
FX_ERROR_REPORT_MINIMAL = FX_ERROR_REPORT_STATUS | FX_ERROR_REPORT_DESCRIPTION,
FX_ERROR_REPORT_DEFAULT = FX_ERROR_REPORT_MINIMAL | FX_ERROR_REPORT_SUBMSG
| FX_ERROR_REPORT_CAUSE,
FX_ERROR_REPORT_ALL = FX_ERROR_REPORT_DEFAULT | FX_ERROR_REPORT_STACK_TRACE,
} fx_error_report_flags;
typedef enum fx_error_template_parameter_type {
FX_ERROR_TEMPLATE_PARAM_NONE = 0,
FX_ERROR_TEMPLATE_PARAM_STRING,
FX_ERROR_TEMPLATE_PARAM_CHAR,
FX_ERROR_TEMPLATE_PARAM_INT,
FX_ERROR_TEMPLATE_PARAM_UINT,
FX_ERROR_TEMPLATE_PARAM_LONG,
FX_ERROR_TEMPLATE_PARAM_ULONG,
FX_ERROR_TEMPLATE_PARAM_LONGLONG,
FX_ERROR_TEMPLATE_PARAM_ULONGLONG,
FX_ERROR_TEMPLATE_PARAM_SIZE_T,
FX_ERROR_TEMPLATE_PARAM_INTPTR,
FX_ERROR_TEMPLATE_PARAM_UINTPTR,
FX_ERROR_TEMPLATE_PARAM_PTR,
} fx_error_template_parameter_type;
typedef struct fx_error_template_parameter_definition {
const char *param_name;
fx_error_template_parameter_type param_type;
const char *param_format;
} fx_error_template_parameter_definition;
typedef struct fx_error_template_parameter {
const char *param_name;
uintptr_t param_value;
const struct fx_error_template_parameter_definition *__param_def;
} fx_error_template_parameter;
struct fx_error_vendor;
typedef struct fx_error fx_error;
typedef struct fx_error *fx_result;
typedef struct fx_error_submsg fx_error_submsg;
typedef struct fx_error_stack_frame fx_error_stack_frame;
typedef long fx_error_status_code;
typedef unsigned long fx_error_msg_id;
typedef struct fx_error_definition {
const char *err_name;
const char *err_message;
const fx_error_template_parameter_definition err_params[FX_ERROR_TEMPLATE_PARAMETER_MAX];
} fx_error_definition;
typedef struct fx_error_msg {
const char *msg_message;
const fx_error_template_parameter_definition msg_params[FX_ERROR_TEMPLATE_PARAMETER_MAX];
} fx_error_msg;
typedef const fx_error_definition *(*fx_error_status_code_get_definition)(
const struct fx_error_vendor *, fx_error_status_code);
typedef const fx_error_msg *(*fx_error_msg_get_definition)(
const struct fx_error_vendor *, fx_error_msg_id);
typedef void (*fx_error_report_function)(
const struct fx_error *, fx_error_report_flags);
typedef struct fx_error_vendor {
const char *v_name;
fx_error_status_code_get_definition v_status_get_definition;
fx_error_msg_get_definition v_msg_get_definition;
const fx_error_definition *v_error_definitions;
size_t v_error_definitions_length;
const fx_error_msg *v_msg;
size_t v_msg_length;
} fx_error_vendor;
FX_API fx_error *z__fx_error_create_template(
const fx_error_vendor *, fx_error_status_code, fx_error *, const char *,
unsigned int, const char *, const fx_error_template_parameter[]);
FX_API fx_error *z__fx_error_create_string(
const fx_error_vendor *, fx_error_status_code, fx_error *, const char *,
unsigned int, const char *, const char *, va_list);
FX_API fx_error *z__fx_error_create_msg(
const fx_error_vendor *, fx_error_status_code, fx_error *, const char *,
unsigned int, const char *, fx_error_msg_id,
const fx_error_template_parameter[]);
FX_API fx_error *z__fx_error_propagate(
fx_error *, const char *, unsigned int, const char *);
FX_API fx_error *z__fx_error_caused_by(fx_error *, fx_error *);
FX_API fx_error *z__fx_error_caused_by_fx_status(fx_error *, fx_status);
FX_API void z__fx_error_throw(fx_error *, const char *, unsigned int, const char *);
FX_API bool fx_result_is(
fx_result result, const fx_error_vendor *vendor, fx_error_status_code code);
FX_API const fx_error_vendor *fx_error_vendor_get_builtin(void);
FX_API const fx_error_vendor *fx_error_vendor_get_errno(void);
FX_API const fx_error_definition *fx_error_vendor_get_error_definition(
const fx_error_vendor *vendor, fx_error_status_code code);
FX_API const char *fx_error_vendor_get_status_code_name(
const fx_error_vendor *vendor, fx_error_status_code code);
FX_API const char *fx_error_vendor_get_status_code_description(
const fx_error_vendor *vendor, fx_error_status_code code);
FX_API const fx_error_msg *fx_error_vendor_get_msg(
const fx_error_vendor *vendor, fx_error_msg_id msg_id);
static inline fx_error *z__fx_error_create(
const fx_error_vendor *v, fx_error_status_code c, fx_error *c2,
const char *f0, unsigned int l, const char *f1, const char *d, ...)
{
va_list arg;
va_start(arg, d);
fx_error *err = z__fx_error_create_string(v, c, c2, f0, l, f1, d, arg);
va_end(arg);
return err;
}
FX_API enum fx_status fx_error_add_submsg_string(
fx_error *error, fx_error_submsg_type type, const char *msg, ...);
FX_API enum fx_status z__fx_error_add_submsg_template(
fx_error *error, fx_error_submsg_type type, fx_error_msg_id msg_id,
fx_error_template_parameter param[]);
#define fx_error_add_submsg(error, type, msg_id) \
(z__fx_error_add_submsg_template( \
error, type, msg_id, (fx_error_template_parameter[]) {{}}))
#define fx_error_add_submsg_template(error, type, msg_id, ...) \
(z__fx_error_add_submsg_template( \
error, type, msg_id, \
(fx_error_template_parameter[]) {__VA_ARGS__, {}}))
FX_API void fx_error_discard(fx_error *error);
FX_API fx_error_status_code fx_error_get_status_code(const fx_error *error);
FX_API const fx_error_vendor *fx_error_get_vendor(const fx_error *error);
FX_API const fx_error_definition *fx_error_get_definition(const fx_error *error);
FX_API const fx_error_template_parameter *fx_error_get_template_parameter(
const fx_error *error, const char *param_name);
FX_API const fx_error_template_parameter *fx_error_get_template_parameters(
const fx_error *error);
FX_API const char *fx_error_get_description(const fx_error *error);
FX_API const fx_error_msg *fx_error_get_msg(const fx_error *error);
FX_API const fx_error_submsg *fx_error_get_first_submsg(const fx_error *error);
FX_API const fx_error_submsg *fx_error_get_next_submsg(
const fx_error *error, const fx_error_submsg *msg);
FX_API const fx_error_stack_frame *fx_error_get_first_stack_frame(
const fx_error *error);
FX_API const fx_error_stack_frame *fx_error_get_next_stack_frame(
const fx_error *error, const fx_error_stack_frame *frame);
FX_API const fx_error *fx_error_get_caused_by(const fx_error *error);
FX_API fx_error_submsg_type fx_error_submsg_get_type(const fx_error_submsg *msg);
FX_API const char *fx_error_submsg_get_content(const fx_error_submsg *msg);
FX_API const fx_error_msg *fx_error_submsg_get_msg(const fx_error_submsg *msg);
FX_API const fx_error_template_parameter *fx_error_submsg_get_template_parameters(
const fx_error_submsg *msg);
FX_API const char *fx_error_stack_frame_get_filepath(
const fx_error_stack_frame *frame);
FX_API unsigned int fx_error_stack_frame_get_line_number(
const fx_error_stack_frame *frame);
FX_API const char *fx_error_stack_frame_get_function_name(
const fx_error_stack_frame *frame);
FX_API const fx_error_template_parameter_definition *fx_error_definition_get_template_parameter(
const fx_error_definition *error_def, const char *param_name);
FX_API const char *fx_error_msg_get_content(const fx_error_msg *msg);
FX_API const fx_error_template_parameter_definition *fx_error_msg_get_template_parameter(
const fx_error_msg *msg, const char *param_name);
FX_API void fx_set_error_report_function(
fx_error_report_function func, fx_error_report_flags flags);
#endif

0
core/include/blue/core/exception.h → core/include/fx/core/exception.h
View File

111
core/include/fx/core/hash.h Normal file
View File

@@ -0,0 +1,111 @@
#ifndef FX_CORE_HASH_H_
#define FX_CORE_HASH_H_
#include <fx/core/misc.h>
#include <fx/core/status.h>
#include <stddef.h>
#include <stdint.h>
#define FX_DIGEST_LENGTH_128 16
#define FX_DIGEST_LENGTH_160 20
#define FX_DIGEST_LENGTH_192 24
#define FX_DIGEST_LENGTH_224 28
#define FX_DIGEST_LENGTH_256 32
#define FX_DIGEST_LENGTH_384 48
#define FX_DIGEST_LENGTH_512 64
#define FX_DIGEST_LENGTH_MD4 FX_DIGEST_LENGTH_128
#define FX_DIGEST_LENGTH_MD5 FX_DIGEST_LENGTH_128
#define FX_DIGEST_LENGTH_SHA1 FX_DIGEST_LENGTH_160
#define FX_DIGEST_LENGTH_SHA2_224 FX_DIGEST_LENGTH_224
#define FX_DIGEST_LENGTH_SHA2_256 FX_DIGEST_LENGTH_256
#define FX_DIGEST_LENGTH_SHA2_384 FX_DIGEST_LENGTH_384
#define FX_DIGEST_LENGTH_SHA2_512 FX_DIGEST_LENGTH_512
#define FX_DIGEST_LENGTH_SHA3_224 FX_DIGEST_LENGTH_224
#define FX_DIGEST_LENGTH_SHA3_256 FX_DIGEST_LENGTH_256
#define FX_DIGEST_LENGTH_SHA3_384 FX_DIGEST_LENGTH_384
#define FX_DIGEST_LENGTH_SHA3_512 FX_DIGEST_LENGTH_512
#define FX_DIGEST_LENGTH_SHAKE128 FX_DIGEST_LENGTH_128
#define FX_DIGEST_LENGTH_SHAKE256 FX_DIGEST_LENGTH_256
struct fx_hash_function_ops;
struct fx_rope;
typedef enum fx_hash_function {
FX_HASH_NONE = 0,
FX_HASH_MD4,
FX_HASH_MD5,
FX_HASH_SHA1,
FX_HASH_SHA2_224,
FX_HASH_SHA2_256,
FX_HASH_SHA2_384,
FX_HASH_SHA2_512,
FX_HASH_SHA3_224,
FX_HASH_SHA3_256,
FX_HASH_SHA3_384,
FX_HASH_SHA3_512,
FX_HASH_SHAKE128,
FX_HASH_SHAKE256,
} fx_hash_function;
typedef struct fx_hash_ctx {
fx_hash_function ctx_func;
const struct fx_hash_function_ops *ctx_ops;
union {
struct {
uint32_t lo, hi;
uint32_t a, b, c, d;
uint32_t block[16];
unsigned char buffer[64];
} md4;
struct {
unsigned int count[2];
unsigned int a, b, c, d;
unsigned int block[16];
unsigned char input[64];
} md5;
struct {
uint32_t state[5];
uint32_t count[2];
unsigned char buffer[64];
} sha1;
struct {
uint64_t curlen;
uint64_t length;
unsigned char buf[128];
uint32_t state[8];
} sha2_256;
struct {
uint64_t curlen;
uint64_t length;
unsigned char block[256];
uint64_t state[8];
} sha2_512;
struct {
union {
uint8_t b[200];
uint64_t q[25];
} st;
int pt, rsiz, mdlen;
} sha3;
} ctx_state;
} fx_hash_ctx;
FX_API uint64_t fx_hash_cstr(const char *s);
FX_API uint64_t fx_hash_cstr_ex(const char *s, size_t *len);
FX_API fx_status fx_hash_ctx_init(fx_hash_ctx *ctx, fx_hash_function func);
FX_API fx_status fx_hash_ctx_reset(fx_hash_ctx *ctx);
FX_API fx_status fx_hash_ctx_update(fx_hash_ctx *ctx, const void *p, size_t len);
FX_API fx_status fx_hash_ctx_update_rope(fx_hash_ctx *ctx, const struct fx_rope *rope);
FX_API fx_status fx_hash_ctx_finish(
fx_hash_ctx *ctx, void *out_digest, size_t out_max);
#endif

14
core/include/blue/core/init.h → core/include/fx/core/init.h
View File

@@ -1,8 +1,8 @@
#ifndef BLUELIB_INIT_H_
#define BLUELIB_INIT_H_
#ifndef FX_INIT_H_
#define FX_INIT_H_
#ifdef __cplusplus
#define B_INIT(f) \
#define FX_INIT(f) \
static void f(void); \
struct f##_t_ { \
f##_t_(void) \
@@ -14,17 +14,17 @@
static void f(void)
#elif defined(_MSC_VER)
#pragma section(".CRT$XCU", read)
#define B_INIT2_(f, p) \
#define FX_INIT2_(f, p) \
static void f(void); \
__declspec(allocate(".CRT$XCU")) void (*f##_)(void) = f; \
__pragma(comment(linker, "/include:" p #f "_")) static void f(void)
#ifdef _WIN64
#define B_INIT(f) B_INIT2_(f, "")
#define FX_INIT(f) FX_INIT2_(f, "")
#else
#define B_INIT(f) B_INIT2_(f, "_")
#define FX_INIT(f) FX_INIT2_(f, "_")
#endif
#else
#define B_INIT(f) \
#define FX_INIT(f) \
static void f(void) __attribute__((constructor)); \
static void f(void)
#endif

93
core/include/fx/core/iterator.h Normal file
View File

@@ -0,0 +1,93 @@
#ifndef FX_CORE_ITERATOR_H_
#define FX_CORE_ITERATOR_H_
#include <fx/core/macros.h>
#include <fx/core/misc.h>
#include <fx/core/status.h>
#include <stdbool.h>
FX_DECLS_BEGIN;
#define fx_foreach(type, var, iterator) \
for (type var = (type)fx_iterator_get_value(iterator).v_int; \
FX_OK(fx_iterator_get_status(iterator)); \
fx_iterator_move_next(iterator), \
var = (type)fx_iterator_get_value(iterator).v_int)
#define fx_foreach_ptr(type, var, iterator) \
for (type *var = (type *)fx_iterator_get_value(iterator).v_ptr; \
FX_OK(fx_iterator_get_status(iterator)); \
fx_iterator_move_next(iterator), \
var = (type *)fx_iterator_get_value(iterator).v_ptr)
#define fx_foreach_c(type, var, iterator) \
for (type var = (type)fx_iterator_get_cvalue(iterator).v_int; \
FX_OK(fx_iterator_get_status(iterator)); \
fx_iterator_move_next(iterator), \
var = (type)fx_iterator_get_cvalue(iterator).v_int)
#define fx_foreach_cptr(type, var, iterator) \
for (const type *var \
= (const type *)fx_iterator_get_cvalue(iterator).v_cptr; \
FX_OK(fx_iterator_get_status(iterator)); \
fx_iterator_move_next(iterator), \
var = (const type *)fx_iterator_get_cvalue(iterator).v_cptr)
#define FX_ITERATOR_VALUE_INT(v) ((fx_iterator_value) {.v_int = (v)})
#define FX_ITERATOR_VALUE_PTR(v) ((fx_iterator_value) {.v_ptr = (v)})
#define FX_ITERATOR_VALUE_CPTR(v) ((const fx_iterator_value) {.v_cptr = (v)})
#define FX_ITERATOR_VALUE_NULL ((fx_iterator_value) {})
#define FX_ITERATOR_VALUE_IS_NULL(v) ((v)->v_ptr == NULL)
#define FX_TYPE_ITERATOR (fx_iterator_get_type())
#define FX_TYPE_ITERABLE (fx_iterable_get_type())
typedef union fx_iterator_value {
uintptr_t v_int;
void *v_ptr;
const void *v_cptr;
} fx_iterator_value;
__FX_DECLARE_TYPE(fx_iterator);
FX_DECLARE_TYPE(fx_iterable);
FX_TYPE_CLASS_DECLARATION_BEGIN(fx_iterator)
fx_status (*it_move_next)(const fx_iterator *);
fx_status (*it_erase)(fx_iterator *);
fx_iterator_value (*it_get_value)(fx_iterator *);
const fx_iterator_value (*it_get_cvalue)(const fx_iterator *);
FX_TYPE_CLASS_DECLARATION_END(fx_iterator)
FX_TYPE_CLASS_DECLARATION_BEGIN(fx_iterable)
fx_iterator *(*it_begin)(fx_iterable *);
const fx_iterator *(*it_cbegin)(const fx_iterable *);
FX_TYPE_CLASS_DECLARATION_END(fx_iterable)
FX_API fx_type fx_iterator_get_type(void);
FX_API fx_type fx_iterable_get_type(void);
static inline const fx_iterator *fx_iterator_ref(const fx_iterator *p)
{
return fx_object_ref((fx_object *)p);
}
static inline void fx_iterator_unref(const fx_iterator *p)
{
fx_object_unref((fx_object *)p);
}
FX_API fx_iterator *fx_iterator_begin(fx_iterable *it);
FX_API const fx_iterator *fx_iterator_cbegin(const fx_iterable *it);
FX_API fx_status fx_iterator_get_status(const fx_iterator *it);
FX_API fx_status fx_iterator_set_status(const fx_iterator *it, fx_status status);
FX_API fx_status fx_iterator_move_next(const fx_iterator *it);
FX_API fx_iterator_value fx_iterator_get_value(fx_iterator *it);
FX_API const fx_iterator_value fx_iterator_get_cvalue(const fx_iterator *it);
FX_API fx_status fx_iterator_erase(fx_iterator *it);
static inline bool fx_iterator_is_valid(const fx_iterator *it)
{
return FX_OK(fx_iterator_get_status(it));
}
FX_DECLS_END;
#endif

197
core/include/fx/core/macros.h Normal file
View File

@@ -0,0 +1,197 @@
#ifndef FX_CORE_MACROS_H_
#define FX_CORE_MACROS_H_
#include <fx/core/class.h>
#include <fx/core/object.h>
#include <fx/core/thread.h>
#include <fx/core/type.h>
#include <stdlib.h>
#define __FX_IFACE_I0(p, x) p##x
#define __FX_IFACE_I1(p, x) __FX_IFACE_I0(p, x)
/* Type definitions macros (for use in .c source file) */
#define FX_TYPE_CLASS_DEFINITION_BEGIN(type_name) \
static void type_name##_class_init(fx_class *p, void *d) \
{
#define FX_TYPE_CLASS_DEFINITION_END(type_name) }
#define FX_TYPE_CLASS_INTERFACE_BEGIN(interface_name, interface_id) \
interface_name##_class *__FX_IFACE_I1(iface, __LINE__) \
= fx_class_get_interface(p, interface_id); \
if (!__FX_IFACE_I1(iface, __LINE__)) { \
fx_throw_error_with_msg_template( \
FX_ERRORS_BUILTIN, FX_ERR_CLASS_INIT_FAILURE, \
FX_MSG_CLASS_SPECIFIES_UNKNOWN_INTERFACE, \
FX_ERROR_PARAM("class_name", fx_class_get_name(p)), \
FX_ERROR_PARAM("interface_name", #interface_name)); \
exit(-1); \
} else { \
interface_name##_class *iface = __FX_IFACE_I1(iface, __LINE__);
#define FX_TYPE_CLASS_INTERFACE_END(interface_name, interface_id) }
#define FX_INTERFACE_ENTRY(slot) iface->slot
#define FX_TYPE_DEFINITION_BEGIN(name) \
static fx_type_info name##_type_info = {0}; \
static void name##_class_init(fx_class *, void *); \
static void name##_type_init(void) \
{ \
fx_type_info *type_info = &name##_type_info; \
unsigned int nr_vtables = 0; \
type_info->t_name = #name; \
type_info->t_class_init = name##_class_init;
#define FX_TYPE_DEFINITION_END(name) \
fx_result result = fx_type_register(type_info); \
if (fx_result_is_error(result)) { \
fx_throw_error_caused_by_error( \
FX_ERRORS_BUILTIN, FX_ERR_TYPE_REGISTRATION_FAILURE, \
result); \
abort(); \
} \
} \
fx_type name##_get_type(void) \
{ \
static fx_once static_type_init = FX_ONCE_INIT; \
\
if (fx_init_once(&static_type_init)) { \
name##_type_init(); \
} \
\
return &name##_type_info.t_id; \
}
#define FX_TYPE_ID(a, b, c, d, e) fx_type_id_init(&type_info->t_id, a, b, c, d, e)
#define FX_TYPE_EXTENDS(parent_id) \
fx_type_id_copy(parent_id, &type_info->t_parent_id)
#define FX_TYPE_IMPLEMENTS(interface_id) \
fx_type_id_copy( \
interface_id, \
&type_info->t_interfaces[type_info->t_nr_interfaces++])
#define FX_TYPE_CLASS(class_struct) \
type_info->t_class_size = sizeof(class_struct)
#define FX_TYPE_FLAGS(flags) type_info->t_flags = (flags)
#define FX_TYPE_INSTANCE_INIT(func) type_info->t_instance_init = (func)
#define FX_TYPE_INSTANCE_FINI(func) type_info->t_instance_fini = (func)
#if 0
#define FX_TYPE_VTABLE_BEGIN(vtable_struct, interface_id) \
vtable_struct __FX_IFACE_I1(iface, __LINE__) = {0}; \
{ \
vtable_struct *iface = &__FX_IFACE_I1(iface, __LINE__); \
type_info->t_vtables[nr_vtables].v_vtable = iface; \
type_info->t_vtables[nr_vtables].v_interface_id = interface_id; \
nr_vtables++;
#define FX_TYPE_VTABLE_END(vtable_struct, interface_id) }
#endif
#define FX_TYPE_INSTANCE_PRIVATE(instance_struct) \
type_info->t_instance_private_size = sizeof(instance_struct)
#define FX_TYPE_INSTANCE_PROTECTED(instance_struct) \
type_info->t_instance_protected_size = sizeof(instance_struct)
/* Type declaration macros (for use in .h header file) */
#define __FX_DECLARE_TYPE(name) \
typedef FX_TYPE_FWDREF(name) name; \
typedef struct _##name##_class name##_class;
#define FX_DECLARE_TYPE(name) \
__FX_DECLARE_TYPE(name); \
static inline name *name##_ref(name *p) \
{ \
return fx_object_ref(p); \
} \
static inline void name##_unref(name *p) \
{ \
fx_object_unref(p); \
}
#define FX_TYPE_CLASS_DECLARATION_BEGIN(name) struct _##name##_class {
#define FX_TYPE_CLASS_DECLARATION_END(name) \
} \
;
#define FX_TYPE_VIRTUAL_METHOD(return_type, method_name) \
return_type(*method_name)
#define FX_TYPE_DEFAULT_CONSTRUCTOR(type_name, type_id) \
static inline type_name *type_name##_create(void) \
{ \
return fx_object_create(type_id); \
}
/* Other macros */
#define FX_CLASS_DISPATCH_VIRTUAL( \
type_name, type_id, default_value, func, object, ...) \
do { \
type_name##_class *iface \
= fx_object_get_interface(object, type_id); \
if (iface && iface->func) { \
return iface->func(object, __VA_ARGS__); \
} else { \
return default_value; \
} \
} while (0)
#define FX_CLASS_DISPATCH_VIRTUAL_0(type_name, type_id, default_value, func, object) \
do { \
type_name##_class *iface \
= fx_object_get_interface(object, type_id); \
if (iface && iface->func) { \
return iface->func(object); \
} else { \
return default_value; \
} \
} while (0)
#define FX_CLASS_DISPATCH_VIRTUAL_V(type_name, type_id, func, object, ...) \
do { \
type_name##_class *iface \
= fx_object_get_interface(object, type_id); \
if (iface && iface->func) { \
iface->func(object, __VA_ARGS__); \
return; \
} \
} while (0)
#define FX_CLASS_DISPATCH_VIRTUAL_V0(type_name, type_id, func, object) \
do { \
type_name##_class *iface \
= fx_object_get_interface(object, type_id); \
if (iface && iface->func) { \
iface->func(object); \
return; \
} \
} while (0)
#define FX_CLASS_DISPATCH_STATIC(type_id, func_name, obj, ...) \
do { \
void *priv = fx_object_get_private(obj, type_id); \
return func_name(priv, __VA_ARGS__); \
} while (0)
#define FX_CLASS_DISPATCH_STATIC_V(type_id, func_name, obj, ...) \
do { \
void *priv = fx_object_get_private(obj, type_id); \
func_name(priv, __VA_ARGS__); \
} while (0)
#define FX_CLASS_DISPATCH_STATIC_0(type_id, func_name, obj) \
do { \
void *priv = fx_object_get_private(obj, type_id); \
return func_name(priv); \
} while (0)
#define FX_CLASS_DISPATCH_STATIC_V0(type_id, func_name, obj) \
do { \
void *priv = fx_object_get_private(obj, type_id); \
func_name(priv); \
} while (0)
#ifdef __cplusplus
#define FX_DECLS_BEGIN extern "C" {
#define FX_DECLS_END }
#else
#define FX_DECLS_BEGIN
#define FX_DECLS_END
#endif
#endif

118
core/include/fx/core/misc.h Normal file
View File

@@ -0,0 +1,118 @@
#ifndef FX_CORE_MISC_H_
#define FX_CORE_MISC_H_
#include <stddef.h>
#include <stdint.h>
#ifndef _Nonnull
#define _Nonnull
#endif
#define FX_NPOS ((size_t)-1)
#define fx_min(type, x, y) (z__fx_min_##type(x, y))
#define fx_max(type, x, y) (z__fx_max_##type(x, y))
#define fx_unbox(type, box, member) \
((type *_Nonnull)((box) ? (uintptr_t)(box) - (offsetof(type, member)) : 0))
#define z__fx_merge_(a, b) a##b
#define z__fx_label_(a) z__fx_merge_(__unique_name_, a)
#define z__fx_unique_name() z__fx_label_(__LINE__)
#define z__fx_numargs(arg_type, ...) \
(sizeof((arg_type[]) {__VA_ARGS__}) / sizeof(arg_type))
#ifdef _MSC_VER
#ifdef FX_STATIC
#define FX_API extern
#else
#ifdef FX_EXPORT
#define FX_API extern __declspec(dllexport)
#else
#define FX_API extern __declspec(dllimport)
#endif
#endif
#else
#define FX_API extern
#endif
static inline char z__fx_min_char(char x, char y)
{
return x < y ? x : y;
}
static inline unsigned char z__fx_min_uchar(unsigned char x, unsigned char y)
{
return x < y ? x : y;
}
static inline int z__fx_min_int(int x, int y)
{
return x < y ? x : y;
}
static inline unsigned int z__fx_min_uint(unsigned int x, unsigned int y)
{
return x < y ? x : y;
}
static inline long z__fx_min_long(long x, long y)
{
return x < y ? x : y;
}
static inline unsigned int z__fx_min_ulong(unsigned long x, unsigned long y)
{
return x < y ? x : y;
}
static inline long long z__fx_min_longlong(long long x, long long y)
{
return x < y ? x : y;
}
static inline unsigned long long z__fx_min_ulonglong(
unsigned long long x, unsigned long long y)
{
return x < y ? x : y;
}
static inline size_t z__fx_min_size_t(size_t x, size_t y)
{
return x < y ? x : y;
}
static inline char z__fx_max_char(char x, char y)
{
return x > y ? x : y;
}
static inline unsigned char z__fx_max_uchar(unsigned char x, unsigned char y)
{
return x > y ? x : y;
}
static inline int z__fx_max_int(int x, int y)
{
return x > y ? x : y;
}
static inline unsigned int z__fx_max_uint(unsigned int x, unsigned int y)
{
return x > y ? x : y;
}
static inline long z__fx_max_long(long x, long y)
{
return x > y ? x : y;
}
static inline unsigned int z__fx_max_ulong(unsigned long x, unsigned long y)
{
return x > y ? x : y;
}
static inline long long z__fx_max_longlong(long long x, long long y)
{
return x > y ? x : y;
}
static inline unsigned long long z__fx_max_ulonglong(
unsigned long long x, unsigned long long y)
{
return x > y ? x : y;
}
static inline size_t z__fx_max_size_t(size_t x, size_t y)
{
return x > y ? x : y;
}
FX_API size_t fx_int_length(intptr_t v);
FX_API size_t fx_uint_length(uintptr_t v);
#endif // FX_CORE_MISC_H_

39
core/include/fx/core/object.h Normal file
View File

@@ -0,0 +1,39 @@
#ifndef FX_CORE_OBJECT_H_
#define FX_CORE_OBJECT_H_
#include <fx/core/misc.h>
#include <fx/core/type.h>
#define FX_OBJECT_MAGIC 0xDECAFC0C0ABEEF13ULL
#define FX_OBJECT(p) ((fx_object *)(p))
#define FX_TYPE_OBJECT (fx_object_get_type())
#define FX_TYPE_FWDREF(name) struct _fx_object
#define FX_RV(p) (fx_object_make_rvalue(p))
typedef FX_TYPE_FWDREF(fx_object) fx_object;
typedef struct _fx_object_class {
void (*to_string)(const fx_object *, FX_TYPE_FWDREF(fx_stream) *);
} fx_object_class;
FX_API fx_type fx_object_get_type(void);
FX_API void *fx_object_get_private(const fx_object *object, fx_type type);
FX_API void *fx_object_get_protected(const fx_object *object, fx_type type);
FX_API void *fx_object_get_interface(const fx_object *object, fx_type type);
FX_API fx_status fx_object_get_data(
const fx_object *object, fx_type type, void **priv, void **prot,
void **iface);
FX_API fx_object *fx_object_ref(fx_object *p);
FX_API void fx_object_unref(fx_object *p);
FX_API fx_object *fx_object_make_rvalue(fx_object *p);
FX_API fx_object *fx_object_create(fx_type type);
FX_API void fx_object_to_string(const fx_object *p, FX_TYPE_FWDREF(fx_stream) * out);
FX_API bool fx_object_is_type(const fx_object *p, fx_type type);
#endif

82
core/include/fx/core/queue.h Normal file
View File

@@ -0,0 +1,82 @@
#ifndef FX_CORE_QUEUE_H_
#define FX_CORE_QUEUE_H_
#include <fx/core/iterator.h>
#include <fx/core/macros.h>
#include <fx/core/status.h>
#include <stdbool.h>
#include <string.h>
FX_DECLS_BEGIN;
#define FX_TYPE_QUEUE_ITERATOR (fx_queue_iterator_get_type())
FX_DECLARE_TYPE(fx_queue_iterator);
FX_TYPE_CLASS_DECLARATION_BEGIN(fx_queue_iterator)
FX_TYPE_CLASS_DECLARATION_END(fx_queue_iterator)
#define FX_QUEUE_INIT ((fx_queue) {.q_first = NULL, .q_last = NULL})
#define FX_QUEUE_ENTRY_INIT ((fx_queue_entry) {.qe_next = NULL, .qe_prev = NULL})
typedef struct fx_queue_entry {
struct fx_queue_entry *qe_next;
struct fx_queue_entry *qe_prev;
} fx_queue_entry;
typedef struct fx_queue {
fx_queue_entry *q_first;
fx_queue_entry *q_last;
} fx_queue;
static inline void fx_queue_init(fx_queue *q)
{
memset(q, 0x00, sizeof *q);
}
static inline bool fx_queue_empty(const fx_queue *q)
{
return q ? (q->q_first == NULL) : true;
}
static inline fx_queue_entry *fx_queue_first(const fx_queue *q)
{
return q ? q->q_first : NULL;
}
static inline fx_queue_entry *fx_queue_last(const fx_queue *q)
{
return q ? q->q_last : NULL;
}
static inline fx_queue_entry *fx_queue_next(const fx_queue_entry *entry)
{
return entry ? entry->qe_next : NULL;
}
static inline fx_queue_entry *fx_queue_prev(const fx_queue_entry *entry)
{
return entry ? entry->qe_prev : NULL;
}
FX_API fx_type fx_queue_iterator_get_type(void);
FX_API size_t fx_queue_length(const fx_queue *q);
FX_API void fx_queue_insert_before(
fx_queue *q, fx_queue_entry *entry, fx_queue_entry *before);
FX_API void fx_queue_insert_after(
fx_queue *q, fx_queue_entry *entry, fx_queue_entry *after);
FX_API void fx_queue_push_front(fx_queue *q, fx_queue_entry *entry);
FX_API void fx_queue_push_back(fx_queue *q, fx_queue_entry *entry);
FX_API fx_queue_entry *fx_queue_pop_front(fx_queue *q);
FX_API fx_queue_entry *fx_queue_pop_back(fx_queue *q);
FX_API void fx_queue_move(fx_queue *q, fx_queue_entry *dest, fx_queue_entry *src);
FX_API void fx_queue_delete(fx_queue *q, fx_queue_entry *entry);
FX_API void fx_queue_delete_all(fx_queue *q);
FX_API fx_iterator *fx_queue_begin(fx_queue *q);
FX_API fx_iterator *fx_queue_cbegin(const fx_queue *q);
FX_DECLS_END;
#endif

37
core/include/fx/core/random.h Normal file
View File

@@ -0,0 +1,37 @@
#ifndef FX_RANDOM_H_
#define FX_RANDOM_H_
#include <fx/core/status.h>
#include <stddef.h>
struct fx_random_algorithm;
typedef enum fx_random_flags {
/* algorithm selection */
FX_RANDOM_MT19937 = 0x01u,
/* generation flags */
FX_RANDOM_SECURE = 0x100u,
} fx_random_flags;
typedef struct fx_random_ctx {
fx_random_flags __f;
struct fx_random_algorithm *__a;
union {
struct {
unsigned long long mt[312];
size_t mti;
} __mt19937;
};
} fx_random_ctx;
FX_API fx_random_ctx *fx_random_global_ctx(void);
FX_API fx_status fx_random_init(fx_random_ctx *ctx, fx_random_flags flags);
FX_API unsigned long long fx_random_next_int64(fx_random_ctx *ctx);
FX_API double fx_random_next_double(fx_random_ctx *ctx);
FX_API void fx_random_next_bytes(
fx_random_ctx *ctx, unsigned char *out, size_t nbytes);
#endif

47
core/include/fx/core/ringbuffer.h Normal file
View File

@@ -0,0 +1,47 @@
#ifndef FX_CORE_RINGBUFFER_H_
#define FX_CORE_RINGBUFFER_H_
#include <fx/core/macros.h>
#include <fx/core/misc.h>
#include <fx/core/status.h>
FX_DECLS_BEGIN;
#define FX_TYPE_RINGBUFFER (fx_ringbuffer_get_type())
FX_DECLARE_TYPE(fx_ringbuffer);
FX_TYPE_CLASS_DECLARATION_BEGIN(fx_ringbuffer)
FX_TYPE_CLASS_DECLARATION_END(fx_ringbuffer)
FX_API fx_type fx_ringbuffer_get_type(void);
FX_API fx_ringbuffer *fx_ringbuffer_create(size_t capacity);
FX_API fx_ringbuffer *fx_ringbuffer_create_with_buffer(void *ptr, size_t capacity);
FX_API fx_status fx_ringbuffer_clear(fx_ringbuffer *buf);
FX_API fx_status fx_ringbuffer_read(
fx_ringbuffer *buf, void *p, size_t count, size_t *nr_read);
FX_API fx_status fx_ringbuffer_write(
fx_ringbuffer *buf, const void *p, size_t count, size_t *nr_written);
FX_API int fx_ringbuffer_getc(fx_ringbuffer *buf);
FX_API fx_status fx_ringbuffer_putc(fx_ringbuffer *buf, int c);
FX_API size_t fx_ringbuffer_write_capacity_remaining(const fx_ringbuffer *buf);
FX_API size_t fx_ringbuffer_available_data_remaining(const fx_ringbuffer *buf);
FX_API fx_status fx_ringbuffer_open_read_buffer(
fx_ringbuffer *buf, const void **ptr, size_t *length);
FX_API fx_status fx_ringbuffer_close_read_buffer(
fx_ringbuffer *buf, const void **ptr, size_t nr_read);
FX_API fx_status fx_ringbuffer_open_write_buffer(
fx_ringbuffer *buf, void **ptr, size_t *capacity);
FX_API fx_status fx_ringbuffer_close_write_buffer(
fx_ringbuffer *buf, void **ptr, size_t nr_written);
FX_DECLS_END;
#endif

109
core/include/fx/core/rope.h Normal file
View File

@@ -0,0 +1,109 @@
#ifndef FX_CORE_ROPE_H_
#define FX_CORE_ROPE_H_
#include <fx/core/hash.h>
#include <fx/core/misc.h>
#include <fx/core/stream.h>
#include <stdint.h>
#include <string.h>
struct fx_string;
struct fx_bstr;
#define FX_ROPE_TYPE(f) ((f) & 0xFF)
#define FX_ROPE_CHAR(c) \
\
{ \
.r_flags = FX_ROPE_F_CHAR, .r_len_total = 1, \
.r_v = {.v_char = (c) } \
}
#define FX_ROPE_CSTR(str) \
{ \
.r_flags = FX_ROPE_F_CSTR_BORROWED, \
.r_len_total = strlen(str), \
.r_v = { \
.v_cstr = { \
.s = (str), \
.hash = fx_hash_cstr(str), \
}, \
}, \
}
#define FX_ROPE_CSTR_STATIC(str) \
{ \
.r_flags = FX_ROPE_F_CSTR_STATIC, \
.r_len_total = strlen(str), \
.r_v = { \
.v_cstr = { \
.s = (str), \
.hash = fx_hash_cstr(str), \
}, \
}, \
}
#define FX_ROPE_INT(v) \
\
{ \
.r_flags = FX_ROPE_F_INT, .r_len_total = fx_int_length(v), \
.r_v = {.v_int = (v) } \
}
#define FX_ROPE_UINT(v) \
\
{ \
.r_flags = FX_ROPE_F_UINT, .r_len_total = fx_uint_length(v), \
.r_v = {.v_uint = (v) } \
}
typedef enum fx_rope_flags {
FX_ROPE_F_NONE = 0x0000u,
FX_ROPE_F_CHAR = 0x0001u,
FX_ROPE_F_CSTR = 0x0002u,
FX_ROPE_F_CSTR_BORROWED = 0x0003u,
FX_ROPE_F_CSTR_STATIC = 0x0004u,
FX_ROPE_F_INT = 0x0005u,
FX_ROPE_F_UINT = 0x0006u,
FX_ROPE_F_COMPOSITE = 0x0007u,
FX_ROPE_F_MALLOC = 0x0100u,
} fx_rope_flags;
typedef struct fx_rope {
fx_rope_flags r_flags;
unsigned long r_len_left, r_len_total;
union {
char v_char;
intptr_t v_int;
uintptr_t v_uint;
struct {
const char *s;
uint64_t hash;
} v_cstr;
struct {
const struct fx_rope *r_left, *r_right;
} v_composite;
} r_v;
} fx_rope;
FX_API void fx_rope_init_char(fx_rope *rope, char c);
FX_API void fx_rope_init_cstr(fx_rope *rope, const char *s);
FX_API void fx_rope_init_cstr_borrowed(fx_rope *rope, const char *s);
FX_API void fx_rope_init_cstr_static(fx_rope *rope, const char *s);
FX_API void fx_rope_init_int(fx_rope *rope, intptr_t v);
FX_API void fx_rope_init_uint(fx_rope *rope, uintptr_t v);
FX_API void fx_rope_destroy(fx_rope *rope);
FX_API void fx_rope_iterate(
const fx_rope *rope, void (*func)(const fx_rope *, void *), void *arg);
FX_API size_t fx_rope_get_size(const fx_rope *rope);
FX_API void fx_rope_concat(fx_rope *result, const fx_rope *left, const fx_rope *right);
FX_API void fx_rope_join(fx_rope *result, const fx_rope **ropes, size_t nr_ropes);
FX_API fx_status fx_rope_to_cstr(const fx_rope *rope, char *out, size_t max);
FX_API fx_status fx_rope_to_bstr(const fx_rope *rope, struct fx_bstr *str);
FX_API fx_status fx_rope_to_string(const fx_rope *rope, fx_stream *out);
#endif

48
core/include/fx/core/status.h Normal file
View File

@@ -0,0 +1,48 @@
#ifndef FX_CORE_STATUS_H_
#define FX_CORE_STATUS_H_
#include <fx/core/misc.h>
#define FX_OK(status) ((enum fx_status)((uintptr_t)(status)) == FX_SUCCESS)
#define FX_ERR(status) ((status) != FX_SUCCESS)
typedef enum fx_status {
FX_SUCCESS = 0x00u,
FX_ERR_NO_MEMORY,
FX_ERR_OUT_OF_BOUNDS,
FX_ERR_INVALID_ARGUMENT,
FX_ERR_NAME_EXISTS,
FX_ERR_NOT_SUPPORTED,
FX_ERR_BAD_STATE,
FX_ERR_NO_ENTRY,
FX_ERR_NO_DATA,
FX_ERR_NO_SPACE,
FX_ERR_UNKNOWN_FUNCTION,
FX_ERR_BAD_FORMAT,
FX_ERR_IO_FAILURE,
FX_ERR_IS_DIRECTORY,
FX_ERR_NOT_DIRECTORY,
FX_ERR_PERMISSION_DENIED,
FX_ERR_BUSY,
/* fx-compress specific code */
FX_ERR_COMPRESSION_FAILURE,
/* fx-object specific code */
FX_ERR_TYPE_REGISTRATION_FAILURE,
FX_ERR_CLASS_INIT_FAILURE,
} fx_status;
typedef enum fx_status_msg {
FX_MSG_SUCCESS = 0,
/* fx-object specific messages */
FX_MSG_TYPE_REGISTRATION_FAILURE,
FX_MSG_CLASS_INIT_FAILURE,
FX_MSG_CLASS_SPECIFIES_UNKNOWN_INTERFACE,
} fx_status_msg;
FX_API const char *fx_status_to_string(fx_status status);
FX_API const char *fx_status_description(fx_status status);
#endif

100
core/include/fx/core/stream.h Normal file
View File

@@ -0,0 +1,100 @@
#ifndef FX_CORE_STREAM_H_
#define FX_CORE_STREAM_H_
#include <fx/core/encoding.h>
#include <fx/core/macros.h>
#include <fx/core/misc.h>
#include <fx/core/status.h>
#include <stdarg.h>
#include <stdio.h>
FX_DECLS_BEGIN;
#define fx_stdin (z__fx_stream_get_stdin())
#define fx_stdout (z__fx_stream_get_stdout())
#define fx_stderr (z__fx_stream_get_stderr())
#define FX_TYPE_STREAM (fx_stream_get_type())
#define FX_TYPE_STREAM_BUFFER (fx_stream_buffer_get_type())
FX_DECLARE_TYPE(fx_stream);
FX_DECLARE_TYPE(fx_stream_buffer);
typedef enum fx_stream_mode {
FX_STREAM_READ = 0x01u,
FX_STREAM_WRITE = 0x02u,
FX_STREAM_BINARY = 0x10u,
Z__FX_STREAM_STATIC = 0x80u,
} fx_stream_mode;
typedef enum fx_stream_seek_origin {
FX_STREAM_SEEK_START = 0x01u,
FX_STREAM_SEEK_CURRENT = 0x02u,
FX_STREAM_SEEK_END = 0x03u,
} fx_stream_seek_origin;
typedef struct fx_stream_cfg {
fx_stream_mode s_mode;
} fx_stream_cfg;
FX_TYPE_CLASS_DECLARATION_BEGIN(fx_stream)
fx_status (*s_close)(fx_stream *);
fx_status (*s_seek)(fx_stream *, long long, fx_stream_seek_origin);
fx_status (*s_tell)(const fx_stream *, size_t *);
fx_status (*s_getc)(fx_stream *, fx_wchar *);
fx_status (*s_read)(fx_stream *, void *, size_t, size_t *);
fx_status (*s_write)(fx_stream *, const void *, size_t, size_t *);
fx_status (*s_reserve)(fx_stream *, size_t);
FX_TYPE_CLASS_DECLARATION_END(fx_stream)
FX_TYPE_CLASS_DECLARATION_BEGIN(fx_stream_buffer)
FX_TYPE_CLASS_DECLARATION_END(fx_stream_buffer)
FX_API fx_type fx_stream_get_type();
FX_API fx_type fx_stream_buffer_get_type();
FX_API fx_stream *z__fx_stream_get_stdin(void);
FX_API fx_stream *z__fx_stream_get_stdout(void);
FX_API fx_stream *z__fx_stream_get_stderr(void);
FX_API fx_stream_buffer *fx_stream_buffer_create(void *p, size_t len);
FX_API fx_stream_buffer *fx_stream_buffer_create_dynamic(size_t buffer_size);
FX_API fx_stream *fx_stream_open_fp(FILE *fp);
FX_API fx_status fx_stream_reserve(fx_stream *stream, size_t len);
FX_API fx_status fx_stream_seek(
fx_stream *stream, long long offset, fx_stream_seek_origin origin);
FX_API size_t fx_stream_cursor(const fx_stream *stream);
FX_API fx_status fx_stream_push_indent(fx_stream *stream, int indent);
FX_API fx_status fx_stream_pop_indent(fx_stream *stream);
FX_API fx_status fx_stream_read_char(fx_stream *stream, fx_wchar *c);
FX_API fx_status fx_stream_read_bytes(
fx_stream *stream, void *buf, size_t count, size_t *nr_read);
FX_API fx_status fx_stream_read_line(fx_stream *stream, char *s, size_t max);
FX_API fx_status fx_stream_read_line_s(fx_stream *src, fx_stream *dest);
FX_API fx_status fx_stream_read_all_bytes(
fx_stream *stream, void *p, size_t max, size_t *nr_read);
FX_API fx_status fx_stream_read_all_bytes_s(
fx_stream *src, fx_stream *dest, fx_stream_buffer *buffer, size_t *nr_read);
FX_API fx_status fx_stream_write_char(fx_stream *stream, fx_wchar c);
FX_API fx_status fx_stream_write_string(
fx_stream *stream, const char *s, size_t *nr_written);
FX_API fx_status fx_stream_write_bytes(
fx_stream *stream, const void *buf, size_t count, size_t *nr_written);
FX_API fx_status fx_stream_write_fmt(
fx_stream *stream, size_t *nr_written, const char *format, ...);
FX_API fx_status fx_stream_write_vfmt(
fx_stream *stream, size_t *nr_written, const char *format, va_list arg);
FX_DECLS_END;
#endif

35
core/include/fx/core/stringstream.h Normal file
View File

@@ -0,0 +1,35 @@
#ifndef FX_CORE_STRINGSTREAM_H_
#define FX_CORE_STRINGSTREAM_H_
#include <fx/core/macros.h>
#include <fx/core/misc.h>
#include <fx/core/status.h>
#include <fx/core/stream.h>
#include <stddef.h>
FX_DECLS_BEGIN;
#define FX_TYPE_STRINGSTREAM (fx_stringstream_get_type())
FX_DECLARE_TYPE(fx_stringstream);
FX_TYPE_CLASS_DECLARATION_BEGIN(fx_stringstream)
FX_TYPE_CLASS_DECLARATION_END(fx_stringstream)
FX_API fx_type fx_stringstream_get_type(void);
FX_API fx_stringstream *fx_stringstream_create(void);
FX_API fx_stringstream *fx_stringstream_create_with_buffer(char *buf, size_t max);
FX_API fx_status fx_stringstream_reset(fx_stringstream *strv);
FX_API fx_status fx_stringstream_reset_with_buffer(
fx_stringstream *strv, char *buf, size_t max);
FX_API const char *fx_stringstream_ptr(const fx_stringstream *strv);
FX_API char *fx_stringstream_steal(fx_stringstream *strv);
FX_API size_t fx_stringstream_get_length(const fx_stringstream *strv);
FX_DECLS_END;
#endif

36
core/include/fx/core/thread.h Normal file
View File

@@ -0,0 +1,36 @@
#ifndef FX_CORE_THREAD_H_
#define FX_CORE_THREAD_H_
#include <fx/core/bitop.h>
#include <fx/core/misc.h>
#include <stdbool.h>
#if defined(__APPLE__) || defined(__linux__)
#include <pthread.h>
#define FX_MUTEX_INIT PTHREAD_MUTEX_INITIALIZER
typedef pthread_mutex_t fx_mutex;
#else
#error Unsupported compiler/system
#endif
#define FX_ONCE_INIT ((fx_once)0)
typedef struct fx_thread fx_thread;
typedef int fx_once;
static inline bool fx_init_once(fx_once *once)
{
int x = 0;
return fx_cmpxchg(once, &x, 1);
}
FX_API fx_thread *fx_thread_self(void);
FX_API bool fx_mutex_lock(fx_mutex *mut);
FX_API bool fx_mutex_trylock(fx_mutex *mut);
FX_API bool fx_mutex_unlock(fx_mutex *mut);
#endif

66
core/include/fx/core/type.h Normal file
View File

@@ -0,0 +1,66 @@
#ifndef FX_CORE_TYPE_H_
#define FX_CORE_TYPE_H_
#include <fx/core/error.h>
#include <fx/core/misc.h>
#include <stddef.h>
#include <stdint.h>
#include <string.h>
#define FX_TYPE_MAX_INTERFACES 64
struct _fx_class;
struct _fx_object;
typedef void (*fx_class_init_function)(struct _fx_class *, void *);
typedef void (*fx_instance_init_function)(struct _fx_object *, void *);
typedef void (*fx_instance_fini_function)(struct _fx_object *, void *);
typedef const union fx_type {
struct {
uint64_t p00, p01;
} a;
unsigned char b[16];
} *fx_type;
typedef enum fx_type_flags {
FX_TYPE_F_ABSTRACT = 0x01u,
} fx_type_flags;
typedef struct fx_type_info {
union fx_type t_id;
union fx_type t_parent_id;
const char *t_name;
fx_type_flags t_flags;
union fx_type t_interfaces[FX_TYPE_MAX_INTERFACES];
size_t t_nr_interfaces;
size_t t_class_size;
fx_class_init_function t_class_init;
size_t t_instance_private_size;
size_t t_instance_protected_size;
fx_instance_init_function t_instance_init;
fx_instance_fini_function t_instance_fini;
} fx_type_info;
FX_API void fx_type_id_init(
union fx_type *out, uint32_t a, uint16_t b, uint16_t c, uint16_t d,
uint64_t e);
static inline void fx_type_id_copy(fx_type src, union fx_type *dest)
{
dest->a.p00 = src->a.p00;
dest->a.p01 = src->a.p01;
}
static inline int fx_type_id_compare(fx_type a, fx_type b)
{
if (a == b) {
return 0;
}
return memcmp(a, b, sizeof(union fx_type));
}
FX_API fx_result fx_type_register(fx_type_info *info);
#endif

102
core/iterator.c
View File

@@ -1,85 +1,85 @@
#include <blue/core/iterator.h>
#include <fx/core/iterator.h>
/*** PRIVATE DATA *************************************************************/
struct b_iterator_p {
enum b_status it_status;
struct fx_iterator_p {
enum fx_status it_status;
};
/*** PRIVATE FUNCTIONS ********************************************************/
static enum b_status iterator_get_status(const struct b_iterator_p *it)
static enum fx_status iterator_get_status(const struct fx_iterator_p *it)
{
return it->it_status;
}
static enum b_status iterator_set_status(struct b_iterator_p *it, b_status status)
static enum fx_status iterator_set_status(struct fx_iterator_p *it, fx_status status)
{
it->it_status = status;
return B_SUCCESS;
return FX_SUCCESS;
}
/*** PUBLIC FUNCTIONS *********************************************************/
b_iterator *b_iterator_begin(b_iterable *it)
fx_iterator *fx_iterator_begin(fx_iterable *it)
{
B_CLASS_DISPATCH_VIRTUAL_0(b_iterable, B_TYPE_ITERABLE, NULL, it_begin, it);
FX_CLASS_DISPATCH_VIRTUAL_0(fx_iterable, FX_TYPE_ITERABLE, NULL, it_begin, it);
}
const b_iterator *b_iterator_cbegin(const b_iterable *it)
const fx_iterator *fx_iterator_cbegin(const fx_iterable *it)
{
B_CLASS_DISPATCH_VIRTUAL_0(b_iterable, B_TYPE_ITERABLE, NULL, it_cbegin, it);
FX_CLASS_DISPATCH_VIRTUAL_0(fx_iterable, FX_TYPE_ITERABLE, NULL, it_cbegin, it);
}
enum b_status b_iterator_get_status(const b_iterator *it)
enum fx_status fx_iterator_get_status(const fx_iterator *it)
{
B_CLASS_DISPATCH_STATIC_0(B_TYPE_ITERATOR, iterator_get_status, it);
FX_CLASS_DISPATCH_STATIC_0(FX_TYPE_ITERATOR, iterator_get_status, it);
}
enum b_status b_iterator_set_status(const b_iterator *it, b_status status)
enum fx_status fx_iterator_set_status(const fx_iterator *it, fx_status status)
{
B_CLASS_DISPATCH_STATIC(B_TYPE_ITERATOR, iterator_set_status, it, status);
FX_CLASS_DISPATCH_STATIC(FX_TYPE_ITERATOR, iterator_set_status, it, status);
}
enum b_status b_iterator_move_next(const b_iterator *it)
enum fx_status fx_iterator_move_next(const fx_iterator *it)
{
enum b_status status = B_ERR_NOT_SUPPORTED;
enum fx_status status = FX_ERR_NOT_SUPPORTED;
b_iterator_class *iface = b_object_get_interface(it, B_TYPE_ITERATOR);
fx_iterator_class *iface = fx_object_get_interface(it, FX_TYPE_ITERATOR);
if (iface && iface->it_move_next) {
status = iface->it_move_next(it);
}
struct b_iterator_p *p = b_object_get_private(it, B_TYPE_ITERATOR);
struct fx_iterator_p *p = fx_object_get_private(it, FX_TYPE_ITERATOR);
p->it_status = status;
return status;
}
b_iterator_value b_iterator_get_value(b_iterator *it)
fx_iterator_value fx_iterator_get_value(fx_iterator *it)
{
B_CLASS_DISPATCH_VIRTUAL_0(
b_iterator, B_TYPE_ITERATOR, B_ITERATOR_VALUE_NULL,
FX_CLASS_DISPATCH_VIRTUAL_0(
fx_iterator, FX_TYPE_ITERATOR, FX_ITERATOR_VALUE_NULL,
it_get_value, it);
}
const b_iterator_value b_iterator_get_cvalue(const b_iterator *it)
const fx_iterator_value fx_iterator_get_cvalue(const fx_iterator *it)
{
B_CLASS_DISPATCH_VIRTUAL_0(
b_iterator, B_TYPE_ITERATOR, B_ITERATOR_VALUE_NULL,
FX_CLASS_DISPATCH_VIRTUAL_0(
fx_iterator, FX_TYPE_ITERATOR, FX_ITERATOR_VALUE_NULL,
it_get_cvalue, it);
}
b_status b_iterator_erase(b_iterator *it)
fx_status fx_iterator_erase(fx_iterator *it)
{
enum b_status status = B_ERR_NOT_SUPPORTED;
enum fx_status status = FX_ERR_NOT_SUPPORTED;
b_iterator_class *iface = b_object_get_interface(it, B_TYPE_ITERATOR);
fx_iterator_class *iface = fx_object_get_interface(it, FX_TYPE_ITERATOR);
if (iface && iface->it_erase) {
status = iface->it_erase(it);
}
struct b_iterator_p *p = b_object_get_private(it, B_TYPE_ITERATOR);
struct fx_iterator_p *p = fx_object_get_private(it, FX_TYPE_ITERATOR);
p->it_status = status;
return status;
@@ -87,29 +87,29 @@ b_status b_iterator_erase(b_iterator *it)
/*** CLASS DEFINITION *********************************************************/
// ---- b_iterator DEFINITION
B_TYPE_CLASS_DEFINITION_BEGIN(b_iterator)
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_iterator)
// ---- fx_iterator DEFINITION
FX_TYPE_CLASS_DEFINITION_BEGIN(fx_iterator)
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_iterator)
B_TYPE_DEFINITION_BEGIN(b_iterator)
B_TYPE_FLAGS(B_TYPE_F_ABSTRACT);
B_TYPE_ID(0xfd40b67f, 0x7087, 0x40a9, 0x8fd8, 0x8ae27bd58c9e);
B_TYPE_CLASS(b_iterator_class);
B_TYPE_INSTANCE_PRIVATE(struct b_iterator_p);
B_TYPE_DEFINITION_END(b_iterator)
FX_TYPE_DEFINITION_BEGIN(fx_iterator)
FX_TYPE_FLAGS(FX_TYPE_F_ABSTRACT);
FX_TYPE_ID(0xfd40b67f, 0x7087, 0x40a9, 0x8fd8, 0x8ae27bd58c9e);
FX_TYPE_CLASS(fx_iterator_class);
FX_TYPE_INSTANCE_PRIVATE(struct fx_iterator_p);
FX_TYPE_DEFINITION_END(fx_iterator)
// ---- b_iterable DEFINITION
B_TYPE_CLASS_DEFINITION_BEGIN(b_iterable)
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_iterable)
// ---- fx_iterable DEFINITION
FX_TYPE_CLASS_DEFINITION_BEGIN(fx_iterable)
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_iterable)
B_TYPE_DEFINITION_BEGIN(b_iterable)
B_TYPE_FLAGS(B_TYPE_F_ABSTRACT);
B_TYPE_ID(0x4bbabf2d, 0xfc5d, 0x40cc, 0x89fc, 0x164085e47f73);
B_TYPE_CLASS(b_iterable_class);
B_TYPE_DEFINITION_END(b_iterable)
FX_TYPE_DEFINITION_BEGIN(fx_iterable)
FX_TYPE_FLAGS(FX_TYPE_F_ABSTRACT);
FX_TYPE_ID(0x4bbabf2d, 0xfc5d, 0x40cc, 0x89fc, 0x164085e47f73);
FX_TYPE_CLASS(fx_iterable_class);
FX_TYPE_DEFINITION_END(fx_iterable)

8
core/misc.c
View File

@@ -1,10 +1,10 @@
#include <blue/core/misc.h>
#include <fx/core/misc.h>
#define LENGTH_RET(v, boundary, len) \
if ((v) < (boundary)) \
return (len);
size_t b_int_length(intptr_t v)
size_t fx_int_length(intptr_t v)
{
size_t len = 0;
if (v < 0) {
@@ -12,10 +12,10 @@ size_t b_int_length(intptr_t v)
len++;
}
return len + b_uint_length(v);
return len + fx_uint_length(v);
}
size_t b_uint_length(uintptr_t v)
size_t fx_uint_length(uintptr_t v)
{
LENGTH_RET(v, 10, 1);
LENGTH_RET(v, 100, 2);

16
core/mt19937.c
View File

@@ -55,7 +55,7 @@
#include "random.h"
#include <blue/core/random.h>
#include <fx/core/random.h>
#define NN 312
#define MM 156
@@ -64,7 +64,7 @@
#define LM 0x7FFFFFFFULL /* Least significant 31 bits */
/* initializes mt[NN] with a seed */
static void init_genrand64(struct b_random_ctx *context, unsigned long long seed)
static void init_genrand64(struct fx_random_ctx *context, unsigned long long seed)
{
context->__mt19937.mt[0] = seed;
for (context->__mt19937.mti = 1; context->__mt19937.mti < NN;
@@ -82,7 +82,7 @@ static void init_genrand64(struct b_random_ctx *context, unsigned long long seed
/* init_key is the array for initializing keys */
/* key_length is its length */
static void init_by_array64(
struct b_random_ctx *context, unsigned long long init_key[],
struct fx_random_ctx *context, unsigned long long init_key[],
unsigned long long key_length)
{
unsigned long long i, j, k;
@@ -125,7 +125,7 @@ static void init_by_array64(
}
/* generates a random number on [0, 2^64-1]-interval */
static uint64_t genrand64_int64(struct b_random_ctx *context)
static uint64_t genrand64_int64(struct fx_random_ctx *context)
{
#if 0
/* This is the original implementation. It is replaced by the alternate implementation, below. */
@@ -218,25 +218,25 @@ static uint64_t genrand64_int64(struct b_random_ctx *context)
}
/* generates a random number on [0,1]-real-interval */
double genrand64_real1(struct b_random_ctx *context)
double genrand64_real1(struct fx_random_ctx *context)
{
return (genrand64_int64(context) >> 11) * (1.0 / 9007199254740991.0);
}
/* generates a random number on [0,1)-real-interval */
double genrand64_real2(struct b_random_ctx *context)
double genrand64_real2(struct fx_random_ctx *context)
{
return (genrand64_int64(context) >> 11) * (1.0 / 9007199254740992.0);
}
/* generates a random number on (0,1)-real-interval */
double genrand64_real3(struct b_random_ctx *context)
double genrand64_real3(struct fx_random_ctx *context)
{
return ((genrand64_int64(context) >> 12) + 0.5)
* (1.0 / 4503599627370496.0);
}
struct b_random_algorithm z__b_gen_mt19937 = {
struct fx_random_algorithm z__fx_gen_mt19937 = {
.gen_name = "mt19937",
.gen_init = init_genrand64,
.gen_getrand = genrand64_int64,

134
core/object.c
View File

@@ -3,42 +3,42 @@
#include "type.h"
#include <assert.h>
#include <blue/core/class.h>
#include <blue/core/macros.h>
#include <blue/core/object.h>
#include <blue/core/stream.h>
#include <blue/core/thread.h>
#include <fx/core/class.h>
#include <fx/core/macros.h>
#include <fx/core/object.h>
#include <fx/core/stream.h>
#include <fx/core/thread.h>
B_TYPE_CLASS_DEFINITION_BEGIN(b_object)
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_object)
FX_TYPE_CLASS_DEFINITION_BEGIN(fx_object)
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_object)
B_TYPE_DEFINITION_BEGIN(b_object)
B_TYPE_ID(0x45f15a2c, 0x6831, 0x4bef, 0xb350, 0x15c650679211);
B_TYPE_CLASS(b_object_class);
B_TYPE_DEFINITION_END(b_object)
FX_TYPE_DEFINITION_BEGIN(fx_object)
FX_TYPE_ID(0x45f15a2c, 0x6831, 0x4bef, 0xb350, 0x15c650679211);
FX_TYPE_CLASS(fx_object_class);
FX_TYPE_DEFINITION_END(fx_object)
b_result b_object_instantiate(
struct b_type_registration *type, struct _b_object **out_object)
fx_result fx_object_instantiate(
struct fx_type_registration *type, struct _fx_object **out_object)
{
struct _b_object *out = malloc(type->r_instance_size);
struct _fx_object *out = malloc(type->r_instance_size);
if (!out) {
return B_RESULT_ERR(NO_MEMORY);
return FX_RESULT_ERR(NO_MEMORY);
}
memset(out, 0x0, type->r_instance_size);
out->obj_magic = B_OBJECT_MAGIC;
out->obj_magic = FX_OBJECT_MAGIC;
out->obj_type = type;
out->obj_ref = 1;
struct b_queue_entry *entry = b_queue_first(&type->r_class_hierarchy);
struct fx_queue_entry *entry = fx_queue_first(&type->r_class_hierarchy);
while (entry) {
struct b_type_component *comp
= b_unbox(struct b_type_component, entry, c_entry);
const struct b_type_info *class_info = comp->c_type->r_info;
struct fx_type_component *comp
= fx_unbox(struct fx_type_component, entry, c_entry);
const struct fx_type_info *class_info = comp->c_type->r_info;
void *private_data
= (char *)out + comp->c_instance_private_data_offset;
@@ -51,62 +51,62 @@ b_result b_object_instantiate(
= comp->c_instance_private_data_offset;
}
entry = b_queue_next(entry);
entry = fx_queue_next(entry);
}
*out_object = out;
return B_RESULT_SUCCESS;
return FX_RESULT_SUCCESS;
}
struct _b_object *b_object_create(b_type type)
struct _fx_object *fx_object_create(fx_type type)
{
struct b_type_registration *type_reg = b_type_get_registration(type);
struct fx_type_registration *type_reg = fx_type_get_registration(type);
if (!type_reg) {
return NULL;
}
struct _b_object *out = NULL;
b_result result = b_object_instantiate(type_reg, &out);
if (b_result_is_error(result)) {
b_error_discard(result);
struct _fx_object *out = NULL;
fx_result result = fx_object_instantiate(type_reg, &out);
if (fx_result_is_error(result)) {
fx_error_discard(result);
return NULL;
}
return out;
}
void b_object_to_string(const struct _b_object *p, b_stream *out)
void fx_object_to_string(const struct _fx_object *p, fx_stream *out)
{
B_CLASS_DISPATCH_VIRTUAL_V(b_object, B_TYPE_OBJECT, to_string, p, out);
b_stream_write_fmt(out, NULL, "<%s@%p>", p->obj_type->r_info->t_name, p);
FX_CLASS_DISPATCH_VIRTUAL_V(fx_object, FX_TYPE_OBJECT, to_string, p, out);
fx_stream_write_fmt(out, NULL, "<%s@%p>", p->obj_type->r_info->t_name, p);
}
bool b_object_is_type(const struct _b_object *p, b_type type)
bool fx_object_is_type(const struct _fx_object *p, fx_type type)
{
if (b_type_id_compare(&p->obj_type->r_info->t_id, type) == 0) {
if (fx_type_id_compare(&p->obj_type->r_info->t_id, type) == 0) {
return true;
}
struct b_type_component *comp
= b_type_get_component(&p->obj_type->r_components, type);
struct fx_type_component *comp
= fx_type_get_component(&p->obj_type->r_components, type);
return comp != NULL;
}
void *b_object_get_private(const struct _b_object *object, b_type type)
void *fx_object_get_private(const struct _fx_object *object, fx_type type)
{
if (!object) {
return NULL;
}
assert(object->obj_magic == B_OBJECT_MAGIC);
assert(object->obj_magic == FX_OBJECT_MAGIC);
if (b_type_id_compare(&object->obj_type->r_info->t_id, type) == 0) {
if (fx_type_id_compare(&object->obj_type->r_info->t_id, type) == 0) {
return (char *)object + object->obj_main_priv_offset;
}
struct b_type_component *comp
= b_type_get_component(&object->obj_type->r_components, type);
struct fx_type_component *comp
= fx_type_get_component(&object->obj_type->r_components, type);
if (!comp) {
return NULL;
}
@@ -114,16 +114,16 @@ void *b_object_get_private(const struct _b_object *object, b_type type)
return (char *)object + comp->c_instance_private_data_offset;
}
void *b_object_get_protected(const struct _b_object *object, b_type type)
void *fx_object_get_protected(const struct _fx_object *object, fx_type type)
{
if (!object) {
return NULL;
}
assert(object->obj_magic == B_OBJECT_MAGIC);
assert(object->obj_magic == FX_OBJECT_MAGIC);
struct b_type_component *comp
= b_type_get_component(&object->obj_type->r_components, type);
struct fx_type_component *comp
= fx_type_get_component(&object->obj_type->r_components, type);
if (!comp) {
return NULL;
}
@@ -131,31 +131,31 @@ void *b_object_get_protected(const struct _b_object *object, b_type type)
return (char *)object + comp->c_instance_protected_data_offset;
}
void *b_object_get_interface(const struct _b_object *object, b_type type)
void *fx_object_get_interface(const struct _fx_object *object, fx_type type)
{
if (!object) {
return NULL;
}
assert(object->obj_magic == B_OBJECT_MAGIC);
assert(object->obj_magic == FX_OBJECT_MAGIC);
return b_class_get_interface(object->obj_type->r_class, type);
return fx_class_get_interface(object->obj_type->r_class, type);
}
enum b_status b_object_get_data(
const struct _b_object *object, b_type type, void **priv, void **prot,
enum fx_status fx_object_get_data(
const struct _fx_object *object, fx_type type, void **priv, void **prot,
void **iface)
{
if (!object) {
return B_ERR_INVALID_ARGUMENT;
return FX_ERR_INVALID_ARGUMENT;
}
assert(object->obj_magic == B_OBJECT_MAGIC);
assert(object->obj_magic == FX_OBJECT_MAGIC);
struct b_type_component *comp
= b_type_get_component(&object->obj_type->r_components, type);
struct fx_type_component *comp
= fx_type_get_component(&object->obj_type->r_components, type);
if (!comp) {
return B_ERR_INVALID_ARGUMENT;
return FX_ERR_INVALID_ARGUMENT;
}
if (priv) {
@@ -171,16 +171,16 @@ enum b_status b_object_get_data(
+ comp->c_class_data_offset;
}
return B_SUCCESS;
return FX_SUCCESS;
}
struct _b_object *b_object_ref(struct _b_object *p)
struct _fx_object *fx_object_ref(struct _fx_object *p)
{
p->obj_ref++;
return p;
}
void b_object_unref(struct _b_object *p)
void fx_object_unref(struct _fx_object *p)
{
if (p->obj_ref > 1) {
p->obj_ref--;
@@ -188,14 +188,14 @@ void b_object_unref(struct _b_object *p)
}
p->obj_ref = 0;
const struct b_type_registration *type = p->obj_type;
const struct fx_type_registration *type = p->obj_type;
struct b_queue_entry *cur = b_queue_last(&type->r_class_hierarchy);
struct fx_queue_entry *cur = fx_queue_last(&type->r_class_hierarchy);
while (cur) {
struct b_type_component *comp
= b_unbox(struct b_type_component, cur, c_entry);
struct fx_type_component *comp
= fx_unbox(struct fx_type_component, cur, c_entry);
const struct b_type_info *class_info = comp->c_type->r_info;
const struct fx_type_info *class_info = comp->c_type->r_info;
void *private_data
= (char *)p + comp->c_instance_private_data_offset;
@@ -203,7 +203,7 @@ void b_object_unref(struct _b_object *p)
class_info->t_instance_fini(p, private_data);
}
cur = b_queue_prev(cur);
cur = fx_queue_prev(cur);
}
p->obj_magic = 0;
@@ -212,7 +212,7 @@ void b_object_unref(struct _b_object *p)
free(p);
}
struct _b_object *b_object_make_rvalue(struct _b_object *p)
struct _fx_object *fx_object_make_rvalue(struct _fx_object *p)
{
p->obj_ref = 0;
return p;

14
core/object.h
View File

@@ -1,19 +1,19 @@
#ifndef _OBJECT_H_
#define _OBJECT_H_
#include <blue/core/error.h>
#include <blue/core/misc.h>
#include <fx/core/error.h>
#include <fx/core/misc.h>
#include <stdint.h>
struct b_type_registration;
struct fx_type_registration;
struct _b_object {
struct _fx_object {
uint64_t obj_magic;
const struct b_type_registration *obj_type;
const struct fx_type_registration *obj_type;
unsigned int obj_ref, obj_main_priv_offset;
};
extern b_result b_object_instantiate(
struct b_type_registration *type, struct _b_object **out);
extern fx_result fx_object_instantiate(
struct fx_type_registration *type, struct _fx_object **out);
#endif

2
core/printf.c
View File

@@ -1621,7 +1621,7 @@ static int vsnprintf_impl(output_gadget_t *output, const char *format, va_list a
return (int)output->pos;
}
int z__b_fctprintf(
int z__fx_fctprintf(
void (*out)(char c, void *extra_arg), void *extra_arg,
const char *format, va_list arg)
{

2
core/printf.h
View File

@@ -132,7 +132,7 @@ void putchar_(char c);
*
*/
PRINTF_VISIBILITY
int z__b_fctprintf(
int z__fx_fctprintf(
void (*out)(char c, void *extra_arg), void *extra_arg,
const char *format, va_list arg) ATTR_VPRINTF(3);

136
core/queue.c
View File

@@ -1,15 +1,15 @@
#include <blue/core/queue.h>
#include <fx/core/queue.h>
struct b_queue_iterator_p {
struct fx_queue_iterator_p {
size_t i;
b_queue_entry *entry;
b_queue *_q;
fx_queue_entry *entry;
fx_queue *_q;
};
size_t b_queue_length(const struct b_queue *q)
size_t fx_queue_length(const struct fx_queue *q)
{
size_t i = 0;
struct b_queue_entry *x = q->q_first;
struct fx_queue_entry *x = q->q_first;
while (x) {
i++;
x = x->qe_next;
@@ -18,10 +18,10 @@ size_t b_queue_length(const struct b_queue *q)
return i;
}
void b_queue_insert_before(
struct b_queue *q, struct b_queue_entry *entry, struct b_queue_entry *before)
void fx_queue_insert_before(
struct fx_queue *q, struct fx_queue_entry *entry, struct fx_queue_entry *before)
{
struct b_queue_entry *x = before->qe_prev;
struct fx_queue_entry *x = before->qe_prev;
if (x) {
x->qe_next = entry;
} else {
@@ -34,10 +34,10 @@ void b_queue_insert_before(
entry->qe_next = before;
}
void b_queue_insert_after(
struct b_queue *q, struct b_queue_entry *entry, struct b_queue_entry *after)
void fx_queue_insert_after(
struct fx_queue *q, struct fx_queue_entry *entry, struct fx_queue_entry *after)
{
struct b_queue_entry *x = after->qe_next;
struct fx_queue_entry *x = after->qe_next;
if (x) {
x->qe_prev = entry;
} else {
@@ -50,7 +50,7 @@ void b_queue_insert_after(
entry->qe_prev = after;
}
void b_queue_push_front(struct b_queue *q, struct b_queue_entry *entry)
void fx_queue_push_front(struct fx_queue *q, struct fx_queue_entry *entry)
{
if (q->q_first) {
q->q_first->qe_prev = entry;
@@ -66,7 +66,7 @@ void b_queue_push_front(struct b_queue *q, struct b_queue_entry *entry)
}
}
void b_queue_push_back(struct b_queue *q, struct b_queue_entry *entry)
void fx_queue_push_back(struct fx_queue *q, struct fx_queue_entry *entry)
{
if (q->q_last) {
q->q_last->qe_next = entry;
@@ -82,27 +82,27 @@ void b_queue_push_back(struct b_queue *q, struct b_queue_entry *entry)
}
}
struct b_queue_entry *b_queue_pop_front(struct b_queue *q)
struct fx_queue_entry *fx_queue_pop_front(struct fx_queue *q)
{
struct b_queue_entry *x = q->q_first;
struct fx_queue_entry *x = q->q_first;
if (x) {
b_queue_delete(q, x);
fx_queue_delete(q, x);
}
return x;
}
struct b_queue_entry *b_queue_pop_back(struct b_queue *q)
struct fx_queue_entry *fx_queue_pop_back(struct fx_queue *q)
{
struct b_queue_entry *x = q->q_last;
struct fx_queue_entry *x = q->q_last;
if (x) {
b_queue_delete(q, x);
fx_queue_delete(q, x);
}
return x;
}
void b_queue_move(b_queue *q, b_queue_entry *dest, b_queue_entry *src)
void fx_queue_move(fx_queue *q, fx_queue_entry *dest, fx_queue_entry *src)
{
if (src->qe_next) {
src->qe_next->qe_prev = dest;
@@ -123,7 +123,7 @@ void b_queue_move(b_queue *q, b_queue_entry *dest, b_queue_entry *src)
memmove(dest, src, sizeof *src);
}
void b_queue_delete(struct b_queue *q, struct b_queue_entry *entry)
void fx_queue_delete(struct fx_queue *q, struct fx_queue_entry *entry)
{
if (!entry) {
return;
@@ -148,11 +148,11 @@ void b_queue_delete(struct b_queue *q, struct b_queue_entry *entry)
entry->qe_next = entry->qe_prev = NULL;
}
void b_queue_delete_all(struct b_queue *q)
void fx_queue_delete_all(struct fx_queue *q)
{
struct b_queue_entry *x = q->q_first;
struct fx_queue_entry *x = q->q_first;
while (x) {
struct b_queue_entry *next = x->qe_next;
struct fx_queue_entry *next = x->qe_next;
x->qe_next = x->qe_prev = NULL;
x = next;
}
@@ -160,86 +160,86 @@ void b_queue_delete_all(struct b_queue *q)
q->q_first = q->q_last = NULL;
}
b_iterator *b_queue_begin(struct b_queue *q)
fx_iterator *fx_queue_begin(struct fx_queue *q)
{
b_queue_iterator *it_obj = b_object_create(B_TYPE_QUEUE_ITERATOR);
struct b_queue_iterator_p *it
= b_object_get_private(it_obj, B_TYPE_QUEUE_ITERATOR);
fx_queue_iterator *it_obj = fx_object_create(FX_TYPE_QUEUE_ITERATOR);
struct fx_queue_iterator_p *it
= fx_object_get_private(it_obj, FX_TYPE_QUEUE_ITERATOR);
it->_q = (struct b_queue *)q;
it->_q = (struct fx_queue *)q;
it->entry = q->q_first;
it->i = 0;
if (!it->entry) {
b_iterator_set_status(it_obj, B_ERR_NO_DATA);
fx_iterator_set_status(it_obj, FX_ERR_NO_DATA);
}
return it_obj;
}
static enum b_status iterator_move_next(const b_iterator *obj)
static enum fx_status iterator_move_next(const fx_iterator *obj)
{
struct b_queue_iterator_p *it
= b_object_get_private(obj, B_TYPE_QUEUE_ITERATOR);
struct fx_queue_iterator_p *it
= fx_object_get_private(obj, FX_TYPE_QUEUE_ITERATOR);
if (!it->entry) {
return B_ERR_NO_DATA;
return FX_ERR_NO_DATA;
}
it->entry = it->entry->qe_next;
it->i++;
return (it->entry != NULL) ? B_SUCCESS : B_ERR_NO_DATA;
return (it->entry != NULL) ? FX_SUCCESS : FX_ERR_NO_DATA;
}
static enum b_status iterator_erase(b_iterator *obj)
static enum fx_status iterator_erase(fx_iterator *obj)
{
struct b_queue_iterator_p *it
= b_object_get_private(obj, B_TYPE_QUEUE_ITERATOR);
struct fx_queue_iterator_p *it
= fx_object_get_private(obj, FX_TYPE_QUEUE_ITERATOR);
if (!it->entry) {
return B_ERR_OUT_OF_BOUNDS;
return FX_ERR_OUT_OF_BOUNDS;
}
struct b_queue_entry *next = it->entry->qe_next;
b_queue_delete(it->_q, it->entry);
struct fx_queue_entry *next = it->entry->qe_next;
fx_queue_delete(it->_q, it->entry);
it->entry = next;
return B_SUCCESS;
return FX_SUCCESS;
}
static b_iterator_value iterator_get_value(b_iterator *obj)
static fx_iterator_value iterator_get_value(fx_iterator *obj)
{
struct b_queue_iterator_p *it
= b_object_get_private(obj, B_TYPE_QUEUE_ITERATOR);
struct fx_queue_iterator_p *it
= fx_object_get_private(obj, FX_TYPE_QUEUE_ITERATOR);
return B_ITERATOR_VALUE_PTR(it->entry);
return FX_ITERATOR_VALUE_PTR(it->entry);
}
static const b_iterator_value iterator_get_cvalue(const b_iterator *obj)
static const fx_iterator_value iterator_get_cvalue(const fx_iterator *obj)
{
struct b_queue_iterator_p *it
= b_object_get_private(obj, B_TYPE_QUEUE_ITERATOR);
struct fx_queue_iterator_p *it
= fx_object_get_private(obj, FX_TYPE_QUEUE_ITERATOR);
return B_ITERATOR_VALUE_CPTR(it->entry);
return FX_ITERATOR_VALUE_CPTR(it->entry);
}
B_TYPE_CLASS_DEFINITION_BEGIN(b_queue_iterator)
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)
FX_TYPE_CLASS_DEFINITION_BEGIN(fx_queue_iterator)
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)
B_TYPE_CLASS_INTERFACE_BEGIN(b_iterator, B_TYPE_ITERATOR)
B_INTERFACE_ENTRY(it_move_next) = iterator_move_next;
B_INTERFACE_ENTRY(it_erase) = iterator_erase;
B_INTERFACE_ENTRY(it_get_value) = iterator_get_value;
B_INTERFACE_ENTRY(it_get_cvalue) = iterator_get_cvalue;
B_TYPE_CLASS_INTERFACE_END(b_iterator, B_TYPE_ITERATOR)
B_TYPE_CLASS_DEFINITION_END(b_queue_iterator)
FX_TYPE_CLASS_INTERFACE_BEGIN(fx_iterator, FX_TYPE_ITERATOR)
FX_INTERFACE_ENTRY(it_move_next) = iterator_move_next;
FX_INTERFACE_ENTRY(it_erase) = iterator_erase;
FX_INTERFACE_ENTRY(it_get_value) = iterator_get_value;
FX_INTERFACE_ENTRY(it_get_cvalue) = iterator_get_cvalue;
FX_TYPE_CLASS_INTERFACE_END(fx_iterator, FX_TYPE_ITERATOR)
FX_TYPE_CLASS_DEFINITION_END(fx_queue_iterator)
B_TYPE_DEFINITION_BEGIN(b_queue_iterator)
B_TYPE_ID(0x560dc263, 0xff98, 0x4812, 0x9b29, 0xa1218bd70881);
B_TYPE_EXTENDS(B_TYPE_ITERATOR);
B_TYPE_CLASS(b_queue_iterator_class);
B_TYPE_INSTANCE_PRIVATE(struct b_queue_iterator_p);
B_TYPE_DEFINITION_END(b_queue_iterator)
FX_TYPE_DEFINITION_BEGIN(fx_queue_iterator)
FX_TYPE_ID(0x560dc263, 0xff98, 0x4812, 0x9b29, 0xa1218bd70881);
FX_TYPE_EXTENDS(FX_TYPE_ITERATOR);
FX_TYPE_CLASS(fx_queue_iterator_class);
FX_TYPE_INSTANCE_PRIVATE(struct fx_queue_iterator_p);
FX_TYPE_DEFINITION_END(fx_queue_iterator)

40
core/random.c
View File

@@ -1,24 +1,24 @@
#include "random.h"
#include <blue/core/random.h>
#include <fx/core/random.h>
#define GET_ALGORITHM_ID(flags) ((flags) & 0xFF)
BLUE_API struct b_random_algorithm z__b_gen_mt19937;
FX_API struct fx_random_algorithm z__fx_gen_mt19937;
static struct b_random_algorithm *generators[] = {
[B_RANDOM_MT19937] = &z__b_gen_mt19937,
static struct fx_random_algorithm *generators[] = {
[FX_RANDOM_MT19937] = &z__fx_gen_mt19937,
};
static size_t nr_generators = sizeof generators / sizeof generators[0];
static struct b_random_ctx g_global_ctx = {0};
static struct fx_random_ctx g_global_ctx = {0};
static void init_global_ctx(void)
{
b_random_init(&g_global_ctx, B_RANDOM_MT19937);
fx_random_init(&g_global_ctx, FX_RANDOM_MT19937);
}
struct b_random_ctx *b_random_global_ctx(void)
struct fx_random_ctx *fx_random_global_ctx(void)
{
if (!g_global_ctx.__f) {
init_global_ctx();
@@ -27,31 +27,31 @@ struct b_random_ctx *b_random_global_ctx(void)
return &g_global_ctx;
}
b_status b_random_init(struct b_random_ctx *ctx, b_random_flags flags)
fx_status fx_random_init(struct fx_random_ctx *ctx, fx_random_flags flags)
{
unsigned int algorithm_id = GET_ALGORITHM_ID(flags);
if (algorithm_id >= nr_generators || !generators[algorithm_id]) {
return B_ERR_INVALID_ARGUMENT;
return FX_ERR_INVALID_ARGUMENT;
}
struct b_random_algorithm *algorithm = generators[algorithm_id];
struct fx_random_algorithm *algorithm = generators[algorithm_id];
ctx->__f = flags;
ctx->__a = algorithm;
unsigned long long seed;
if (flags & B_RANDOM_SECURE) {
seed = z__b_platform_random_seed_secure();
if (flags & FX_RANDOM_SECURE) {
seed = z__fx_platform_random_seed_secure();
} else {
seed = z__b_platform_random_seed();
seed = z__fx_platform_random_seed();
}
algorithm->gen_init(ctx, seed);
return B_SUCCESS;
return FX_SUCCESS;
}
unsigned long long b_random_next_int64(struct b_random_ctx *ctx)
unsigned long long fx_random_next_int64(struct fx_random_ctx *ctx)
{
if (!ctx->__a || !ctx->__a->gen_getrand) {
return 0;
@@ -60,9 +60,9 @@ unsigned long long b_random_next_int64(struct b_random_ctx *ctx)
return ctx->__a->gen_getrand(ctx);
}
double b_random_next_double(struct b_random_ctx *ctx)
double fx_random_next_double(struct fx_random_ctx *ctx)
{
unsigned long long v = b_random_next_int64(ctx);
unsigned long long v = fx_random_next_int64(ctx);
if (!v) {
return 0.0;
}
@@ -70,7 +70,7 @@ double b_random_next_double(struct b_random_ctx *ctx)
return (double)(v >> 11) * (1.0 / 9007199254740991.0);
}
void b_random_next_bytes(struct b_random_ctx *ctx, unsigned char *out, size_t nbytes)
void fx_random_next_bytes(struct fx_random_ctx *ctx, unsigned char *out, size_t nbytes)
{
size_t n_qwords = 0;
n_qwords = nbytes >> 3;
@@ -82,7 +82,7 @@ void b_random_next_bytes(struct b_random_ctx *ctx, unsigned char *out, size_t nb
size_t bytes_written = 0;
for (size_t i = 0; i < n_qwords; i++) {
uint64_t *dest = (uint64_t *)&out[bytes_written];
*dest = b_random_next_int64(ctx);
*dest = fx_random_next_int64(ctx);
bytes_written += 8;
}
@@ -90,7 +90,7 @@ void b_random_next_bytes(struct b_random_ctx *ctx, unsigned char *out, size_t nb
return;
}
uint64_t padding = b_random_next_int64(ctx);
uint64_t padding = fx_random_next_int64(ctx);
unsigned char *padding_bytes = (unsigned char *)&padding;
for (size_t i = 0; i < 8; i++) {

18
core/random.h
View File

@@ -1,18 +1,18 @@
#ifndef _BLUELIB_RANDOM_H_
#define _BLUELIB_RANDOM_H_
#ifndef _FX_RANDOM_H_
#define _FX_RANDOM_H_
#include <stdint.h>
#include <blue/core/misc.h>
#include <fx/core/misc.h>
struct b_random_ctx;
struct fx_random_ctx;
struct b_random_algorithm {
struct fx_random_algorithm {
const char *gen_name;
void(*gen_init)(struct b_random_ctx *, unsigned long long seed);
uint64_t(*gen_getrand)(struct b_random_ctx *);
void(*gen_init)(struct fx_random_ctx *, unsigned long long seed);
uint64_t(*gen_getrand)(struct fx_random_ctx *);
};
BLUE_API uint64_t z__b_platform_random_seed(void);
BLUE_API uint64_t z__b_platform_random_seed_secure(void);
FX_API uint64_t z__fx_platform_random_seed(void);
FX_API uint64_t z__fx_platform_random_seed_secure(void);
#endif

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)

176
core/rope.c
View File

@@ -1,23 +1,23 @@
#include <blue/core/bstr.h>
#include <blue/core/rope.h>
#include <fx/core/bstr.h>
#include <fx/core/rope.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void b_rope_init_char(struct b_rope *rope, char c)
void fx_rope_init_char(struct fx_rope *rope, char c)
{
memset(rope, 0x0, sizeof *rope);
rope->r_flags = B_ROPE_F_CHAR;
rope->r_flags = FX_ROPE_F_CHAR;
rope->r_len_left = rope->r_len_total = 1;
rope->r_v.v_char = c;
}
void b_rope_init_cstr(struct b_rope *rope, const char *s)
void fx_rope_init_cstr(struct fx_rope *rope, const char *s)
{
memset(rope, 0x0, sizeof *rope);
rope->r_flags = B_ROPE_F_CSTR;
rope->r_v.v_cstr.hash = b_hash_cstr_ex(s, &rope->r_len_total);
rope->r_flags = FX_ROPE_F_CSTR;
rope->r_v.v_cstr.hash = fx_hash_cstr_ex(s, &rope->r_len_total);
rope->r_len_left = rope->r_len_total;
char *s2 = malloc(rope->r_len_total + 1);
@@ -32,110 +32,110 @@ void b_rope_init_cstr(struct b_rope *rope, const char *s)
rope->r_v.v_cstr.s = s2;
}
void b_rope_init_cstr_borrowed(struct b_rope *rope, const char *s)
void fx_rope_init_cstr_borrowed(struct fx_rope *rope, const char *s)
{
memset(rope, 0x0, sizeof *rope);
rope->r_flags = B_ROPE_F_CSTR_BORROWED;
rope->r_flags = FX_ROPE_F_CSTR_BORROWED;
rope->r_v.v_cstr.s = s;
rope->r_v.v_cstr.hash = b_hash_cstr_ex(s, &rope->r_len_total);
rope->r_v.v_cstr.hash = fx_hash_cstr_ex(s, &rope->r_len_total);
rope->r_len_left = rope->r_len_total;
}
void b_rope_init_cstr_static(struct b_rope *rope, const char *s)
void fx_rope_init_cstr_static(struct fx_rope *rope, const char *s)
{
memset(rope, 0x0, sizeof *rope);
rope->r_flags = B_ROPE_F_CSTR_STATIC;
rope->r_flags = FX_ROPE_F_CSTR_STATIC;
rope->r_v.v_cstr.s = s;
rope->r_v.v_cstr.hash = b_hash_cstr_ex(s, &rope->r_len_total);
rope->r_v.v_cstr.hash = fx_hash_cstr_ex(s, &rope->r_len_total);
rope->r_len_left = rope->r_len_total;
}
void b_rope_init_int(struct b_rope *rope, intptr_t v)
void fx_rope_init_int(struct fx_rope *rope, intptr_t v)
{
memset(rope, 0x0, sizeof *rope);
rope->r_flags = B_ROPE_F_INT;
rope->r_len_left = rope->r_len_total = b_int_length(v);
rope->r_flags = FX_ROPE_F_INT;
rope->r_len_left = rope->r_len_total = fx_int_length(v);
rope->r_v.v_int = v;
}
void b_rope_init_uint(struct b_rope *rope, uintptr_t v)
void fx_rope_init_uint(struct fx_rope *rope, uintptr_t v)
{
memset(rope, 0x0, sizeof *rope);
rope->r_flags = B_ROPE_F_UINT;
rope->r_len_left = rope->r_len_total = b_uint_length(v);
rope->r_flags = FX_ROPE_F_UINT;
rope->r_len_left = rope->r_len_total = fx_uint_length(v);
rope->r_v.v_uint = v;
}
void b_rope_destroy(struct b_rope *rope)
void fx_rope_destroy(struct fx_rope *rope)
{
unsigned int type = B_ROPE_TYPE(rope->r_flags);
unsigned int type = FX_ROPE_TYPE(rope->r_flags);
switch (type) {
case B_ROPE_F_CSTR:
case FX_ROPE_F_CSTR:
free((char *)rope->r_v.v_cstr.s);
break;
case B_ROPE_F_COMPOSITE:
b_rope_destroy((struct b_rope *)rope->r_v.v_composite.r_left);
b_rope_destroy((struct b_rope *)rope->r_v.v_composite.r_right);
case FX_ROPE_F_COMPOSITE:
fx_rope_destroy((struct fx_rope *)rope->r_v.v_composite.r_left);
fx_rope_destroy((struct fx_rope *)rope->r_v.v_composite.r_right);
break;
default:
break;
}
if (rope->r_flags & B_ROPE_F_MALLOC) {
if (rope->r_flags & FX_ROPE_F_MALLOC) {
free(rope);
}
}
void b_rope_iterate(
const struct b_rope *rope, void (*func)(const b_rope *, void *), void *arg)
void fx_rope_iterate(
const struct fx_rope *rope, void (*func)(const fx_rope *, void *), void *arg)
{
if (B_ROPE_TYPE(rope->r_flags) != B_ROPE_F_COMPOSITE) {
if (FX_ROPE_TYPE(rope->r_flags) != FX_ROPE_F_COMPOSITE) {
func(rope, arg);
return;
}
if (rope->r_v.v_composite.r_left) {
b_rope_iterate(rope->r_v.v_composite.r_left, func, arg);
fx_rope_iterate(rope->r_v.v_composite.r_left, func, arg);
}
if (rope->r_v.v_composite.r_right) {
b_rope_iterate(rope->r_v.v_composite.r_right, func, arg);
fx_rope_iterate(rope->r_v.v_composite.r_right, func, arg);
}
}
size_t b_rope_get_size(const struct b_rope *rope)
size_t fx_rope_get_size(const struct fx_rope *rope)
{
return rope->r_len_total;
}
void b_rope_concat(
struct b_rope *result, const struct b_rope *left, const struct b_rope *right)
void fx_rope_concat(
struct fx_rope *result, const struct fx_rope *left, const struct fx_rope *right)
{
memset(result, 0x0, sizeof *result);
result->r_flags = B_ROPE_F_COMPOSITE;
result->r_flags = FX_ROPE_F_COMPOSITE;
result->r_len_left = left->r_len_total;
result->r_len_total = left->r_len_total + right->r_len_total;
result->r_v.v_composite.r_left = left;
result->r_v.v_composite.r_right = right;
}
static struct b_rope *create_composite_node(void)
static struct fx_rope *create_composite_node(void)
{
struct b_rope *out = malloc(sizeof *out);
struct fx_rope *out = malloc(sizeof *out);
if (!out) {
return NULL;
}
memset(out, 0x0, sizeof *out);
out->r_flags = B_ROPE_F_COMPOSITE | B_ROPE_F_MALLOC;
out->r_flags = FX_ROPE_F_COMPOSITE | FX_ROPE_F_MALLOC;
return out;
}
void b_rope_join(b_rope *result, const b_rope **ropes, size_t nr_ropes)
void fx_rope_join(fx_rope *result, const fx_rope **ropes, size_t nr_ropes)
{
if (nr_ropes == 0) {
return;
@@ -146,17 +146,17 @@ void b_rope_join(b_rope *result, const b_rope **ropes, size_t nr_ropes)
return;
}
struct b_rope *prev = NULL;
struct fx_rope *prev = NULL;
for (size_t i = 0; i < nr_ropes - 1; i++) {
const struct b_rope *left = ropes[i];
const struct b_rope *right = ropes[i + 1];
const struct fx_rope *left = ropes[i];
const struct fx_rope *right = ropes[i + 1];
if (prev) {
left = prev;
}
struct b_rope *composite = create_composite_node();
struct fx_rope *composite = create_composite_node();
if (!composite) {
return;
}
@@ -171,26 +171,26 @@ void b_rope_join(b_rope *result, const b_rope **ropes, size_t nr_ropes)
*result = *prev;
result->r_flags &= ~B_ROPE_F_MALLOC;
result->r_flags &= ~FX_ROPE_F_MALLOC;
free(prev);
}
static void rope_iterate(
const struct b_rope *rope,
void (*callback)(const struct b_rope *, void *), void *arg)
const struct fx_rope *rope,
void (*callback)(const struct fx_rope *, void *), void *arg)
{
unsigned int type = B_ROPE_TYPE(rope->r_flags);
unsigned int type = FX_ROPE_TYPE(rope->r_flags);
switch (type) {
case B_ROPE_F_CHAR:
case B_ROPE_F_CSTR:
case B_ROPE_F_CSTR_BORROWED:
case B_ROPE_F_CSTR_STATIC:
case B_ROPE_F_INT:
case B_ROPE_F_UINT:
case FX_ROPE_F_CHAR:
case FX_ROPE_F_CSTR:
case FX_ROPE_F_CSTR_BORROWED:
case FX_ROPE_F_CSTR_STATIC:
case FX_ROPE_F_INT:
case FX_ROPE_F_UINT:
callback(rope, arg);
break;
case B_ROPE_F_COMPOSITE:
case FX_ROPE_F_COMPOSITE:
rope_iterate(rope->r_v.v_composite.r_left, callback, arg);
rope_iterate(rope->r_v.v_composite.r_right, callback, arg);
break;
@@ -199,77 +199,77 @@ static void rope_iterate(
}
}
static void to_bstr(const struct b_rope *rope, void *arg)
static void to_bstr(const struct fx_rope *rope, void *arg)
{
b_bstr *str = arg;
fx_bstr *str = arg;
unsigned int type = B_ROPE_TYPE(rope->r_flags);
unsigned int type = FX_ROPE_TYPE(rope->r_flags);
switch (type) {
case B_ROPE_F_CHAR:
b_bstr_write_char(str, rope->r_v.v_char);
case FX_ROPE_F_CHAR:
fx_bstr_write_char(str, rope->r_v.v_char);
break;
case B_ROPE_F_CSTR:
case B_ROPE_F_CSTR_BORROWED:
case B_ROPE_F_CSTR_STATIC:
b_bstr_write_cstr(str, rope->r_v.v_cstr.s, NULL);
case FX_ROPE_F_CSTR:
case FX_ROPE_F_CSTR_BORROWED:
case FX_ROPE_F_CSTR_STATIC:
fx_bstr_write_cstr(str, rope->r_v.v_cstr.s, NULL);
break;
case B_ROPE_F_INT:
b_bstr_write_fmt(str, NULL, "%" PRIdPTR, rope->r_v.v_int);
case FX_ROPE_F_INT:
fx_bstr_write_fmt(str, NULL, "%" PRIdPTR, rope->r_v.v_int);
break;
case B_ROPE_F_UINT:
b_bstr_write_fmt(str, NULL, "%" PRIuPTR, rope->r_v.v_uint);
case FX_ROPE_F_UINT:
fx_bstr_write_fmt(str, NULL, "%" PRIuPTR, rope->r_v.v_uint);
break;
default:
break;
}
}
static void to_stream(const struct b_rope *rope, void *arg)
static void to_stream(const struct fx_rope *rope, void *arg)
{
b_stream *out = arg;
fx_stream *out = arg;
unsigned int type = B_ROPE_TYPE(rope->r_flags);
unsigned int type = FX_ROPE_TYPE(rope->r_flags);
switch (type) {
case B_ROPE_F_CHAR:
b_stream_write_char(out, rope->r_v.v_char);
case FX_ROPE_F_CHAR:
fx_stream_write_char(out, rope->r_v.v_char);
break;
case B_ROPE_F_CSTR:
case B_ROPE_F_CSTR_BORROWED:
case B_ROPE_F_CSTR_STATIC:
b_stream_write_string(out, rope->r_v.v_cstr.s, NULL);
case FX_ROPE_F_CSTR:
case FX_ROPE_F_CSTR_BORROWED:
case FX_ROPE_F_CSTR_STATIC:
fx_stream_write_string(out, rope->r_v.v_cstr.s, NULL);
break;
case B_ROPE_F_INT:
b_stream_write_fmt(out, NULL, "%" PRIdPTR, rope->r_v.v_int);
case FX_ROPE_F_INT:
fx_stream_write_fmt(out, NULL, "%" PRIdPTR, rope->r_v.v_int);
break;
case B_ROPE_F_UINT:
b_stream_write_fmt(out, NULL, "%" PRIuPTR, rope->r_v.v_uint);
case FX_ROPE_F_UINT:
fx_stream_write_fmt(out, NULL, "%" PRIuPTR, rope->r_v.v_uint);
break;
default:
break;
}
}
b_status b_rope_to_cstr(const struct b_rope *rope, char *out, size_t max)
fx_status fx_rope_to_cstr(const struct fx_rope *rope, char *out, size_t max)
{
b_bstr str;
b_bstr_begin(&str, out, max);
fx_bstr str;
fx_bstr_begin(&str, out, max);
rope_iterate(rope, to_bstr, &str);
return B_SUCCESS;
return FX_SUCCESS;
}
b_status b_rope_to_bstr(const struct b_rope *rope, b_bstr *str)
fx_status fx_rope_to_bstr(const struct fx_rope *rope, fx_bstr *str)
{
rope_iterate(rope, to_bstr, str);
return B_SUCCESS;
return FX_SUCCESS;
}
b_status b_rope_to_string(const struct b_rope *rope, b_stream *out)
fx_status fx_rope_to_string(const struct fx_rope *rope, fx_stream *out)
{
rope_iterate(rope, to_stream, out);
return B_SUCCESS;
return FX_SUCCESS;
}

74
core/status.c
View File

@@ -1,4 +1,4 @@
#include <blue/core/status.h>
#include <fx/core/status.h>
#include <stddef.h>
#define ENUM_STR(s) \
@@ -9,51 +9,51 @@
case c: \
return s;
const char *b_status_to_string(b_status status)
const char *fx_status_to_string(fx_status status)
{
switch (status) {
ENUM_STR(B_SUCCESS);
ENUM_STR(B_ERR_NO_MEMORY);
ENUM_STR(B_ERR_OUT_OF_BOUNDS);
ENUM_STR(B_ERR_INVALID_ARGUMENT);
ENUM_STR(B_ERR_NAME_EXISTS);
ENUM_STR(B_ERR_NOT_SUPPORTED);
ENUM_STR(B_ERR_BAD_STATE);
ENUM_STR(B_ERR_NO_ENTRY);
ENUM_STR(B_ERR_NO_DATA);
ENUM_STR(B_ERR_NO_SPACE);
ENUM_STR(B_ERR_UNKNOWN_FUNCTION);
ENUM_STR(B_ERR_BAD_FORMAT);
ENUM_STR(B_ERR_IO_FAILURE);
ENUM_STR(B_ERR_IS_DIRECTORY);
ENUM_STR(B_ERR_NOT_DIRECTORY);
ENUM_STR(B_ERR_PERMISSION_DENIED);
ENUM_STR(B_ERR_BUSY);
ENUM_STR(FX_SUCCESS);
ENUM_STR(FX_ERR_NO_MEMORY);
ENUM_STR(FX_ERR_OUT_OF_BOUNDS);
ENUM_STR(FX_ERR_INVALID_ARGUMENT);
ENUM_STR(FX_ERR_NAME_EXISTS);
ENUM_STR(FX_ERR_NOT_SUPPORTED);
ENUM_STR(FX_ERR_BAD_STATE);
ENUM_STR(FX_ERR_NO_ENTRY);
ENUM_STR(FX_ERR_NO_DATA);
ENUM_STR(FX_ERR_NO_SPACE);
ENUM_STR(FX_ERR_UNKNOWN_FUNCTION);
ENUM_STR(FX_ERR_BAD_FORMAT);
ENUM_STR(FX_ERR_IO_FAILURE);
ENUM_STR(FX_ERR_IS_DIRECTORY);
ENUM_STR(FX_ERR_NOT_DIRECTORY);
ENUM_STR(FX_ERR_PERMISSION_DENIED);
ENUM_STR(FX_ERR_BUSY);
default:
return NULL;
}
}
const char *b_status_description(b_status status)
const char *fx_status_description(fx_status status)
{
switch (status) {
ENUM_STR2(B_SUCCESS, "Success");
ENUM_STR2(B_ERR_NO_MEMORY, "Out of memory");
ENUM_STR2(B_ERR_OUT_OF_BOUNDS, "Argument out of bounds");
ENUM_STR2(B_ERR_INVALID_ARGUMENT, "Invalid argument");
ENUM_STR2(B_ERR_NAME_EXISTS, "Name already exists");
ENUM_STR2(B_ERR_NOT_SUPPORTED, "Operation not supported");
ENUM_STR2(B_ERR_BAD_STATE, "Bad state");
ENUM_STR2(B_ERR_NO_ENTRY, "No entry");
ENUM_STR2(B_ERR_NO_DATA, "No data available");
ENUM_STR2(B_ERR_NO_SPACE, "No space available");
ENUM_STR2(B_ERR_UNKNOWN_FUNCTION, "Unknown function");
ENUM_STR2(B_ERR_BAD_FORMAT, "Bad format");
ENUM_STR2(B_ERR_IO_FAILURE, "I/O failure");
ENUM_STR2(B_ERR_IS_DIRECTORY, "Object is a directory");
ENUM_STR2(B_ERR_NOT_DIRECTORY, "Object is not a directory");
ENUM_STR2(B_ERR_PERMISSION_DENIED, "Permission denied");
ENUM_STR2(B_ERR_BUSY, "Resource busy or locked");
ENUM_STR2(FX_SUCCESS, "Success");
ENUM_STR2(FX_ERR_NO_MEMORY, "Out of memory");
ENUM_STR2(FX_ERR_OUT_OF_BOUNDS, "Argument out of bounds");
ENUM_STR2(FX_ERR_INVALID_ARGUMENT, "Invalid argument");
ENUM_STR2(FX_ERR_NAME_EXISTS, "Name already exists");
ENUM_STR2(FX_ERR_NOT_SUPPORTED, "Operation not supported");
ENUM_STR2(FX_ERR_BAD_STATE, "Bad state");
ENUM_STR2(FX_ERR_NO_ENTRY, "No entry");
ENUM_STR2(FX_ERR_NO_DATA, "No data available");
ENUM_STR2(FX_ERR_NO_SPACE, "No space available");
ENUM_STR2(FX_ERR_UNKNOWN_FUNCTION, "Unknown function");
ENUM_STR2(FX_ERR_BAD_FORMAT, "Bad format");
ENUM_STR2(FX_ERR_IO_FAILURE, "I/O failure");
ENUM_STR2(FX_ERR_IS_DIRECTORY, "Object is a directory");
ENUM_STR2(FX_ERR_NOT_DIRECTORY, "Object is not a directory");
ENUM_STR2(FX_ERR_PERMISSION_DENIED, "Permission denied");
ENUM_STR2(FX_ERR_BUSY, "Resource busy or locked");
default:
return NULL;
}

688
core/stream.c
View File

File diff suppressed because it is too large Load Diff

174
core/stringstream.c
View File

@@ -1,4 +1,4 @@
#include <blue/core/stringstream.h>
#include <fx/core/stringstream.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
@@ -8,7 +8,7 @@
/*** PRIVATE DATA *************************************************************/
struct b_stringstream_p {
struct fx_stringstream_p {
char *ss_buf;
size_t ss_ptr;
size_t ss_len;
@@ -18,31 +18,31 @@ struct b_stringstream_p {
/*** PRIVATE FUNCTIONS ********************************************************/
static enum b_status __getc(struct b_stringstream_p *ss, b_wchar *out)
static enum fx_status __getc(struct fx_stringstream_p *ss, fx_wchar *out)
{
size_t available = ss->ss_len - ss->ss_ptr;
const char *p = ss->ss_buf + ss->ss_ptr;
size_t to_copy = b_wchar_utf8_codepoint_stride(p);
size_t to_copy = fx_wchar_utf8_codepoint_stride(p);
if (to_copy > available) {
return B_ERR_BAD_STATE;
return FX_ERR_BAD_STATE;
}
b_wchar c = b_wchar_utf8_codepoint_decode(p);
fx_wchar c = fx_wchar_utf8_codepoint_decode(p);
*out = c;
if (c == B_WCHAR_INVALID) {
return B_ERR_BAD_STATE;
if (c == FX_WCHAR_INVALID) {
return FX_ERR_BAD_STATE;
}
ss->ss_ptr += to_copy;
return B_SUCCESS;
return FX_SUCCESS;
}
static enum b_status __gets(
struct b_stringstream_p *ss, char *s, size_t len, size_t *nr_read)
static enum fx_status __gets(
struct fx_stringstream_p *ss, char *s, size_t len, size_t *nr_read)
{
size_t available = ss->ss_len - ss->ss_ptr;
size_t to_copy = len;
@@ -59,11 +59,11 @@ static enum b_status __gets(
*nr_read = to_copy;
}
return B_SUCCESS;
return FX_SUCCESS;
}
static enum b_status __puts(
struct b_stringstream_p *ss, const char *s, size_t len, size_t *nr_written)
static enum fx_status __puts(
struct fx_stringstream_p *ss, const char *s, size_t len, size_t *nr_written)
{
size_t available = ss->ss_max - ss->ss_len;
size_t to_copy = len;
@@ -71,7 +71,7 @@ static enum b_status __puts(
if (to_copy > available && ss->ss_alloc == 1) {
char *new_buf = realloc(ss->ss_buf, ss->ss_len + to_copy + 1);
if (!new_buf) {
return B_ERR_NO_MEMORY;
return FX_ERR_NO_MEMORY;
}
ss->ss_buf = new_buf;
@@ -93,10 +93,10 @@ static enum b_status __puts(
*nr_written = to_copy;
}
return B_SUCCESS;
return FX_SUCCESS;
}
static enum b_status stringstream_reset(struct b_stringstream_p *ss)
static enum fx_status stringstream_reset(struct fx_stringstream_p *ss)
{
ss->ss_len = 0;
@@ -104,11 +104,11 @@ static enum b_status stringstream_reset(struct b_stringstream_p *ss)
*ss->ss_buf = 0;
}
return B_SUCCESS;
return FX_SUCCESS;
}
static enum b_status stringstream_reset_with_buffer(
struct b_stringstream_p *ss, char *buf, size_t max)
static enum fx_status stringstream_reset_with_buffer(
struct fx_stringstream_p *ss, char *buf, size_t max)
{
ss->ss_len = 0;
@@ -120,20 +120,20 @@ static enum b_status stringstream_reset_with_buffer(
ss->ss_max = max;
ss->ss_alloc = 0;
return B_SUCCESS;
return FX_SUCCESS;
}
static size_t stringstream_get_length(const struct b_stringstream_p *strv)
static size_t stringstream_get_length(const struct fx_stringstream_p *strv)
{
return strv->ss_len;
}
static const char *stringstream_ptr(const struct b_stringstream_p *ss)
static const char *stringstream_ptr(const struct fx_stringstream_p *ss)
{
return ss->ss_buf;
}
static char *stringstream_steal(struct b_stringstream_p *ss)
static char *stringstream_steal(struct fx_stringstream_p *ss)
{
char *out = ss->ss_buf;
@@ -146,17 +146,17 @@ static char *stringstream_steal(struct b_stringstream_p *ss)
/*** PUBLIC FUNCTIONS *********************************************************/
b_stringstream *b_stringstream_create_with_buffer(char *buf, size_t max)
fx_stringstream *fx_stringstream_create_with_buffer(char *buf, size_t max)
{
b_stringstream *s = b_object_create(B_TYPE_STRINGSTREAM);
fx_stringstream *s = fx_object_create(FX_TYPE_STRINGSTREAM);
if (!s) {
return NULL;
}
b_stream_cfg *cfg = b_object_get_protected(s, B_TYPE_STREAM);
struct b_stringstream_p *p = b_object_get_private(s, B_TYPE_STRINGSTREAM);
fx_stream_cfg *cfg = fx_object_get_protected(s, FX_TYPE_STREAM);
struct fx_stringstream_p *p = fx_object_get_private(s, FX_TYPE_STRINGSTREAM);
cfg->s_mode = B_STREAM_READ | B_STREAM_WRITE | Z__B_STREAM_STATIC;
cfg->s_mode = FX_STREAM_READ | FX_STREAM_WRITE | Z__FX_STREAM_STATIC;
p->ss_buf = buf;
p->ss_max = max;
@@ -166,21 +166,21 @@ b_stringstream *b_stringstream_create_with_buffer(char *buf, size_t max)
return s;
}
b_stringstream *b_stringstream_create(void)
fx_stringstream *fx_stringstream_create(void)
{
b_stringstream *s = b_object_create(B_TYPE_STRINGSTREAM);
fx_stringstream *s = fx_object_create(FX_TYPE_STRINGSTREAM);
if (!s) {
return NULL;
}
b_stream_cfg *cfg = b_object_get_protected(s, B_TYPE_STREAM);
struct b_stringstream_p *p = b_object_get_private(s, B_TYPE_STRINGSTREAM);
fx_stream_cfg *cfg = fx_object_get_protected(s, FX_TYPE_STREAM);
struct fx_stringstream_p *p = fx_object_get_private(s, FX_TYPE_STRINGSTREAM);
cfg->s_mode = B_STREAM_READ | B_STREAM_WRITE | Z__B_STREAM_STATIC;
cfg->s_mode = FX_STREAM_READ | FX_STREAM_WRITE | Z__FX_STREAM_STATIC;
p->ss_buf = malloc(DEFAULT_CAPACITY + 1);
if (!p->ss_buf) {
b_stringstream_unref(s);
fx_stringstream_unref(s);
return NULL;
}
@@ -192,106 +192,106 @@ b_stringstream *b_stringstream_create(void)
return s;
}
size_t b_stringstream_get_length(const b_stringstream *strv)
size_t fx_stringstream_get_length(const fx_stringstream *strv)
{
B_CLASS_DISPATCH_STATIC_0(
B_TYPE_STRINGSTREAM, stringstream_get_length, strv);
FX_CLASS_DISPATCH_STATIC_0(
FX_TYPE_STRINGSTREAM, stringstream_get_length, strv);
}
enum b_status b_stringstream_reset(b_stringstream *strv)
enum fx_status fx_stringstream_reset(fx_stringstream *strv)
{
B_CLASS_DISPATCH_STATIC_0(B_TYPE_STRINGSTREAM, stringstream_reset, strv);
FX_CLASS_DISPATCH_STATIC_0(FX_TYPE_STRINGSTREAM, stringstream_reset, strv);
}
enum b_status b_stringstream_reset_with_buffer(
b_stringstream *strv, char *buf, size_t max)
enum fx_status fx_stringstream_reset_with_buffer(
fx_stringstream *strv, char *buf, size_t max)
{
B_CLASS_DISPATCH_STATIC(
B_TYPE_STRINGSTREAM, stringstream_reset_with_buffer, strv, buf,
FX_CLASS_DISPATCH_STATIC(
FX_TYPE_STRINGSTREAM, stringstream_reset_with_buffer, strv, buf,
max);
}
const char *b_stringstream_ptr(const b_stringstream *ss)
const char *fx_stringstream_ptr(const fx_stringstream *ss)
{
B_CLASS_DISPATCH_STATIC_0(B_TYPE_STRINGSTREAM, stringstream_ptr, ss);
FX_CLASS_DISPATCH_STATIC_0(FX_TYPE_STRINGSTREAM, stringstream_ptr, ss);
}
char *b_stringstream_steal(b_stringstream *ss)
char *fx_stringstream_steal(fx_stringstream *ss)
{
B_CLASS_DISPATCH_STATIC_0(B_TYPE_STRINGSTREAM, stringstream_steal, ss);
FX_CLASS_DISPATCH_STATIC_0(FX_TYPE_STRINGSTREAM, stringstream_steal, ss);
}
/*** PUBLIC ALIAS FUNCTIONS ***************************************************/
/*** VIRTUAL FUNCTIONS ********************************************************/
static void stringstream_init(b_object *obj, void *priv)
static void stringstream_init(fx_object *obj, void *priv)
{
struct b_stringstream_p *stream = priv;
struct fx_stringstream_p *stream = priv;
}
static void stringstream_fini(b_object *obj, void *priv)
static void stringstream_fini(fx_object *obj, void *priv)
{
struct b_stringstream_p *stream = priv;
struct fx_stringstream_p *stream = priv;
if (stream->ss_alloc && stream->ss_buf) {
free(stream->ss_buf);
}
}
enum b_status stream_getc(b_stream *stream, b_wchar *c)
enum fx_status stream_getc(fx_stream *stream, fx_wchar *c)
{
struct b_stringstream_p *s
= b_object_get_private(stream, B_TYPE_STRINGSTREAM);
struct fx_stringstream_p *s
= fx_object_get_private(stream, FX_TYPE_STRINGSTREAM);
enum b_status status = __getc(s, c);
enum fx_status status = __getc(s, c);
return status;
}
enum b_status stream_read(b_stream *stream, void *buf, size_t count, size_t *nr_read)
enum fx_status stream_read(fx_stream *stream, void *buf, size_t count, size_t *nr_read)
{
struct b_stringstream_p *s
= b_object_get_private(stream, B_TYPE_STRINGSTREAM);
struct fx_stringstream_p *s
= fx_object_get_private(stream, FX_TYPE_STRINGSTREAM);
enum b_status status = __gets(s, buf, count, nr_read);
enum fx_status status = __gets(s, buf, count, nr_read);
return status;
}
enum b_status stream_write(
b_stream *stream, const void *buf, size_t count, size_t *nr_written)
enum fx_status stream_write(
fx_stream *stream, const void *buf, size_t count, size_t *nr_written)
{
struct b_stringstream_p *s
= b_object_get_private(stream, B_TYPE_STRINGSTREAM);
struct fx_stringstream_p *s
= fx_object_get_private(stream, FX_TYPE_STRINGSTREAM);
enum b_status status = __puts(s, (const char *)buf, count, nr_written);
enum fx_status status = __puts(s, (const char *)buf, count, nr_written);
return status;
}
/*** CLASS DEFINITION *********************************************************/
B_TYPE_CLASS_DEFINITION_BEGIN(b_stringstream)
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)
FX_TYPE_CLASS_DEFINITION_BEGIN(fx_stringstream)
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)
B_TYPE_CLASS_INTERFACE_BEGIN(b_stream, B_TYPE_STREAM)
B_INTERFACE_ENTRY(s_close) = NULL;
B_INTERFACE_ENTRY(s_seek) = NULL;
B_INTERFACE_ENTRY(s_tell) = NULL;
B_INTERFACE_ENTRY(s_getc) = stream_getc;
B_INTERFACE_ENTRY(s_read) = stream_read;
B_INTERFACE_ENTRY(s_write) = stream_write;
B_INTERFACE_ENTRY(s_reserve) = NULL;
B_TYPE_CLASS_INTERFACE_END(b_stream, B_TYPE_STREAM)
B_TYPE_CLASS_DEFINITION_END(b_stringstream)
FX_TYPE_CLASS_INTERFACE_BEGIN(fx_stream, FX_TYPE_STREAM)
FX_INTERFACE_ENTRY(s_close) = NULL;
FX_INTERFACE_ENTRY(s_seek) = NULL;
FX_INTERFACE_ENTRY(s_tell) = NULL;
FX_INTERFACE_ENTRY(s_getc) = stream_getc;
FX_INTERFACE_ENTRY(s_read) = stream_read;
FX_INTERFACE_ENTRY(s_write) = stream_write;
FX_INTERFACE_ENTRY(s_reserve) = NULL;
FX_TYPE_CLASS_INTERFACE_END(fx_stream, FX_TYPE_STREAM)
FX_TYPE_CLASS_DEFINITION_END(fx_stringstream)
B_TYPE_DEFINITION_BEGIN(b_stringstream)
B_TYPE_ID(0x508a609a, 0xfac5, 0x4d31, 0x843a, 0x44b68ad329f3);
B_TYPE_EXTENDS(B_TYPE_STREAM);
B_TYPE_CLASS(b_stringstream_class);
B_TYPE_INSTANCE_PRIVATE(struct b_stringstream_p);
B_TYPE_INSTANCE_INIT(stringstream_init);
B_TYPE_INSTANCE_FINI(stringstream_fini);
B_TYPE_DEFINITION_END(b_stringstream)
FX_TYPE_DEFINITION_BEGIN(fx_stringstream)
FX_TYPE_ID(0x508a609a, 0xfac5, 0x4d31, 0x843a, 0x44b68ad329f3);
FX_TYPE_EXTENDS(FX_TYPE_STREAM);
FX_TYPE_CLASS(fx_stringstream_class);
FX_TYPE_INSTANCE_PRIVATE(struct fx_stringstream_p);
FX_TYPE_INSTANCE_INIT(stringstream_init);
FX_TYPE_INSTANCE_FINI(stringstream_fini);
FX_TYPE_DEFINITION_END(fx_stringstream)

8
core/sys/darwin/bitop.c
View File

@@ -1,16 +1,16 @@
#include <blue/core/bitop.h>
#include <fx/core/bitop.h>
int b_popcountl(long v)
int fx_popcountl(long v)
{
return __builtin_popcountl(v);
}
int b_ctzl(long v)
int fx_ctzl(long v)
{
return __builtin_ctzl(v);
}
int b_clzl(long v)
int fx_clzl(long v)
{
return __builtin_clzl(v);
}

4
core/sys/darwin/random.c
View File

@@ -2,7 +2,7 @@
#include <stdint.h>
#include <unistd.h>
uint64_t z__b_platform_random_seed()
uint64_t z__fx_platform_random_seed()
{
int fd = open("/dev/urandom", O_RDONLY);
if (fd == -1) {
@@ -18,7 +18,7 @@ uint64_t z__b_platform_random_seed()
return v;
}
uint64_t z__b_platform_random_seed_secure()
uint64_t z__fx_platform_random_seed_secure()
{
int fd = open("/dev/random", O_RDONLY);
if (fd == -1) {

24
core/sys/darwin/thread.c
View File

@@ -1,20 +1,20 @@
#include <assert.h>
#include <blue/core/error.h>
#include <blue/core/thread.h>
#include <fx/core/error.h>
#include <fx/core/thread.h>
#include <stdlib.h>
#include <string.h>
struct b_thread {
struct fx_thread {
pthread_t thr_p;
b_result thr_result;
fx_result thr_result;
};
static b_once thread_tls_init_once = B_ONCE_INIT;
static fx_once thread_tls_init_once = FX_ONCE_INIT;
static pthread_key_t thread_tls_key = {0};
static void thread_dtor(void *p)
{
struct b_thread *thread = p;
struct fx_thread *thread = p;
}
static void thread_tls_init()
@@ -22,13 +22,13 @@ static void thread_tls_init()
pthread_key_create(&thread_tls_key, thread_dtor);
}
struct b_thread *b_thread_self(void)
struct fx_thread *fx_thread_self(void)
{
if (b_init_once(&thread_tls_init_once)) {
if (fx_init_once(&thread_tls_init_once)) {
thread_tls_init();
}
struct b_thread *thread = pthread_getspecific(thread_tls_key);
struct fx_thread *thread = pthread_getspecific(thread_tls_key);
if (thread) {
return thread;
}
@@ -45,17 +45,17 @@ struct b_thread *b_thread_self(void)
return thread;
}
bool b_mutex_lock(b_mutex *mut)
bool fx_mutex_lock(fx_mutex *mut)
{
return pthread_mutex_lock(mut) == 0;
}
bool b_mutex_trylock(b_mutex *mut)
bool fx_mutex_trylock(fx_mutex *mut)
{
return pthread_mutex_trylock(mut) == 0;
}
bool b_mutex_unlock(b_mutex *mut)
bool fx_mutex_unlock(fx_mutex *mut)
{
return pthread_mutex_unlock(mut) == 0;
}

8
core/sys/linux/bitop.c
View File

@@ -1,16 +1,16 @@
#include <blue/core/bitop.h>
#include <fx/core/bitop.h>
int b_popcountl(long v)
int fx_popcountl(long v)
{
return __builtin_popcountl(v);
}
int b_ctzl(long v)
int fx_ctzl(long v)
{
return __builtin_ctzl(v);
}
int b_clzl(long v)
int fx_clzl(long v)
{
return __builtin_clzl(v);
}

4
core/sys/linux/random.c
View File

@@ -2,7 +2,7 @@
#include <stdint.h>
#include <unistd.h>
uint64_t z__b_platform_random_seed()
uint64_t z__fx_platform_random_seed()
{
int fd = open("/dev/urandom", O_RDONLY);
if (fd == -1) {
@@ -18,7 +18,7 @@ uint64_t z__b_platform_random_seed()
return v;
}
uint64_t z__b_platform_random_seed_secure()
uint64_t z__fx_platform_random_seed_secure()
{
int fd = open("/dev/random", O_RDONLY);
if (fd == -1) {

8
core/sys/windows/bitop.c
View File

@@ -1,4 +1,4 @@
#include <blue/core/bitop.h>
#include <fx/core/bitop.h>
#include <intrin.h>
#include <assert.h>
@@ -16,7 +16,7 @@ static int check_popcnt_support()
return (d[2] & 0x800000) ? CPU_FEATURE_YES : CPU_FEATURE_NO;
}
int b_popcountl(long v)
int fx_popcountl(long v)
{
if (cpu_supports_popcnt == CPU_FEATURE_UNKNOWN) {
cpu_supports_popcnt = check_popcnt_support();
@@ -34,7 +34,7 @@ int b_popcountl(long v)
return 0;
}
int b_ctzl(long v)
int fx_ctzl(long v)
{
unsigned long trailing_zero = 0;
@@ -51,7 +51,7 @@ int b_ctzl(long v)
}
}
int b_clzl(long v)
int fx_clzl(long v)
{
unsigned long leading_zero = 0;

6
core/sys/windows/random.c
View File

@@ -5,7 +5,7 @@
#include <Windows.h>
#include <wincrypt.h>
uint64_t z__b_platform_random_seed_secure(void)
uint64_t z__fx_platform_random_seed_secure(void)
{
BOOL status;
HCRYPTPROV hCryptProv;
@@ -24,7 +24,7 @@ uint64_t z__b_platform_random_seed_secure(void)
return status == TRUE ? v : (uint64_t)-1;
}
uint64_t z__b_platform_random_seed(void)
uint64_t z__fx_platform_random_seed(void)
{
return z__b_platform_random_seed_secure();
return z__fx_platform_random_seed_secure();
}

202
core/type.c
View File

@@ -3,16 +3,16 @@
#include "class.h"
#include "object.h"
#include <blue/core/btree.h>
#include <blue/core/endian.h>
#include <blue/core/object.h>
#include <blue/core/type.h>
#include <fx/core/btree.h>
#include <fx/core/endian.h>
#include <fx/core/object.h>
#include <fx/core/type.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
static struct b_btree type_list = B_BTREE_INIT;
static union b_type zero_id = {0};
static struct fx_bst type_list = FX_BTREE_INIT;
static union fx_type zero_id = {0};
struct type_init_ctx {
size_t ctx_class_offset;
@@ -20,37 +20,37 @@ struct type_init_ctx {
};
static inline int registration_compare(
const struct b_type_registration *a, const struct b_type_registration *b)
const struct fx_type_registration *a, const struct fx_type_registration *b)
{
return b_type_id_compare(&a->r_info->t_id, &b->r_info->t_id);
return fx_type_id_compare(&a->r_info->t_id, &b->r_info->t_id);
}
static inline int component_compare(
const struct b_type_component *a, const struct b_type_component *b)
const struct fx_type_component *a, const struct fx_type_component *b)
{
return b_type_id_compare(&a->c_type->r_info->t_id, &b->c_type->r_info->t_id);
return fx_type_id_compare(&a->c_type->r_info->t_id, &b->c_type->r_info->t_id);
}
B_BTREE_DEFINE_INSERT(
struct b_type_registration, r_node, r_info->r_id, put_type,
FX_BTREE_DEFINE_INSERT(
struct fx_type_registration, r_node, r_info->r_id, put_type,
registration_compare)
B_BTREE_DEFINE_INSERT(
struct b_type_component, c_node, &c_type->r_info->t_id,
FX_BTREE_DEFINE_INSERT(
struct fx_type_component, c_node, &c_type->r_info->t_id,
put_type_component, component_compare)
static struct b_type_registration *get_type(
const b_btree *tree, const union b_type *key)
static struct fx_type_registration *get_type(
const fx_bst *tree, const union fx_type *key)
{
b_btree_node *cur = tree->b_root;
fx_bst_node *cur = tree->bst_root;
while (cur) {
struct b_type_registration *cur_node
= b_unbox(struct b_type_registration, cur, r_node);
int cmp = b_type_id_compare(key, &cur_node->r_info->t_id);
struct fx_type_registration *cur_node
= fx_unbox(struct fx_type_registration, cur, r_node);
int cmp = fx_type_id_compare(key, &cur_node->r_info->t_id);
if (cmp > 0) {
cur = b_btree_right(cur);
cur = fx_bst_right(cur);
} else if (cmp < 0) {
cur = b_btree_left(cur);
cur = fx_bst_left(cur);
} else {
return cur_node;
}
@@ -59,19 +59,19 @@ static struct b_type_registration *get_type(
return NULL;
}
struct b_type_component *b_type_get_component(
const b_btree *tree, const union b_type *key)
struct fx_type_component *fx_type_get_component(
const fx_bst *tree, const union fx_type *key)
{
b_btree_node *cur = tree->b_root;
fx_bst_node *cur = tree->bst_root;
while (cur) {
struct b_type_component *cur_node
= b_unbox(struct b_type_component, cur, c_node);
int cmp = b_type_id_compare(key, &cur_node->c_type->r_info->t_id);
struct fx_type_component *cur_node
= fx_unbox(struct fx_type_component, cur, c_node);
int cmp = fx_type_id_compare(key, &cur_node->c_type->r_info->t_id);
if (cmp > 0) {
cur = b_btree_right(cur);
cur = fx_bst_right(cur);
} else if (cmp < 0) {
cur = b_btree_left(cur);
cur = fx_bst_left(cur);
} else {
return cur_node;
}
@@ -80,10 +80,10 @@ struct b_type_component *b_type_get_component(
return NULL;
}
static struct b_type_component *create_type_component(
const struct b_type_registration *type_reg)
static struct fx_type_component *create_type_component(
const struct fx_type_registration *type_reg)
{
struct b_type_component *c = malloc(sizeof *c);
struct fx_type_component *c = malloc(sizeof *c);
if (!c) {
return NULL;
}
@@ -95,15 +95,15 @@ static struct b_type_component *create_type_component(
return c;
}
void b_type_id_init(
union b_type *out, uint32_t a, uint16_t b, uint16_t c, uint16_t d,
void fx_type_id_init(
union fx_type *out, uint32_t a, uint16_t b, uint16_t c, uint16_t d,
uint64_t e)
{
b_i32 x_a = b_i32_htob(a);
b_i16 x_b = b_i16_htob(b);
b_i16 x_c = b_i16_htob(c);
b_i16 x_d = b_i16_htob(d);
b_i64 x_e = b_i64_htob(e);
fx_i32 x_a = fx_i32_htob(a);
fx_i16 x_b = fx_i16_htob(b);
fx_i16 x_c = fx_i16_htob(c);
fx_i16 x_d = fx_i16_htob(d);
fx_i64 x_e = fx_i64_htob(e);
memcpy(&out->b[0], x_a.i_bytes, sizeof x_a.i_bytes);
memcpy(&out->b[4], x_b.i_bytes, sizeof x_b.i_bytes);
@@ -113,7 +113,7 @@ void b_type_id_init(
}
static void initialise_type_component(
struct b_type_component *comp, const struct b_type_info *info,
struct fx_type_component *comp, const struct fx_type_info *info,
struct type_init_ctx *init_ctx)
{
comp->c_class_data_offset = init_ctx->ctx_class_offset;
@@ -129,43 +129,43 @@ static void initialise_type_component(
init_ctx->ctx_instance_offset += comp->c_instance_protected_data_size;
}
static b_result locate_interface(
b_type interface_id, struct b_type_registration *dest,
static fx_result locate_interface(
fx_type interface_id, struct fx_type_registration *dest,
struct type_init_ctx *init_ctx)
{
struct b_type_component *interface_comp
= b_type_get_component(&dest->r_components, interface_id);
struct fx_type_component *interface_comp
= fx_type_get_component(&dest->r_components, interface_id);
if (interface_comp) {
return B_RESULT_SUCCESS;
return FX_RESULT_SUCCESS;
}
struct b_type_registration *interface_reg
struct fx_type_registration *interface_reg
= get_type(&type_list, interface_id);
if (!interface_reg) {
return B_RESULT_ERR(NO_ENTRY);
return FX_RESULT_ERR(NO_ENTRY);
}
interface_comp = create_type_component(interface_reg);
if (!interface_comp) {
return B_RESULT_ERR(NO_MEMORY);
return FX_RESULT_ERR(NO_MEMORY);
}
initialise_type_component(interface_comp, interface_reg->r_info, init_ctx);
put_type_component(&dest->r_components, interface_comp);
return B_RESULT_SUCCESS;
return FX_RESULT_SUCCESS;
}
static b_result locate_interfaces(
const union b_type *interfaces, size_t nr_interfaces,
struct b_type_registration *dest, struct type_init_ctx *init_ctx)
static fx_result locate_interfaces(
const union fx_type *interfaces, size_t nr_interfaces,
struct fx_type_registration *dest, struct type_init_ctx *init_ctx)
{
b_result result = B_RESULT_SUCCESS;
fx_result result = FX_RESULT_SUCCESS;
for (size_t i = 0; i < nr_interfaces; i++) {
b_type interface_id = &interfaces[i];
fx_type interface_id = &interfaces[i];
result = locate_interface(interface_id, dest, init_ctx);
if (b_result_is_error(result)) {
if (fx_result_is_error(result)) {
break;
}
}
@@ -173,45 +173,45 @@ static b_result locate_interfaces(
return result;
}
static b_result find_type_components(struct b_type_registration *reg)
static fx_result find_type_components(struct fx_type_registration *reg)
{
const struct b_type_info *current = reg->r_info;
struct b_type_component *comp = create_type_component(reg);
const struct fx_type_info *current = reg->r_info;
struct fx_type_component *comp = create_type_component(reg);
if (!comp) {
return B_RESULT_ERR(NO_MEMORY);
return FX_RESULT_ERR(NO_MEMORY);
}
struct type_init_ctx init_ctx = {
.ctx_instance_offset = sizeof(struct _b_object),
.ctx_class_offset = sizeof(struct _b_class),
.ctx_instance_offset = sizeof(struct _fx_object),
.ctx_class_offset = sizeof(struct _fx_class),
};
put_type_component(&reg->r_components, comp);
b_queue_push_front(&reg->r_class_hierarchy, &comp->c_entry);
fx_queue_push_front(&reg->r_class_hierarchy, &comp->c_entry);
b_result result = locate_interfaces(
fx_result result = locate_interfaces(
current->t_interfaces, current->t_nr_interfaces, reg, &init_ctx);
if (b_result_is_error(result)) {
if (fx_result_is_error(result)) {
return result;
}
b_type current_id = &current->t_parent_id;
if (!current_id || b_type_id_compare(current_id, &zero_id) == 0) {
fx_type current_id = &current->t_parent_id;
if (!current_id || fx_type_id_compare(current_id, &zero_id) == 0) {
goto skip_class_hierarchy;
}
while (1) {
struct b_type_registration *dep_class
struct fx_type_registration *dep_class
= get_type(&type_list, current_id);
if (!dep_class) {
return B_RESULT_ERR(NO_ENTRY);
return FX_RESULT_ERR(NO_ENTRY);
}
comp = b_type_get_component(&reg->r_components, current_id);
comp = fx_type_get_component(&reg->r_components, current_id);
if (comp) {
/* circular class dependency */
// result = B_RESULT_ERR(INVALID_ARGUMENT);
// result = FX_RESULT_ERR(INVALID_ARGUMENT);
// break;
current_id = &dep_class->r_info->t_parent_id;
continue;
@@ -222,38 +222,38 @@ static b_result find_type_components(struct b_type_registration *reg)
result = locate_interfaces(
dep_class->r_info->t_interfaces,
dep_class->r_info->t_nr_interfaces, reg, &init_ctx);
if (b_result_is_error(result)) {
if (fx_result_is_error(result)) {
break;
}
put_type_component(&reg->r_components, comp);
b_queue_push_front(&reg->r_class_hierarchy, &comp->c_entry);
fx_queue_push_front(&reg->r_class_hierarchy, &comp->c_entry);
if (b_type_id_compare(current_id, B_TYPE_OBJECT) == 0) {
if (fx_type_id_compare(current_id, FX_TYPE_OBJECT) == 0) {
break;
}
current_id = &dep_class->r_info->t_parent_id;
}
b_queue_entry *entry = b_queue_first(&reg->r_class_hierarchy);
fx_queue_entry *entry = fx_queue_first(&reg->r_class_hierarchy);
while (entry) {
comp = b_unbox(struct b_type_component, entry, c_entry);
comp = fx_unbox(struct fx_type_component, entry, c_entry);
initialise_type_component(comp, comp->c_type->r_info, &init_ctx);
entry = b_queue_next(entry);
entry = fx_queue_next(entry);
}
b_btree_node *node = b_btree_first(&reg->r_components);
fx_bst_node *node = fx_bst_first(&reg->r_components);
while (node) {
comp = b_unbox(struct b_type_component, node, c_node);
if (comp->c_type->r_category == B_TYPE_CLASS) {
comp = fx_unbox(struct fx_type_component, node, c_node);
if (comp->c_type->r_category == FX_TYPE_CLASS) {
/* this component was already initialised above */
node = b_btree_next(node);
node = fx_bst_next(node);
continue;
}
initialise_type_component(comp, comp->c_type->r_info, &init_ctx);
node = b_btree_next(node);
node = fx_bst_next(node);
}
skip_class_hierarchy:
@@ -263,57 +263,57 @@ skip_class_hierarchy:
return result;
}
static bool type_has_base_class(struct b_type_info *info)
static bool type_has_base_class(struct fx_type_info *info)
{
if (b_type_id_compare(&info->t_id, B_TYPE_OBJECT) == 0) {
if (fx_type_id_compare(&info->t_id, FX_TYPE_OBJECT) == 0) {
return true;
}
return b_type_id_compare(&info->t_parent_id, &zero_id) != 0;
return fx_type_id_compare(&info->t_parent_id, &zero_id) != 0;
}
b_result b_type_register(struct b_type_info *info)
fx_result fx_type_register(struct fx_type_info *info)
{
if (!type_has_base_class(info)) {
b_type_id_copy(B_TYPE_OBJECT, &info->t_parent_id);
fx_type_id_copy(FX_TYPE_OBJECT, &info->t_parent_id);
}
struct b_type_registration *r = get_type(&type_list, &info->t_id);
struct fx_type_registration *r = get_type(&type_list, &info->t_id);
if (r) {
return B_RESULT_ERR(NAME_EXISTS);
return FX_RESULT_ERR(NAME_EXISTS);
}
r = malloc(sizeof *r);
if (!r) {
return B_RESULT_ERR(NO_MEMORY);
return FX_RESULT_ERR(NO_MEMORY);
}
memset(r, 0x0, sizeof *r);
r->r_category = B_TYPE_CLASS;
r->r_category = FX_TYPE_CLASS;
r->r_info = info;
b_result result = find_type_components(r);
if (b_result_is_error(result)) {
fx_result result = find_type_components(r);
if (fx_result_is_error(result)) {
free(r);
return b_result_propagate(result);
return fx_result_propagate(result);
}
result = b_class_instantiate(r, &r->r_class);
result = fx_class_instantiate(r, &r->r_class);
if (!r->r_class) {
free(r);
return b_error_with_msg_template_caused_by_error(
B_ERRORS_BUILTIN, B_ERR_TYPE_REGISTRATION_FAILURE,
result, B_MSG_TYPE_REGISTRATION_FAILURE,
B_ERROR_PARAM("typename", info->t_name));
return fx_error_with_msg_template_caused_by_error(
FX_ERRORS_BUILTIN, FX_ERR_TYPE_REGISTRATION_FAILURE,
result, FX_MSG_TYPE_REGISTRATION_FAILURE,
FX_ERROR_PARAM("typename", info->t_name));
}
put_type(&type_list, r);
return B_RESULT_SUCCESS;
return FX_RESULT_SUCCESS;
}
struct b_type_registration *b_type_get_registration(b_type id)
struct fx_type_registration *fx_type_get_registration(fx_type id)
{
return get_type(&type_list, id);
}

42
core/type.h
View File

@@ -1,40 +1,40 @@
#ifndef _TYPE_H_
#define _TYPE_H_
#include <blue/core/btree.h>
#include <blue/core/queue.h>
#include <blue/core/type.h>
#include <fx/core/btree.h>
#include <fx/core/queue.h>
#include <fx/core/type.h>
#include <stddef.h>
enum b_type_category {
B_TYPE_NONE = 0,
B_TYPE_CLASS,
B_TYPE_INTERFACE,
enum fx_type_category {
FX_TYPE_NONE = 0,
FX_TYPE_CLASS,
FX_TYPE_INTERFACE,
};
struct b_type_component {
struct b_btree_node c_node;
struct b_queue_entry c_entry;
const struct b_type_registration *c_type;
struct fx_type_component {
struct fx_bst_node c_node;
struct fx_queue_entry c_entry;
const struct fx_type_registration *c_type;
size_t c_class_data_offset, c_class_data_size;
size_t c_instance_private_data_offset, c_instance_private_data_size;
size_t c_instance_protected_data_offset, c_instance_protected_data_size;
};
struct b_type_registration {
enum b_type_category r_category;
struct b_btree_node r_node;
const b_type_info *r_info;
struct _b_class *r_class;
struct b_btree r_components;
struct b_queue r_class_hierarchy;
struct fx_type_registration {
enum fx_type_category r_category;
struct fx_bst_node r_node;
const fx_type_info *r_info;
struct _fx_class *r_class;
struct fx_bst r_components;
struct fx_queue r_class_hierarchy;
size_t r_instance_size, r_class_size;
};
extern struct b_type_registration *b_type_get_registration(b_type id);
extern struct b_type_component *b_type_get_component(
const b_btree *tree, const union b_type *key);
extern struct fx_type_registration *fx_type_get_registration(fx_type id);
extern struct fx_type_component *fx_type_get_component(
const fx_bst *tree, const union fx_type *key);
#endif