Switched from floats to halfword

Registers are now just words, with pushing from and moving to
registers with specified subtypes just pushing those types into the
word registers.  That means there are 8 word registers which can act
as 16 half word registers, which themselves can act as 64 byte
registers.

1 files changed, 54 insertions, 80 deletions

diff --git a/src/inst.c b/src/inst.c
index 26f7fa5..d7edd94 100644
--- a/src/inst.c
+++ b/src/inst.c
@@ -29,17 +29,17 @@ const char *opcode_as_cstr(opcode_t code)
   case OP_PUSH_WORD:
     return "PUSH_WORD";
     break;
-  case OP_PUSH_FLOAT:
-    return "PUSH_FLOAT";
+  case OP_PUSH_HWORD:
+    return "PUSH_HWORD";
     break;
-  case OP_PUSH_BYTE_REGISTER:
-    return "PUSH_BYTE_REGISTER";
+  case OP_PUSH_REGISTER_BYTE:
+    return "PUSH_REGISTER_BYTE";
     break;
-  case OP_PUSH_WORD_REGISTER:
-    return "PUSH_WORD_REGISTER";
+  case OP_PUSH_REGISTER_WORD:
+    return "PUSH_REGISTER_WORD";
     break;
-  case OP_PUSH_FLOAT_REGISTER:
-    return "PUSH_FLOAT_REGISTER";
+  case OP_PUSH_REGISTER_HWORD:
+    return "PUSH_REGISTER_HWORD";
     break;
   case OP_POP_BYTE:
     return "POP_BYTE";
@@ -47,8 +47,8 @@ const char *opcode_as_cstr(opcode_t code)
   case OP_POP_WORD:
     return "POP_WORD";
     break;
-  case OP_POP_FLOAT:
-    return "POP_FLOAT";
+  case OP_POP_HWORD:
+    return "POP_HWORD";
     break;
   case OP_MOV_BYTE:
     return "MOV_BYTE";
@@ -56,8 +56,8 @@ const char *opcode_as_cstr(opcode_t code)
   case OP_MOV_WORD:
     return "MOV_WORD";
     break;
-  case OP_MOV_FLOAT:
-    return "MOV_FLOAT";
+  case OP_MOV_HWORD:
+    return "MOV_HWORD";
     break;
   case OP_HALT:
     return "HALT";
@@ -66,24 +66,6 @@ const char *opcode_as_cstr(opcode_t code)
   return "";
 }
 
-const char *opcode_type_as_cstr(opcode_type_t type)
-{
-  switch (type)
-  {
-  case OP_TYPE_PUSH:
-    return "TYPE_PUSH";
-  case OP_TYPE_PUSH_REGISTER:
-    return "TYPE_PUSH_REGISTER";
-  case OP_TYPE_POP:
-    return "TYPE_POP";
-  case OP_TYPE_MOV:
-    return "TYPE_MOV";
-  case OP_TYPE_HALT:
-    return "TYPE_HALT";
-  }
-  return "";
-}
-
 void data_print(data_t datum, data_type_t type, FILE *fp)
 {
   switch (type)
@@ -93,25 +75,25 @@ void data_print(data_t datum, data_type_t type, FILE *fp)
   case DATA_TYPE_BYTE:
     fprintf(fp, "%X", datum.as_byte);
     break;
+  case DATA_TYPE_HWORD:
+    fprintf(fp, "%d", datum.as_hword);
+    break;
   case DATA_TYPE_WORD:
     fprintf(fp, "%lX", datum.as_word);
     break;
-  case DATA_TYPE_FLOAT:
-    fprintf(fp, "%f", datum.as_float);
-    break;
   }
 }
 
 data_type_t get_opcode_data_type(opcode_t opcode)
 {
   data_type_t type = DATA_TYPE_NIL;
-  if (OPCODE_IS_TYPE(opcode, OP_TYPE_PUSH))
+  if (OPCODE_IS_TYPE(opcode, OP_PUSH))
     type = (data_type_t)opcode;
-  else if (OPCODE_IS_TYPE(opcode, OP_TYPE_PUSH_REGISTER))
+  else if (OPCODE_IS_TYPE(opcode, OP_PUSH_REGISTER))
     type = opcode >> 1;
-  else if (OPCODE_IS_TYPE(opcode, OP_TYPE_POP))
+  else if (OPCODE_IS_TYPE(opcode, OP_POP))
     type = opcode >> 2;
-  else if (OPCODE_IS_TYPE(opcode, OP_TYPE_MOV))
+  else if (OPCODE_IS_TYPE(opcode, OP_MOV))
     type = opcode >> 3;
   return type;
 }
