renaming due to name collisions

vm/Arrays.c

@@ -7,23 +7,23 @@
 
 static long long allocatedBytes = 0;
 
-void asInit(Arrays* as) {
+void asInit(SnuviArrays* as) {
     as->capacity = 0;
     as->usedStart = -1;
     as->freeStart = -1;
     as->data = NULL;
 }
 
-void asDelete(Arrays* as) {
+void asDelete(SnuviArrays* as) {
     for(int i = 0; i < as->capacity; i++) {
         allocatedBytes -= as->data[i].size;
         free(as->data[i].data);
     }
-    allocatedBytes -= as->capacity * sizeof(Array);
+    allocatedBytes -= as->capacity * sizeof(SnuviArray);
     free(as->data);
 }
 
-static void aInitArray(Array* a, int previous, int next) {
+static void aInitArray(SnuviArray* a, int previous, int next) {
     a->size = 0;
     a->length = 0;
     a->next = next;
@@ -31,7 +31,7 @@ static void aInitArray(Array* a, int previous, int next) {
     a->data = NULL;
 }
 
-static void asInitArrays(Arrays* as, int start) {
+static void asInitArrays(SnuviArrays* as, int start) {
     int end = as->capacity - 1;
     aInitArray(as->data + start, -1, start + 1);
     for(int i = start + 1; i < end; i++) {
@@ -41,14 +41,14 @@ static void asInitArrays(Arrays* as, int start) {
     as->freeStart = start;
 }
 
-static bool asEnsureCapacity(Arrays* as) {
+static bool asEnsureCapacity(SnuviArrays* as) {
     if(as->freeStart != -1) {
         return false;
     }
     int oldCapacity = as->capacity;
     int capacity = (as->data == NULL) ? 4 : as->capacity * 2;
-    int oldBytes = sizeof(Array) * oldCapacity;
-    int bytes = sizeof(Array) * capacity;
+    int oldBytes = sizeof(SnuviArray) * oldCapacity;
+    int bytes = sizeof(SnuviArray) * capacity;
     if(bytes < 0 || allocatedBytes - oldBytes + bytes > MAX_ALLOCATED_BYTES) {
         return true;
     }
@@ -59,17 +59,17 @@ static bool asEnsureCapacity(Arrays* as) {
     return false;
 }
 
-static void asPrintDebug(Arrays* as) {
+static void asPrintDebug(SnuviArrays* as) {
     printf("Free: %d, Used: %d\n", as->freeStart, as->usedStart);
     for(int i = 0; i < as->capacity; i++) {
-        Array* a = as->data + i;
+        SnuviArray* a = as->data + i;
         printf("%d: %s, size: %d, next: %d, previous: %d\n", i,
                a->data == NULL ? "null" : "valid", a->size, a->next,
                a->previous);
     }
 }
 
-int asAllocate(Arrays* as, int typeSize, int length) {
+int asAllocate(SnuviArrays* as, int typeSize, int length) {
     (void)asPrintDebug;
     if(asEnsureCapacity(as)) {
         return -1;
@@ -83,7 +83,7 @@ int asAllocate(Arrays* as, int typeSize, int length) {
     allocatedBytes += bytes;
 
     int index = as->freeStart;
-    Array* array = as->data + index;
+    SnuviArray* array = as->data + index;
 
     as->freeStart = array->next;
     if(array->next != -1) {
@@ -102,14 +102,14 @@ int asAllocate(Arrays* as, int typeSize, int length) {
     return index;
 }
 
-Array* asGet(Arrays* as, int p) {
+SnuviArray* asGet(SnuviArrays* as, int p) {
     if(p < 0 || p >= as->capacity || as->data[p].size == 0) {
         return NULL;
     }
     return as->data + p;
 }
 
-void asDeleteArray(Arrays* as, Array* a, int p) {
+void asDeleteArray(SnuviArrays* as, SnuviArray* a, int p) {
     if(a->previous != -1) {
         as->data[a->previous].next = a->next;
     } else {

vm/Arrays.h

@@ -11,19 +11,19 @@ typedef struct {
     int next;
     int previous;
     void* data;
-} Array;
+} SnuviArray;
 
 typedef struct {
     int capacity;
     int usedStart;
     int freeStart;
-    Array* data;
-} Arrays;
+    SnuviArray* data;
+} SnuviArrays;
 
-void asInit(Arrays* as);
-void asDelete(Arrays* as);
-int asAllocate(Arrays* as, int typeSize, int length);
-Array* asGet(Arrays* as, int p);
-void asDeleteArray(Arrays* as, Array* a, int p);
+void asInit(SnuviArrays* as);
+void asDelete(SnuviArrays* as);
+int asAllocate(SnuviArrays* as, int typeSize, int length);
+SnuviArray* asGet(SnuviArrays* as, int p);
+void asDeleteArray(SnuviArrays* as, SnuviArray* a, int p);
 
 #endif

vm/Script.c

@@ -214,7 +214,7 @@ static void* sCheckTextAddress(Script* sc, Pointer* p, int length) {
 
 void* sCheckAddress(Script* sc, Pointer* p, int length) {
     if(p->array >= 0) {
-        Array* a = asGet(&sc->arrays, p->array);
+        SnuviArray* a = asGet(&sc->arrays, p->array);
         if(a == NULL) {
             sError(sc, "invalid heap pointer");
             return NULL;
@@ -356,7 +356,7 @@ static void sDeleteArray(Script* sc) {
             sError(sc, "delete of array with offset: %d", p.offset);
             return;
         }
-        Array* a = asGet(&sc->arrays, p.array);
+        SnuviArray* a = asGet(&sc->arrays, p.array);
         if(a == NULL) {
             sError(sc, "delete of invalid array");
             return;
@@ -377,7 +377,7 @@ bool sGetPointerLength(Script* sc, Pointer* p, int32* length) {
         }
         return true;
     }
-    Array* a = asGet(&sc->arrays, p->array);
+    SnuviArray* a = asGet(&sc->arrays, p->array);
     if(a == NULL) {
         sError(sc, "invalid heap pointer %d", p->array);
         return true;

vm/Script.h

@@ -17,7 +17,7 @@ typedef struct {
     int stackIndex;
     int stackVarIndex;
     int line;
-    Arrays arrays;
+    SnuviArrays arrays;
 } Script;
 
 Script* sInit(ByteCode* code);