register struct update

src/VM/VM.h

@@ -3,28 +3,31 @@
 #include "../string/str.h"
 
 typedef union Register {
-    u32 u32v;
+    u64 u64v;
-    i32 i32v;
+    f64 f64v;
-    f32 f32v;
+    struct {
+        u32 u32v0;
+        u32 u32v1;
+    };
+    struct {
+        f32 f32v0;
+        f32 f32v1;
+    };
     struct { 
         u16 u16v0;
         u16 u16v1;
-    };
+        u16 u16v2;
-    struct {
+        u16 u16v3;
-        i16 i16v0;
-        i16 i16v1;
     };
     struct { 
         u8 u8v0;
         u8 u8v1;
         u8 u8v2;
         u8 u8v3;
-    };
+        u8 u8v4;
-    struct { 
+        u8 u8v5;
-        i8 i8v0;
+        u8 u8v6;
-        i8 i8v1;
+        u8 u8v7;
-        i8 i8v2;
-        i8 i8v3;
     };
 } Register;
 
@@ -38,13 +41,13 @@ typedef enum VMState {
 typedef struct VM {
     union {
         struct {
-            Register ax;
+            Register a;
-            Register bx;
+            Register b;
-            Register cx;
+            Register c;
-            Register dx;
+            Register d;
         };
-        Register registers[4];
+        Register array[4];
-    };
+    } registers;
     
     VMState state;
     char* NULLABLE(error_message); // not null on if state == VMState_InternalError

src/instructions/impl/MOVC.c

@@ -8,8 +8,8 @@ i32 MOVC_impl(VM* vm){
     readValueSizeVar(value_size);*/
     u8 value_size = 4;\
     
-    vm->registers[dst_register_i].u32v = 0;
+    vm->registers.array[dst_register_i].u64v = 0;
-    if(!VM_dataRead(vm, &vm->registers[dst_register_i].u32v, vm->current_pos, value_size))
+    if(!VM_dataRead(vm, &vm->registers.array[dst_register_i].u64v, vm->current_pos, value_size))
         return -1;
     vm->current_pos += value_size;
 

src/instructions/impl/MOVR.c

@@ -11,6 +11,6 @@ i32 MOVR_impl(VM* vm){
         return -1;
     }
 
-    vm->registers[dst_register_i].u32v = vm->registers[src_register_i].u32v;
+    vm->registers.array[dst_register_i].u64v = vm->registers.array[src_register_i].u64v;
     return sizeof(dst_register_i) + sizeof(src_register_i);
 }

src/instructions/impl/SYS.c

@@ -19,9 +19,9 @@ FILE* NULLABLE(fileFromN)(VM* vm, u32 file_n){
 // cx - buffer ptr
 // dx - buffer size
 i32 SYS_read(VM* vm){
-    const u32 file_n = vm->bx.u32v;
+    const u32 file_n = vm->registers.b.u32v0;
-    u8* const buf = vm->data + vm->cx.u32v;
+    u8* const buf = vm->data + vm->registers.c.u32v0;
-    const u32 size = vm->dx.u32v;
+    const u32 size = vm->registers.d.u32v0;
 
     if(buf + size > vm->data + vm->data_size)
         return 40;
@@ -35,9 +35,9 @@ i32 SYS_read(VM* vm){
 // cx - buffer ptr
 // dx - buffer size
 i32 SYS_write(VM* vm){
-    const u32 file_n = vm->bx.u32v;
+    const u32 file_n = vm->registers.b.u32v0;
-    u8* const buf = vm->data + vm->cx.u32v;
+    u8* const buf = vm->data + vm->registers.c.u32v0;
-    const u32 size = vm->dx.u32v;
+    const u32 size = vm->registers.d.u32v0;
 
     if(buf + size > vm->data + vm->data_size)
         return 41;
@@ -50,13 +50,13 @@ i32 SYS_write(VM* vm){
 /// before call: ax - func code
 /// after  call: ax - result code
 i32 SYS_impl(VM* vm){
-    u8 func_code = vm->ax.u8v0;
+    u32 func_code = vm->registers.a.u32v0;
-    u32 result_code = 0;
+    i32 result_code = 0;
     switch(func_code){
         case 0:
             result_code = SYS_read(vm);
             break;
-        case 1:;
+        case 1:
             result_code = SYS_write(vm);
             break;
         default:
@@ -64,6 +64,6 @@ i32 SYS_impl(VM* vm){
             return -1;
     }
 
-    vm->ax.u32v = result_code;
+    vm->registers.a.u64v = result_code;
     return 0;
 }

src/instructions/impl/impl_macros.h

@@ -23,7 +23,7 @@
 
 /*
 #define validateValueSize(VAR) {\
-    if(VAR < 1 || VAR > 4){\
+    if(VAR < 1 || VAR > 8){\
         VM_setError(vm, "invalid value_size (%x)", VAR);\
         return -1;\
     }\

src/instructions/impl/math_operators.c

@@ -10,13 +10,16 @@
     \
     switch(value_size){\
         case 1: \
-            vm->registers[dst_register_i].u8v0 OPERATOR##= vm->registers[src_register_i].u8v0;\
+            vm->registers.array[dst_register_i].u8v0 OPERATOR##= vm->registers.array[src_register_i].u8v0;\
             break;\
         case 2: \
-            vm->registers[dst_register_i].u16v0 OPERATOR##= vm->registers[src_register_i].u16v0;\
+            vm->registers.array[dst_register_i].u16v0 OPERATOR##= vm->registers.array[src_register_i].u16v0;\
             break;\
         case 4: \
-            vm->registers[dst_register_i].u32v OPERATOR##= vm->registers[src_register_i].u32v;\
+            vm->registers.array[dst_register_i].u32v0 OPERATOR##= vm->registers.array[src_register_i].u32v0;\
+            break;\
+        case 8: \
+            vm->registers.array[dst_register_i].u64v OPERATOR##= vm->registers.array[src_register_i].u64v;\
             break;\
     }\
     return sizeof(dst_register_i) + sizeof(src_register_i) + sizeof(value_size);\