oreodave/avm
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactor type word -> word_t

Browse Source
This commit is contained in:
Aryadev Chavali
2024-04-25 11:07:37 +05:30
parent 9c0125542e
commit 43d14d05cf
9 changed files with 82 additions and 84 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
lib/base.c
View File

@@ -22,7 +22,7 @@ union hword_pun
union word_pun union word_pun
{ {
word h; word_t h;
byte_t bytes[WORD_SIZE]; byte_t bytes[WORD_SIZE];
}; };
@@ -52,7 +52,7 @@ hword_t hword_bctoh(hword_t w)
#endif #endif
} }
word word_htobc(word w) word_t word_htobc(word_t w)
{ {
#if __LITTLE_ENDIAN__ #if __LITTLE_ENDIAN__
return w; return w;
@@ -65,7 +65,7 @@ word word_htobc(word w)
#endif #endif
} }
word word_bctoh(word w) word_t word_bctoh(word_t w)
{ {
#if __LITTLE_ENDIAN__ #if __LITTLE_ENDIAN__
return w; return w;
@@ -92,16 +92,16 @@ void convert_hword_to_bytes(hword_t w, byte_t *bytes)
memcpy(bytes, &be_h, HWORD_SIZE); memcpy(bytes, &be_h, HWORD_SIZE);
} }
void convert_word_to_bytes(word w, byte_t *bytes) void convert_word_to_bytes(word_t w, byte_t *bytes)
{ {
word be_w = word_htobc(w); word_t be_w = word_htobc(w);
memcpy(bytes, &be_w, WORD_SIZE); memcpy(bytes, &be_w, WORD_SIZE);
} }
word convert_bytes_to_word(byte_t *bytes) word_t convert_bytes_to_word(byte_t *bytes)
{ {
word be_w = 0; word_t be_w = 0;
memcpy(&be_w, bytes, WORD_SIZE); memcpy(&be_w, bytes, WORD_SIZE);
word w = word_bctoh(be_w); word_t w = word_bctoh(be_w);
return w; return w;
} }

20
lib/base.h
View File

@@ -46,15 +46,13 @@ typedef double f64;
typedef u8 byte_t; typedef u8 byte_t;
typedef i8 char8_t; typedef i8 char8_t;
typedef u32 hword_t; typedef u32 hword_t;
typedef i32 s_hword; typedef i32 int_t;
typedef u64 word; typedef u64 word_t;
typedef i64 s_word; typedef i64 s_word;
/* Macros for the sizes of common base data types. */ /* Macros for the sizes of common base data types. */
#define HWORD_SIZE sizeof(hword_t) #define HWORD_SIZE sizeof(hword_t)
#define SHWORD_SIZE sizeof(s_hword) #define WORD_SIZE sizeof(word_t)
#define WORD_SIZE sizeof(word)
#define SWORD_SIZE sizeof(s_word)
/** Union for all basic data types in the virtual machine. /** Union for all basic data types in the virtual machine.
*/ */
@@ -63,8 +61,8 @@ typedef union
byte_t as_byte; byte_t as_byte;
char8_t as_char; char8_t as_char;
hword_t as_hword; hword_t as_hword;
s_hword as_int; int_t as_int;
word as_word; word_t as_word;
s_word as_long; s_word as_long;
} data_t; } data_t;
@@ -119,14 +117,14 @@ void convert_hword_to_bytes(hword_t h, byte_t *buffer);
* format (big endian) and that they are at least WORD_SIZE in * format (big endian) and that they are at least WORD_SIZE in
* size. * size.
*/ */
word convert_bytes_to_word(byte_t *); word_t convert_bytes_to_word(byte_t *);
/** Convert a word into a VM byte code format bytes (big endian) /** Convert a word into a VM byte code format bytes (big endian)
* @param w: Word to convert * @param w: Word to convert
* @param buffer: Buffer to store into. We assume the buffer has at * @param buffer: Buffer to store into. We assume the buffer has at
* least WORD_SIZE space. * least WORD_SIZE space.
*/ */
void convert_word_to_bytes(word w, byte_t *buffer); void convert_word_to_bytes(word_t w, byte_t *buffer);
/** Convert a half word into bytecode format (little endian) /** Convert a half word into bytecode format (little endian)
*/ */
@@ -139,10 +137,10 @@ hword_t hword_bctoh(hword_t);
/** Convert a word into bytecode format (little endian) /** Convert a word into bytecode format (little endian)
*/ */
word word_htobc(word); word_t word_htobc(word_t);
/** Convert a word in bytecode format (little endian) to host format /** Convert a word in bytecode format (little endian) to host format
*/ */
word word_bctoh(word); word_t word_bctoh(word_t);
#endif #endif