@@ -119,16 +101,16 @@ data_type_t get_opcode_data_type(opcode_t opcode)
 void inst_print(inst_t instruction, FILE *fp)
 {
   fprintf(fp, "(%s", opcode_as_cstr(instruction.opcode));
-  if (OPCODE_IS_TYPE(instruction.opcode, OP_TYPE_PUSH))
+  if (OPCODE_IS_TYPE(instruction.opcode, OP_PUSH))
   {
     data_type_t type = get_opcode_data_type(instruction.opcode);
-    fprintf(fp, ", datum=");
+    fprintf(fp, ", datum=0x");
     data_print(instruction.operand, type, fp);
   }
-  else if (OPCODE_IS_TYPE(instruction.opcode, OP_TYPE_PUSH_REGISTER) ||
-           OPCODE_IS_TYPE(instruction.opcode, OP_TYPE_MOV))
+  else if (OPCODE_IS_TYPE(instruction.opcode, OP_PUSH_REGISTER) ||
+           OPCODE_IS_TYPE(instruction.opcode, OP_MOV))
   {
-    fprintf(fp, ", reg=");
+    fprintf(fp, ", reg=0x");
     data_print(instruction.operand, DATA_TYPE_BYTE, fp);
   }
   fprintf(fp, ")");
@@ -137,32 +119,22 @@ void inst_print(inst_t instruction, FILE *fp)
 size_t inst_bytecode_size(inst_t inst)
 {
   size_t size = 1; // for opcode
-  if (OPCODE_IS_TYPE(inst.opcode, OP_TYPE_PUSH))
+  if (OPCODE_IS_TYPE(inst.opcode, OP_PUSH))
   {
     if (inst.opcode == OP_PUSH_BYTE)
       ++size;
+    else if (inst.opcode == OP_PUSH_HWORD)
+      size += sizeof(i32);
     else if (inst.opcode == OP_PUSH_WORD)
       size += sizeof(word);
-    else if (inst.opcode == OP_PUSH_FLOAT)
-      size += sizeof(f64);
   }
-  else if (OPCODE_IS_TYPE(inst.opcode, OP_TYPE_PUSH_REGISTER))
+  else if (OPCODE_IS_TYPE(inst.opcode, OP_PUSH_REGISTER) ||
+           OPCODE_IS_TYPE(inst.opcode, OP_MOV))
+    // Only need a byte for the register
     ++size;
-  else if (OPCODE_IS_TYPE(inst.opcode, OP_TYPE_POP))
-  {
-    // No operand or register so leave as is
-  }
-  else if (OPCODE_IS_TYPE(inst.opcode, OP_TYPE_MOV))
-  {
-    if (inst.opcode == OP_MOV_BYTE)
-      ++size;
-    else if (inst.opcode == OP_MOV_WORD)
-      size += sizeof(word);
-    else if (inst.opcode == OP_MOV_FLOAT)
-      size += sizeof(f64);
-    // For the register
-    ++size;
-  }
+  else if (OPCODE_IS_TYPE(inst.opcode, OP_POP))
+  // No operand or register so leave as is
+  {}
   return size;
 }
 
@@ -172,10 +144,10 @@ void inst_write_bytecode(inst_t inst, darr_t *darr)
   darr_append_byte(darr, inst.opcode);
   // Then append 0 or more operands
   data_type_t to_append = DATA_TYPE_NIL;
-  if (OPCODE_IS_TYPE(inst.opcode, OP_TYPE_PUSH))
+  if (OPCODE_IS_TYPE(inst.opcode, OP_PUSH))
     to_append = (data_type_t)inst.opcode;
-  else if (OPCODE_IS_TYPE(inst.opcode, OP_TYPE_PUSH_REGISTER) ||
-           OPCODE_IS_TYPE(inst.opcode, OP_TYPE_MOV))
+  else if (OPCODE_IS_TYPE(inst.opcode, OP_PUSH_REGISTER) ||
+           OPCODE_IS_TYPE(inst.opcode, OP_MOV))
     to_append = DATA_TYPE_BYTE;
 
   switch (to_append)
@@ -185,11 +157,13 @@ void inst_write_bytecode(inst_t inst, darr_t *darr)
   case DATA_TYPE_BYTE:
     darr_append_byte(darr, inst.operand.as_byte);
     break;
-  case DATA_TYPE_WORD:
-    darr_append_bytes(darr, (byte *)&inst.operand.as_word, sizeof(word));
+  case DATA_TYPE_HWORD:
+    darr_append_bytes(darr, (byte *)&inst.operand.as_hword,
+                      sizeof(inst.operand.as_hword));
     break;
-  case DATA_TYPE_FLOAT:
-    darr_append_bytes(darr, (byte *)&inst.operand.as_float, sizeof(f64));
+  case DATA_TYPE_WORD:
+    darr_append_bytes(darr, (byte *)&inst.operand.as_word,
+                      sizeof(inst.operand.as_word));
     break;
   }
 }
