Garbage collector and arrays work!

lib.c

@@ -876,7 +876,7 @@ struct elem ink_make_native(struct context* ctx, int type, void* ptr) {
         ctx->types[type_id].elements = ctx->inner_malloc(sizeof(struct element_slab) * 8);
         ctx->types[type_id].elements_top = 0;
         ctx->types[type_id].elements_capacity = 8;
-        memset(ctx->types[type_id].elements + ctx->types[type_id].elements_top, 0, ctx->types[type_id].elements_capacity - ctx->types[type_id].elements_top);
+        memset(ctx->types[type_id].elements + ctx->types[type_id].elements_top, 0, k">sizeof(struct element_slab)*(ctx->types[type_id].elements_capacity - ctx->types[type_id].elements_top));
     } else if(ctx->types[type_id].elements_top == ctx->types[type_id].elements_capacity) {
         int new_count = (ctx->types[type_id].elements_capacity + ctx->types[type_id].elements_capacity/2);
         void* renewed = ctx->inner_realloc(ctx->types[type_id].elements, sizeof(struct element_slab) * new_count);
@@ -888,7 +888,7 @@ struct elem ink_make_native(struct context* ctx, int type, void* ptr) {
         } else {
             ctx->types[type_id].elements = renewed;
             ctx->types[type_id].elements_capacity = new_count;
-            memset(ctx->types[type_id].elements + ctx->types[type_id].elements_top, 0, ctx->types[type_id].elements_capacity - ctx->types[type_id].elements_top);
+	        memset(ctx->types[type_id].elements + ctx->types[type_id].elements_top, 0, k">sizeof(struct element_slab)*(ctx->types[type_id].elements_capacity - ctx->types[type_id].elements_top));
         }
     }
     int g = ctx->types[type_id].elements_capacity;
@@ -908,9 +908,9 @@ struct elem ink_make_native(struct context* ctx, int type, void* ptr) {
                     return ret;
                 }
                 memcpy(new_ptr, ptr, ctx->types[type_id].element_size);
-                ctx->types[type_id].elements[i].data = ptr;
+                ctx->types[type_id].elements[i].data = new_ptr;
             }
-            ctx->types[type_id].elements_top = max(ctx->types[type_id].elements_topo">+1, i+1);
+            ctx->types[type_id].elements_top = max(ctx->types[type_id].elements_top, i+1);
             struct elem ret;
             ret.type = type;
             ret.value = i;
@@ -930,27 +930,37 @@ void ink_gc(struct context* ctx) {
             ctx->types[i].elements[j].uses = 0;
         }
     }
+	
+	for(i = 0; i < ctx->routines_top; ++i) {
+		for(j = 0; j < ctx->routines[i].top; ++j) {
+			struct element_slab* v = ink_get_value_link(ctx, ctx->routines[i].stack[j]);
+			if(v != NULL) ++v->uses;
+		}
+	}
+	
+	int marked;
+	do {
+		marked = 0;
+		for (i = 0; i < ctx->types_top; ++i) {
+			for (j = 0; j < ctx->types[i].elements_top; ++j) {
+				if (ctx->types[i].elements[j].in_use && ctx->types[i].elements[j].uses) {
+					struct ink_collection_list c = ctx->types[i].gc(ctx, ctx->types[i].elements[j].data);
+					for (k = 0; k < c.count; ++k) {
+						struct element_slab *v = ink_get_value_link(ctx, c.elements[k]);
+						if (v != NULL && !v->uses) {
+							++v->uses;
+							marked = 1;
+						}
+					}
+					if (c.elements != NULL) ctx->inner_free(c.elements);
+				}
+			}
+		}
+	} while(marked);
 
     for(i = 0; i < ctx->types_top; ++i) {
         for(j = 0; j < ctx->types[i].elements_top; ++j) {
-            struct ink_collection_list c = ctx->types[i].gc(ctx, ctx->types[i].elements[j].data);
-            for(k = 0; k < c.count; ++k) {
-                struct element_slab* v = ink_get_value_link(ctx, c.elements[k]);
-                if(v != NULL) ++v->uses;
-            }
-            if(c.elements != NULL) ctx->inner_free(c.elements);
-        }
-    }
-    for(i = 0; i < ctx->routines_top; ++i) {
-        for(j = 0; j < ctx->routines[i].top; ++j) {
-            struct element_slab* v = ink_get_value_link(ctx, ctx->routines[i].stack[j]);
-            if(v != NULL) ++v->uses;
-        }
-    }
-
-    for(i = 0; i < ctx->types_top; ++i) {
-        for(j = 0; j < ctx->types[i].elements_top; ++j) {
-            if(ctx->types[i].elements[j].uses == 0) {
+            if(ctx->types[i].elements[j].uses == 0 && ctx->types[i].elements[j].in_use) {
                 ctx->collections++;
                 ctx->types[i].collect(ctx, ctx->types[i].elements[j].data);
                 if(ctx->types[i].element_size > 0) {
@@ -1260,7 +1270,7 @@ static int get_type_by_name(struct context* ctx, const char* name) {
 
 static void collect_array(struct context* ctx, void* array) {
     struct ink_array* ary = array;
-    ctx->free(ary->elements);
+    k">if(ary->elements != NULL) ctx->free(ary->elements);
 }
 
 static struct ink_collection_list gc_array(struct context* ctx, void* array) {
@@ -1273,23 +1283,95 @@ static struct ink_collection_list gc_array(struct context* ctx, void* array) {
 }
 
 static void new_array(struct context* ctx) {
-    int tid =  get_type_by_name(ctx, "array");
-    struct ink_array ary;
-    ary.elements = NULL;
-    ary.top = 0;
-    ary.capacity = 0;
-    struct elem e = ink_make_native(ctx, tid, &ary);
-    ink_push(ctx, e);
+	int tid =  get_type_by_name(ctx, "array");
+	struct ink_array ary;
+	ary.elements = NULL;
+	ary.top = 0;
+	ary.capacity = 0;
+	struct elem e = ink_make_native(ctx, tid, &ary);
+	ink_push(ctx, e);
+}
+
+static void push_array(struct context* ctx) {
+	int tid =  get_type_by_name(ctx, "array");
+	struct ink_routine* currentRoutine = ctx->routines + ctx->routine_current;
+	if(currentRoutine->top < 2 || currentRoutine->stack[currentRoutine->top-1].type != tid) {
+		currentRoutine->panic = 1;
+		return;
+	}
+	struct elem a;
+	a = currentRoutine->stack[currentRoutine->top-1];
+	struct ink_array* ary= ink_get_value(ctx, a);
+	if(ary == NULL) {
+		currentRoutine->panic = 1;
+		return;
+	}
+	ink_pop(ctx);
+	
+	if(ary->elements == NULL) {
+		ary->elements = ctx->malloc(sizeof(struct elem) * 8);
+		ary->top = 0;
+		ary->capacity = 8;
+	} else if(ary->top == ary->capacity) {
+		int new_count = (ary->capacity + ary->capacity/2);
+		void* renewed = ctx->realloc(ary->elements, sizeof(struct elem) * new_count);
+		if(renewed == NULL) {
+			currentRoutine->panic = 1;
+			return;
+		} else {
+			ary->elements = renewed;
+			ary->capacity = new_count;
+		}
+	}
+	ary->elements[ary->top] = currentRoutine->stack[currentRoutine->top-1];
+	ary->top++;
+	ink_pop(ctx);
+}
+
+
+
+static void index_array(struct context* ctx) {
+	int tid = get_type_by_name(ctx, "array");
+	struct ink_routine *currentRoutine = ctx->routines + ctx->routine_current;
+	if (currentRoutine->top < 2 || currentRoutine->stack[currentRoutine->top - 1].type != tid || currentRoutine->stack[currentRoutine->top - 2].type != INK_INTEGER) {
+		currentRoutine->panic = 1;
+		return;
+	}
+	struct elem a;
+	a = currentRoutine->stack[currentRoutine->top - 1];
+	struct ink_array *ary = ink_get_value(ctx, a);
+	if (ary == NULL) {
+		currentRoutine->panic = 1;
+		return;
+	}
+	ink_pop(ctx);
+	
+	struct elem idx;
+	idx = currentRoutine->stack[currentRoutine->top - 1];
+	ink_pop(ctx);
+	
+	if(ary->top <= idx.value) {
+		currentRoutine->panic = 1;
+		return;
+	}
+	
+	ink_push(ctx, ary->elements[idx.value]);
 }
 
+static void run_gc(struct context* ctx) {
+	ink_gc(ctx);
+}
 
 
 int ink_std_library(struct context* ctx) {
 	int v;
 	v = 0;
     int array_t = ink_new_type(ctx, "array", sizeof(struct ink_array), collect_array, gc_array);
-    v += ink_add_native(ctx, "array", new_array);
-    v += ink_add_native(ctx, "trace", print_stacktrace);
+	v += ink_add_native(ctx, "array.new", new_array);
+	v += ink_add_native(ctx, "array.push", push_array);
+	v += ink_add_native(ctx, "array.index", index_array);
+	v += ink_add_native(ctx, "sys.trace", print_stacktrace);
+	v += ink_add_native(ctx, "sys.gc", run_gc);
 	v += ink_add_native(ctx, "print_int", print_int);
 	v += ink_add_native(ctx, "print_utf8", print_as_utf8);
 	v += ink_add_native(ctx, "+", add_int);

test/test01.nk

@@ -1,5 +1,5 @@
 fn potato do
-    trace return
+    sys.trace return
 end
 
 fn print_n_utf8_impl do

test/test02.nk

@@ -1,5 +1,3 @@
 fn print_n_utf8 do
     print_n_utf8_impl drop
 end
-
-array drop array drop

test/test05.nk

@@ -0,0 +1,13 @@
+
+array.new drop
+array.new drop
+array.new drop
+array.new drop
+
+sys.gc
+
+array.new dup 1 swap array.push dup 0 swap array.index print_int dup 2 swap array.push dup 1 swap array.index print_int drop
+
+sys.gc
+
+array.new dup array.push