#define _POSIX_C_SOURCE 200809L
#include "types.h"
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
static RavaType_t _type_void = { RAVA_TYPE_VOID, "void", { .array = { NULL, 0 } } };
static RavaType_t _type_boolean = { RAVA_TYPE_BOOLEAN, "boolean", { .array = { NULL, 0 } } };
static RavaType_t _type_byte = { RAVA_TYPE_BYTE, "byte", { .array = { NULL, 0 } } };
static RavaType_t _type_short = { RAVA_TYPE_SHORT, "short", { .array = { NULL, 0 } } };
static RavaType_t _type_int = { RAVA_TYPE_INT, "int", { .array = { NULL, 0 } } };
static RavaType_t _type_long = { RAVA_TYPE_LONG, "long", { .array = { NULL, 0 } } };
static RavaType_t _type_char = { RAVA_TYPE_CHAR, "char", { .array = { NULL, 0 } } };
static RavaType_t _type_float = { RAVA_TYPE_FLOAT, "float", { .array = { NULL, 0 } } };
static RavaType_t _type_double = { RAVA_TYPE_DOUBLE, "double", { .array = { NULL, 0 } } };
static RavaType_t _type_null = { RAVA_TYPE_NULL, "null", { .array = { NULL, 0 } } };
static RavaType_t _type_string = { RAVA_TYPE_CLASS, "String", { .class_type = { "String" } } };
static inline bool _is_pooled_type(RavaType_t *type) {
return type == &_type_void || type == &_type_boolean || type == &_type_byte ||
type == &_type_short || type == &_type_int || type == &_type_long ||
type == &_type_char || type == &_type_float || type == &_type_double ||
type == &_type_null || type == &_type_string;
}
RavaType_t* rava_type_create_primitive(RavaTypeKind_e kind) {
switch (kind) {
case RAVA_TYPE_VOID: return &_type_void;
case RAVA_TYPE_BOOLEAN: return &_type_boolean;
case RAVA_TYPE_BYTE: return &_type_byte;
case RAVA_TYPE_SHORT: return &_type_short;
case RAVA_TYPE_INT: return &_type_int;
case RAVA_TYPE_LONG: return &_type_long;
case RAVA_TYPE_CHAR: return &_type_char;
case RAVA_TYPE_FLOAT: return &_type_float;
case RAVA_TYPE_DOUBLE: return &_type_double;
case RAVA_TYPE_NULL: return &_type_null;
default: {
RavaType_t *type = calloc(1, sizeof(RavaType_t));
type->kind = kind;
type->name = strdup("unknown");
return type;
}
}
}
RavaType_t* rava_type_create_class(const char *class_name) {
RavaType_t *type = calloc(1, sizeof(RavaType_t));
type->kind = RAVA_TYPE_CLASS;
type->name = strdup(class_name);
type->data.class_type.class_name = strdup(class_name);
return type;
}
RavaType_t* rava_type_create_array(RavaType_t *element_type, int dimensions) {
RavaType_t *type = calloc(1, sizeof(RavaType_t));
type->kind = RAVA_TYPE_ARRAY;
type->data.array.element_type = element_type;
type->data.array.dimensions = dimensions;
char buffer[256];
snprintf(buffer, sizeof(buffer), "%s", rava_type_to_string(element_type));
for (int i = 0; i < dimensions; i++) {
strcat(buffer, "[]");
}
type->name = strdup(buffer);
return type;
}
void rava_type_destroy(RavaType_t *type) {
if (!type || _is_pooled_type(type)) return;
free(type->name);
if (type->kind == RAVA_TYPE_ARRAY) {
rava_type_destroy(type->data.array.element_type);
} else if (type->kind == RAVA_TYPE_CLASS) {
free(type->data.class_type.class_name);
}
free(type);
}
RavaType_t* rava_type_from_name(const char *type_name) {
if (strcmp(type_name, "void") == 0) return rava_type_create_primitive(RAVA_TYPE_VOID);
if (strcmp(type_name, "boolean") == 0) return rava_type_create_primitive(RAVA_TYPE_BOOLEAN);
if (strcmp(type_name, "byte") == 0) return rava_type_create_primitive(RAVA_TYPE_BYTE);
if (strcmp(type_name, "short") == 0) return rava_type_create_primitive(RAVA_TYPE_SHORT);
if (strcmp(type_name, "int") == 0) return rava_type_create_primitive(RAVA_TYPE_INT);
if (strcmp(type_name, "long") == 0) return rava_type_create_primitive(RAVA_TYPE_LONG);
if (strcmp(type_name, "char") == 0) return rava_type_create_primitive(RAVA_TYPE_CHAR);
if (strcmp(type_name, "float") == 0) return rava_type_create_primitive(RAVA_TYPE_FLOAT);
if (strcmp(type_name, "double") == 0) return rava_type_create_primitive(RAVA_TYPE_DOUBLE);
return rava_type_create_class(type_name);
}
bool rava_type_is_primitive(RavaType_t *type) {
return type->kind >= RAVA_TYPE_VOID && type->kind <= RAVA_TYPE_DOUBLE;
}
bool rava_type_is_numeric(RavaType_t *type) {
return type->kind >= RAVA_TYPE_BYTE && type->kind <= RAVA_TYPE_DOUBLE;
}
bool rava_type_is_integral(RavaType_t *type) {
return type->kind >= RAVA_TYPE_BYTE && type->kind <= RAVA_TYPE_CHAR;
}
bool rava_type_is_floating(RavaType_t *type) {
return type->kind == RAVA_TYPE_FLOAT || type->kind == RAVA_TYPE_DOUBLE;
}
bool rava_type_is_reference(RavaType_t *type) {
return type->kind == RAVA_TYPE_CLASS ||
type->kind == RAVA_TYPE_ARRAY ||
type->kind == RAVA_TYPE_NULL;
}
bool rava_type_equals(RavaType_t *a, RavaType_t *b) {
if (!a || !b) return false;
if (a->kind != b->kind) return false;
if (a->kind == RAVA_TYPE_ARRAY) {
return a->data.array.dimensions == b->data.array.dimensions &&
rava_type_equals(a->data.array.element_type, b->data.array.element_type);
}
if (a->kind == RAVA_TYPE_CLASS) {
return strcmp(a->data.class_type.class_name, b->data.class_type.class_name) == 0;
}
return true;
}
bool rava_type_is_assignable_to(RavaType_t *from, RavaType_t *to) {
if (!from || !to) return false;
if (rava_type_equals(from, to)) return true;
if (from->kind == RAVA_TYPE_NULL && rava_type_is_reference(to)) {
return true;
}
if (rava_type_is_numeric(from) && rava_type_is_numeric(to)) {
int from_rank = from->kind - RAVA_TYPE_BYTE;
int to_rank = to->kind - RAVA_TYPE_BYTE;
return from_rank <= to_rank;
}
return false;
}
bool rava_type_is_castable_to(RavaType_t *from, RavaType_t *to) {
if (rava_type_is_assignable_to(from, to)) return true;
if (rava_type_is_numeric(from) && rava_type_is_numeric(to)) {
return true;
}
if (rava_type_is_reference(from) && rava_type_is_reference(to)) {
return true;
}
return false;
}
static bool _is_string_type(RavaType_t *type) {
return type->kind == RAVA_TYPE_CLASS &&
type->data.class_type.class_name &&
strcmp(type->data.class_type.class_name, "String") == 0;
}
RavaType_t* rava_type_binary_result(RavaType_t *left, RavaType_t *right) {
if (!left || !right) return NULL;
if (_is_string_type(left) || _is_string_type(right)) {
return &_type_string;
}
if (!rava_type_is_numeric(left) || !rava_type_is_numeric(right)) {
return NULL;
}
if (left->kind == RAVA_TYPE_DOUBLE || right->kind == RAVA_TYPE_DOUBLE) {
return &_type_double;
}
if (left->kind == RAVA_TYPE_FLOAT || right->kind == RAVA_TYPE_FLOAT) {
return &_type_float;
}
if (left->kind == RAVA_TYPE_LONG || right->kind == RAVA_TYPE_LONG) {
return &_type_long;
}
return &_type_int;
}
RavaType_t* rava_type_unary_result(RavaType_t *operand) {
if (!operand) return NULL;
if (!rava_type_is_numeric(operand)) {
return NULL;
}
if (operand->kind == RAVA_TYPE_BYTE ||
operand->kind == RAVA_TYPE_SHORT ||
operand->kind == RAVA_TYPE_CHAR) {
return &_type_int;
}
return rava_type_create_primitive(operand->kind);
}
const char* rava_type_to_string(RavaType_t *type) {
if (!type) return "null";
return type->name;
}
Reference in New Issue View Git Blame Copy Permalink