Rava/runtime.h at de7f824feb4eb83debfec6cc7daac0eddf379eda

 #ifndef RAVA_RUNTIME_H
 #define RAVA_RUNTIME_H
 #include "../ir/ir.h"
 #include "../types/types.h"
 #include "../loader/loader.h"
 #include <stddef.h>
 #include <stdint.h>
 #include <stdbool.h>
 typedef enum {
     RAVA_VAL_INT,
     RAVA_VAL_LONG,
     RAVA_VAL_FLOAT,
     RAVA_VAL_DOUBLE,
     RAVA_VAL_BOOLEAN,
     RAVA_VAL_CHAR,
     RAVA_VAL_NULL,
     RAVA_VAL_OBJECT,
     RAVA_VAL_ARRAY,
     RAVA_VAL_STRING,
     RAVA_VAL_ARRAYLIST,
     RAVA_VAL_HASHMAP,
     RAVA_VAL_SOCKET,
     RAVA_VAL_STREAM,
     RAVA_VAL_METHOD_REF
 } RavaValueType_e;
 typedef struct {
     RavaValueType_e element_type;
     size_t length;
     void *data;
 } RavaArray_t;
 typedef struct RavaObject_t RavaObject_t;
 typedef struct RavaValue_t RavaValue_t;
 typedef struct RavaArrayList_t RavaArrayList_t;
 typedef struct RavaHashMap_t RavaHashMap_t;
 typedef struct RavaSocket_t RavaSocket_t;
 typedef struct RavaStream_t RavaStream_t;
 typedef struct RavaMethodRef_t RavaMethodRef_t;
 #define RAVA_OBJECT_HASH_SIZE 32
 struct RavaObject_t {
     char *class_name;
     char **field_names;
     RavaValue_t *field_values;
     size_t field_count;
     size_t field_capacity;
     int field_hash[RAVA_OBJECT_HASH_SIZE];
 };
 struct RavaValue_t {
     RavaValueType_e type;
     union {
         int32_t int_val;
         int64_t long_val;
         float float_val;
         double double_val;
         bool bool_val;
         char char_val;
         RavaObject_t *object_val;
         RavaArray_t *array_val;
         char *string_val;
         RavaArrayList_t *arraylist_val;
         RavaHashMap_t *hashmap_val;
         RavaSocket_t *socket_val;
         RavaStream_t *stream_val;
         RavaMethodRef_t *method_ref_val;
     } data;
 };
 #define RAVA_COLLECTION_ARRAYLIST 1
 #define RAVA_COLLECTION_HASHMAP 2
 struct RavaArrayList_t {
     int collection_type;
     RavaValue_t *data;
     size_t size;
     size_t capacity;
 };
 #define RAVA_HASHMAP_BUCKET_SIZE 32
 typedef struct {
     char *key;
     RavaValue_t value;
     bool occupied;
 } RavaHashMapEntry_t;
 struct RavaHashMap_t {
     int collection_type;
     RavaHashMapEntry_t *buckets;
     size_t bucket_count;
     size_t size;
 };
 #define RAVA_SOCKET_TYPE_CLIENT 1
 #define RAVA_SOCKET_TYPE_SERVER 2
 struct RavaSocket_t {
     int socket_type;
     int fd;
     bool connected;
     bool closed;
 };
 #define RAVA_STREAM_TYPE_INPUT 1
 #define RAVA_STREAM_TYPE_OUTPUT 2
 struct RavaStream_t {
     int stream_type;
     int fd;
     bool closed;
 };
 struct RavaMethodRef_t {
     char *class_name;
     char *method_name;
     bool is_constructor;
     bool is_static;
     RavaValue_t target;
     bool has_target;
 };
 typedef struct {
     RavaValue_t *values;
     size_t capacity;
     size_t top;
 } RavaStack_t;
 typedef struct {
     RavaMethod_t *method;
     RavaValue_t *locals;
     size_t local_count;
     size_t pc;
     RavaStack_t *operand_stack;
     RavaValue_t this_ref;
     bool has_this;
 } RavaCallFrame_t;
 typedef struct {
     RavaCallFrame_t **frames;
     size_t capacity;
     size_t count;
 } RavaCallStack_t;
 #define RAVA_STATIC_HASH_SIZE 128
 typedef struct {
     char *class_name;
     char *field_name;
     RavaValue_t value;
 } RavaStaticField_t;
 typedef struct {
     RavaStaticField_t *fields;
     size_t count;
     size_t capacity;
     int hash_table[RAVA_STATIC_HASH_SIZE];
 } RavaStaticFieldTable_t;
 struct MethodCache_s;
 typedef struct {
     int catch_label;
     int finally_label;
     int end_label;
     int exception_local;
     size_t stack_depth;
 } RavaExceptionHandler_t;
 #define RAVA_MAX_EXCEPTION_DEPTH 64
 typedef struct {
     RavaExceptionHandler_t handlers[RAVA_MAX_EXCEPTION_DEPTH];
     size_t count;
 } RavaExceptionStack_t;
 #define RAVA_CLASS_HASH_SIZE 64
 #define RAVA_STRING_BUFFER_SIZE 4096
 #define RAVA_STRING_BUFFER_COUNT 4
 typedef struct {
     char buffers[RAVA_STRING_BUFFER_COUNT][RAVA_STRING_BUFFER_SIZE];
     int current;
 } RavaStringPool_t;
 #define RAVA_INTERN_TABLE_SIZE 1024
 typedef struct {
     char *strings[RAVA_INTERN_TABLE_SIZE];
     size_t count;
 } RavaInternTable_t;
 typedef struct {
     RavaProgram_t *program;
     RavaCallStack_t *call_stack;
     RavaStaticFieldTable_t *static_fields;
     struct MethodCache_s *method_cache;
     RavaNativeRegistry_t *native_registry;
     char *error_message;
     bool had_error;
     bool has_exception;
     RavaValue_t exception_value;
     RavaExceptionStack_t *exception_stack;
     int class_hash[RAVA_CLASS_HASH_SIZE];
     RavaStringPool_t string_pool;
     RavaInternTable_t intern_table;
 } RavaVM_t;
 static inline RavaValue_t rava_value_int(int32_t value) {
     RavaValue_t val;
     val.type = RAVA_VAL_INT;
     val.data.int_val = value;
     return val;
 }
 static inline RavaValue_t rava_value_long(int64_t value) {
     RavaValue_t val;
     val.type = RAVA_VAL_LONG;
     val.data.long_val = value;
     return val;
 }
 static inline RavaValue_t rava_value_float(float value) {
     RavaValue_t val;
     val.type = RAVA_VAL_FLOAT;
     val.data.float_val = value;
     return val;
 }
 static inline RavaValue_t rava_value_double(double value) {
     RavaValue_t val;
     val.type = RAVA_VAL_DOUBLE;
     val.data.double_val = value;
     return val;
 }
 static inline RavaValue_t rava_value_boolean(bool value) {
     RavaValue_t val;
     val.type = RAVA_VAL_BOOLEAN;
     val.data.bool_val = value;
     return val;
 }
 static inline RavaValue_t rava_value_null(void) {
     RavaValue_t val;
     val.type = RAVA_VAL_NULL;
     val.data.object_val = NULL;
     return val;
 }
 static inline RavaValue_t rava_value_array(RavaArray_t *array) {
     RavaValue_t val;
     val.type = RAVA_VAL_ARRAY;
     val.data.array_val = array;
     return val;
 }
 static inline RavaValue_t rava_value_object(RavaObject_t *obj) {
     RavaValue_t val;
     val.type = RAVA_VAL_OBJECT;
     val.data.object_val = obj;
     return val;
 }
 static inline RavaValue_t rava_value_arraylist(RavaArrayList_t *list) {
     RavaValue_t val;
     val.type = RAVA_VAL_ARRAYLIST;
     val.data.arraylist_val = list;
     return val;
 }
 static inline RavaValue_t rava_value_hashmap(RavaHashMap_t *map) {
     RavaValue_t val;
     val.type = RAVA_VAL_HASHMAP;
     val.data.hashmap_val = map;
     return val;
 }
 RavaValue_t rava_value_string(const char *str);
 int32_t rava_value_as_int(RavaValue_t value);
 int64_t rava_value_as_long(RavaValue_t value);
 double rava_value_as_double(RavaValue_t value);
 bool rava_value_as_boolean(RavaValue_t value);
 const char* rava_value_as_string(RavaValue_t value);
 RavaArray_t* rava_array_create(RavaValueType_e element_type, size_t length);
 void rava_array_destroy(RavaArray_t *array);
 void rava_array_set_int(RavaArray_t *array, size_t index, int32_t value);
 int32_t rava_array_get_int(RavaArray_t *array, size_t index);
 void rava_array_set_long(RavaArray_t *array, size_t index, int64_t value);
 int64_t rava_array_get_long(RavaArray_t *array, size_t index);
 void rava_array_set_double(RavaArray_t *array, size_t index, double value);
 double rava_array_get_double(RavaArray_t *array, size_t index);
 void rava_array_set_value(RavaArray_t *array, size_t index, RavaValue_t value);
 RavaValue_t rava_array_get_value(RavaArray_t *array, size_t index);
 size_t rava_array_length(RavaArray_t *array);
 RavaObject_t* rava_object_create(const char *class_name);
 void rava_object_destroy(RavaObject_t *obj);
 void rava_object_set_field(RavaObject_t *obj, const char *name, RavaValue_t value);
 RavaValue_t rava_object_get_field(RavaObject_t *obj, const char *name);
 int rava_object_get_field_index(RavaObject_t *obj, const char *name);
 RavaValue_t rava_object_get_field_by_index(RavaObject_t *obj, int index);
 void rava_object_set_field_by_index(RavaObject_t *obj, int index, RavaValue_t value);
 int32_t rava_object_hashcode(RavaValue_t value);
 bool rava_object_equals(RavaValue_t a, RavaValue_t b);
 char* rava_object_tostring(RavaValue_t value);
 const char* rava_object_getclass(RavaValue_t value);
 RavaArrayList_t* rava_arraylist_create(void);
 void rava_arraylist_destroy(RavaArrayList_t *list);
 void rava_arraylist_add(RavaArrayList_t *list, RavaValue_t value);
 RavaValue_t rava_arraylist_get(RavaArrayList_t *list, size_t index);
 void rava_arraylist_set(RavaArrayList_t *list, size_t index, RavaValue_t value);
 size_t rava_arraylist_size(RavaArrayList_t *list);
 RavaValue_t rava_arraylist_remove(RavaArrayList_t *list, size_t index);
 void rava_arraylist_clear(RavaArrayList_t *list);
 bool rava_arraylist_isempty(RavaArrayList_t *list);
 RavaHashMap_t* rava_hashmap_create(void);
 void rava_hashmap_destroy(RavaHashMap_t *map);
 void rava_hashmap_put(RavaHashMap_t *map, const char *key, RavaValue_t value);
 RavaValue_t rava_hashmap_get(RavaHashMap_t *map, const char *key);
 RavaValue_t rava_hashmap_remove(RavaHashMap_t *map, const char *key);
 size_t rava_hashmap_size(RavaHashMap_t *map);
 bool rava_hashmap_containskey(RavaHashMap_t *map, const char *key);
 void rava_hashmap_clear(RavaHashMap_t *map);
 RavaSocket_t* rava_socket_create(void);
 RavaSocket_t* rava_socket_create_connected(const char *host, int port);
 RavaSocket_t* rava_server_socket_create(int port);
 void rava_socket_destroy(RavaSocket_t *socket);
 bool rava_socket_connect(RavaSocket_t *socket, const char *host, int port);
 RavaSocket_t* rava_server_socket_accept(RavaSocket_t *server);
 RavaStream_t* rava_socket_get_input_stream(RavaSocket_t *socket);
 RavaStream_t* rava_socket_get_output_stream(RavaSocket_t *socket);
 void rava_socket_close(RavaSocket_t *socket);
 RavaStream_t* rava_stream_create(int fd, int stream_type);
 void rava_stream_destroy(RavaStream_t *stream);
 char* rava_stream_read(RavaStream_t *stream);
 int rava_stream_read_byte(RavaStream_t *stream);
 void rava_stream_write(RavaStream_t *stream, const char *data);
 void rava_stream_write_byte(RavaStream_t *stream, int byte);
 void rava_stream_close(RavaStream_t *stream);
 static inline RavaValue_t rava_value_socket(RavaSocket_t *socket) {
     RavaValue_t val;
     val.type = RAVA_VAL_SOCKET;
     val.data.socket_val = socket;
     return val;
 }
 static inline RavaValue_t rava_value_stream(RavaStream_t *stream) {
     RavaValue_t val;
     val.type = RAVA_VAL_STREAM;
     val.data.stream_val = stream;
     return val;
 }
 RavaMethodRef_t* rava_method_ref_create(const char *class_name, const char *method_name, bool is_constructor, bool is_static);
 void rava_method_ref_destroy(RavaMethodRef_t *ref);
 static inline RavaValue_t rava_value_method_ref(RavaMethodRef_t *ref) {
     RavaValue_t val;
     val.type = RAVA_VAL_METHOD_REF;
     val.data.method_ref_val = ref;
     return val;
 }
 RavaStack_t* rava_stack_create(size_t capacity);
 void rava_stack_destroy(RavaStack_t *stack);
 void rava_stack_push(RavaStack_t *stack, RavaValue_t value);
 RavaValue_t rava_stack_pop(RavaStack_t *stack);
 RavaValue_t rava_stack_peek(RavaStack_t *stack);
 bool rava_stack_is_empty(RavaStack_t *stack);
 RavaCallFrame_t* rava_call_frame_create(RavaMethod_t *method);
 void rava_call_frame_destroy(RavaCallFrame_t *frame);
 RavaCallStack_t* rava_call_stack_create();
 void rava_call_stack_destroy(RavaCallStack_t *stack);
 bool rava_call_stack_push(RavaCallStack_t *stack, RavaCallFrame_t *frame);
 RavaCallFrame_t* rava_call_stack_pop(RavaCallStack_t *stack);
 RavaCallFrame_t* rava_call_stack_current(RavaCallStack_t *stack);
 RavaVM_t* rava_vm_create(RavaProgram_t *program);
 void rava_vm_destroy(RavaVM_t *vm);
 bool rava_vm_execute(RavaVM_t *vm, const char *class_name, const char *method_name);
 RavaValue_t rava_vm_get_result(RavaVM_t *vm);
 bool rava_vm_load_native_library(RavaVM_t *vm, const char *path);
 bool rava_vm_register_native(RavaVM_t *vm, 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);
 RavaValue_t rava_vm_call_native(RavaVM_t *vm, const char *class_name, const char *method_name,
                                  RavaValue_t *args, size_t arg_count);
 RavaNativeValue_t rava_value_to_native(RavaValue_t value);
 RavaValue_t rava_native_to_value(RavaNativeValue_t native);
 #endif