@@ -206,6 +180,15 @@ data_t read_type_from_darr(darr_t *darr, data_type_t type)
       return DBYTE(0);
     return DBYTE(darr->data[darr->used++]);
     break;
+  case DATA_TYPE_HWORD:
+    if (darr->used + HWORD_SIZE >= darr->available)
+      // TODO: Error (darr has no space left)
+      return DWORD(0);
+    hword u = 0;
+    memcpy(&u, darr->data + darr->used, sizeof(u));
+    darr->used += sizeof(u);
+    return DHWORD(u);
+    break;
   case DATA_TYPE_WORD:
     if (darr->used + sizeof(word) >= darr->available)
       // TODO: Error (darr has no space left)
@@ -215,15 +198,6 @@ data_t read_type_from_darr(darr_t *darr, data_type_t type)
     darr->used += sizeof(w);
     return DWORD(w);
     break;
-  case DATA_TYPE_FLOAT:
-    if (darr->used + sizeof(word) >= darr->available)
-      // TODO: Error (darr has no space left)
-      return DWORD(0);
-    f64 f = 0;
-    memcpy(&f, darr->data + darr->used, sizeof(f));
-    darr->used += sizeof(f);
-    return DFLOAT(f);
-    break;
   }
   // TODO: Error (unrecognised type)
   return DBYTE(0);
@@ -239,11 +213,11 @@ inst_t inst_read_bytecode(darr_t *darr)
     // Translate to NOOP
     return inst;
   // Read operands
-  if (OPCODE_IS_TYPE(opcode, OP_TYPE_PUSH))
+  if (OPCODE_IS_TYPE(opcode, OP_PUSH))
     inst.operand = read_type_from_darr(darr, get_opcode_data_type(opcode));
   // Read register (as a byte)
-  else if (OPCODE_IS_TYPE(opcode, OP_TYPE_PUSH_REGISTER) ||
-           OPCODE_IS_TYPE(opcode, OP_TYPE_MOV))
+  else if (OPCODE_IS_TYPE(opcode, OP_PUSH_REGISTER) ||
+           OPCODE_IS_TYPE(opcode, OP_MOV))
     inst.operand = read_type_from_darr(darr, DATA_TYPE_BYTE);
   // Otherwise opcode doesn't take operands