#include "loader.h"
#include <stdlib.h>
#include <string.h>
#include <dlfcn.h>
RavaNativeRegistry_t* rava_native_registry_create(void) {
RavaNativeRegistry_t *registry = calloc(1, sizeof(RavaNativeRegistry_t));
if (!registry) return NULL;
registry->library_count = 0;
registry->cache_count = 0;
return registry;
}
void rava_native_registry_destroy(RavaNativeRegistry_t *registry) {
if (!registry) return;
for (size_t i = 0; i < registry->library_count; i++) {
rava_native_library_unload(registry, registry->libraries[i]);
}
free(registry);
}
static uint32_t _hash_method_name(const char *class_name, const char *method_name) {
uint32_t hash = 5381;
for (const char *p = class_name; *p; p++) {
hash = ((hash << 5) + hash) + (uint32_t)*p;
}
hash = ((hash << 5) + hash) + '.';
for (const char *p = method_name; *p; p++) {
hash = ((hash << 5) + hash) + (uint32_t)*p;
}
return hash % RAVA_MAX_NATIVE_METHODS;
}
RavaNativeLibrary_t* rava_native_library_load(RavaNativeRegistry_t *registry, const char *path) {
if (!registry || !path) return NULL;
if (registry->library_count >= RAVA_MAX_NATIVE_LIBRARIES) return NULL;
void *handle = dlopen(path, RTLD_NOW | RTLD_LOCAL);
if (!handle) {
return NULL;
}
RavaNativeLibrary_t *lib = calloc(1, sizeof(RavaNativeLibrary_t));
if (!lib) {
dlclose(handle);
return NULL;
}
lib->path = strdup(path);
lib->handle = handle;
lib->method_count = 0;
lib->method_capacity = 16;
lib->methods = calloc(lib->method_capacity, sizeof(RavaNativeMethod_t));
const char *name_start = strrchr(path, '/');
if (name_start) {
name_start++;
} else {
name_start = path;
}
if (strncmp(name_start, "lib", 3) == 0) {
name_start += 3;
}
size_t name_len = strlen(name_start);
if (name_len > 3 && strcmp(name_start + name_len - 3, ".so") == 0) {
lib->name = strndup(name_start, name_len - 3);
} else {
lib->name = strdup(name_start);
}
RavaLibraryRegisterFn register_fn = (RavaLibraryRegisterFn)dlsym(handle, RAVA_LIBRARY_REGISTER_SYMBOL);
if (register_fn) {
register_fn(registry);
}
registry->libraries[registry->library_count++] = lib;
return lib;
}
void rava_native_library_unload(RavaNativeRegistry_t *registry, RavaNativeLibrary_t *lib) {
if (!registry || !lib) return;
for (size_t i = 0; i < lib->method_count; i++) {
free(lib->methods[i].class_name);
free(lib->methods[i].method_name);
}
free(lib->methods);
if (lib->handle) {
dlclose(lib->handle);
}
free(lib->name);
free(lib->path);
free(lib);
}
bool rava_native_register_method(RavaNativeRegistry_t *registry,
const char *class_name,
const char *method_name,
RavaNativeType_e return_type,
RavaNativeType_e *param_types,
size_t param_count,
RavaNativeFunction_fn function,
void *user_data) {
if (!registry || !class_name || !method_name || !function) return false;
if (param_count > RAVA_MAX_METHOD_PARAMS) return false;
if (registry->cache_count >= RAVA_MAX_NATIVE_METHODS) return false;
RavaNativeMethod_t *method = calloc(1, sizeof(RavaNativeMethod_t));
if (!method) return false;
method->class_name = strdup(class_name);
method->method_name = strdup(method_name);
method->return_type = return_type;
method->param_count = param_count;
method->function = function;
method->user_data = user_data;
for (size_t i = 0; i < param_count; i++) {
method->param_types[i] = param_types[i];
}
uint32_t hash = _hash_method_name(class_name, method_name);
while (registry->method_cache[hash] != NULL) {
hash = (hash + 1) % RAVA_MAX_NATIVE_METHODS;
}
registry->method_cache[hash] = method;
registry->cache_count++;
return true;
}
RavaNativeMethod_t* rava_native_find_method(RavaNativeRegistry_t *registry,
const char *class_name,
const char *method_name) {
if (!registry || !class_name || !method_name) return NULL;
uint32_t hash = _hash_method_name(class_name, method_name);
uint32_t start = hash;
do {
RavaNativeMethod_t *method = registry->method_cache[hash];
if (!method) return NULL;
if (strcmp(method->class_name, class_name) == 0 &&
strcmp(method->method_name, method_name) == 0) {
return method;
}
hash = (hash + 1) % RAVA_MAX_NATIVE_METHODS;
} while (hash != start);
return NULL;
}
RavaNativeValue_t rava_native_invoke(RavaNativeMethod_t *method,
RavaNativeValue_t *args,
size_t arg_count) {
if (!method || !method->function) {
return rava_native_void();
}
return method->function(args, arg_count, method->user_data);
}
RavaNativeValue_t rava_native_int(int32_t val) {
RavaNativeValue_t native;
native.type = RAVA_NATIVE_INT;
native.data.int_val = val;
return native;
}
RavaNativeValue_t rava_native_long(int64_t val) {
RavaNativeValue_t native;
native.type = RAVA_NATIVE_LONG;
native.data.long_val = val;
return native;
}
RavaNativeValue_t rava_native_double(double val) {
RavaNativeValue_t native;
native.type = RAVA_NATIVE_DOUBLE;
native.data.double_val = val;
return native;
}
RavaNativeValue_t rava_native_boolean(bool val) {
RavaNativeValue_t native;
native.type = RAVA_NATIVE_BOOLEAN;
native.data.bool_val = val;
return native;
}
RavaNativeValue_t rava_native_string(const char *val) {
RavaNativeValue_t native;
native.type = RAVA_NATIVE_STRING;
native.data.string_val = val ? strdup(val) : NULL;
return native;
}
RavaNativeValue_t rava_native_void(void) {
RavaNativeValue_t native;
native.type = RAVA_NATIVE_VOID;
return native;
}
RavaNativeValue_t rava_native_null(void) {
RavaNativeValue_t native;
native.type = RAVA_NATIVE_OBJECT;
native.data.object_val = NULL;
return native;
}
Reference in New Issue View Git Blame Copy Permalink