Refactor type word -> word_t

lib/base.c

@@ -22,7 +22,7 @@ union hword_pun
 
 union word_pun
 {
-  word h;
+  word_t h;
   byte_t bytes[WORD_SIZE];
 };
 
@@ -52,7 +52,7 @@ hword_t hword_bctoh(hword_t w)
 #endif
 }
 
-word word_htobc(word w)
+word_t word_htobc(word_t w)
 {
 #if __LITTLE_ENDIAN__
   return w;
@@ -65,7 +65,7 @@ word word_htobc(word w)
 #endif
 }
 
-word word_bctoh(word w)
+word_t word_bctoh(word_t w)
 {
 #if __LITTLE_ENDIAN__
   return w;
@@ -92,16 +92,16 @@ void convert_hword_to_bytes(hword_t w, byte_t *bytes)
   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);
 }
 
-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);
-  word w = word_bctoh(be_w);
+  word_t w = word_bctoh(be_w);
   return w;
 }

lib/base.h

@@ -46,15 +46,13 @@ typedef double f64;
 typedef u8 byte_t;
 typedef i8 char8_t;
 typedef u32 hword_t;
-typedef i32 s_hword;
-typedef u64 word;
+typedef i32 int_t;
+typedef u64 word_t;
 typedef i64 s_word;
 
 /* Macros for the sizes of common base data types. */
-#define HWORD_SIZE  sizeof(hword_t)
-#define SHWORD_SIZE sizeof(s_hword)
-#define WORD_SIZE   sizeof(word)
-#define SWORD_SIZE  sizeof(s_word)
+#define HWORD_SIZE sizeof(hword_t)
+#define WORD_SIZE  sizeof(word_t)
 
 /** Union for all basic data types in the virtual machine.
  */
@@ -63,8 +61,8 @@ typedef union
   byte_t as_byte;
   char8_t as_char;
   hword_t as_hword;
-  s_hword as_int;
-  word as_word;
+  int_t as_int;
+  word_t as_word;
   s_word as_long;
 } 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
  * 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)
  * @param w: Word to convert
  * @param buffer: Buffer to store into.  We assume the buffer has at
  * 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)
  */
@@ -139,10 +137,10 @@ hword_t hword_bctoh(hword_t);
 
 /** 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
  */
-word word_bctoh(word);
+word_t word_bctoh(word_t);
 
 #endif

lib/inst.c

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

lib/prog.h

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

vm/main.c

@@ -58,7 +58,7 @@ int main(int argc, char *argv[])
   heap_t heap = {0};
   heap_create(&heap);
   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_load_stack(&vm, stack, stack_size);

vm/runtime.c

@@ -181,8 +181,8 @@ err_t vm_execute(vm_t *vm)
   {
     if (vm->call_stack.ptr == 0)
       return ERR_CALL_STACK_UNDERFLOW;
-    word addr = vm->call_stack.address_pointers[vm->call_stack.ptr - 1];
-    err_t err = vm_jump(vm, vm->call_stack.address_pointers[addr]);
+    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]);
     if (err)
       return err;
 
@@ -324,7 +324,7 @@ err_t vm_execute_all(vm_t *vm)
   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)
     return ERR_INVALID_PROGRAM_ADDRESS;
@@ -372,7 +372,7 @@ err_t vm_push_word(vm_t *vm, data_t w)
   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)
     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));
 }
 
-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))
     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));
 }
 
-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))
     return ERR_INVALID_REGISTER_WORD;
   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)
   {
@@ -415,7 +415,7 @@ err_t vm_mov_byte(vm_t *vm, word reg)
   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))
   {
@@ -440,7 +440,7 @@ err_t vm_mov_hword(vm_t *vm, word reg)
   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))
   {
@@ -452,24 +452,24 @@ err_t vm_mov_word(vm_t *vm, word reg)
     darr_ensure_capacity(&vm->registers, diff);
     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;
   data_t ret = {0};
   err_t err  = vm_pop_word(vm, &ret);
   if (err)
     return err;
-  ((word *)(vm->registers.data))[reg] = ret.as_word;
+  ((word_t *)(vm->registers.data))[reg] = ret.as_word;
   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)
     return ERR_STACK_UNDERFLOW;
   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))
     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)));
 }
 
-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))
     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)));
 }
 
-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);
-  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);
-  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);
-  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]
   data_t byte = {0};
@@ -529,7 +529,7 @@ err_t vm_mset_byte(vm_t *vm, word nth)
   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]
   data_t byte = {0};
@@ -549,7 +549,7 @@ err_t vm_mset_hword(vm_t *vm, word nth)
   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]
   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;
   if (nth >= (page->available / WORD_SIZE))
     return ERR_OUT_OF_BOUNDS;
-  ((word *)page->data)[nth] = byte.as_word;
+  ((word_t *)page->data)[nth] = byte.as_word;
 
   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]
   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]));
 }
 
-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]
   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]));
 }
 
-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]
   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;
   if (n >= (page->available / WORD_SIZE))
     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)

vm/runtime.h

@@ -43,7 +43,7 @@ const char *err_as_cstr(err_t);
 err_t vm_execute(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_hword(vm_t *, data_t *);
@@ -68,31 +68,31 @@ static const push_f PUSH_ROUTINES[] = {
 };
 
 /* Operations that have input determined at deserializing i.e.  */
-err_t vm_push_byte_register(vm_t *, word);
-err_t vm_push_hword_register(vm_t *, word);
-err_t vm_push_word_register(vm_t *, word);
+err_t vm_push_byte_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);
-err_t vm_mov_hword(vm_t *, word);
-err_t vm_mov_word(vm_t *, word);
+err_t vm_mov_byte(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);
-err_t vm_dup_hword(vm_t *, word);
-err_t vm_dup_word(vm_t *, word);
+err_t vm_dup_byte(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);
-err_t vm_malloc_hword(vm_t *, word);
-err_t vm_malloc_word(vm_t *, word);
+err_t vm_malloc_byte(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);
-err_t vm_mset_hword(vm_t *, word);
-err_t vm_mset_word(vm_t *, word);
+err_t vm_mset_byte(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);
-err_t vm_mget_hword(vm_t *, word);
-err_t vm_mget_word(vm_t *, word);
+err_t vm_mget_byte(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);
+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_HWORD] = vm_push_hword_register,

vm/struct.c

@@ -38,7 +38,7 @@ void vm_load_heap(vm_t *vm, heap_t 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 =
       (struct CallStack){.address_pointers = buffer, .ptr = 0, .max = size};
@@ -58,7 +58,7 @@ void vm_stop(vm_t *vm)
            vm->call_stack.ptr);
     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);
       if (i != 1)
         printf(", ");
@@ -225,7 +225,7 @@ void vm_print_call_stack(vm_t *vm, FILE *fp)
   printf("\n");
   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);
     if (i != 1)
       fprintf(fp, ", ");

vm/struct.h

@@ -18,7 +18,7 @@
 #include <lib/inst.h>
 
 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)
 
 struct Stack
@@ -30,12 +30,12 @@ struct Stack
 struct Program
 {
   prog_t *data;
-  word ptr;
+  word_t ptr;
 };
 
 struct CallStack
 {
-  word *address_pointers;
+  word_t *address_pointers;
   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_heap(vm_t *, heap_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 *);
 
 // Printing the VM