Rava/runtime/runtime.h

#ifndef RAVA_RUNTIME_H
#define RAVA_RUNTIME_H

#include "../ir/ir.h"
#include "../types/types.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
} 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;

struct RavaObject_t {
    char *class_name;
    char **field_names;
    RavaValue_t *field_values;
    size_t field_count;
    size_t field_capacity;
};

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;
    } data;
};

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;

typedef struct {
    char *class_name;
    char *field_name;
    RavaValue_t value;
} RavaStaticField_t;

typedef struct {
    RavaStaticField_t *fields;
    size_t count;
    size_t capacity;
} 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;

typedef struct {
    RavaExceptionHandler_t *handlers;
    size_t count;
    size_t capacity;
} RavaExceptionStack_t;

typedef struct {
    RavaProgram_t *program;
    RavaCallStack_t *call_stack;
    RavaStaticFieldTable_t *static_fields;
    struct MethodCache_s *method_cache;
    char *error_message;
    bool had_error;
    bool has_exception;
    RavaValue_t exception_value;
    RavaExceptionStack_t *exception_stack;
} RavaVM_t;

RavaValue_t rava_value_int(int32_t value);
RavaValue_t rava_value_long(int64_t value);
RavaValue_t rava_value_float(float value);
RavaValue_t rava_value_double(double value);
RavaValue_t rava_value_boolean(bool value);
RavaValue_t rava_value_null();
RavaValue_t rava_value_array(RavaArray_t *array);
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_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);
RavaValue_t rava_value_object(RavaObject_t *obj);

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);
void 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);

#endif