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

kernel: don't use typedef for enums or non-opaque structs

Browse Source
This commit is contained in:
max 🍓
2023-04-12 20:17:11 +01:00
parent 0d75e347e9
commit b6f8c1ccaa
51 changed files with 663 additions and 665 deletions
Download Patch File Download Diff File Expand all files Collapse all files

88
ds/btree.c
View File

@@ -50,7 +50,7 @@
this file intentionally excludes any kind of search function implementation.
it is up to the programmer to implement their own tree node type
using btree_node_t, and their own search function using btree_t.
using struct btree_node, and their own search function using struct btree.
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
@@ -75,12 +75,12 @@
#define HEIGHT(x) ((x) ? (x)->b_height : 0)
static inline void update_height(btree_node_t *x)
static inline void update_height(struct btree_node *x)
{
x->b_height = MAX(HEIGHT(x->b_left), HEIGHT((x->b_right))) + 1;
}
static inline int bf(btree_node_t *x)
static inline int bf(struct btree_node *x)
{
int bf = 0;
@@ -125,11 +125,11 @@ static inline int bf(btree_node_t *x)
note that this function does NOT update b_height for the rotated
nodes. it is up to you to call update_height_to_root().
*/
static void rotate_left(btree_t *tree, btree_node_t *x)
static void rotate_left(struct btree *tree, struct btree_node *x)
{
btree_node_t *y = x->b_right;
struct btree_node *y = x->b_right;
btree_node_t *p = x->b_parent;
struct btree_node *p = x->b_parent;
if (y->b_left) {
y->b_left->b_parent = x;
@@ -150,7 +150,7 @@ static void rotate_left(btree_t *tree, btree_node_t *x)
y->b_parent = p;
}
static void update_height_to_root(btree_node_t *x)
static void update_height_to_root(struct btree_node *x)
{
while (x) {
update_height(x);
@@ -184,11 +184,11 @@ static void update_height_to_root(btree_node_t *x)
note that this function does NOT update b_height for the rotated
nodes. it is up to you to call update_height_to_root().
*/
static void rotate_right(btree_t *tree, btree_node_t *y)
static void rotate_right(struct btree *tree, struct btree_node *y)
{
btree_node_t *x = y->b_left;
struct btree_node *x = y->b_left;
btree_node_t *p = y->b_parent;
struct btree_node *p = y->b_parent;
if (x->b_right) {
x->b_right->b_parent = y;
@@ -236,10 +236,10 @@ static void rotate_right(btree_t *tree, btree_node_t *y)
DOES update b_height for the rotated nodes (since it needs to be
done in a certain order).
*/
static void rotate_double_left(btree_t *tree, btree_node_t *z)
static void rotate_double_left(struct btree *tree, struct btree_node *z)
{
btree_node_t *x = z->b_right;
btree_node_t *y = x->b_left;
struct btree_node *x = z->b_right;
struct btree_node *y = x->b_left;
rotate_right(tree, x);
rotate_left(tree, z);
@@ -280,10 +280,10 @@ static void rotate_double_left(btree_t *tree, btree_node_t *z)
DOES update b_height for the rotated nodes (since it needs to be
done in a certain order).
*/
static void rotate_double_right(btree_t *tree, btree_node_t *z)
static void rotate_double_right(struct btree *tree, struct btree_node *z)
{
btree_node_t *x = z->b_left;
btree_node_t *y = x->b_right;
struct btree_node *x = z->b_left;
struct btree_node *y = x->b_right;
rotate_left(tree, x);
rotate_right(tree, z);
@@ -309,9 +309,9 @@ static void rotate_double_right(btree_t *tree, btree_node_t *z)
@param w the node that was just inserted into the tree
*/
static void insert_fixup(btree_t *tree, btree_node_t *w)
static void insert_fixup(struct btree *tree, struct btree_node *w)
{
btree_node_t *z = NULL, *y = NULL, *x = NULL;
struct btree_node *z = NULL, *y = NULL, *x = NULL;
z = w;
while (z) {
@@ -360,9 +360,9 @@ next_ancestor:
- the node that replaced the node that was deleted, if
the node that was deleted had one child.
*/
static void delete_fixup(btree_t *tree, btree_node_t *w)
static void delete_fixup(struct btree *tree, struct btree_node *w)
{
btree_node_t *z = w;
struct btree_node *z = w;
while (z) {
if (bf(z) > 1) {
@@ -390,11 +390,11 @@ static void delete_fixup(btree_t *tree, btree_node_t *w)
@param node the node that was just inserted into the tree.
*/
void btree_insert_fixup(btree_t *tree, btree_node_t *node)
void btree_insert_fixup(struct btree *tree, struct btree_node *node)
{
node->b_height = 0;
btree_node_t *cur = node;
struct btree_node *cur = node;
while (cur) {
update_height(cur);
cur = cur->b_parent;
@@ -412,10 +412,10 @@ void btree_insert_fixup(btree_t *tree, btree_node_t *node)
@param node the node to delete.
*/
static btree_node_t *remove_node_with_no_children(btree_t *tree, btree_node_t *node)
static struct btree_node *remove_node_with_no_children(struct btree *tree, struct btree_node *node)
{
btree_node_t *w = node->b_parent;
btree_node_t *p = node->b_parent;
struct btree_node *w = node->b_parent;
struct btree_node *p = node->b_parent;
node->b_parent = NULL;
if (!p) {
@@ -444,10 +444,10 @@ static btree_node_t *remove_node_with_no_children(btree_t *tree, btree_node_t *n
@param node the node to delete.
*/
static btree_node_t *replace_node_with_one_subtree(btree_t *tree, btree_node_t *node)
static struct btree_node *replace_node_with_one_subtree(struct btree *tree, struct btree_node *node)
{
btree_node_t *p = node->b_parent;
btree_node_t *z = NULL;
struct btree_node *p = node->b_parent;
struct btree_node *z = NULL;
if (HAS_LEFT_CHILD(node)) {
z = node->b_left;
@@ -455,7 +455,7 @@ static btree_node_t *replace_node_with_one_subtree(btree_t *tree, btree_node_t *
z = node->b_right;
}
btree_node_t *w = z;
struct btree_node *w = z;
if (!p) {
tree->b_root = z;
} else if (IS_LEFT_CHILD(p, node)) {
@@ -491,20 +491,20 @@ static btree_node_t *replace_node_with_one_subtree(btree_t *tree, btree_node_t *
@param z the node to delete.
*/
static btree_node_t *replace_node_with_two_subtrees(btree_t *tree, btree_node_t *z)
static struct btree_node *replace_node_with_two_subtrees(struct btree *tree, struct btree_node *z)
{
/* x will replace z */
btree_node_t *x = z->b_left;
struct btree_node *x = z->b_left;
while (x->b_right) {
x = x->b_right;
}
/* y is the node that will replace x (if x has a left child) */
btree_node_t *y = x->b_left;
struct btree_node *y = x->b_left;
/* w is the starting point for the height update and fixup */
btree_node_t *w = x;
struct btree_node *w = x;
if (w->b_parent != z) {
w = w->b_parent;
}
@@ -545,7 +545,7 @@ static btree_node_t *replace_node_with_two_subtrees(btree_t *tree, btree_node_t
tree->b_root = x;
}
btree_node_t *cur = w;
struct btree_node *cur = w;
while (cur) {
update_height(cur);
cur = cur->b_parent;
@@ -555,9 +555,9 @@ static btree_node_t *replace_node_with_two_subtrees(btree_t *tree, btree_node_t
}
/* delete a node from the tree and re-balance it afterwards */
void btree_delete(btree_t *tree, btree_node_t *node)
void btree_delete(struct btree *tree, struct btree_node *node)
{
btree_node_t *w = NULL;
struct btree_node *w = NULL;
if (HAS_NO_CHILDREN(node)) {
w = remove_node_with_no_children(tree, node);
@@ -574,11 +574,11 @@ void btree_delete(btree_t *tree, btree_node_t *node)
node->b_left = node->b_right = node->b_parent = NULL;
}
btree_node_t *btree_first(btree_t *tree)
struct btree_node *btree_first(struct btree *tree)
{
/* the first node in the tree is the node with the smallest key.
we keep moving left until we can't go any further */
btree_node_t *cur = tree->b_root;
struct btree_node *cur = tree->b_root;
if (!cur) {
return NULL;
}
@@ -590,11 +590,11 @@ btree_node_t *btree_first(btree_t *tree)
return cur;
}
btree_node_t *btree_last(btree_t *tree)
struct btree_node *btree_last(struct btree *tree)
{
/* the first node in the tree is the node with the largest key.
we keep moving right until we can't go any further */
btree_node_t *cur = tree->b_root;
struct btree_node *cur = tree->b_root;
if (!cur) {
return NULL;
}
@@ -606,7 +606,7 @@ btree_node_t *btree_last(btree_t *tree)
return cur;
}
btree_node_t *btree_next(btree_node_t *node)
struct btree_node *btree_next(struct btree_node *node)
{
if (!node) {
return NULL;
@@ -624,7 +624,7 @@ btree_node_t *btree_next(btree_node_t *node)
if (node->b_right) {
/* case 1: step into `node`'s right sub-tree and keep going
left to find the smallest node */
btree_node_t *cur = node->b_right;
struct btree_node *cur = node->b_right;
while (cur->b_left) {
cur = cur->b_left;
}
@@ -643,7 +643,7 @@ btree_node_t *btree_next(btree_node_t *node)
return node->b_parent;
}
btree_node_t *btree_prev(btree_node_t *node)
struct btree_node *btree_prev(struct btree_node *node)
{
if (!node) {
return NULL;
@@ -661,7 +661,7 @@ btree_node_t *btree_prev(btree_node_t *node)
if (node->b_left) {
/* case 1: step into `node`'s left sub-tree and keep going
right to find the largest node */
btree_node_t *cur = node->b_left;
struct btree_node *cur = node->b_left;
while (cur->b_right) {
cur = cur->b_right;
}

32
ds/queue.c
View File

@@ -1,9 +1,9 @@
#include <socks/queue.h>
size_t queue_length(queue_t *q)
size_t queue_length(struct queue *q)
{
size_t i = 0;
queue_entry_t *x = q->q_first;
struct queue_entry *x = q->q_first;
while (x) {
i++;
x = x->qe_next;
@@ -12,9 +12,9 @@ size_t queue_length(queue_t *q)
return i;
}
void queue_insert_before(queue_t *q, queue_entry_t *entry, queue_entry_t *before)
void queue_insert_before(struct queue *q, struct queue_entry *entry, struct queue_entry *before)
{
queue_entry_t *x = before->qe_prev;
struct queue_entry *x = before->qe_prev;
if (x) {
x->qe_next = entry;
} else {
@@ -27,9 +27,9 @@ void queue_insert_before(queue_t *q, queue_entry_t *entry, queue_entry_t *before
entry->qe_next = before;
}
void queue_insert_after(queue_t *q, queue_entry_t *entry, queue_entry_t *after)
void queue_insert_after(struct queue *q, struct queue_entry *entry, struct queue_entry *after)
{
queue_entry_t *x = after->qe_next;
struct queue_entry *x = after->qe_next;
if (x) {
x->qe_prev = entry;
} else {
@@ -42,7 +42,7 @@ void queue_insert_after(queue_t *q, queue_entry_t *entry, queue_entry_t *after)
entry->qe_prev = after;
}
void queue_push_front(queue_t *q, queue_entry_t *entry)
void queue_push_front(struct queue *q, struct queue_entry *entry)
{
if (q->q_first) {
q->q_first->qe_prev = entry;
@@ -58,7 +58,7 @@ void queue_push_front(queue_t *q, queue_entry_t *entry)
}
}
void queue_push_back(queue_t *q, queue_entry_t *entry)
void queue_push_back(struct queue *q, struct queue_entry *entry)
{
if (q->q_last) {
q->q_last->qe_next = entry;
@@ -74,9 +74,9 @@ void queue_push_back(queue_t *q, queue_entry_t *entry)
}
}
queue_entry_t *queue_pop_front(queue_t *q)
struct queue_entry *queue_pop_front(struct queue *q)
{
queue_entry_t *x = q->q_first;
struct queue_entry *x = q->q_first;
if (x) {
queue_delete(q, x);
}
@@ -84,9 +84,9 @@ queue_entry_t *queue_pop_front(queue_t *q)
return x;
}
queue_entry_t *queue_pop_back(queue_t *q)
struct queue_entry *queue_pop_back(struct queue *q)
{
queue_entry_t *x = q->q_last;
struct queue_entry *x = q->q_last;
if (x) {
queue_delete(q, x);
}
@@ -94,7 +94,7 @@ queue_entry_t *queue_pop_back(queue_t *q)
return x;
}
void queue_delete(queue_t *q, queue_entry_t *entry)
void queue_delete(struct queue *q, struct queue_entry *entry)
{
if (!entry) {
return;
@@ -119,11 +119,11 @@ void queue_delete(queue_t *q, queue_entry_t *entry)
entry->qe_next = entry->qe_prev = NULL;
}
void queue_delete_all(queue_t *q)
void queue_delete_all(struct queue *q)
{
queue_entry_t *x = q->q_first;
struct queue_entry *x = q->q_first;
while (x) {
queue_entry_t *next = x->qe_next;
struct queue_entry *next = x->qe_next;
x->qe_next = x->qe_prev = NULL;
x = next;
}