diff --git a/Makefile b/Makefile index b0b39f2..fabdeda 100644 --- a/Makefile +++ b/Makefile @@ -155,7 +155,7 @@ UNITTEST_OBJECTS = $(UNITTEST_SOURCES:.c=.o) TEST_UNITTEST_DEMO_SOURCES = tests/test_unittest_demo.c TEST_UNITTEST_DEMO_OBJECTS = $(TEST_UNITTEST_DEMO_SOURCES:.c=.o) -all: test_lexer test_parser test_semantic test_ir test_runtime test_strings test_arrays test_objects test_instance_methods test_fileio test_dowhile test_switch test_math test_string_methods test_static test_interfaces test_exceptions test_ternary test_bitwise test_enhanced_for test_array_init test_instanceof test_shortcircuit test_multidim_arrays test_static_init test_negative test_enums test_collections test_super test_inheritance test_break test_elseif test_forloop test_println test_loader test_object_methods test_autobox test_gc +all: test_lexer test_parser test_semantic test_ir test_runtime test_strings test_arrays test_objects test_instance_methods test_fileio test_dowhile test_switch test_math test_string_methods test_static test_interfaces test_exceptions test_ternary test_bitwise test_enhanced_for test_array_init test_instanceof test_shortcircuit test_multidim_arrays test_static_init test_negative test_enums test_collections test_super test_inheritance test_break test_elseif test_forloop test_println test_loader test_object_methods test_autobox test_sockets test_method_ref test_gc test_lexer: $(LEXER_OBJECTS) $(UNITTEST_OBJECTS) $(TEST_LEXER_OBJECTS) $(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) @@ -345,8 +345,8 @@ clean: $(PHASE0_OBJECTS) $(UNITTEST_OBJECTS) $(TEST_UNITTEST_DEMO_OBJECTS) \ $(TEST_LEXER_OBJECTS) $(TEST_PARSER_OBJECTS) $(TEST_SEMANTIC_OBJECTS) $(TEST_IR_OBJECTS) $(TEST_RUNTIME_OBJECTS) \ $(TEST_STRINGS_OBJECTS) $(TEST_ARRAYS_OBJECTS) $(TEST_OBJECTS_OBJECTS) $(TEST_INSTANCE_OBJECTS) $(TEST_FILEIO_OBJECTS) \ - $(TEST_DOWHILE_OBJECTS) $(TEST_SWITCH_OBJECTS) $(TEST_MATH_OBJECTS) $(TEST_STRING_METHODS_OBJECTS) $(TEST_STATIC_OBJECTS) $(TEST_INTERFACES_OBJECTS) $(TEST_EXCEPTIONS_OBJECTS) $(TEST_TERNARY_OBJECTS) $(TEST_BITWISE_OBJECTS) $(TEST_ENHANCED_FOR_OBJECTS) $(TEST_ARRAY_INIT_OBJECTS) $(TEST_INSTANCEOF_OBJECTS) $(TEST_SHORTCIRCUIT_OBJECTS) $(TEST_MULTIDIM_ARRAYS_OBJECTS) $(TEST_STATIC_INIT_OBJECTS) $(TEST_NEGATIVE_OBJECTS) $(TEST_ENUMS_OBJECTS) $(TEST_COLLECTIONS_OBJECTS) $(TEST_SUPER_OBJECTS) $(TEST_INHERITANCE_OBJECTS) $(TEST_BREAK_OBJECTS) $(TEST_ELSEIF_OBJECTS) $(TEST_FORLOOP_OBJECTS) $(TEST_PRINTLN_OBJECTS) $(TEST_LOADER_OBJECTS) $(TEST_OBJECT_METHODS_OBJECTS) $(TEST_AUTOBOX_OBJECTS) $(TEST_SOCKETS_OBJECTS) $(TEST_BENCHMARK_OBJECTS) \ - test_lexer test_parser test_semantic test_ir test_runtime test_strings test_arrays test_objects test_instance_methods test_fileio test_dowhile test_switch test_math test_string_methods test_static test_interfaces test_exceptions test_ternary test_bitwise test_enhanced_for test_array_init test_instanceof test_shortcircuit test_multidim_arrays test_static_init test_negative test_enums test_collections test_super test_inheritance test_break test_elseif test_forloop test_println test_loader test_object_methods test_autobox test_sockets test_benchmark \ + $(TEST_DOWHILE_OBJECTS) $(TEST_SWITCH_OBJECTS) $(TEST_MATH_OBJECTS) $(TEST_STRING_METHODS_OBJECTS) $(TEST_STATIC_OBJECTS) $(TEST_INTERFACES_OBJECTS) $(TEST_EXCEPTIONS_OBJECTS) $(TEST_TERNARY_OBJECTS) $(TEST_BITWISE_OBJECTS) $(TEST_ENHANCED_FOR_OBJECTS) $(TEST_ARRAY_INIT_OBJECTS) $(TEST_INSTANCEOF_OBJECTS) $(TEST_SHORTCIRCUIT_OBJECTS) $(TEST_MULTIDIM_ARRAYS_OBJECTS) $(TEST_STATIC_INIT_OBJECTS) $(TEST_NEGATIVE_OBJECTS) $(TEST_ENUMS_OBJECTS) $(TEST_COLLECTIONS_OBJECTS) $(TEST_SUPER_OBJECTS) $(TEST_INHERITANCE_OBJECTS) $(TEST_BREAK_OBJECTS) $(TEST_ELSEIF_OBJECTS) $(TEST_FORLOOP_OBJECTS) $(TEST_PRINTLN_OBJECTS) $(TEST_LOADER_OBJECTS) $(TEST_OBJECT_METHODS_OBJECTS) $(TEST_AUTOBOX_OBJECTS) $(TEST_SOCKETS_OBJECTS) $(TEST_METHOD_REF_OBJECTS) $(TEST_GC_OBJECTS) $(TEST_BENCHMARK_OBJECTS) \ + test_lexer test_parser test_semantic test_ir test_runtime test_strings test_arrays test_objects test_instance_methods test_fileio test_dowhile test_switch test_math test_string_methods test_static test_interfaces test_exceptions test_ternary test_bitwise test_enhanced_for test_array_init test_instanceof test_shortcircuit test_multidim_arrays test_static_init test_negative test_enums test_collections test_super test_inheritance test_break test_elseif test_forloop test_println test_loader test_object_methods test_autobox test_sockets test_method_ref test_gc test_benchmark \ test_nanbox test_fastframe test_labeltable test_methodcache test_benchmark_pgo test_unittest_demo *.gcda */*.gcda .PHONY: all clean benchmark test_phase0 pgo test_benchmark_pgo_gen pgo_run test_benchmark_pgo test @@ -361,5 +361,5 @@ test: all ./test_shortcircuit && ./test_multidim_arrays && ./test_static_init && ./test_negative && \ ./test_enums && ./test_collections && ./test_super && ./test_inheritance && ./test_break && \ ./test_elseif && ./test_forloop && ./test_println && ./test_loader && ./test_object_methods && \ - ./test_autobox && ./test_sockets && \ + ./test_autobox && ./test_sockets && ./test_method_ref && ./test_gc && \ echo "" && echo "=== All Tests Passed ===" diff --git a/runtime/nanbox.h b/runtime/nanbox.h index f30d0ec..efb83ff 100644 --- a/runtime/nanbox.h +++ b/runtime/nanbox.h @@ -22,8 +22,8 @@ typedef uint64_t RavaNanboxValue_t; #define RAVA_TAG_STRING (RAVA_QNAN | 0x0006000000000000ULL) #define RAVA_TAG_ARRAY (RAVA_QNAN | 0x0007000000000000ULL) -static inline RavaNanboxValue_t rava_nanbox_int(int32_t v) { - return RAVA_TAG_INT | (uint64_t)(uint32_t)v; +static inline RavaNanboxValue_t rava_nanbox_int(int64_t v) { + return RAVA_TAG_LONG | ((uint64_t)v & RAVA_PAYLOAD_MASK); } static inline RavaNanboxValue_t rava_nanbox_long(int64_t v) { @@ -56,7 +56,7 @@ static inline RavaNanboxValue_t rava_nanbox_array(void* ptr) { } static inline bool rava_nanbox_is_int(RavaNanboxValue_t v) { - return (v & RAVA_TAG_MASK) == RAVA_TAG_INT; + return (v & RAVA_TAG_MASK) == RAVA_TAG_LONG; } static inline bool rava_nanbox_is_long(RavaNanboxValue_t v) { @@ -87,8 +87,12 @@ static inline bool rava_nanbox_is_double(RavaNanboxValue_t v) { return (v & RAVA_QNAN) != RAVA_QNAN; } -static inline int32_t rava_nanbox_as_int(RavaNanboxValue_t v) { - return (int32_t)(v & 0xFFFFFFFF); +static inline int64_t rava_nanbox_as_int(RavaNanboxValue_t v) { + int64_t payload = (int64_t)(v & RAVA_PAYLOAD_MASK); + if (payload & 0x800000000000ULL) { + payload |= (int64_t)0xFFFF000000000000ULL; + } + return payload; } static inline int64_t rava_nanbox_as_long(RavaNanboxValue_t v) { @@ -120,11 +124,11 @@ static inline void* rava_nanbox_as_array(RavaNanboxValue_t v) { return (void*)(uintptr_t)(v & RAVA_PAYLOAD_MASK); } -static inline int32_t rava_nanbox_to_int(RavaNanboxValue_t v) { +static inline int64_t rava_nanbox_to_int(RavaNanboxValue_t v) { if (rava_nanbox_is_int(v)) return rava_nanbox_as_int(v); - if (rava_nanbox_is_long(v)) return (int32_t)rava_nanbox_as_long(v); + if (rava_nanbox_is_long(v)) return rava_nanbox_as_long(v); if (rava_nanbox_is_bool(v)) return rava_nanbox_as_bool(v) ? 1 : 0; - if (rava_nanbox_is_double(v)) return (int32_t)rava_nanbox_as_double(v); + if (rava_nanbox_is_double(v)) return (int64_t)rava_nanbox_as_double(v); return 0; } diff --git a/runtime/runtime.c b/runtime/runtime.c index 1699700..ee90b82 100644 --- a/runtime/runtime.c +++ b/runtime/runtime.c @@ -205,12 +205,12 @@ static void _rava_object_set_field_vm(RavaObject_t *obj, const char *name, RavaV } -int32_t rava_value_as_int(RavaValue_t value) { +int64_t rava_value_as_int(RavaValue_t value) { switch (value.type) { case RAVA_VAL_INT: return value.data.int_val; - case RAVA_VAL_LONG: return (int32_t)value.data.long_val; - case RAVA_VAL_FLOAT: return (int32_t)value.data.float_val; - case RAVA_VAL_DOUBLE: return (int32_t)value.data.double_val; + case RAVA_VAL_LONG: return value.data.long_val; + case RAVA_VAL_FLOAT: return (int64_t)value.data.float_val; + case RAVA_VAL_DOUBLE: return (int64_t)value.data.double_val; case RAVA_VAL_BOOLEAN: return value.data.bool_val ? 1 : 0; case RAVA_VAL_CHAR: return value.data.char_val; default: return 0; @@ -687,7 +687,7 @@ static bool _rava_vm_execute_instruction(RavaVM_t *vm, RavaCallFrame_t *frame, R snprintf(buf_a, sizeof(buf_a), "%ld", (long)rava_value_as_long(a)); str_a = buf_a; } else { - snprintf(buf_a, sizeof(buf_a), "%d", rava_value_as_int(a)); + snprintf(buf_a, sizeof(buf_a), "%ld", (long)rava_value_as_int(a)); str_a = buf_a; } if (b.type == RAVA_VAL_STRING) { @@ -696,7 +696,7 @@ static bool _rava_vm_execute_instruction(RavaVM_t *vm, RavaCallFrame_t *frame, R snprintf(buf_b, sizeof(buf_b), "%ld", (long)rava_value_as_long(b)); str_b = buf_b; } else { - snprintf(buf_b, sizeof(buf_b), "%d", rava_value_as_int(b)); + snprintf(buf_b, sizeof(buf_b), "%ld", (long)rava_value_as_int(b)); str_b = buf_b; } size_t len = strlen(str_a) + strlen(str_b) + 1; @@ -738,46 +738,26 @@ static bool _rava_vm_execute_instruction(RavaVM_t *vm, RavaCallFrame_t *frame, R case RAVA_OP_DIV: { RavaValue_t b = rava_stack_pop(stack); RavaValue_t a = rava_stack_pop(stack); - if (a.type == RAVA_VAL_LONG || b.type == RAVA_VAL_LONG) { - int64_t divisor = rava_value_as_long(b); - if (divisor == 0) { - vm->had_error = true; - vm->error_message = strdup("Division by zero"); - return false; - } - rava_stack_push(stack, rava_value_long(rava_value_as_long(a) / divisor)); - } else { - int32_t divisor = rava_value_as_int(b); - if (divisor == 0) { - vm->had_error = true; - vm->error_message = strdup("Division by zero"); - return false; - } - rava_stack_push(stack, rava_value_int(rava_value_as_int(a) / divisor)); + int64_t divisor = rava_value_as_int(b); + if (divisor == 0) { + vm->had_error = true; + vm->error_message = strdup("Division by zero"); + return false; } + rava_stack_push(stack, rava_value_int(rava_value_as_int(a) / divisor)); break; } case RAVA_OP_MOD: { RavaValue_t b = rava_stack_pop(stack); RavaValue_t a = rava_stack_pop(stack); - if (a.type == RAVA_VAL_LONG || b.type == RAVA_VAL_LONG) { - int64_t divisor = rava_value_as_long(b); - if (divisor == 0) { - vm->had_error = true; - vm->error_message = strdup("Division by zero"); - return false; - } - rava_stack_push(stack, rava_value_long(rava_value_as_long(a) % divisor)); - } else { - int32_t divisor = rava_value_as_int(b); - if (divisor == 0) { - vm->had_error = true; - vm->error_message = strdup("Division by zero"); - return false; - } - rava_stack_push(stack, rava_value_int(rava_value_as_int(a) % divisor)); + int64_t divisor = rava_value_as_int(b); + if (divisor == 0) { + vm->had_error = true; + vm->error_message = strdup("Division by zero"); + return false; } + rava_stack_push(stack, rava_value_int(rava_value_as_int(a) % divisor)); break; } @@ -1156,7 +1136,7 @@ static bool _rava_vm_execute_instruction(RavaVM_t *vm, RavaCallFrame_t *frame, R printf("[array@%p]", (void*)value.data.array_val); break; default: - printf("%d", rava_value_as_int(value)); + printf("%ld", (long)rava_value_as_int(value)); break; } fflush(stdout); @@ -1188,7 +1168,7 @@ static bool _rava_vm_execute_instruction(RavaVM_t *vm, RavaCallFrame_t *frame, R printf("[array@%p]\n", (void*)value.data.array_val); break; default: - printf("%d\n", rava_value_as_int(value)); + printf("%ld\n", (long)rava_value_as_int(value)); break; } fflush(stdout); @@ -1208,7 +1188,7 @@ static bool _rava_vm_execute_instruction(RavaVM_t *vm, RavaCallFrame_t *frame, R case RAVA_OP_NEW_ARRAY: { RavaValue_t length_val = rava_stack_pop(stack); - int32_t length = rava_value_as_int(length_val); + int64_t length = rava_value_as_int(length_val); if (length < 0) length = 0; RavaArray_t *array = rava_array_create(RAVA_VAL_INT, (size_t)length); if (array) { @@ -1221,7 +1201,7 @@ static bool _rava_vm_execute_instruction(RavaVM_t *vm, RavaCallFrame_t *frame, R case RAVA_OP_NEW_ARRAY_OF_ARRAYS: { RavaValue_t length_val = rava_stack_pop(stack); - int32_t length = rava_value_as_int(length_val); + int64_t length = rava_value_as_int(length_val); if (length < 0) length = 0; RavaArray_t *array = rava_array_create(RAVA_VAL_ARRAY, (size_t)length); if (array) { @@ -1256,7 +1236,7 @@ static bool _rava_vm_execute_instruction(RavaVM_t *vm, RavaCallFrame_t *frame, R RavaValue_t array_val = rava_stack_pop(stack); if (array_val.type == RAVA_VAL_ARRAY) { size_t length = rava_array_length(array_val.data.array_val); - rava_stack_push(stack, rava_value_int((int32_t)length)); + rava_stack_push(stack, rava_value_int((int64_t)length)); } else { rava_stack_push(stack, rava_value_int(0)); } @@ -1267,12 +1247,12 @@ static bool _rava_vm_execute_instruction(RavaVM_t *vm, RavaCallFrame_t *frame, R RavaValue_t index_val = rava_stack_pop(stack); RavaValue_t array_val = rava_stack_pop(stack); if (array_val.type == RAVA_VAL_ARRAY) { - int32_t index = rava_value_as_int(index_val); + int64_t index = rava_value_as_int(index_val); RavaArray_t *arr = array_val.data.array_val; if (arr->element_type == RAVA_VAL_ARRAY || arr->element_type == RAVA_VAL_OBJECT) { rava_stack_push(stack, rava_array_get_value(arr, (size_t)index)); } else { - int32_t value = rava_array_get_int(arr, (size_t)index); + int64_t value = rava_array_get_int(arr, (size_t)index); rava_stack_push(stack, rava_value_int(value)); } } else { @@ -1286,12 +1266,12 @@ static bool _rava_vm_execute_instruction(RavaVM_t *vm, RavaCallFrame_t *frame, R RavaValue_t index_val = rava_stack_pop(stack); RavaValue_t array_val = rava_stack_pop(stack); if (array_val.type == RAVA_VAL_ARRAY) { - int32_t index = rava_value_as_int(index_val); + int64_t index = rava_value_as_int(index_val); RavaArray_t *arr = array_val.data.array_val; if (arr->element_type == RAVA_VAL_ARRAY || arr->element_type == RAVA_VAL_OBJECT) { rava_array_set_value(arr, (size_t)index, value_val); } else { - int32_t value = rava_value_as_int(value_val); + int64_t value = rava_value_as_int(value_val); rava_array_set_int(arr, (size_t)index, value); } } @@ -1301,7 +1281,7 @@ static bool _rava_vm_execute_instruction(RavaVM_t *vm, RavaCallFrame_t *frame, R case RAVA_OP_STRING_LENGTH: { RavaValue_t str_val = rava_stack_pop(stack); if (str_val.type == RAVA_VAL_STRING && str_val.data.string_val) { - rava_stack_push(stack, rava_value_int((int32_t)strlen(str_val.data.string_val))); + rava_stack_push(stack, rava_value_int((int64_t)strlen(str_val.data.string_val))); } else { rava_stack_push(stack, rava_value_int(0)); } @@ -2289,10 +2269,10 @@ op_add: { const char *str_a, *str_b; if (a.type == RAVA_VAL_STRING) str_a = a.data.string_val ? a.data.string_val : "null"; else if (VALUE_IS_LONG(a)) { snprintf(buf_a, 64, "%ld", (long)VALUE_AS_LONG_FAST(a)); str_a = buf_a; } - else { snprintf(buf_a, 64, "%d", rava_value_as_int(a)); str_a = buf_a; } + else { snprintf(buf_a, 64, "%ld", (long)rava_value_as_int(a)); str_a = buf_a; } if (b.type == RAVA_VAL_STRING) str_b = b.data.string_val ? b.data.string_val : "null"; else if (VALUE_IS_LONG(b)) { snprintf(buf_b, 64, "%ld", (long)VALUE_AS_LONG_FAST(b)); str_b = buf_b; } - else { snprintf(buf_b, 64, "%d", rava_value_as_int(b)); str_b = buf_b; } + else { snprintf(buf_b, 64, "%ld", (long)rava_value_as_int(b)); str_b = buf_b; } size_t len_a = strlen(str_a); size_t len_b = strlen(str_b); size_t len = len_a + len_b + 1; @@ -2867,7 +2847,7 @@ op_print: { case RAVA_VAL_DOUBLE: printf("%g", value.data.double_val); break; case RAVA_VAL_LONG: printf("%ld", (long)value.data.long_val); break; case RAVA_VAL_NULL: printf("null"); break; - default: printf("%d", rava_value_as_int(value)); break; + default: printf("%ld", (long)rava_value_as_int(value)); break; } fflush(stdout); DISPATCH(); @@ -2881,7 +2861,7 @@ op_println: { case RAVA_VAL_DOUBLE: printf("%g\n", value.data.double_val); break; case RAVA_VAL_LONG: printf("%ld\n", (long)value.data.long_val); break; case RAVA_VAL_NULL: printf("null\n"); break; - default: printf("%d\n", rava_value_as_int(value)); break; + default: printf("%ld\n", (long)rava_value_as_int(value)); break; } DISPATCH(); } @@ -2948,7 +2928,7 @@ op_string_equals: { STACK_PUSH_BOOL(stack, a.data.string_val == b.data.string_val); } } else { - STACK_PUSH_BOOL(stack, false); + STACK_PUSH_BOOL(stack, rava_object_equals(a, b)); } DISPATCH(); } @@ -3501,13 +3481,13 @@ uf_add: { char buf_a[64], buf_b[64]; const char *str_a, *str_b; if (rava_nanbox_is_string(a)) str_a = rava_nanbox_as_string(a) ? rava_nanbox_as_string(a) : "null"; - else if (rava_nanbox_is_int(a)) { snprintf(buf_a, 64, "%d", rava_nanbox_as_int(a)); str_a = buf_a; } + else if (rava_nanbox_is_int(a)) { snprintf(buf_a, 64, "%ld", (long)rava_nanbox_as_int(a)); str_a = buf_a; } else if (rava_nanbox_is_long(a)) { snprintf(buf_a, 64, "%ld", (long)rava_nanbox_as_long(a)); str_a = buf_a; } else if (rava_nanbox_is_double(a)) { snprintf(buf_a, 64, "%g", rava_nanbox_as_double(a)); str_a = buf_a; } else if (rava_nanbox_is_bool(a)) { str_a = rava_nanbox_as_bool(a) ? "true" : "false"; } else { str_a = "null"; } if (rava_nanbox_is_string(b)) str_b = rava_nanbox_as_string(b) ? rava_nanbox_as_string(b) : "null"; - else if (rava_nanbox_is_int(b)) { snprintf(buf_b, 64, "%d", rava_nanbox_as_int(b)); str_b = buf_b; } + else if (rava_nanbox_is_int(b)) { snprintf(buf_b, 64, "%ld", (long)rava_nanbox_as_int(b)); str_b = buf_b; } else if (rava_nanbox_is_long(b)) { snprintf(buf_b, 64, "%ld", (long)rava_nanbox_as_long(b)); str_b = buf_b; } else if (rava_nanbox_is_double(b)) { snprintf(buf_b, 64, "%g", rava_nanbox_as_double(b)); str_b = buf_b; } else if (rava_nanbox_is_bool(b)) { str_b = rava_nanbox_as_bool(b) ? "true" : "false"; } @@ -3993,13 +3973,13 @@ uf_load_array: { RavaNanboxValue_t idx = UF_POP(); RavaNanboxValue_t arr_val = UF_POP(); RavaArray_t *arr = rava_nanbox_as_array(arr_val); - int32_t i = rava_nanbox_to_int(idx); + int64_t i = rava_nanbox_to_int(idx); if (arr && i >= 0 && (size_t)i < arr->length) { if (arr->element_type == RAVA_VAL_ARRAY || arr->element_type == RAVA_VAL_OBJECT) { RavaValue_t v = rava_array_get_value(arr, (size_t)i); UF_PUSH(rava_value_to_nanbox(v)); } else { - int32_t val = rava_array_get_int(arr, (size_t)i); + int64_t val = rava_array_get_int(arr, (size_t)i); UF_PUSH(rava_nanbox_int(val)); } } else { @@ -4017,7 +3997,7 @@ uf_load_array_unchecked: { RavaValue_t v = rava_array_get_value(arr, i); UF_PUSH(rava_value_to_nanbox(v)); } else { - int32_t val = rava_array_get_int(arr, i); + int64_t val = rava_array_get_int(arr, i); UF_PUSH(rava_nanbox_int(val)); } UF_DISPATCH(); @@ -4028,7 +4008,7 @@ uf_store_array: { RavaNanboxValue_t idx = UF_POP(); RavaNanboxValue_t arr_val = UF_POP(); RavaArray_t *arr = rava_nanbox_as_array(arr_val); - int32_t i = rava_nanbox_to_int(idx); + int64_t i = rava_nanbox_to_int(idx); if (arr && i >= 0 && (size_t)i < arr->length) { if (arr->element_type == RAVA_VAL_ARRAY || arr->element_type == RAVA_VAL_OBJECT) { rava_array_set_value(arr, (size_t)i, rava_nanbox_to_value(val)); @@ -4217,9 +4197,9 @@ uf_dup: { uf_print: { RavaNanboxValue_t v = UF_POP(); if (rava_nanbox_is_int(v)) { - printf("%d", rava_nanbox_as_int(v)); + printf("%ld", (long)rava_nanbox_as_int(v)); } else if (rava_nanbox_is_long(v)) { - printf("%ld", rava_nanbox_as_long(v)); + printf("%ld", (long)rava_nanbox_as_long(v)); } else if (rava_nanbox_is_double(v)) { printf("%g", rava_nanbox_as_double(v)); } else if (rava_nanbox_is_bool(v)) { @@ -4235,9 +4215,9 @@ uf_print: { uf_println: { RavaNanboxValue_t v = UF_POP(); if (rava_nanbox_is_int(v)) { - printf("%d\n", rava_nanbox_as_int(v)); + printf("%ld\n", (long)rava_nanbox_as_int(v)); } else if (rava_nanbox_is_long(v)) { - printf("%ld\n", rava_nanbox_as_long(v)); + printf("%ld\n", (long)rava_nanbox_as_long(v)); } else if (rava_nanbox_is_double(v)) { printf("%g\n", rava_nanbox_as_double(v)); } else if (rava_nanbox_is_bool(v)) { @@ -4292,9 +4272,15 @@ uf_string_substring: { uf_string_equals: { RavaNanboxValue_t b = UF_POP(); RavaNanboxValue_t a = UF_POP(); - const char *sa = rava_nanbox_as_string(a); - const char *sb = rava_nanbox_as_string(b); - UF_PUSH(rava_nanbox_bool(sa && sb && strcmp(sa, sb) == 0)); + if (rava_nanbox_is_string(a) && rava_nanbox_is_string(b)) { + const char *sa = rava_nanbox_as_string(a); + const char *sb = rava_nanbox_as_string(b); + UF_PUSH(rava_nanbox_bool(sa && sb && strcmp(sa, sb) == 0)); + } else { + RavaValue_t val_a = rava_nanbox_to_value(a); + RavaValue_t val_b = rava_nanbox_to_value(b); + UF_PUSH(rava_nanbox_bool(rava_object_equals(val_a, val_b))); + } UF_DISPATCH(); } diff --git a/runtime/runtime.h b/runtime/runtime.h index ce8a678..e7ddd22 100644 --- a/runtime/runtime.h +++ b/runtime/runtime.h @@ -65,7 +65,7 @@ struct RavaObject_t { struct RavaValue_t { RavaValueType_e type; union { - int32_t int_val; + int64_t int_val; int64_t long_val; float float_val; double double_val; @@ -227,7 +227,7 @@ typedef struct { RavaInternTable_t intern_table; } RavaVM_t; -static inline RavaValue_t rava_value_int(int32_t value) { +static inline RavaValue_t rava_value_int(int64_t value) { RavaValue_t val; val.type = RAVA_VAL_INT; val.data.int_val = value; @@ -299,7 +299,7 @@ static inline RavaValue_t rava_value_hashmap(RavaHashMap_t *map) { RavaValue_t rava_value_string(const char *str); -int32_t rava_value_as_int(RavaValue_t value); +int64_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); @@ -307,8 +307,8 @@ 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_int(RavaArray_t *array, size_t index, int64_t value); +int64_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); diff --git a/runtime/runtime_array.c b/runtime/runtime_array.c index 2d408f7..1aadb8e 100644 --- a/runtime/runtime_array.c +++ b/runtime/runtime_array.c @@ -25,7 +25,7 @@ RavaArray_t* rava_array_create(RavaValueType_e element_type, size_t length) { switch (element_type) { case RAVA_VAL_INT: - array->data = calloc(length, sizeof(int32_t)); + array->data = calloc(length, sizeof(int64_t)); break; case RAVA_VAL_LONG: array->data = calloc(length, sizeof(int64_t)); @@ -57,14 +57,14 @@ void rava_array_destroy(RavaArray_t *array) { free(array->data); } -void rava_array_set_int(RavaArray_t *array, size_t index, int32_t value) { +void rava_array_set_int(RavaArray_t *array, size_t index, int64_t value) { if (!array || !array->data || index >= array->length) return; - ((int32_t*)array->data)[index] = value; + ((int64_t*)array->data)[index] = value; } -int32_t rava_array_get_int(RavaArray_t *array, size_t index) { +int64_t rava_array_get_int(RavaArray_t *array, size_t index) { if (!array || !array->data || index >= array->length) return 0; - return ((int32_t*)array->data)[index]; + return ((int64_t*)array->data)[index]; } void rava_array_set_long(RavaArray_t *array, size_t index, int64_t value) { diff --git a/runtime/runtime_object.c b/runtime/runtime_object.c index 96b15e5..72548c0 100644 --- a/runtime/runtime_object.c +++ b/runtime/runtime_object.c @@ -234,10 +234,10 @@ char* rava_object_tostring(RavaValue_t value) { strcpy(buffer, "null"); break; case RAVA_VAL_INT: - snprintf(buffer, 128, "%d", value.data.int_val); + snprintf(buffer, 128, "%ld", (long)value.data.int_val); break; case RAVA_VAL_LONG: - snprintf(buffer, 128, "%ld", value.data.long_val); + snprintf(buffer, 128, "%ld", (long)value.data.long_val); break; case RAVA_VAL_FLOAT: snprintf(buffer, 128, "%g", (double)value.data.float_val);