make mov and def more dynamic

4 files changed, 71 insertions, 59 deletions

diff --git a/src/compiler/ast-tree.c b/src/compiler/ast-tree.c
index c9b719c..7bb9f8f 100644
--- a/src/compiler/ast-tree.c
+++ b/src/compiler/ast-tree.c
@@ -1180,7 +1180,15 @@ bool setTypesVariable(AstTree *tree) {
 }
 
 bool setTypesOperatorAssign(AstTree *tree) {
-  return setTypesAstInfix(tree->metadata);
+  AstTreeInfix *infix = tree->metadata;
+  if (!setTypesAstInfix(infix)) {
+    return true;
+  } else if (!typeIsEqual(&infix->leftType, &infix->rightType)) {
+    printLog("Type mismatch");
+    return false;
+  } else {
+    return true;
+  }
 }
 
 bool setTypesAstVariable(AstTreeVariable *variable) {
@@ -1211,11 +1219,6 @@ bool setTypesAstInfix(AstTreeInfix *infix) {
   AstTree *lType = makeTypeOf(&infix->left);
   AstTree *rType = makeTypeOf(&infix->right);
 
-  if (!typeIsEqual(lType, rType)) {
-    printLog("Type mismatch");
-    return false;
-  }
-
   infix->leftType = *lType;
   infix->rightType = *rType;
 
@@ -1313,3 +1316,22 @@ bool astTreeCleanAstVariable(AstTreeVariable *variable) {
 
   return true;
 }
+
+size_t astTreeTypeSize(AstTree tree) {
+  switch (tree.token) {
+  case AST_TREE_TOKEN_TYPE_U64:
+    return 8;
+  case AST_TREE_TOKEN_FUNCTION:
+  case AST_TREE_TOKEN_KEYWORD_PRINT_U64:
+  case AST_TREE_TOKEN_TYPE_TYPE:
+  case AST_TREE_TOKEN_TYPE_FUNCTION:
+  case AST_TREE_TOKEN_TYPE_VOID:
+  case AST_TREE_TOKEN_FUNCTION_CALL:
+  case AST_TREE_TOKEN_VARIABLE:
+  case AST_TREE_TOKEN_VARIABLE_DEFINE:
+  case AST_TREE_TOKEN_VALUE_U64:
+  case AST_TREE_TOKEN_OPERATOR_ASSIGN:
+  case AST_TREE_TOKEN_NONE:
+  }
+  UNREACHABLE;
+}
diff --git a/src/compiler/ast-tree.h b/src/compiler/ast-tree.h
index 645ef5f..1aada03 100644
--- a/src/compiler/ast-tree.h
+++ b/src/compiler/ast-tree.h
@@ -162,3 +162,5 @@ bool astTreeClean(AstTree *tree);
 bool astTreeCleanFunction(AstTree *tree);
 bool astTreeCleanVariable(AstTree *tree);
 bool astTreeCleanAstVariable(AstTreeVariable *variable);
+
+size_t astTreeTypeSize(AstTree tree);
diff --git a/src/compiler/code-generator.c b/src/compiler/code-generator.c
index 905f408..b1c5604 100644
--- a/src/compiler/code-generator.c
+++ b/src/compiler/code-generator.c
@@ -31,8 +31,8 @@ void codeGeneratorDelete(CodeGeneratorCodes *code) {
       free(metadata);
     }
       continue;
-    case CODE_GENERATOR_INSTRUCTION_MOV_64: {
-      CodeGeneratorDoubleOperand *metadata = current.metadata;
+    case CODE_GENERATOR_INSTRUCTION_MOV: {
+      CodeGeneratorMov *metadata = current.metadata;
       codeGeneratorOperandDestroy(metadata->op0);
       codeGeneratorOperandDestroy(metadata->op1);
       free(metadata);
@@ -42,13 +42,7 @@ void codeGeneratorDelete(CodeGeneratorCodes *code) {
     UNREACHABLE;
   }
   for (size_t i = 0; i < code->defines_size; ++i) {
-    CodeGeneratorDefine current = code->defines[i];
-    switch (current.type) {
-    case CODE_GENERATOR_TYPE_64:
-      codeGeneratorOperandDestroy(current.operand);
-      continue;
-    }
-    UNREACHABLE;
+    codeGeneratorOperandDestroy(code->defines[i].operand);
   }
   free(code->codes);
   free(code);
@@ -132,12 +126,12 @@ CodeGeneratorCode createGenerateCode(char *label_begin, char *label_end,
 
 CodeGeneratorDefine createGenerateDefine(char *label_begin, char *label_end,
                                          CodeGeneratorOperand operand,
-                                         CodeGeneratorType type) {
+                                         size_t bytes) {
   CodeGeneratorDefine define = {
       .label_begin = label_begin,
       .label_end = label_end,
       .operand = operand,
-      .type = type,
+      .bytes = bytes,
   };
   return define;
 }
@@ -198,10 +192,10 @@ CodeGeneratorCodes *codeGenerator(AstTreeRoot *astTreeRoot) {
       if (!variable->isConst) {
         CodeGeneratorOperand value = makeCodeGeneratorOperand(
             (void *)(uint64_t)(AstTreeU64)variable->value->metadata, false);
-        generateCodePushDefine(codes,
-                               createGenerateDefine(variable->name_begin,
-                                                    variable->name_end, value,
-                                                    CODE_GENERATOR_TYPE_64));
+        generateCodePushDefine(
+            codes,
+            createGenerateDefine(variable->name_begin, variable->name_end,
+                                 value, astTreeTypeSize(*variable->type)));
       }
       continue;
     case AST_TREE_TOKEN_TYPE_TYPE:
@@ -293,25 +287,22 @@ bool codeGeneratorAstTreeFunction(char *label_begin, char *label_end,
       if (infix->left.token != AST_TREE_TOKEN_VARIABLE) {
         printLog("Not implemented yet");
         exit(1);
-      } else if (infix->leftType.token != AST_TREE_TOKEN_TYPE_U64) {
-        printLog("Not implemented yet");
-        exit(1);
       }
 
-      CodeGeneratorDoubleOperand *operands = a404m_malloc(sizeof(*operands));
+      CodeGeneratorMov *operands = a404m_malloc(sizeof(*operands));
       CodeGeneratorOperand *op0 =
           newCodeGeneratorOperandFromAstTree(infix->left);
       CodeGeneratorOperand *op1 =
           newCodeGeneratorOperandFromAstTree(infix->right);
       operands->op0 = *op0;
       operands->op1 = *op1;
+      operands->bytes = astTreeTypeSize(infix->leftType);
       free(op0);
       free(op1);
 
-      generateCodePushCode(codes,
-                           createGenerateCode(label_begin, label_end,
-                                              CODE_GENERATOR_INSTRUCTION_MOV_64,
-                                              operands));
+      generateCodePushCode(
+          codes, createGenerateCode(label_begin, label_end,
+                                    CODE_GENERATOR_INSTRUCTION_MOV, operands));
     }
       goto OK;
     case AST_TREE_TOKEN_VARIABLE_DEFINE:
@@ -430,11 +421,12 @@ char *codeGeneratorToFlatASM(const CodeGeneratorCodes *codes) {
       free(inst);
     }
       continue;
-    case CODE_GENERATOR_INSTRUCTION_MOV_64: {
-      CodeGeneratorDoubleOperand *metadata = code.metadata;
+    case CODE_GENERATOR_INSTRUCTION_MOV: {
+      CodeGeneratorMov *metadata = code.metadata;
       char *inst;
       if (metadata->op0.isReference) {
-        asprintf(&inst, "mov64 [%s],", metadata->op0.value.reference);
+        asprintf(&inst, "mov%ld [%s],", metadata->bytes * 8,
+                 metadata->op0.value.reference);
       } else {
         UNREACHABLE;
       }
@@ -461,26 +453,20 @@ char *codeGeneratorToFlatASM(const CodeGeneratorCodes *codes) {
   for (size_t i = 0; i < codes->defines_size; ++i) {
     const CodeGeneratorDefine define = codes->defines[i];
 
-    switch (define.type) {
-    case CODE_GENERATOR_TYPE_64:
-      CodeGeneratorOperand operand = define.operand;
-      char *inst;
-      if (operand.isReference) {
-        asprintf(&inst, "def64 %.*s, [%s]\n",
-                 (int)(define.label_end - define.label_begin),
-                 define.label_begin, operand.value.reference);
-      } else {
-        asprintf(&inst, "def64 %.*s, %lu\n",
-                 (int)(define.label_end - define.label_begin),
-                 define.label_begin, operand.value.value);
-      }
-      codeGeneratorAppendFlatASMCommand(&fasm, &fasm_size, &fasm_inserted, inst,
-                                        strlen(inst));
-      free(inst);
-
-      continue;
+    CodeGeneratorOperand operand = define.operand;
+    char *inst;
+    if (operand.isReference) {
+      asprintf(&inst, "def%ld %.*s, [%s]\n", define.bytes * 8,
+               (int)(define.label_end - define.label_begin), define.label_begin,
+               operand.value.reference);
+    } else {
+      asprintf(&inst, "def%ld %.*s, %lu\n", define.bytes * 8,
+               (int)(define.label_end - define.label_begin), define.label_begin,
+               operand.value.value);
     }
-    UNREACHABLE;
+    codeGeneratorAppendFlatASMCommand(&fasm, &fasm_size, &fasm_inserted, inst,
+                                      strlen(inst));
+    free(inst);
   }
 
   fasm[fasm_inserted] = '\0';
diff --git a/src/compiler/code-generator.h b/src/compiler/code-generator.h
index 0c388b9..3399ee3 100644
--- a/src/compiler/code-generator.h
+++ b/src/compiler/code-generator.h
@@ -9,13 +9,9 @@ typedef enum CodeGeneratorInstruction : uint8_t {
   CODE_GENERATOR_INSTRUCTION_CALL,
   CODE_GENERATOR_INSTRUCTION_RET,
   CODE_GENERATOR_INSTRUCTION_DEF_VAR64,
-  CODE_GENERATOR_INSTRUCTION_MOV_64,
+  CODE_GENERATOR_INSTRUCTION_MOV,
 } CodeGeneratorInstruction;
 
-typedef enum CodeGeneratorType : uint8_t {
-  CODE_GENERATOR_TYPE_64,
-} CodeGeneratorType;
-
 typedef struct CodeGeneratorCode {
   char *label_begin;
   char *label_end;
@@ -41,11 +37,17 @@ typedef struct CodeGeneratorDoubleOperand {
   CodeGeneratorOperand op1;
 } CodeGeneratorDoubleOperand;
 
+typedef struct CodeGeneratorMov {
+  CodeGeneratorOperand op0;
+  CodeGeneratorOperand op1;
+  size_t bytes;
+} CodeGeneratorMov;
+
 typedef struct CodeGeneratorDefine {
   char *label_begin;
   char *label_end;
   CodeGeneratorOperand operand;
-  CodeGeneratorType type;
+  size_t bytes;
 } CodeGeneratorDefine;
 
 typedef struct CodeGeneratorCodes {
@@ -68,8 +70,8 @@ CodeGeneratorCode createGenerateCode(char *label_begin, char *label_end,
                                      void *metadata);
 
 CodeGeneratorDefine createGenerateDefine(char *label_begin, char *label_end,
-                                       CodeGeneratorOperand operand,
-                                       CodeGeneratorType type);
+                                         CodeGeneratorOperand operand,
+                                         size_t bytes);
 
 CodeGeneratorCode *newGenerateCode(char *label_begin, char *label_end,
                                    CodeGeneratorInstruction instruction);