zzy/scc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

format using clang-format to formate code

Browse Source
This commit is contained in:
zzy
2025-11-20 17:55:08 +08:00
parent 9762cf8a2b
commit d1fafa830d
27 changed files with 1047 additions and 766 deletions
Download Patch File Download Diff File Expand all files Collapse all files

82
runtime/libutils/src/hashtable.c
View File

@@ -2,7 +2,7 @@
#define INIT_HASH_TABLE_SIZE (32)
void init_hashtable(hash_table_t* ht) {
void init_hashtable(hash_table_t *ht) {
vector_init(ht->entries);
ht->count = 0;
ht->tombstone_count = 0;
@@ -19,36 +19,39 @@ static int next_power_of_two(int n) {
return n + 1;
}
static hash_entry_t* find_entry(hash_table_t* ht, const void* key, u32 hash) {
if (ht->entries.cap == 0) return NULL;
static hash_entry_t *find_entry(hash_table_t *ht, const void *key, u32 hash) {
if (ht->entries.cap == 0)
return NULL;
u32 index = hash & (ht->entries.cap - 1); // 容量是2的幂
u32 probe = 0;
hash_entry_t* tombstone = NULL;
hash_entry_t *tombstone = NULL;
while (1) {
hash_entry_t* entry = &vector_at(ht->entries, index);
hash_entry_t *entry = &vector_at(ht->entries, index);
if (entry->state == ENTRY_EMPTY) {
return tombstone ? tombstone : entry;
}
if (entry->state == ENTRY_TOMBSTONE) {
if (!tombstone) tombstone = entry;
if (!tombstone)
tombstone = entry;
} else if (entry->hash == hash && ht->key_cmp(entry->key, key) == 0) {
return entry;
}
// Liner finding
index = (index + 1) & (ht->entries.cap - 1);
probe++;
if (probe >= ht->entries.cap) break;
if (probe >= ht->entries.cap)
break;
}
LOG_ERROR("hashset_find: hash table is full");
return NULL;
}
static void adjust_capacity(hash_table_t* ht, int new_cap) {
static void adjust_capacity(hash_table_t *ht, int new_cap) {
new_cap = next_power_of_two(new_cap);
Assert(new_cap >= ht->entries.cap);
@@ -64,9 +67,9 @@ static void adjust_capacity(hash_table_t* ht, int new_cap) {
// rehash the all of the old data
for (usize i = 0; i < old_entries.cap; i++) {
hash_entry_t* entry = &vector_at(old_entries, i);
hash_entry_t *entry = &vector_at(old_entries, i);
if (entry->state == ENTRY_ACTIVE) {
hash_entry_t* dest = find_entry(ht, entry->key, entry->hash);
hash_entry_t *dest = find_entry(ht, entry->key, entry->hash);
*dest = *entry;
}
}
@@ -75,23 +78,26 @@ static void adjust_capacity(hash_table_t* ht, int new_cap) {
ht->tombstone_count = 0;
}
void* hashtable_set(hash_table_t* ht, const void* key, void* value) {
void *hashtable_set(hash_table_t *ht, const void *key, void *value) {
if (ht->count + ht->tombstone_count >= ht->entries.cap * 0.75) {
int new_cap = ht->entries.cap < INIT_HASH_TABLE_SIZE ? INIT_HASH_TABLE_SIZE : ht->entries.cap * 2;
int new_cap = ht->entries.cap < INIT_HASH_TABLE_SIZE
? INIT_HASH_TABLE_SIZE
: ht->entries.cap * 2;
adjust_capacity(ht, new_cap);
}
u32 hash = ht->hash_func(key);
hash_entry_t* entry = find_entry(ht, key, hash);
void* old_value = NULL;
hash_entry_t *entry = find_entry(ht, key, hash);
void *old_value = NULL;
if (entry->state == ENTRY_ACTIVE) {
old_value = entry->value;
} else {
if (entry->state == ENTRY_TOMBSTONE) ht->tombstone_count--;
if (entry->state == ENTRY_TOMBSTONE)
ht->tombstone_count--;
ht->count++;
}
entry->key = key;
entry->value = value;
entry->hash = hash;
@@ -99,38 +105,42 @@ void* hashtable_set(hash_table_t* ht, const void* key, void* value) {
return old_value;
}
void* hashtable_get(hash_table_t* ht, const void* key) {
if (ht->entries.cap == 0) return NULL;
void *hashtable_get(hash_table_t *ht, const void *key) {
if (ht->entries.cap == 0)
return NULL;
u32 hash = ht->hash_func(key);
hash_entry_t* entry = find_entry(ht, key, hash);
hash_entry_t *entry = find_entry(ht, key, hash);
return (entry && entry->state == ENTRY_ACTIVE) ? entry->value : NULL;
}
void* hashtable_del(hash_table_t* ht, const void* key) {
if (ht->entries.cap == 0) return NULL;
void *hashtable_del(hash_table_t *ht, const void *key) {
if (ht->entries.cap == 0)
return NULL;
u32 hash = ht->hash_func(key);
hash_entry_t* entry = find_entry(ht, key, hash);
if (entry == NULL || entry->state != ENTRY_ACTIVE) return NULL;
void* value = entry->value;
hash_entry_t *entry = find_entry(ht, key, hash);
if (entry == NULL || entry->state != ENTRY_ACTIVE)
return NULL;
void *value = entry->value;
entry->state = ENTRY_TOMBSTONE;
ht->count--;
ht->tombstone_count++;
return value;
}
void hashtable_destory(hash_table_t* ht) {
void hashtable_destory(hash_table_t *ht) {
vector_free(ht->entries);
ht->count = 0;
ht->tombstone_count = 0;
}
void hashtable_foreach(hash_table_t* ht, hash_table_iter_func iter_func, void* context) {
void hashtable_foreach(hash_table_t *ht, hash_table_iter_func iter_func,
void *context) {
for (usize i = 0; i < ht->entries.cap; i++) {
hash_entry_t* entry = &vector_at(ht->entries, i);
hash_entry_t *entry = &vector_at(ht->entries, i);
if (entry->state == ENTRY_ACTIVE) {
if (!iter_func(entry->key, entry->value, context)) {
break; // enable callback function terminal the iter

18
runtime/libutils/src/strpool.c
View File

@@ -1,6 +1,6 @@
#include "strpool.h"
u32 rt_strhash(const char* s) {
u32 rt_strhash(const char *s) {
u32 hash = 2166136261u; // FNV-1a偏移基础值
while (*s) {
hash ^= *s++;
@@ -9,7 +9,7 @@ u32 rt_strhash(const char* s) {
return hash;
}
int rt_strcmp(const char* s1, const char* s2) {
int rt_strcmp(const char *s1, const char *s2) {
while (*s1 && *s2 && *s1 == *s2) {
s1++;
s2++;
@@ -17,20 +17,20 @@ int rt_strcmp(const char* s1, const char* s2) {
return *s1 - *s2;
}
void init_strpool(strpool_t* pool) {
pool->ht.hash_func = (u32(*)(const void*))rt_strhash;
pool->ht.key_cmp = (int(*)(const void*, const void*))rt_strcmp;
void init_strpool(strpool_t *pool) {
pool->ht.hash_func = (u32 (*)(const void *))rt_strhash;
pool->ht.key_cmp = (int (*)(const void *, const void *))rt_strcmp;
init_hashtable(&pool->ht);
}
const char* strpool_intern(strpool_t* pool, const char* str) {
void* existing = hashtable_get(&pool->ht, str);
const char *strpool_intern(strpool_t *pool, const char *str) {
void *existing = hashtable_get(&pool->ht, str);
if (existing) {
return existing;
}
rt_size_t len = rt_strlen(str) + 1;
char* new_str = lalloc_alloc(&pool->stralloc, len);
char *new_str = lalloc_alloc(&pool->stralloc, len);
if (!new_str) {
LOG_ERROR("strpool: Failed to allocate memory for string");
return NULL;
@@ -41,7 +41,7 @@ const char* strpool_intern(strpool_t* pool, const char* str) {
return new_str;
}
void strpool_destroy(strpool_t* pool) {
void strpool_destroy(strpool_t *pool) {
hashtable_destory(&pool->ht);
lalloc_destroy(&pool->stralloc);
}