improved data type names

Compiler.c

@@ -721,7 +721,7 @@ static void cWhile() {
     cConsumeBreaks(breakStart, code->length);
 }
 
-static DataType cDimension(DataType dt) {
+static DataType cExtendType(DataType dt) {
     int dimension = 0;
     while(cConsumeTokenIf(T_MUL)) {
         dimension++;
@@ -729,11 +729,14 @@ static DataType cDimension(DataType dt) {
     if(dimension > 0) {
         dt = dtToArray(dt, dimension);
     }
+    if(cConsumeTokenIf(T_BIT_AND)) {
+        dt = dtToReference(dt);
+    }
     return dt;
 }
 
 static void cDeclare(DataType dt) {
-    dt = cDimension(dt);
+    dt = cExtendType(dt);
     cConsumeToken(T_LITERAL);
     const char* var = cReadString();
     Variable* v = vSearchScope(&vars, var);
@@ -979,7 +982,7 @@ static void cStruct() {
             case T_FLOAT: dt = dtFloat(); break;
             default: cUnexpectedToken(t);
         }
-        dt = cDimension(dt);
+        dt = cExtendType(dt);
         cConsumeToken(T_LITERAL);
         const char* name = cReadString();
         stAddVariable(st, name, dt);

DataType.c

@@ -1,49 +1,45 @@
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "DataType.h"
 
-#define ARRAY_NAME 20
-#define ARRAY_FACTOR 10
+#define ARRAY_NAME 30
 
-static char arrayName[ARRAY_NAME];
+static int typeNameIndex = 0;
+static int typeNameSwap = 0;
+static char typeName[2][ARRAY_NAME];
 
-static const char* dtGetBaseName(unsigned int type) {
-    switch(type) {
-        case DT_INT: return "int";
-        case DT_FLOAT: return "float";
-        case DT_BOOL: return "bool";
-        default: return "";
-    }
-}
-
-static const char* dtGetArrayName(DataType dt) {
-    int dimension = dt.pointers;
-    const char* name = dtGetBaseName(dt.type);
-    if(name[0] == '\0' || dimension <= 0 || dimension > dtMaxDimensions()) {
-        return "unknown";
-    }
+static void dtAppend(const char* s) {
     int index = 0;
-    while(index < (ARRAY_NAME - 1) && name[index] != '\0') {
-        arrayName[index] = name[index];
+    while(typeNameIndex < (ARRAY_NAME - 1) && s[index] != '\0') {
+        typeName[typeNameSwap][typeNameIndex] = s[index];
         index++;
+        typeNameIndex++;
     }
-    while(index < (ARRAY_NAME - 1) && dimension > 0) {
-        arrayName[index] = '*';
-        index++;
-        dimension--;
-    }
-    arrayName[index] = '\0';
-    return arrayName;
+    typeName[typeNameSwap][typeNameIndex] = '\0';
 }
 
 const char* dtGetName(Structs* sts, DataType dt) {
+    typeNameSwap = !typeNameSwap;
+    typeNameIndex = 0;
     if(dt.structId > 0) {
-        return sts->data[dt.structId - 1].name;
-    } else if(dt.pointers > 0) {
-        return dtGetArrayName(dt);
+        dtAppend(sts->data[dt.structId - 1].name);
+    } else {
+        switch(dt.type) {
+            case DT_INT: dtAppend("int"); break;
+            case DT_FLOAT: dtAppend("float"); break;
+            case DT_BOOL: dtAppend("bool"); break;
+            default: dtAppend("unknown");
+        }
+    }
+    for(unsigned int i = 0; i < dt.pointers; i++) {
+        dtAppend("*");
+    }
+    if(dt.reference) {
+        dtAppend("&");
     }
-    return dtGetBaseName(dt.type);
+    return typeName[typeNameSwap];
 }
 
 int dtGetSize(DataType dt) {