Fix type conversions

README.md

@@ -75,7 +75,7 @@ build
         - [x] String operations
     - [x] Maths
     - [x] Comparisions
-    - [ ] Type conversions
+    - [x] Type conversions
     - [x] Functions
         - [x] Define functions
         - [x] Call functions
@@ -83,7 +83,7 @@ build
         - [x] Arguments for functions
         - [x] Jumping within functions
     - [x] Custom data structures
-    - [ ] Working with external libraries
+    - [x] Working with external libraries
 
 ## Debugger
 
@@ -102,7 +102,7 @@ Commands:
 
 CGround now includes an experimental Ground -> x86_64 Linux ASM compiler. You can try it by adding the `-c` flag when running Ground. This will print the generated ASM to the console.
 
-At present only the `int`, `char`, and `bool` data types are supported.
+At present only the `int` data type is supported.
 
 Supported instructions so far:
 

docs/syntax.md

@@ -362,3 +362,23 @@ Looks in the path $GROUND_LIBS/`$libraryName`.grnd for the library. ($GROUND_LIB
 Attempts to import a shared library written in a compiled language like C or C++ for usage within the current program.
 
 Looks in the path $GROUND_LIBS/`$libraryName`.so for the library. ($GROUND_LIBS is a system environment variable.)
+
+### Data Structures
+
+#### struct -structName
+
+Creates a new struct which can be initialised. Until the endstruct keyword, the only valid instructions are init, set, fun, endfun, struct, and endstruct.
+
+Any value created inside the struct will be added to the struct.
+
+#### endstruct
+
+Ends the creation of a struct.
+
+#### getfield $object &fieldName &outputVar
+
+Gets a field from an initialised object. fieldName must be a valid name of a field in the object. Errors if the field does not exist. 
+
+#### setfield &object &fieldName $value
+
+Sets a field to a new value in the object. The value must be of the same type as the field's old value.

src/compiler.c

@@ -4,7 +4,6 @@
 #include "include/estr.h"
 #include <stdint.h>
 #include <inttypes.h>
-#include <stdio.h>
 
 VariableTable createVariableTable() {
     VariableTable vt;
@@ -14,7 +13,7 @@ VariableTable createVariableTable() {
     return vt;
 } 
 
-void addVtVariable(VariableTable* vt, const char* name, GroundValueType type) {
+void addVtVariable(VariableTable* vt, const char* name) {
     // check if it already exists
     for (size_t i = 0; i < vt->count; i++) {
         if (strcmp(vt->vars[i].name, name) == 0) {
@@ -30,20 +29,10 @@ void addVtVariable(VariableTable* vt, const char* name, GroundValueType type) {
 
     // add the variable
     strcpy(vt->vars[vt->count].name, name);
-    vt->vars[vt->count].type = type;
     vt->vars[vt->count].offset = vt->count * 8;
     vt->count++;
 }
 
-VariableInfo* getVariable(VariableTable* vt, const char* name) {
-    for (size_t i = 0; i < vt->count; i++) {
-        if (strcmp(vt->vars[i].name, name) == 0) {
-            return &vt->vars[i];
-        }
-    }
-    return NULL;
-}
-
 int getVariablePos(VariableTable* vt, const char* name) {
     for (size_t i = 0; i < vt->count; i++) {
         if (strcmp(vt->vars[i].name, name) == 0) {
@@ -53,318 +42,6 @@ int getVariablePos(VariableTable* vt, const char* name) {
     return -1;
 }
 
-DoubleTable createDoubleTable() {
-    DoubleTable dt;
-    dt.count = 0;
-    dt.capacity = 16;
-    dt.constants = malloc(sizeof(DoubleConstant) * 16);
-    return dt;
-}
-
-char* addDoubleConstant(DoubleTable* dt, Estr* rodata, double value, int* counter) {
-    for (size_t i = 0; i < dt->count; i++) {
-        if (dt->constants[i].value == value) {
-            return dt->constants[i].label;
-        }
-    }
-
-    if (dt->count >= dt->capacity) {
-        dt->capacity = dt->capacity == 0 ? 16 : dt->capacity * 2; 
-        dt->constants = realloc(dt->constants, sizeof(DoubleConstant) * dt->capacity);
-    }
-
-    char label[64];
-    snprintf(label, sizeof(label), "float_const_%d", (*counter)++);
-    strcpy(dt->constants[dt->count].label, label);
-    dt->constants[dt->count].value = value;
-    dt->count++;
-
-    char line[128];
-    snprintf(line, 128, "%s: dq %.17g ; double constant\n", label, value);
-    APPEND_ESTR((*rodata), line);
-
-    return dt->constants[dt->count - 1].label;
-}
-
-GroundValueType getInstructionReturnType(GroundInstruction* gi, VariableTable* table) {
-    switch (gi->type) {
-        case JUMP:
-        case PRINT:
-        case PRINTLN:
-        case END:
-        case IF:
-        case RETURN:
-        case ENDFUN:
-        case PUSHARG:
-        case CALL: // FIXME do this when functions are added
-        case USE:
-        case EXTERN:
-        case CREATELABEL:
-        case PAUSE:
-        case DROP:
-        case ERRORCMD:
-        case ENDSTRUCT:
-        case INIT: // FIXME do this when objects are added
-        case GETFIELD: // FIXME do this when objects are added
-        case SETFIELD: // FIXME do this when objects are added
-        case DIVIDE: // FIXME do this when division is added
-        case SETLISTAT:
-        case GETLISTAT: // FIXME do this when lists are getting implemented
-        case LISTAPPEND: {
-            return NONE;
-        }
-        case TOSTRING:
-        case GETTYPE:
-        case INPUT: {
-            return STRING;
-        }
-        case STOI:
-        case GETLISTSIZE:
-        case GETSTRSIZE: {
-            return INT;
-        }
-        case STOD: {
-            return DOUBLE;
-        }
-        case EQUAL:
-        case INEQUAL:
-        case GREATER:
-        case LESSER:
-        case NOT:
-        case EXISTS: {
-            return BOOL;
-        }
-        case GETSTRCHARAT: {
-            return CHAR;
-        }
-        case SETLIST: {
-            return LIST;
-        }
-        case FUN: {
-            return FUNCTION;
-        }
-        case STRUCT: {
-            return STRUCTVAL;
-        }
-        case SET: {
-            if (gi->args.length == 2) {
-                if (gi->args.args[1].type == VALUE) {
-                    return gi->args.args[1].value.value.type;
-                } else if (gi->args.args[1].type == VALREF) {
-                    VariableInfo* var = getVariable(table, gi->args.args[1].value.refName);
-                    if (var == NULL) {
-                        return NONE;
-                    }
-                    return var->type;
-                } else {
-                    return NONE;
-                }
-            } else {
-                return NONE;
-            }
-        }
-        case ADD: {
-            if (gi->args.length == 3) {
-                GroundValueType leftType;
-                GroundValueType rightType;
-                if (gi->args.args[0].type == VALUE) {
-                    leftType = gi->args.args[0].value.value.type;
-                } else if (gi->args.args[0].type == VALREF) {
-                    VariableInfo* var = getVariable(table, gi->args.args[0].value.refName);
-                    if (var == NULL) {
-                        return NONE;
-                    }
-                    leftType = var->type;
-                } else {
-                    return NONE;
-                }
-                if (gi->args.args[1].type == VALUE) {
-                    rightType = gi->args.args[1].value.value.type;
-                } else if (gi->args.args[1].type == VALREF) {
-                    VariableInfo* var = getVariable(table, gi->args.args[1].value.refName);
-                    if (var == NULL) {
-                        return NONE;
-                    }
-                    rightType = var->type;
-                } else {
-                    return NONE;
-                }
-
-                if (leftType == STRING) {
-                    if (rightType == STRING) {
-                        return STRING;
-                    } else {
-                        return NONE;
-                    }
-                }
-                if (leftType == DOUBLE) {
-                    if (rightType == DOUBLE || rightType == INT) {
-                        return DOUBLE;
-                    } else {
-                        return NONE;
-                    }
-                }
-                if (rightType == DOUBLE) {
-                    if (leftType == DOUBLE || leftType == INT) {
-                        return DOUBLE;
-                    } else {
-                        return NONE;
-                    }
-                }
-                if (rightType == INT && leftType == INT) {
-                    return INT;
-                }
-                return NONE;
-            } else {
-                return NONE;
-            }
-        }
-        case SUBTRACT: {
-            if (gi->args.length == 3) {
-                GroundValueType leftType;
-                GroundValueType rightType;
-                if (gi->args.args[0].type == VALUE) {
-                    leftType = gi->args.args[0].value.value.type;
-                } else if (gi->args.args[0].type == VALREF) {
-                    VariableInfo* var = getVariable(table, gi->args.args[0].value.refName);
-                    if (var == NULL) {
-                        return NONE;
-                    }
-                    leftType = var->type;
-                } else {
-                    return NONE;
-                }
-                if (gi->args.args[1].type == VALUE) {
-                    rightType = gi->args.args[1].value.value.type;
-                } else if (gi->args.args[1].type == VALREF) {
-                    VariableInfo* var = getVariable(table, gi->args.args[1].value.refName);
-                    if (var == NULL) {
-                        return NONE;
-                    }
-                    rightType = var->type;
-                } else {
-                    return NONE;
-                }
-
-                if (leftType == DOUBLE) {
-                    if (rightType == DOUBLE || rightType == INT) {
-                        return DOUBLE;
-                    } else {
-                        return NONE;
-                    }
-                }
-                if (rightType == DOUBLE) {
-                    if (leftType == DOUBLE || leftType == INT) {
-                        return DOUBLE;
-                    } else {
-                        return NONE;
-                    }
-                }
-                if (rightType == INT && leftType == INT) {
-                    return INT;
-                }
-                return NONE;
-            } else {
-                return NONE;
-            }
-        }
-        case MULTIPLY: {
-            if (gi->args.length == 3) {
-                GroundValueType leftType;
-                GroundValueType rightType;
-                if (gi->args.args[0].type == VALUE) {
-                    leftType = gi->args.args[0].value.value.type;
-                } else if (gi->args.args[0].type == VALREF) {
-                    VariableInfo* var = getVariable(table, gi->args.args[0].value.refName);
-                    if (var == NULL) {
-                        return NONE;
-                    }
-                    leftType = var->type;
-                } else {
-                    return NONE;
-                }
-                if (gi->args.args[1].type == VALUE) {
-                    rightType = gi->args.args[1].value.value.type;
-                } else if (gi->args.args[1].type == VALREF) {
-                    VariableInfo* var = getVariable(table, gi->args.args[1].value.refName);
-                    if (var == NULL) {
-                        return NONE;
-                    }
-                    rightType = var->type;
-                } else {
-                    return NONE;
-                }
-
-                if (leftType == DOUBLE) {
-                    if (rightType == DOUBLE || rightType == INT) {
-                        return DOUBLE;
-                    } else {
-                        return NONE;
-                    }
-                }
-                if (rightType == DOUBLE) {
-                    if (leftType == DOUBLE || leftType == INT) {
-                        return DOUBLE;
-                    } else {
-                        return NONE;
-                    }
-                }
-                if (rightType == INT && leftType == INT) {
-                    return INT;
-                }
-                return NONE;
-            } else {
-                return NONE;
-            }
-        }
-    }
-    return INT;
-}
-
-char* processValueString(GroundArg arg, VariableTable* vt, GroundValueType* outType, DoubleTable* dt, Estr* rodata, int* doubleCounter) {
-    if (arg.type == VALREF) {
-        VariableInfo* var = getVariable(vt, arg.value.refName);
-        if (var && outType) *outType = var->type;
-        char* buf = malloc(260);
-        snprintf(buf, 260, "[%s]", arg.value.refName);
-        return buf;
-    }
-    if (arg.type == VALUE) {
-        if (outType) *outType = arg.value.value.type;
-        switch(arg.value.value.type) {
-            case INT: {
-                char* buf = malloc(64);
-                snprintf(buf, 64, "%" PRId64, arg.value.value.data.intVal);
-                return buf;
-                break;
-            }
-            case DOUBLE: {
-                char* label = addDoubleConstant(dt, rodata, arg.value.value.data.doubleVal, doubleCounter);
-                char* buf = malloc(128);
-                snprintf(buf, 128, "[rel %s]", label);
-                return buf;
-                break;
-            }
-            case BOOL:
-                return arg.value.value.data.boolVal ? "1" : "0";
-                break;
-            case CHAR: {
-                char* buf = malloc(8);
-                snprintf(buf, 8, "%d", (int)arg.value.value.data.charVal);
-                return buf;
-                break;
-            }
-            default: {
-                printf("For now, only int, bool, and char are supported data types in the compiler.");
-                exit(1);
-                break;
-            }
-        }
-    }
-    return NULL;
-}
-
-/*
 char* processValueString(GroundArg arg) {
     if (arg.type == VALREF) {
         char* buf = malloc(sizeof(char) * 260);
@@ -372,43 +49,21 @@ char* processValueString(GroundArg arg) {
         return buf;
     }
     if (arg.type == VALUE) {
-        switch (arg.value.value.type) {
+        if (arg.value.value.type != INT) {
-            case INT: {
+            printf("Only int is supported right now\n");
+            exit(1);
+        }
         char* buf = malloc(sizeof(char) * 64);
         snprintf(buf, sizeof(char) * 260, "%" PRId64, arg.value.value.data.intVal);
         return buf;
-                break;
-            }
-            case BOOL: {
-                return arg.value.value.data.boolVal ? "1" : "0";
-                break;
-            }
-            case CHAR: {
-                char* buf = malloc(8);
-                snprintf(buf, 8, "%d", (int) arg.value.value.data.charVal);
-                return buf;
-                break;
-            }
-            default: {
-                printf("For now, only int, bool, and char are supported data types in the compiler.");
-                exit(1);
-                break;
-            }
-        }
     }
     return NULL;
 }
-*/
 
 char* compileGroundProgram(GroundProgram* program) {
     Estr start = CREATE_ESTR("global _start\nsection .text\n_start:\n");
     Estr data = CREATE_ESTR("section .bss\n");
     Estr helpers = CREATE_ESTR("");
-    Estr rodata = CREATE_ESTR("section .rodata\n");
-    APPEND_ESTR(rodata, "  newline_char: db 10\n");
-    APPEND_ESTR(rodata, "  space_char: db 32\n");
-    DoubleTable doubleTable = createDoubleTable();
-    int doubleConstCounter = 0;
 
     APPEND_ESTR(helpers, "\n; Helper: Print integer in rax\n");
     APPEND_ESTR(helpers, "print_int:\n");
@@ -469,7 +124,7 @@ char* compileGroundProgram(GroundProgram* program) {
         GroundInstruction gi = program->instructions[i];
         for (size_t j = 0; j < gi.args.length; j++) {
             if (gi.args.args[j].type == DIRREF) {
-                addVtVariable(&varTable, gi.args.args[j].value.refName, getInstructionReturnType(&gi, &varTable));
+                addVtVariable(&varTable, gi.args.args[j].value.refName);
             }
         }
     }
@@ -511,7 +166,7 @@ char* compileGroundProgram(GroundProgram* program) {
 
                 APPEND_ESTR(start, "  ; set\n")
                 APPEND_ESTR(start, "  mov rax, ");
-                APPEND_ESTR(start, processValueString(gi.args.args[1], &varTable, NULL, &doubleTable, &rodata, &doubleConstCounter));
+                APPEND_ESTR(start, processValueString(gi.args.args[1]));
                 APPEND_ESTR(start, "\n");
                 APPEND_ESTR(start, "  mov [");
                 APPEND_ESTR(start, varName);
@@ -557,7 +212,7 @@ char* compileGroundProgram(GroundProgram* program) {
 
                 APPEND_ESTR(start, "  ; if\n");
                 APPEND_ESTR(start, "  mov rax, ");
-                APPEND_ESTR(start, processValueString(gi.args.args[0], &varTable, NULL, &doubleTable, &rodata, &doubleConstCounter));
+                APPEND_ESTR(start, processValueString(gi.args.args[0]));
                 APPEND_ESTR(start, "\n");
                 APPEND_ESTR(start, "  test rax, rax\n");
                 APPEND_ESTR(start, "  jnz ");
@@ -584,7 +239,7 @@ char* compileGroundProgram(GroundProgram* program) {
 
                 APPEND_ESTR(start, "  ; not\n");
                 APPEND_ESTR(start, "  mov rax, ");
-                APPEND_ESTR(start, processValueString(gi.args.args[0], &varTable, NULL, &doubleTable, &rodata, &doubleConstCounter));
+                APPEND_ESTR(start, processValueString(gi.args.args[0]));
                 APPEND_ESTR(start, "\n");
                 APPEND_ESTR(start, "  xor rax, 1\n");
                 APPEND_ESTR(start, "  mov [");
@@ -610,55 +265,17 @@ char* compileGroundProgram(GroundProgram* program) {
                     runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 3", &gi, i);
                 }
 
-                GroundValueType leftType, rightType;
-
-                char* left = processValueString(gi.args.args[0], &varTable, &leftType, &doubleTable, &rodata, &doubleConstCounter);
-                char* right = processValueString(gi.args.args[1], &varTable, &rightType, &doubleTable, &rodata, &doubleConstCounter);
                 char* varName= gi.args.args[2].value.refName;
-
-                bool isDouble = (leftType == DOUBLE || rightType == DOUBLE);
-                
-                if (isDouble) {
-                    APPEND_ESTR(start, "  ; add (double)\n");
-                    
-                    if (leftType == INT) {
-                        APPEND_ESTR(start, "  mov rax, ");
-                        APPEND_ESTR(start, left);
-                        APPEND_ESTR(start, "\n");
-                        APPEND_ESTR(start, "  cvtsi2sd xmm0, rax  ; Convert int to double\n");
-                    } else {
-                        APPEND_ESTR(start, "  movsd xmm0, ");
-                        APPEND_ESTR(start, left);
-                        APPEND_ESTR(start, "\n");
-                    }
-                    
-                    if (rightType == INT) {
-                        APPEND_ESTR(start, "  mov rax, ");
-                        APPEND_ESTR(start, right);
-                        APPEND_ESTR(start, "\n");
-                        APPEND_ESTR(start, "  cvtsi2sd xmm1, rax  ; Convert int to double\n");
-                        APPEND_ESTR(start, "  addsd xmm0, xmm1\n");
-                    } else {
-                        APPEND_ESTR(start, "  addsd xmm0, ");
-                        APPEND_ESTR(start, right);
-                        APPEND_ESTR(start, "\n");
-                    }
-                    
-                    APPEND_ESTR(start, "  movsd [");
-                    APPEND_ESTR(start, varName);
-                    APPEND_ESTR(start, "], xmm0\n");
-                } else {
                 APPEND_ESTR(start, "  ; add\n");
                 APPEND_ESTR(start, "  mov rax, ");
-                    APPEND_ESTR(start, processValueString(gi.args.args[0], &varTable, NULL, &doubleTable, &rodata, &doubleConstCounter));
+                APPEND_ESTR(start, processValueString(gi.args.args[0]));
                 APPEND_ESTR(start, "\n");
                 APPEND_ESTR(start, "  add rax, ");
-                    APPEND_ESTR(start, processValueString(gi.args.args[1], &varTable, NULL, &doubleTable, &rodata, &doubleConstCounter));
+                APPEND_ESTR(start, processValueString(gi.args.args[1]));
                 APPEND_ESTR(start, "\n");
                 APPEND_ESTR(start, "  mov [");
                 APPEND_ESTR(start, varName);
                 APPEND_ESTR(start, "], rax\n");
-                }
                 break;
             }
             case SUBTRACT: {
@@ -681,10 +298,10 @@ char* compileGroundProgram(GroundProgram* program) {
                 char* varName= gi.args.args[2].value.refName;
                 APPEND_ESTR(start, "  ; subtract\n");
                 APPEND_ESTR(start, "  mov rax, ");
-                APPEND_ESTR(start, processValueString(gi.args.args[0], &varTable, NULL, &doubleTable, &rodata, &doubleConstCounter));
+                APPEND_ESTR(start, processValueString(gi.args.args[0]));
                 APPEND_ESTR(start, "\n");
                 APPEND_ESTR(start, "  sub rax, ");
-                APPEND_ESTR(start, processValueString(gi.args.args[1], &varTable, NULL, &doubleTable, &rodata, &doubleConstCounter));
+                APPEND_ESTR(start, processValueString(gi.args.args[1]));
                 APPEND_ESTR(start, "\n");
                 APPEND_ESTR(start, "  mov [");
                 APPEND_ESTR(start, varName);
@@ -711,10 +328,10 @@ char* compileGroundProgram(GroundProgram* program) {
                 char* varName= gi.args.args[2].value.refName;
                 APPEND_ESTR(start, "  ; multiply\n");
                 APPEND_ESTR(start, "  mov rax, ");
-                APPEND_ESTR(start, processValueString(gi.args.args[0], &varTable, NULL, &doubleTable, &rodata, &doubleConstCounter));
+                APPEND_ESTR(start, processValueString(gi.args.args[0]));
                 APPEND_ESTR(start, "\n");
                 APPEND_ESTR(start, "  imul rax, ");
-                APPEND_ESTR(start, processValueString(gi.args.args[1], &varTable, NULL, &doubleTable, &rodata, &doubleConstCounter));
+                APPEND_ESTR(start, processValueString(gi.args.args[1]));
                 APPEND_ESTR(start, "\n");
                 APPEND_ESTR(start, "  mov [");
                 APPEND_ESTR(start, varName);
@@ -741,10 +358,10 @@ char* compileGroundProgram(GroundProgram* program) {
                 char* varName= gi.args.args[2].value.refName;
                 APPEND_ESTR(start, "  ; equal\n");
                 APPEND_ESTR(start, "  mov rax, ");
-                APPEND_ESTR(start, processValueString(gi.args.args[0], &varTable, NULL, &doubleTable, &rodata, &doubleConstCounter));
+                APPEND_ESTR(start, processValueString(gi.args.args[0]));
                 APPEND_ESTR(start, "\n");
                 APPEND_ESTR(start, "  cmp rax, ");
-                APPEND_ESTR(start, processValueString(gi.args.args[1], &varTable, NULL, &doubleTable, &rodata, &doubleConstCounter));
+                APPEND_ESTR(start, processValueString(gi.args.args[1]));
                 APPEND_ESTR(start, "\n");
                 APPEND_ESTR(start, "  sete al\n");
                 APPEND_ESTR(start, "  movzx rax, al\n");
@@ -773,10 +390,10 @@ char* compileGroundProgram(GroundProgram* program) {
                 char* varName= gi.args.args[2].value.refName;
                 APPEND_ESTR(start, "  ; inequal\n");
                 APPEND_ESTR(start, "  mov rax, ");
-                APPEND_ESTR(start, processValueString(gi.args.args[0], &varTable, NULL, &doubleTable, &rodata, &doubleConstCounter));
+                APPEND_ESTR(start, processValueString(gi.args.args[0]));
                 APPEND_ESTR(start, "\n");
                 APPEND_ESTR(start, "  cmp rax, ");
-                APPEND_ESTR(start, processValueString(gi.args.args[1], &varTable, NULL, &doubleTable, &rodata, &doubleConstCounter));
+                APPEND_ESTR(start, processValueString(gi.args.args[1]));
                 APPEND_ESTR(start, "\n");
                 APPEND_ESTR(start, "  setne al\n");
                 APPEND_ESTR(start, "  movzx rax, al\n");
@@ -805,10 +422,10 @@ char* compileGroundProgram(GroundProgram* program) {
                 char* varName= gi.args.args[2].value.refName;
                 APPEND_ESTR(start, "  ; greater\n");
                 APPEND_ESTR(start, "  mov rax, ");
-                APPEND_ESTR(start, processValueString(gi.args.args[0], &varTable, NULL, &doubleTable, &rodata, &doubleConstCounter));
+                APPEND_ESTR(start, processValueString(gi.args.args[0]));
                 APPEND_ESTR(start, "\n");
                 APPEND_ESTR(start, "  cmp rax, ");
-                APPEND_ESTR(start, processValueString(gi.args.args[1], &varTable, NULL, &doubleTable, &rodata, &doubleConstCounter));
+                APPEND_ESTR(start, processValueString(gi.args.args[1]));
                 APPEND_ESTR(start, "\n");
                 APPEND_ESTR(start, "  setg al\n");
                 APPEND_ESTR(start, "  movzx rax, al\n");
@@ -837,10 +454,10 @@ char* compileGroundProgram(GroundProgram* program) {
                 char* varName= gi.args.args[2].value.refName;
                 APPEND_ESTR(start, "  ; lesser\n");
                 APPEND_ESTR(start, "  mov rax, ");
-                APPEND_ESTR(start, processValueString(gi.args.args[0], &varTable, NULL, &doubleTable, &rodata, &doubleConstCounter));
+                APPEND_ESTR(start, processValueString(gi.args.args[0]));
                 APPEND_ESTR(start, "\n");
                 APPEND_ESTR(start, "  cmp rax, ");
-                APPEND_ESTR(start, processValueString(gi.args.args[1], &varTable, NULL, &doubleTable, &rodata, &doubleConstCounter));
+                APPEND_ESTR(start, processValueString(gi.args.args[1]));
                 APPEND_ESTR(start, "\n");
                 APPEND_ESTR(start, "  setl al\n");
                 APPEND_ESTR(start, "  movzx rax, al\n");
@@ -870,7 +487,7 @@ char* compileGroundProgram(GroundProgram* program) {
                     }
                     APPEND_ESTR(start, "  ; print int\n");
                     APPEND_ESTR(start, "  mov rax, ");
-                    APPEND_ESTR(start, processValueString(gi.args.args[j], &varTable, NULL, &doubleTable, &rodata, &doubleConstCounter));
+                    APPEND_ESTR(start, processValueString(gi.args.args[j]));
                     APPEND_ESTR(start, "\n");
                     APPEND_ESTR(start, "  call print_int\n");
                 }
@@ -895,7 +512,7 @@ char* compileGroundProgram(GroundProgram* program) {
                 APPEND_ESTR(start, "  ; end\n");
                 APPEND_ESTR(start, "  mov rax, 60\n");
                 APPEND_ESTR(start, "  mov rdi, ");
-                APPEND_ESTR(start, processValueString(gi.args.args[0], &varTable, NULL, &doubleTable, &rodata, &doubleConstCounter));
+                APPEND_ESTR(start, processValueString(gi.args.args[0]));
                 APPEND_ESTR(start, "\n");
                 APPEND_ESTR(start, "  syscall\n");
                 break;
@@ -915,8 +532,10 @@ char* compileGroundProgram(GroundProgram* program) {
     APPEND_ESTR(complete, start.str);
     APPEND_ESTR(complete, "  ; End of program\n  mov rax, 60\n  mov rdi, 0\n  syscall\n");
     APPEND_ESTR(complete, helpers.str);
-    APPEND_ESTR(complete, data.str);
+    APPEND_ESTR(complete, "\nsection .rodata\n");
-    APPEND_ESTR(complete, rodata.str);
+    APPEND_ESTR(complete, "newline_char: db 10\n");
+    APPEND_ESTR(complete, "space_char: db 32\n");
+    APPEND_ESTR(complete, data.str)
 
     return complete.str;
 }

src/compiler.h

@@ -7,7 +7,6 @@ char* compileGroundProgram(GroundProgram* program);
 typedef struct VariableInfo {
     char name[256];
     int offset;
-    GroundValueType type;
 } VariableInfo;
 
 typedef struct VariableTable {
@@ -16,13 +15,4 @@ typedef struct VariableTable {
     size_t capacity;
 } VariableTable;
 
-typedef struct DoubleConstant {
-    double value;
-    char label[64];
-} DoubleConstant;
 
-typedef struct DoubleTable {
-    DoubleConstant* constants;
-    size_t count;
-    size_t capacity;
-} DoubleTable;

src/interpreter.c

@@ -443,6 +443,7 @@ GroundStruct parseStruct(GroundProgram* in, GroundScope* scope, size_t errorOffs
                     addInstructionToProgram(&gp, in->instructions[i]);
                     i++;
                 }
+                i--;
 
                 GroundFunction* function = parseFunction(&gp, errorOffset);
                 function->startLine = i;
@@ -509,6 +510,7 @@ GroundValue interpretGroundProgram(GroundProgram* in, GroundScope* inScope) {
                 addInstructionToProgram(&gp, in->instructions[i]);
                 i++;
             }
+            i--;
 
             GroundFunction* function = parseFunction(&gp, errorOffset);
             function->startLine = i;
@@ -546,6 +548,7 @@ GroundValue interpretGroundProgram(GroundProgram* in, GroundScope* inScope) {
                 addInstructionToProgram(&gp, in->instructions[i]);
                 i++;
             }
+            i--;
 
             GroundValue gv = {
                 .type = STRUCTVAL,
@@ -1104,7 +1107,7 @@ GroundValue interpretGroundInstruction(GroundInstruction inst, GroundScope* scop
             if (in->args.args[1].type != DIRREF) {
                 runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 2", in, currentInstruction);
             }
-            addVariable(scope->variables, in->args.args[2].value.refName, createIntGroundValue(atoll(in->args.args[0].value.value.data.stringVal)));
+            addVariable(scope->variables, in->args.args[1].value.refName, createIntGroundValue(atoll(in->args.args[0].value.value.data.stringVal)));
             break;
         }
         case STOD: {
@@ -1120,7 +1123,7 @@ GroundValue interpretGroundInstruction(GroundInstruction inst, GroundScope* scop
             if (in->args.args[1].type != DIRREF) {
                 runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 2", in, currentInstruction);
             }
-            addVariable(scope->variables, in->args.args[1].value.refName, createIntGroundValue(atof(in->args.args[0].value.value.data.stringVal)));
+            addVariable(scope->variables, in->args.args[1].value.refName, createDoubleGroundValue(atof(in->args.args[0].value.value.data.stringVal)));
             break;
         }
         case TOSTRING: {
@@ -1137,57 +1140,53 @@ GroundValue interpretGroundInstruction(GroundInstruction inst, GroundScope* scop
                 runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 2", in, currentInstruction);
             }
             GroundValue* value = &in->args.args[0].value.value;
+            char buf[256];
             switch (value->type) {
                 case INT: {
-                    char* buf = malloc(sizeof(char) * 256);
+                    snprintf(buf, sizeof(buf) * 256, "%" PRId64, value->data.intVal);
-                    snprintf(buf, sizeof(char) * 256, "%" PRId64, value->data.intVal);
-                    addVariable(scope->variables, in->args.args[1].value.refName, createStringGroundValue(buf));
                     break;
                 }
                 case DOUBLE: {
-                    char* buf = malloc(sizeof(char) * 256);
+                    snprintf(buf, sizeof(buf) * 256, "%f", value->data.doubleVal);
-                    snprintf(buf, sizeof(char) * 256, "%f", value->data.doubleVal);
-                    addVariable(scope->variables, in->args.args[1].value.refName, createStringGroundValue(buf));
                     break;
                 }
                 case STRING: {
-                    addVariable(scope->variables, in->args.args[1].value.refName, createStringGroundValue(value->data.stringVal));
+                    snprintf(buf, sizeof(buf), "%s", value->data.stringVal);
                     break;
                 }
                 case CHAR: {
-                    char* buf = malloc(sizeof(char) * 2);
                     buf[0] = value->data.charVal;
                     buf[1] = '\0';
-                    addVariable(scope->variables, in->args.args[1].value.refName, createStringGroundValue(buf));
                     break;
                 }
                 case BOOL: {
                     if (value->data.boolVal) {
-                        addVariable(scope->variables, in->args.args[1].value.refName, createStringGroundValue("true"));
+                        snprintf(buf, sizeof(buf), "true");
                     } else {
-                        addVariable(scope->variables, in->args.args[1].value.refName, createStringGroundValue("false"));
+                        snprintf(buf, sizeof(buf), "false");
                     }
                     break;
                 }
                 case LIST: {
-                    addVariable(scope->variables, in->args.args[1].value.refName, createStringGroundValue("<list>"));
+                    snprintf(buf, sizeof(buf), "<list>");
                     break;
                 }
                 case FUNCTION: {
-                    addVariable(scope->variables, in->args.args[1].value.refName, createStringGroundValue("<function>"));
+                    snprintf(buf, sizeof(buf), "<function>");
                     break;
                 }
                 case CUSTOM: {
-                    addVariable(scope->variables, in->args.args[1].value.refName, createStringGroundValue("<custom>"));
+                    snprintf(buf, sizeof(buf), "<custom>");
                     break;
                 }
                 case NONE:
                 default: {
-                    addVariable(scope->variables, in->args.args[1].value.refName, createStringGroundValue("<default>"));
+                    snprintf(buf, sizeof(buf), "<default>");
                     break;
 
                 }
             }
+            addVariable(scope->variables, in->args.args[1].value.refName, createStringGroundValue(buf));
 
             break;
         }

src/types.c

@@ -149,8 +149,47 @@ void printGroundValue(GroundValue* gv) {
             printf("<function>");
             break;
         }
-        default: {
+        case STRUCTVAL: {
-            printf("FIXME");
+            printf("<struct fields: { ");
+            for (size_t i = 0; i < gv->data.structVal->size; i++) {
+                if (i != 0) {
+                    printf(", ");
+                }
+                printf("%s: ", gv->data.structVal->fields[i].id);
+                if (gv->data.structVal->fields[i].value.type == STRING) {
+                    printf("\"");
+                    printGroundValue(&gv->data.structVal->fields[i].value);
+                    printf("\"");
+                } else {
+                    printGroundValue(&gv->data.structVal->fields[i].value);
+                }
+            }
+            printf(" }>");
+            break;
+        }
+        case CUSTOM: {
+            printf("<object fields: { ");
+            for (size_t i = 0; i < gv->customType->size; i++) {
+                if (i != 0) {
+                    printf(", ");
+                }
+                printf("%s: ", gv->customType->fields[i].id);
+                GroundObjectField* field = findField(*gv->data.customVal, gv->customType->fields[i].id);
+                if (field == NULL) {
+                    printf("<missing>");
+                } else {
+                    printGroundValue(&field->value);
+                }
+            }
+            printf(" }>");
+            break;
+        }
+        case ERROR: {
+            printf("<error type: %s, what: %s>", gv->data.errorVal.type, gv->data.errorVal.what);
+            break;
+        }
+        case NONE: {
+            printf("<none>");
             break;
         }
     }

tests/convs.grnd

@@ -1,3 +1,7 @@
-tostring 32 &int
+tostring 32 &str
+stoi "12" &int
+stod "3.14" &dou
 
+println $str
 println $int
+println $dou