12
lib/inst.c
View File

@@ -370,7 +370,7 @@ data_t read_type_from_darr(darr_t *darr, data_type_t type)
if (darr->used + WORD_SIZE > darr->available) if (darr->used + WORD_SIZE > darr->available)
// TODO: Error (darr has no space left) // TODO: Error (darr has no space left)
return DWORD(0); return DWORD(0);
word w = convert_bytes_to_word(darr->data + darr->used); word_t w = convert_bytes_to_word(darr->data + darr->used);
darr->used += WORD_SIZE; darr->used += WORD_SIZE;
return DWORD(w); return DWORD(w);
break; break;
@@ -446,9 +446,9 @@ static_assert(sizeof(prog_t) == WORD_SIZE * 2,
void prog_write_bytecode(prog_t *program, darr_t *buffer) void prog_write_bytecode(prog_t *program, darr_t *buffer)
{ {
// Write program header i.e. the start and count // Write program header i.e. the start and count
word start = word_htobc(program->start_address); word_t start = word_htobc(program->start_address);
darr_append_bytes(buffer, (byte_t *)&start, sizeof(start)); darr_append_bytes(buffer, (byte_t *)&start, sizeof(start));
word count = word_htobc(program->count); word_t count = word_htobc(program->count);
darr_append_bytes(buffer, (byte_t *)&count, sizeof(count)); darr_append_bytes(buffer, (byte_t *)&count, sizeof(count));
// Write instructions // Write instructions
@@ -466,10 +466,10 @@ prog_t *prog_read_bytecode(darr_t *buffer)
if ((buffer->available - buffer->used) < sizeof(prog_t)) if ((buffer->available - buffer->used) < sizeof(prog_t))
return NULL; return NULL;
// Read program header // Read program header
word start_address = convert_bytes_to_word(buffer->data + buffer->used); word_t start_address = convert_bytes_to_word(buffer->data + buffer->used);
buffer->used += sizeof(start_address); buffer->used += sizeof(start_address);
word count = convert_bytes_to_word(buffer->data + buffer->used); word_t count = convert_bytes_to_word(buffer->data + buffer->used);
buffer->used += sizeof(word); buffer->used += sizeof(word_t);
// TODO: Error (not enough space for program instruction count) // TODO: Error (not enough space for program instruction count)
if ((buffer->available - buffer->used) < WORD_SIZE) if ((buffer->available - buffer->used) < WORD_SIZE)

4
lib/prog.h
View File

@@ -165,8 +165,8 @@ typedef struct
typedef struct typedef struct
{ {
word start_address; word_t start_address;
word count; word_t count;
inst_t instructions[]; inst_t instructions[];
} prog_t; } prog_t;

2
vm/main.c
View File

@@ -58,7 +58,7 @@ int main(int argc, char *argv[])
heap_t heap = {0}; heap_t heap = {0};
heap_create(&heap); heap_create(&heap);
size_t call_stack_size = 256; size_t call_stack_size = 256;
word *call_stack = calloc(call_stack_size, sizeof(call_stack)); word_t *call_stack = calloc(call_stack_size, sizeof(call_stack));
vm_t vm = {0}; vm_t vm = {0};
vm_load_stack(&vm, stack, stack_size); vm_load_stack(&vm, stack, stack_size);

54
vm/runtime.c
View File

@@ -181,7 +181,7 @@ err_t vm_execute(vm_t *vm)
{ {
if (vm->call_stack.ptr == 0) if (vm->call_stack.ptr == 0)
return ERR_CALL_STACK_UNDERFLOW; return ERR_CALL_STACK_UNDERFLOW;
word addr = vm->call_stack.address_pointers[vm->call_stack.ptr - 1]; word_t addr = vm->call_stack.address_pointers[vm->call_stack.ptr - 1];
err_t err = vm_jump(vm, vm->call_stack.address_pointers[addr]); err_t err = vm_jump(vm, vm->call_stack.address_pointers[addr]);
if (err) if (err)
return err; return err;
@@ -324,7 +324,7 @@ err_t vm_execute_all(vm_t *vm)
return err; return err;
} }
err_t vm_jump(vm_t *vm, word w) err_t vm_jump(vm_t *vm, word_t w)
{ {
if (w >= vm->program.data->count) if (w >= vm->program.data->count)
return ERR_INVALID_PROGRAM_ADDRESS; return ERR_INVALID_PROGRAM_ADDRESS;
@@ -372,7 +372,7 @@ err_t vm_push_word(vm_t *vm, data_t w)
return ERR_OK; return ERR_OK;
} }
err_t vm_push_byte_register(vm_t *vm, word reg) err_t vm_push_byte_register(vm_t *vm, word_t reg)
{ {
if (reg > vm->registers.used) if (reg > vm->registers.used)
return ERR_INVALID_REGISTER_BYTE; return ERR_INVALID_REGISTER_BYTE;
@@ -383,7 +383,7 @@ err_t vm_push_byte_register(vm_t *vm, word reg)
return vm_push_byte(vm, DBYTE(b)); return vm_push_byte(vm, DBYTE(b));
} }
err_t vm_push_hword_register(vm_t *vm, word reg) err_t vm_push_hword_register(vm_t *vm, word_t reg)
{ {
if (reg > (vm->registers.used / HWORD_SIZE)) if (reg > (vm->registers.used / HWORD_SIZE))
return ERR_INVALID_REGISTER_HWORD; return ERR_INVALID_REGISTER_HWORD;
@@ -392,14 +392,14 @@ err_t vm_push_hword_register(vm_t *vm, word reg)
return vm_push_hword(vm, DHWORD(hw)); return vm_push_hword(vm, DHWORD(hw));
} }
err_t vm_push_word_register(vm_t *vm, word reg) err_t vm_push_word_register(vm_t *vm, word_t reg)
{ {
if (reg > (vm->registers.used / WORD_SIZE)) if (reg > (vm->registers.used / WORD_SIZE))
return ERR_INVALID_REGISTER_WORD; return ERR_INVALID_REGISTER_WORD;
return vm_push_word(vm, DWORD(VM_NTH_REGISTER(vm->registers, reg))); return vm_push_word(vm, DWORD(VM_NTH_REGISTER(vm->registers, reg)));
} }
err_t vm_mov_byte(vm_t *vm, word reg) err_t vm_mov_byte(vm_t *vm, word_t reg)
{ {
if (reg >= vm->registers.used) if (reg >= vm->registers.used)
{ {
@@ -415,7 +415,7 @@ err_t vm_mov_byte(vm_t *vm, word reg)
return ERR_OK; return ERR_OK;
} }
err_t vm_mov_hword(vm_t *vm, word reg) err_t vm_mov_hword(vm_t *vm, word_t reg)
{ {
if (reg >= (vm->registers.used / HWORD_SIZE)) if (reg >= (vm->registers.used / HWORD_SIZE))
{ {
@@ -440,7 +440,7 @@ err_t vm_mov_hword(vm_t *vm, word reg)
return ERR_OK; return ERR_OK;
} }
err_t vm_mov_word(vm_t *vm, word reg) err_t vm_mov_word(vm_t *vm, word_t reg)
{ {
if (reg >= (vm->registers.used / WORD_SIZE)) if (reg >= (vm->registers.used / WORD_SIZE))
{ {
@@ -452,24 +452,24 @@ err_t vm_mov_word(vm_t *vm, word reg)
darr_ensure_capacity(&vm->registers, diff); darr_ensure_capacity(&vm->registers, diff);
vm->registers.used = MAX(vm->registers.used, (reg + 1) * WORD_SIZE); vm->registers.used = MAX(vm->registers.used, (reg + 1) * WORD_SIZE);
} }
else if (vm->stack.ptr < sizeof(word)) else if (vm->stack.ptr < WORD_SIZE)
return ERR_STACK_UNDERFLOW; return ERR_STACK_UNDERFLOW;
data_t ret = {0}; data_t ret = {0};
err_t err = vm_pop_word(vm, &ret); err_t err = vm_pop_word(vm, &ret);
if (err) if (err)
return err; return err;
((word *)(vm->registers.data))[reg] = ret.as_word; ((word_t *)(vm->registers.data))[reg] = ret.as_word;
return ERR_OK; return ERR_OK;
} }
err_t vm_dup_byte(vm_t *vm, word w) err_t vm_dup_byte(vm_t *vm, word_t w)
{ {
if (vm->stack.ptr < w + 1) if (vm->stack.ptr < w + 1)
return ERR_STACK_UNDERFLOW; return ERR_STACK_UNDERFLOW;
return vm_push_byte(vm, DBYTE(vm->stack.data[vm->stack.ptr - 1 - w])); return vm_push_byte(vm, DBYTE(vm->stack.data[vm->stack.ptr - 1 - w]));
} }
err_t vm_dup_hword(vm_t *vm, word w) err_t vm_dup_hword(vm_t *vm, word_t w)
{ {
if (vm->stack.ptr < HWORD_SIZE * (w + 1)) if (vm->stack.ptr < HWORD_SIZE * (w + 1))
return ERR_STACK_UNDERFLOW; return ERR_STACK_UNDERFLOW;
@@ -480,7 +480,7 @@ err_t vm_dup_hword(vm_t *vm, word w)
return vm_push_hword(vm, DHWORD(convert_bytes_to_hword(bytes))); return vm_push_hword(vm, DHWORD(convert_bytes_to_hword(bytes)));
} }
err_t vm_dup_word(vm_t *vm, word w) err_t vm_dup_word(vm_t *vm, word_t w)
{ {
if (vm->stack.ptr < WORD_SIZE * (w + 1)) if (vm->stack.ptr < WORD_SIZE * (w + 1))
return ERR_STACK_UNDERFLOW; return ERR_STACK_UNDERFLOW;
@@ -491,25 +491,25 @@ err_t vm_dup_word(vm_t *vm, word w)
return vm_push_word(vm, DWORD(convert_bytes_to_word(bytes))); return vm_push_word(vm, DWORD(convert_bytes_to_word(bytes)));
} }
err_t vm_malloc_byte(vm_t *vm, word n) err_t vm_malloc_byte(vm_t *vm, word_t n)
{ {
page_t *page = heap_allocate(&vm->heap, n); page_t *page = heap_allocate(&vm->heap, n);
return vm_push_word(vm, DWORD((word)page)); return vm_push_word(vm, DWORD((word_t)page));
} }
err_t vm_malloc_hword(vm_t *vm, word n) err_t vm_malloc_hword(vm_t *vm, word_t n)
{ {
page_t *page = heap_allocate(&vm->heap, n * HWORD_SIZE); page_t *page = heap_allocate(&vm->heap, n * HWORD_SIZE);
return vm_push_word(vm, DWORD((word)page)); return vm_push_word(vm, DWORD((word_t)page));
} }
err_t vm_malloc_word(vm_t *vm, word n) err_t vm_malloc_word(vm_t *vm, word_t n)
{ {
page_t *page = heap_allocate(&vm->heap, n * WORD_SIZE); page_t *page = heap_allocate(&vm->heap, n * WORD_SIZE);
return vm_push_word(vm, DWORD((word)page)); return vm_push_word(vm, DWORD((word_t)page));
} }
err_t vm_mset_byte(vm_t *vm, word nth) err_t vm_mset_byte(vm_t *vm, word_t nth)
{ {
// Stack layout should be [BYTE, PTR] // Stack layout should be [BYTE, PTR]
data_t byte = {0}; data_t byte = {0};
@@ -529,7 +529,7 @@ err_t vm_mset_byte(vm_t *vm, word nth)
return ERR_OK; return ERR_OK;
} }
err_t vm_mset_hword(vm_t *vm, word nth) err_t vm_mset_hword(vm_t *vm, word_t nth)
{ {
// Stack layout should be [HWORD, PTR] // Stack layout should be [HWORD, PTR]
data_t byte = {0}; data_t byte = {0};
@@ -549,7 +549,7 @@ err_t vm_mset_hword(vm_t *vm, word nth)
return ERR_OK; return ERR_OK;
} }
err_t vm_mset_word(vm_t *vm, word nth) err_t vm_mset_word(vm_t *vm, word_t nth)
{ {
// Stack layout should be [WORD, PTR] // Stack layout should be [WORD, PTR]
data_t byte = {0}; data_t byte = {0};
@@ -564,12 +564,12 @@ err_t vm_mset_word(vm_t *vm, word nth)
page_t *page = (page_t *)ptr.as_word; page_t *page = (page_t *)ptr.as_word;
if (nth >= (page->available / WORD_SIZE)) if (nth >= (page->available / WORD_SIZE))
return ERR_OUT_OF_BOUNDS; return ERR_OUT_OF_BOUNDS;
((word *)page->data)[nth] = byte.as_word; ((word_t *)page->data)[nth] = byte.as_word;
return ERR_OK; return ERR_OK;
} }
err_t vm_mget_byte(vm_t *vm, word n) err_t vm_mget_byte(vm_t *vm, word_t n)
{ {
// Stack layout should be [PTR] // Stack layout should be [PTR]
data_t ptr = {0}; data_t ptr = {0};
@@ -582,7 +582,7 @@ err_t vm_mget_byte(vm_t *vm, word n)
return vm_push_byte(vm, DBYTE(page->data[n])); return vm_push_byte(vm, DBYTE(page->data[n]));
} }
err_t vm_mget_hword(vm_t *vm, word n) err_t vm_mget_hword(vm_t *vm, word_t n)
{ {
// Stack layout should be [PTR] // Stack layout should be [PTR]
data_t ptr = {0}; data_t ptr = {0};
@@ -595,7 +595,7 @@ err_t vm_mget_hword(vm_t *vm, word n)
return vm_push_hword(vm, DHWORD(((hword_t *)page->data)[n])); return vm_push_hword(vm, DHWORD(((hword_t *)page->data)[n]));
} }
err_t vm_mget_word(vm_t *vm, word n) err_t vm_mget_word(vm_t *vm, word_t n)
{ {
// Stack layout should be [PTR] // Stack layout should be [PTR]
data_t ptr = {0}; data_t ptr = {0};
@@ -606,7 +606,7 @@ err_t vm_mget_word(vm_t *vm, word n)
page_t *page = (page_t *)ptr.as_word; page_t *page = (page_t *)ptr.as_word;
if (n >= (page->available / WORD_SIZE)) if (n >= (page->available / WORD_SIZE))
return ERR_OUT_OF_BOUNDS; return ERR_OUT_OF_BOUNDS;
return vm_push_word(vm, DWORD(((word *)page->data)[n])); return vm_push_word(vm, DWORD(((word_t *)page->data)[n]));
} }
err_t vm_pop_byte(vm_t *vm, data_t *ret) err_t vm_pop_byte(vm_t *vm, data_t *ret)

40
vm/runtime.h
View File

@@ -43,7 +43,7 @@ const char *err_as_cstr(err_t);
err_t vm_execute(vm_t *); err_t vm_execute(vm_t *);
err_t vm_execute_all(vm_t *); err_t vm_execute_all(vm_t *);
err_t vm_jump(vm_t *, word); err_t vm_jump(vm_t *, word_t);
err_t vm_pop_byte(vm_t *, data_t *); err_t vm_pop_byte(vm_t *, data_t *);
err_t vm_pop_hword(vm_t *, data_t *); err_t vm_pop_hword(vm_t *, data_t *);
@@ -68,31 +68,31 @@ static const push_f PUSH_ROUTINES[] = {
}; };
/* Operations that have input determined at deserializing i.e. */ /* Operations that have input determined at deserializing i.e. */
err_t vm_push_byte_register(vm_t *, word); err_t vm_push_byte_register(vm_t *, word_t);
err_t vm_push_hword_register(vm_t *, word); err_t vm_push_hword_register(vm_t *, word_t);
err_t vm_push_word_register(vm_t *, word); err_t vm_push_word_register(vm_t *, word_t);
err_t vm_mov_byte(vm_t *, word); err_t vm_mov_byte(vm_t *, word_t);
err_t vm_mov_hword(vm_t *, word); err_t vm_mov_hword(vm_t *, word_t);
err_t vm_mov_word(vm_t *, word); err_t vm_mov_word(vm_t *, word_t);
err_t vm_dup_byte(vm_t *, word); err_t vm_dup_byte(vm_t *, word_t);
err_t vm_dup_hword(vm_t *, word); err_t vm_dup_hword(vm_t *, word_t);
err_t vm_dup_word(vm_t *, word); err_t vm_dup_word(vm_t *, word_t);
err_t vm_malloc_byte(vm_t *, word); err_t vm_malloc_byte(vm_t *, word_t);
err_t vm_malloc_hword(vm_t *, word); err_t vm_malloc_hword(vm_t *, word_t);
err_t vm_malloc_word(vm_t *, word); err_t vm_malloc_word(vm_t *, word_t);
err_t vm_mset_byte(vm_t *, word); err_t vm_mset_byte(vm_t *, word_t);
err_t vm_mset_hword(vm_t *, word); err_t vm_mset_hword(vm_t *, word_t);
err_t vm_mset_word(vm_t *, word); err_t vm_mset_word(vm_t *, word_t);
err_t vm_mget_byte(vm_t *, word); err_t vm_mget_byte(vm_t *, word_t);
err_t vm_mget_hword(vm_t *, word); err_t vm_mget_hword(vm_t *, word_t);
err_t vm_mget_word(vm_t *, word); err_t vm_mget_word(vm_t *, word_t);
typedef err_t (*word_f)(vm_t *, word); typedef err_t (*word_f)(vm_t *, word_t);
static const word_f WORD_ROUTINES[] = { static const word_f WORD_ROUTINES[] = {
[OP_PUSH_REGISTER_BYTE] = vm_push_byte_register, [OP_PUSH_REGISTER_BYTE] = vm_push_byte_register,
[OP_PUSH_REGISTER_HWORD] = vm_push_hword_register, [OP_PUSH_REGISTER_HWORD] = vm_push_hword_register,

6
vm/struct.c
View File

@@ -38,7 +38,7 @@ void vm_load_heap(vm_t *vm, heap_t heap)
vm->heap = heap; vm->heap = heap;
} }
void vm_load_call_stack(vm_t *vm, word *buffer, size_t size) void vm_load_call_stack(vm_t *vm, word_t *buffer, size_t size)
{ {
vm->call_stack = vm->call_stack =
(struct CallStack){.address_pointers = buffer, .ptr = 0, .max = size}; (struct CallStack){.address_pointers = buffer, .ptr = 0, .max = size};
@@ -58,7 +58,7 @@ void vm_stop(vm_t *vm)
vm->call_stack.ptr); vm->call_stack.ptr);
for (size_t i = vm->call_stack.ptr; i > 0; --i) for (size_t i = vm->call_stack.ptr; i > 0; --i)
{ {
word w = vm->call_stack.address_pointers[i - 1]; word_t w = vm->call_stack.address_pointers[i - 1];
printf("\t\t%lu: %lX", vm->call_stack.ptr - i, w); printf("\t\t%lu: %lX", vm->call_stack.ptr - i, w);
if (i != 1) if (i != 1)
printf(", "); printf(", ");
@@ -225,7 +225,7 @@ void vm_print_call_stack(vm_t *vm, FILE *fp)
printf("\n"); printf("\n");
for (size_t i = cs.ptr; i > 0; --i) for (size_t i = cs.ptr; i > 0; --i)
{ {
word w = cs.address_pointers[i - 1]; word_t w = cs.address_pointers[i - 1];
fprintf(fp, "\t%lu: %lX", cs.ptr - i, w); fprintf(fp, "\t%lu: %lX", cs.ptr - i, w);
if (i != 1) if (i != 1)
fprintf(fp, ", "); fprintf(fp, ", ");

8
vm/struct.h
View File

@@ -18,7 +18,7 @@
#include <lib/inst.h> #include <lib/inst.h>
typedef darr_t registers_t; typedef darr_t registers_t;
#define VM_NTH_REGISTER(REGISTERS, N) (((word *)((REGISTERS).data))[N]) #define VM_NTH_REGISTER(REGISTERS, N) (((word_t *)((REGISTERS).data))[N])
#define VM_REGISTERS_AVAILABLE(REGISTERS) (((REGISTERS).available) / WORD_SIZE) #define VM_REGISTERS_AVAILABLE(REGISTERS) (((REGISTERS).available) / WORD_SIZE)
struct Stack struct Stack
@@ -30,12 +30,12 @@ struct Stack
struct Program struct Program
{ {
prog_t *data; prog_t *data;
word ptr; word_t ptr;
}; };
struct CallStack struct CallStack
{ {
word *address_pointers; word_t *address_pointers;
size_t ptr, max; size_t ptr, max;
}; };
@@ -54,7 +54,7 @@ void vm_load_stack(vm_t *, byte_t *, size_t);
void vm_load_registers(vm_t *, registers_t); void vm_load_registers(vm_t *, registers_t);
void vm_load_heap(vm_t *, heap_t); void vm_load_heap(vm_t *, heap_t);
void vm_load_program(vm_t *, prog_t *); void vm_load_program(vm_t *, prog_t *);
void vm_load_call_stack(vm_t *, word *, size_t); void vm_load_call_stack(vm_t *, word_t *, size_t);
void vm_stop(vm_t *); void vm_stop(vm_t *);
// Printing the VM // Printing the VM