diff --git a/vm/runtime.c b/vm/runtime.c index 8ef4eca..88039a4 100644 --- a/vm/runtime.c +++ b/vm/runtime.c @@ -38,6 +38,8 @@ const char *err_as_cstr(err_t err) return "INVALID_OPCODE"; case ERR_INVALID_REGISTER_BYTE: return "INVALID_REGISTER_BYTE"; + case ERR_INVALID_REGISTER_SHORT: + return "INVALID_REGISTER_SHORT"; case ERR_INVALID_REGISTER_HWORD: return "INVALID_REGISTER_HWORD"; case ERR_INVALID_REGISTER_WORD: @@ -55,14 +57,7 @@ const char *err_as_cstr(err_t err) } } -static_assert(NUMBER_OF_OPCODES == 99, "vm_execute: Out of date"); - -static_assert(DATA_TYPE_NIL == -1 && DATA_TYPE_WORD == 2, - "Code using OPCODE_DATA_TYPE for quick same type opcode " - "conversion may be out of date."); - -static_assert(OP_PRINT_SWORD - OP_PRINT_BYTE == 5, - "Implementation of OP_PRINT is out of date"); +static_assert(NUMBER_OF_OPCODES == 129, "vm_execute: Out of date"); err_t vm_execute(vm_t *vm) { @@ -94,6 +89,10 @@ err_t vm_execute(vm_t *vm) } else if (UNSIGNED_OPCODE_IS_TYPE(instruction.opcode, OP_POP)) { + static_assert(DATA_TYPE_NIL == -1 && DATA_TYPE_WORD == 3, + "Code using OPCODE_DATA_TYPE for quick same type opcode " + "conversion may be out of date."); + // NOTE: We always use the first register to hold the result of // this pop. @@ -144,8 +143,11 @@ err_t vm_execute(vm_t *vm) { data_t datum = {0}; + static_assert(DATA_TYPE_NIL == -1 && DATA_TYPE_WORD == 3, + "Code using OPCODE_DATA_TYPE for quick same type opcode " + "conversion may be out of date."); // Here we add OP_POP_BYTE and the data_type_t of the opcode to - // get the right typed OP_POP opcode. + // get the right OP_POP opcode. opcode_t pop_opcode = OPCODE_DATA_TYPE(instruction.opcode, OP_JUMP_IF) + OP_POP_BYTE; @@ -157,8 +159,7 @@ err_t vm_execute(vm_t *vm) // If datum != 0 then jump, else go to the next instruction if (datum.as_word != 0) return vm_jump(vm, instruction.operand.as_word); - else - ++prog->ptr; + ++prog->ptr; } else if (instruction.opcode == OP_CALL) { @@ -191,6 +192,11 @@ err_t vm_execute(vm_t *vm) } else if (SIGNED_OPCODE_IS_TYPE(instruction.opcode, OP_PRINT)) { + static_assert(DATA_TYPE_NIL == -1 && DATA_TYPE_WORD == 3, + "Code using OPCODE_DATA_TYPE for quick same type opcode " + "conversion may be out of date."); + static_assert(OP_PRINT_SWORD - OP_PRINT_BYTE == 7, + "Implementation of OP_PRINT is out of date"); /* 1) Pop 2) Format 3) Print @@ -198,13 +204,14 @@ err_t vm_execute(vm_t *vm) // 1) figure out what datum type to pop - // type in [0, 5] representing [byte, char, hword, int, word, - // long] + // type in [0, 7] representing [byte, sbyte, short, sshort, hword, shword, + // word, sword] int type = OPCODE_DATA_TYPE(instruction.opcode, OP_PRINT); - /* Byte and Char -> POP_BYTE - HWord and Int -> POP_HWORD - Word and Long -> POP_WORD + /* Byte and SByte -> POP_BYTE + Short and SShort -> POP_SHORT + HWord and SHword -> POP_HWORD + Word and SWord -> POP_WORD */ opcode_t pop_opcode = OP_POP_BYTE + (type / 2); @@ -217,14 +224,16 @@ err_t vm_execute(vm_t *vm) // 2) create a format string for each datum type possible // TODO: Figure out a way to ensure the ordering of OP_PRINT_* is - // exactly BYTE, CHAR, HWORD, INTEGER, WORD, LONG. Perhaps via - // static_assert + // exactly BYTE, SBYTE, SHORT, SSHORT, HWORD, SHWORD, WORD, SWORD + // via static_assert // lookup table const char *format_strings[] = { - "0x%x", + "0x%X", "%c", #if PRINT_HEX == 1 + "0x%X", + "0x%X", "0x%X", "0x%X", "0x%lX", @@ -350,6 +359,22 @@ err_t vm_push_byte(vm_t *vm, data_t b) return ERR_OK; } +err_t vm_push_short(vm_t *vm, data_t f) +{ + if (vm->stack.ptr + SHORT_SIZE >= vm->stack.max) + return ERR_STACK_OVERFLOW; + byte_t bytes[SHORT_SIZE] = {0}; + convert_short_to_bytes(f.as_short, bytes); + for (size_t i = 0; i < SHORT_SIZE; ++i) + { + byte_t b = bytes[SHORT_SIZE - i - 1]; + err_t err = vm_push_byte(vm, DBYTE(b)); + if (err) + return err; + } + return ERR_OK; +} + err_t vm_push_hword(vm_t *vm, data_t f) { if (vm->stack.ptr + HWORD_SIZE >= vm->stack.max) @@ -393,6 +418,15 @@ err_t vm_push_byte_register(vm_t *vm, word_t reg) return vm_push_byte(vm, DBYTE(b)); } +err_t vm_push_short_register(vm_t *vm, word_t reg) +{ + if (reg > (vm->registers.used / SHORT_SIZE)) + return ERR_INVALID_REGISTER_SHORT; + // Interpret the bytes at point reg * SHORT_SIZE as an short + short_t sh = *(short_t *)(vm->registers.data + (reg * SHORT_SIZE)); + return vm_push_short(vm, DSHORT(sh)); +} + err_t vm_push_hword_register(vm_t *vm, word_t reg) { if (reg > (vm->registers.used / HWORD_SIZE)) @@ -425,6 +459,31 @@ err_t vm_mov_byte(vm_t *vm, word_t reg) return ERR_OK; } +err_t vm_mov_short(vm_t *vm, word_t reg) +{ + if (reg >= (vm->registers.used / SHORT_SIZE)) + { + // Expand capacity till we can ensure that this is a valid + // register to use + + // Number of shorts needed ontop of what is allocated: + const size_t shorts = (reg - (vm->registers.used / SHORT_SIZE)); + // Number of bytes needed ontop of what is allocated + const size_t diff = (shorts + 1) * SHORT_SIZE; + + darr_ensure_capacity(&vm->registers, diff); + vm->registers.used = MAX(vm->registers.used, (reg + 1) * SHORT_SIZE); + } + data_t ret = {0}; + err_t err = vm_pop_short(vm, &ret); + if (err) + return err; + // Here we treat vm->registers as a set of shorts + short_t *short_ptr = (short_t *)(vm->registers.data + (reg * SHORT_SIZE)); + *short_ptr = ret.as_short; + return ERR_OK; +} + err_t vm_mov_hword(vm_t *vm, word_t reg) { if (reg >= (vm->registers.used / HWORD_SIZE)) @@ -479,6 +538,17 @@ err_t vm_dup_byte(vm_t *vm, word_t w) return vm_push_byte(vm, DBYTE(vm->stack.data[vm->stack.ptr - 1 - w])); } +err_t vm_dup_short(vm_t *vm, word_t w) +{ + if (vm->stack.ptr < SHORT_SIZE * (w + 1)) + return ERR_STACK_UNDERFLOW; + byte_t bytes[SHORT_SIZE] = {0}; + for (size_t i = 0; i < SHORT_SIZE; ++i) + bytes[SHORT_SIZE - i - 1] = + vm->stack.data[vm->stack.ptr - (SHORT_SIZE * (w + 1)) + i]; + return vm_push_short(vm, DSHORT(convert_bytes_to_short(bytes))); +} + err_t vm_dup_hword(vm_t *vm, word_t w) { if (vm->stack.ptr < HWORD_SIZE * (w + 1)) @@ -507,6 +577,12 @@ err_t vm_malloc_byte(vm_t *vm, word_t n) return vm_push_word(vm, DWORD((word_t)page)); } +err_t vm_malloc_short(vm_t *vm, word_t n) +{ + page_t *page = heap_allocate(&vm->heap, n * SHORT_SIZE); + return vm_push_word(vm, DWORD((word_t)page)); +} + err_t vm_malloc_hword(vm_t *vm, word_t n) { page_t *page = heap_allocate(&vm->heap, n * HWORD_SIZE); @@ -539,6 +615,26 @@ err_t vm_mset_byte(vm_t *vm, word_t nth) return ERR_OK; } +err_t vm_mset_short(vm_t *vm, word_t nth) +{ + // Stack layout should be [SHORT, PTR] + data_t byte = {0}; + err_t err = vm_pop_short(vm, &byte); + if (err) + return err; + data_t ptr = {0}; + err = vm_pop_word(vm, &ptr); + if (err) + return err; + + page_t *page = (page_t *)ptr.as_word; + if (nth >= (page->available / SHORT_SIZE)) + return ERR_OUT_OF_BOUNDS; + ((short_t *)page->data)[nth] = byte.as_short; + + return ERR_OK; +} + err_t vm_mset_hword(vm_t *vm, word_t nth) { // Stack layout should be [HWORD, PTR] @@ -592,6 +688,19 @@ err_t vm_mget_byte(vm_t *vm, word_t n) return vm_push_byte(vm, DBYTE(page->data[n])); } +err_t vm_mget_short(vm_t *vm, word_t n) +{ + // Stack layout should be [PTR] + data_t ptr = {0}; + err_t err = vm_pop_word(vm, &ptr); + if (err) + return err; + page_t *page = (page_t *)ptr.as_word; + if (n >= (page->available / SHORT_SIZE)) + return ERR_OUT_OF_BOUNDS; + return vm_push_short(vm, DSHORT(((short_t *)page->data)[n])); +} + err_t vm_mget_hword(vm_t *vm, word_t n) { // Stack layout should be [PTR] @@ -627,6 +736,21 @@ err_t vm_pop_byte(vm_t *vm, data_t *ret) return ERR_OK; } +err_t vm_pop_short(vm_t *vm, data_t *ret) +{ + if (vm->stack.ptr < SHORT_SIZE) + return ERR_STACK_UNDERFLOW; + byte_t bytes[SHORT_SIZE] = {0}; + for (size_t i = 0; i < SHORT_SIZE; ++i) + { + data_t b = {0}; + vm_pop_byte(vm, &b); + bytes[i] = b.as_byte; + } + *ret = DSHORT(convert_bytes_to_short(bytes)); + return ERR_OK; +} + err_t vm_pop_hword(vm_t *vm, data_t *ret) { if (vm->stack.ptr < HWORD_SIZE) @@ -669,12 +793,15 @@ err_t vm_pop_word(vm_t *vm, data_t *ret) } VM_MEMORY_STACK_CONSTR(malloc, byte) +VM_MEMORY_STACK_CONSTR(malloc, short) VM_MEMORY_STACK_CONSTR(malloc, hword) VM_MEMORY_STACK_CONSTR(malloc, word) VM_MEMORY_STACK_CONSTR(mset, byte) +VM_MEMORY_STACK_CONSTR(mset, short) VM_MEMORY_STACK_CONSTR(mset, hword) VM_MEMORY_STACK_CONSTR(mset, word) VM_MEMORY_STACK_CONSTR(mget, byte) +VM_MEMORY_STACK_CONSTR(mget, short) VM_MEMORY_STACK_CONSTR(mget, hword) VM_MEMORY_STACK_CONSTR(mget, word) @@ -713,6 +840,7 @@ err_t vm_msize(vm_t *vm) } VM_NOT_TYPE(byte, BYTE) +VM_NOT_TYPE(short, SHORT) VM_NOT_TYPE(hword, HWORD) VM_NOT_TYPE(word, WORD) @@ -745,58 +873,76 @@ VM_NOT_TYPE(word, WORD) } VM_SAME_TYPE(or, |, byte, BYTE) +VM_SAME_TYPE(or, |, short, SHORT) VM_SAME_TYPE(or, |, hword, HWORD) VM_SAME_TYPE(or, |, word, WORD) + VM_SAME_TYPE(and, &, byte, BYTE) +VM_SAME_TYPE(and, &, short, SHORT) VM_SAME_TYPE(and, &, hword, HWORD) VM_SAME_TYPE(and, &, word, WORD) + VM_SAME_TYPE(xor, ^, byte, BYTE) +VM_SAME_TYPE(xor, ^, short, SHORT) VM_SAME_TYPE(xor, ^, hword, HWORD) VM_SAME_TYPE(xor, ^, word, WORD) VM_SAME_TYPE(plus, +, byte, BYTE) +VM_SAME_TYPE(plus, +, short, SHORT) VM_SAME_TYPE(plus, +, hword, HWORD) VM_SAME_TYPE(plus, +, word, WORD) VM_SAME_TYPE(sub, -, byte, BYTE) +VM_SAME_TYPE(sub, -, short, SHORT) VM_SAME_TYPE(sub, -, hword, HWORD) VM_SAME_TYPE(sub, -, word, WORD) VM_SAME_TYPE(mult, *, byte, BYTE) +VM_SAME_TYPE(mult, *, short, SHORT) VM_SAME_TYPE(mult, *, hword, HWORD) VM_SAME_TYPE(mult, *, word, WORD) VM_COMPARATOR_TYPE(eq, ==, byte, byte) -VM_COMPARATOR_TYPE(eq, ==, byte, char) +VM_COMPARATOR_TYPE(eq, ==, byte, sbyte) +VM_COMPARATOR_TYPE(eq, ==, short, short) +VM_COMPARATOR_TYPE(eq, ==, short, sshort) VM_COMPARATOR_TYPE(eq, ==, hword, hword) -VM_COMPARATOR_TYPE(eq, ==, hword, int) +VM_COMPARATOR_TYPE(eq, ==, hword, shword) VM_COMPARATOR_TYPE(eq, ==, word, word) -VM_COMPARATOR_TYPE(eq, ==, word, long) +VM_COMPARATOR_TYPE(eq, ==, word, sword) VM_COMPARATOR_TYPE(lt, <, byte, byte) -VM_COMPARATOR_TYPE(lt, <, byte, char) +VM_COMPARATOR_TYPE(lt, <, byte, sbyte) +VM_COMPARATOR_TYPE(lt, <, short, short) +VM_COMPARATOR_TYPE(lt, <, short, sshort) VM_COMPARATOR_TYPE(lt, <, hword, hword) -VM_COMPARATOR_TYPE(lt, <, hword, int) +VM_COMPARATOR_TYPE(lt, <, hword, shword) VM_COMPARATOR_TYPE(lt, <, word, word) -VM_COMPARATOR_TYPE(lt, <, word, long) +VM_COMPARATOR_TYPE(lt, <, word, sword) VM_COMPARATOR_TYPE(lte, <=, byte, byte) -VM_COMPARATOR_TYPE(lte, <=, byte, char) +VM_COMPARATOR_TYPE(lte, <=, byte, sbyte) +VM_COMPARATOR_TYPE(lte, <=, short, short) +VM_COMPARATOR_TYPE(lte, <=, short, sshort) VM_COMPARATOR_TYPE(lte, <=, hword, hword) -VM_COMPARATOR_TYPE(lte, <=, hword, int) +VM_COMPARATOR_TYPE(lte, <=, hword, shword) VM_COMPARATOR_TYPE(lte, <=, word, word) -VM_COMPARATOR_TYPE(lte, <=, word, long) +VM_COMPARATOR_TYPE(lte, <=, word, sword) VM_COMPARATOR_TYPE(gt, >, byte, byte) -VM_COMPARATOR_TYPE(gt, >, byte, char) +VM_COMPARATOR_TYPE(gt, >, byte, sbyte) +VM_COMPARATOR_TYPE(gt, >, short, short) +VM_COMPARATOR_TYPE(gt, >, short, sshort) VM_COMPARATOR_TYPE(gt, >, hword, hword) -VM_COMPARATOR_TYPE(gt, >, hword, int) +VM_COMPARATOR_TYPE(gt, >, hword, shword) VM_COMPARATOR_TYPE(gt, >, word, word) -VM_COMPARATOR_TYPE(gt, >, word, long) +VM_COMPARATOR_TYPE(gt, >, word, sword) VM_COMPARATOR_TYPE(gte, >=, byte, byte) -VM_COMPARATOR_TYPE(gte, >=, byte, char) +VM_COMPARATOR_TYPE(gte, >=, byte, sbyte) +VM_COMPARATOR_TYPE(gte, >=, short, short) +VM_COMPARATOR_TYPE(gte, >=, short, sshort) VM_COMPARATOR_TYPE(gte, >=, hword, hword) -VM_COMPARATOR_TYPE(gte, >=, hword, int) +VM_COMPARATOR_TYPE(gte, >=, hword, shword) VM_COMPARATOR_TYPE(gte, >=, word, word) -VM_COMPARATOR_TYPE(gte, >=, word, long) +VM_COMPARATOR_TYPE(gte, >=, word, sword) diff --git a/vm/runtime.h b/vm/runtime.h index 550af35..4078728 100644 --- a/vm/runtime.h +++ b/vm/runtime.h @@ -26,6 +26,7 @@ typedef enum ERR_CALL_STACK_OVERFLOW, ERR_INVALID_OPCODE, ERR_INVALID_REGISTER_BYTE, + ERR_INVALID_REGISTER_SHORT, ERR_INVALID_REGISTER_HWORD, ERR_INVALID_REGISTER_WORD, ERR_INVALID_PROGRAM_ADDRESS, @@ -42,84 +43,108 @@ err_t vm_execute_all(vm_t *); err_t vm_jump(vm_t *, word_t); err_t vm_pop_byte(vm_t *, data_t *); +err_t vm_pop_short(vm_t *, data_t *); err_t vm_pop_hword(vm_t *, data_t *); err_t vm_pop_word(vm_t *, data_t *); typedef err_t (*pop_f)(vm_t *, data_t *); static const pop_f POP_ROUTINES[] = { [OP_POP_BYTE] = vm_pop_byte, + [OP_POP_SHORT] = vm_pop_short, [OP_POP_HWORD] = vm_pop_hword, [OP_POP_WORD] = vm_pop_word, }; err_t vm_push_byte(vm_t *, data_t); +err_t vm_push_short(vm_t *, data_t); err_t vm_push_hword(vm_t *, data_t); err_t vm_push_word(vm_t *, data_t); typedef err_t (*push_f)(vm_t *, data_t); static const push_f PUSH_ROUTINES[] = { [OP_PUSH_BYTE] = vm_push_byte, + [OP_PUSH_SHORT] = vm_push_short, [OP_PUSH_HWORD] = vm_push_hword, [OP_PUSH_WORD] = vm_push_word, }; /* Operations where operand is a word from inst_t.operand */ err_t vm_push_byte_register(vm_t *, word_t); +err_t vm_push_short_register(vm_t *, word_t); err_t vm_push_hword_register(vm_t *, word_t); err_t vm_push_word_register(vm_t *, word_t); err_t vm_mov_byte(vm_t *, word_t); +err_t vm_mov_short(vm_t *, word_t); err_t vm_mov_hword(vm_t *, word_t); err_t vm_mov_word(vm_t *, word_t); err_t vm_dup_byte(vm_t *, word_t); +err_t vm_dup_short(vm_t *, word_t); err_t vm_dup_hword(vm_t *, word_t); err_t vm_dup_word(vm_t *, word_t); err_t vm_malloc_byte(vm_t *, word_t); +err_t vm_malloc_short(vm_t *, word_t); err_t vm_malloc_hword(vm_t *, word_t); err_t vm_malloc_word(vm_t *, word_t); err_t vm_mset_byte(vm_t *, word_t); +err_t vm_mset_short(vm_t *, word_t); err_t vm_mset_hword(vm_t *, word_t); err_t vm_mset_word(vm_t *, word_t); err_t vm_mget_byte(vm_t *, word_t); +err_t vm_mget_short(vm_t *, word_t); err_t vm_mget_hword(vm_t *, word_t); err_t vm_mget_word(vm_t *, word_t); typedef err_t (*word_f)(vm_t *, word_t); static const word_f WORD_ROUTINES[] = { [OP_PUSH_REGISTER_BYTE] = vm_push_byte_register, + [OP_PUSH_REGISTER_SHORT] = vm_push_short_register, [OP_PUSH_REGISTER_HWORD] = vm_push_hword_register, [OP_PUSH_REGISTER_WORD] = vm_push_word_register, - [OP_MOV_BYTE] = vm_mov_byte, - [OP_MOV_HWORD] = vm_mov_hword, - [OP_MOV_WORD] = vm_mov_word, - [OP_DUP_BYTE] = vm_dup_byte, - [OP_DUP_HWORD] = vm_dup_hword, - [OP_DUP_WORD] = vm_dup_word, - [OP_MALLOC_BYTE] = vm_malloc_byte, - [OP_MALLOC_HWORD] = vm_malloc_hword, - [OP_MALLOC_WORD] = vm_malloc_word, - [OP_MGET_BYTE] = vm_mget_byte, - [OP_MGET_HWORD] = vm_mget_hword, - [OP_MGET_WORD] = vm_mget_word, - [OP_MSET_BYTE] = vm_mset_byte, - [OP_MSET_HWORD] = vm_mset_hword, - [OP_MSET_WORD] = vm_mset_word, + + [OP_MOV_BYTE] = vm_mov_byte, + [OP_MOV_SHORT] = vm_mov_short, + [OP_MOV_HWORD] = vm_mov_hword, + [OP_MOV_WORD] = vm_mov_word, + + [OP_DUP_BYTE] = vm_dup_byte, + [OP_DUP_SHORT] = vm_dup_short, + [OP_DUP_HWORD] = vm_dup_hword, + [OP_DUP_WORD] = vm_dup_word, + + [OP_MALLOC_BYTE] = vm_malloc_byte, + [OP_MALLOC_SHORT] = vm_malloc_short, + [OP_MALLOC_HWORD] = vm_malloc_hword, + [OP_MALLOC_WORD] = vm_malloc_word, + + [OP_MGET_BYTE] = vm_mget_byte, + [OP_MGET_SHORT] = vm_mget_short, + [OP_MGET_HWORD] = vm_mget_hword, + [OP_MGET_WORD] = vm_mget_word, + + [OP_MSET_BYTE] = vm_mset_byte, + [OP_MSET_SHORT] = vm_mset_short, + [OP_MSET_HWORD] = vm_mset_hword, + [OP_MSET_WORD] = vm_mset_word, }; /* Operations that take input from the stack */ err_t vm_malloc_stack_byte(vm_t *); +err_t vm_malloc_stack_short(vm_t *); err_t vm_malloc_stack_hword(vm_t *); err_t vm_malloc_stack_word(vm_t *); err_t vm_mset_stack_byte(vm_t *); +err_t vm_mset_stack_short(vm_t *); err_t vm_mset_stack_hword(vm_t *); err_t vm_mset_stack_word(vm_t *); err_t vm_mget_stack_byte(vm_t *); +err_t vm_mget_stack_short(vm_t *); err_t vm_mget_stack_hword(vm_t *); err_t vm_mget_stack_word(vm_t *); @@ -127,104 +152,133 @@ err_t vm_mdelete(vm_t *); err_t vm_msize(vm_t *); err_t vm_not_byte(vm_t *); +err_t vm_not_short(vm_t *); err_t vm_not_hword(vm_t *); err_t vm_not_word(vm_t *); err_t vm_or_byte(vm_t *); +err_t vm_or_short(vm_t *); err_t vm_or_hword(vm_t *); err_t vm_or_word(vm_t *); err_t vm_and_byte(vm_t *); +err_t vm_and_short(vm_t *); err_t vm_and_hword(vm_t *); err_t vm_and_word(vm_t *); err_t vm_xor_byte(vm_t *); +err_t vm_xor_short(vm_t *); err_t vm_xor_hword(vm_t *); err_t vm_xor_word(vm_t *); err_t vm_eq_byte(vm_t *); -err_t vm_eq_char(vm_t *); -err_t vm_eq_int(vm_t *); +err_t vm_eq_sbyte(vm_t *); +err_t vm_eq_short(vm_t *); +err_t vm_eq_sshort(vm_t *); +err_t vm_eq_shword(vm_t *); err_t vm_eq_hword(vm_t *); -err_t vm_eq_long(vm_t *); +err_t vm_eq_sword(vm_t *); err_t vm_eq_word(vm_t *); err_t vm_lt_byte(vm_t *); -err_t vm_lt_char(vm_t *); -err_t vm_lt_int(vm_t *); +err_t vm_lt_sbyte(vm_t *); +err_t vm_lt_short(vm_t *); +err_t vm_lt_sshort(vm_t *); +err_t vm_lt_shword(vm_t *); err_t vm_lt_hword(vm_t *); -err_t vm_lt_long(vm_t *); +err_t vm_lt_sword(vm_t *); err_t vm_lt_word(vm_t *); err_t vm_lte_byte(vm_t *); -err_t vm_lte_char(vm_t *); -err_t vm_lte_int(vm_t *); +err_t vm_lte_sbyte(vm_t *); +err_t vm_lte_short(vm_t *); +err_t vm_lte_sshort(vm_t *); +err_t vm_lte_shword(vm_t *); err_t vm_lte_hword(vm_t *); -err_t vm_lte_long(vm_t *); +err_t vm_lte_sword(vm_t *); err_t vm_lte_word(vm_t *); err_t vm_gt_byte(vm_t *); -err_t vm_gt_char(vm_t *); -err_t vm_gt_int(vm_t *); +err_t vm_gt_sbyte(vm_t *); +err_t vm_gt_short(vm_t *); +err_t vm_gt_sshort(vm_t *); +err_t vm_gt_shword(vm_t *); err_t vm_gt_hword(vm_t *); -err_t vm_gt_long(vm_t *); +err_t vm_gt_sword(vm_t *); err_t vm_gt_word(vm_t *); err_t vm_gte_byte(vm_t *); -err_t vm_gte_char(vm_t *); -err_t vm_gte_int(vm_t *); +err_t vm_gte_sbyte(vm_t *); +err_t vm_gte_short(vm_t *); +err_t vm_gte_sshort(vm_t *); +err_t vm_gte_shword(vm_t *); err_t vm_gte_hword(vm_t *); -err_t vm_gte_long(vm_t *); +err_t vm_gte_sword(vm_t *); err_t vm_gte_word(vm_t *); err_t vm_plus_byte(vm_t *); +err_t vm_plus_short(vm_t *); err_t vm_plus_hword(vm_t *); err_t vm_plus_word(vm_t *); err_t vm_sub_byte(vm_t *); +err_t vm_sub_short(vm_t *); err_t vm_sub_hword(vm_t *); err_t vm_sub_word(vm_t *); err_t vm_mult_byte(vm_t *); +err_t vm_mult_short(vm_t *); err_t vm_mult_hword(vm_t *); err_t vm_mult_word(vm_t *); typedef err_t (*stack_f)(vm_t *); static const stack_f STACK_ROUTINES[] = { [OP_MALLOC_STACK_BYTE] = vm_malloc_stack_byte, + [OP_MALLOC_STACK_SHORT] = vm_malloc_stack_short, [OP_MALLOC_STACK_HWORD] = vm_malloc_stack_hword, [OP_MALLOC_STACK_WORD] = vm_malloc_stack_word, - [OP_MGET_STACK_BYTE] = vm_mget_stack_byte, - [OP_MGET_STACK_HWORD] = vm_mget_stack_hword, - [OP_MGET_STACK_WORD] = vm_mget_stack_word, - [OP_MSET_STACK_BYTE] = vm_mset_stack_byte, - [OP_MSET_STACK_HWORD] = vm_mset_stack_hword, - [OP_MSET_STACK_WORD] = vm_mset_stack_word, - [OP_MDELETE] = vm_mdelete, - [OP_MSIZE] = vm_msize, + + [OP_MGET_STACK_BYTE] = vm_mget_stack_byte, + [OP_MGET_STACK_SHORT] = vm_mget_stack_short, + [OP_MGET_STACK_HWORD] = vm_mget_stack_hword, + [OP_MGET_STACK_WORD] = vm_mget_stack_word, + [OP_MSET_STACK_BYTE] = vm_mset_stack_byte, + [OP_MSET_STACK_SHORT] = vm_mset_stack_short, + [OP_MSET_STACK_HWORD] = vm_mset_stack_hword, + [OP_MSET_STACK_WORD] = vm_mset_stack_word, + + [OP_MDELETE] = vm_mdelete, + [OP_MSIZE] = vm_msize, [OP_NOT_BYTE] = vm_not_byte, + [OP_NOT_SHORT] = vm_not_short, [OP_NOT_HWORD] = vm_not_hword, [OP_NOT_WORD] = vm_not_word, [OP_OR_BYTE] = vm_or_byte, + [OP_OR_SHORT] = vm_or_short, [OP_OR_HWORD] = vm_or_hword, [OP_OR_WORD] = vm_or_word, [OP_AND_BYTE] = vm_and_byte, + [OP_AND_SHORT] = vm_and_short, [OP_AND_HWORD] = vm_and_hword, [OP_AND_WORD] = vm_and_word, [OP_XOR_BYTE] = vm_xor_byte, + [OP_XOR_SHORT] = vm_xor_short, [OP_XOR_HWORD] = vm_xor_hword, [OP_XOR_WORD] = vm_xor_word, [OP_EQ_BYTE] = vm_eq_byte, + [OP_EQ_SHORT] = vm_eq_short, [OP_EQ_HWORD] = vm_eq_hword, [OP_EQ_WORD] = vm_eq_word, [OP_LT_BYTE] = vm_lt_byte, [OP_LT_SBYTE] = vm_lt_sbyte, + [OP_LT_SHORT] = vm_lt_short, + [OP_LT_SSHORT] = vm_lt_sshort, [OP_LT_SHWORD] = vm_lt_shword, [OP_LT_HWORD] = vm_lt_hword, [OP_LT_SWORD] = vm_lt_sword, @@ -232,6 +286,8 @@ static const stack_f STACK_ROUTINES[] = { [OP_LTE_BYTE] = vm_lte_byte, [OP_LTE_SBYTE] = vm_lte_sbyte, + [OP_LTE_SHORT] = vm_lte_short, + [OP_LTE_SSHORT] = vm_lte_sshort, [OP_LTE_SHWORD] = vm_lte_shword, [OP_LTE_HWORD] = vm_lte_hword, [OP_LTE_SWORD] = vm_lte_sword, @@ -239,6 +295,8 @@ static const stack_f STACK_ROUTINES[] = { [OP_GT_BYTE] = vm_gt_byte, [OP_GT_SBYTE] = vm_gt_sbyte, + [OP_GT_SHORT] = vm_gt_short, + [OP_GT_SSHORT] = vm_gt_sshort, [OP_GT_SHWORD] = vm_gt_shword, [OP_GT_HWORD] = vm_gt_hword, [OP_GT_SWORD] = vm_gt_sword, @@ -246,19 +304,24 @@ static const stack_f STACK_ROUTINES[] = { [OP_GTE_BYTE] = vm_gte_byte, [OP_GTE_SBYTE] = vm_gte_sbyte, + [OP_GTE_SHORT] = vm_gte_short, + [OP_GTE_SSHORT] = vm_gte_sshort, [OP_GTE_SHWORD] = vm_gte_shword, [OP_GTE_HWORD] = vm_gte_hword, [OP_GTE_SWORD] = vm_gte_sword, [OP_GTE_WORD] = vm_gte_word, [OP_PLUS_BYTE] = vm_plus_byte, + [OP_PLUS_SHORT] = vm_plus_short, [OP_PLUS_HWORD] = vm_plus_hword, [OP_PLUS_WORD] = vm_plus_word, [OP_SUB_BYTE] = vm_sub_byte, + [OP_SUB_SHORT] = vm_sub_short, [OP_SUB_HWORD] = vm_sub_hword, [OP_SUB_WORD] = vm_sub_word, [OP_MULT_BYTE] = vm_mult_byte, + [OP_MULT_SHORT] = vm_mult_short, [OP_MULT_HWORD] = vm_mult_hword, [OP_MULT_WORD] = vm_mult_word, };