2006-12-03 Akira TAGOH <at@gclab.org>

	* hieroglyph/hgstack.c (_hg_stack_real_set_flags): modify due to using
	HgList instead of GList.
	(_hg_stack_real_relocate): likewise.
	(_hg_stack_real_dup): likewise.
	(hg_stack_new): likewise.
	(_hg_stack_push): likewise.
	(hg_stack_pop): likewise.
	(hg_stack_clear): likewise.
	(hg_stack_index): likewise.
	(hg_stack_roll): likewise.
	(hg_stack_dump): likewise.

	* hieroglyph/hglist.c (hg_list_iter_get_index): new function.
	(hg_list_iter_roll): new function.

7 files changed, 502 insertions, 93 deletions

diff --git a/ChangeLog b/ChangeLog
index 4366dbb..fc1c8ec 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,20 @@
+2006-12-03  Akira TAGOH  <at@gclab.org>
+
+	* hieroglyph/hgstack.c (_hg_stack_real_set_flags): modify due to using
+	HgList instead of GList.
+	(_hg_stack_real_relocate): likewise.
+	(_hg_stack_real_dup): likewise.
+	(hg_stack_new): likewise.
+	(_hg_stack_push): likewise.
+	(hg_stack_pop): likewise.
+	(hg_stack_clear): likewise.
+	(hg_stack_index): likewise.
+	(hg_stack_roll): likewise.
+	(hg_stack_dump): likewise.
+
+	* hieroglyph/hglist.c (hg_list_iter_get_index): new function.
+	(hg_list_iter_roll): new function.
+
 2006-11-21  Akira TAGOH  <at@gclab.org>
 
 	* hieroglyph/hglist.c (hg_list_get_iter_previous): new function.
diff --git a/hieroglyph/hglist.c b/hieroglyph/hglist.c
index 9b97bba..43225e8 100644
--- a/hieroglyph/hglist.c
+++ b/hieroglyph/hglist.c
@@ -51,6 +51,7 @@ struct _HieroGlyphListIter {
 	HgList   *top;
 	HgList   *last;
 	HgList   *current;
+	gint32    index;
 };
 
 #define hg_list_next(_list)	((_list)->next)
@@ -522,6 +523,7 @@ hg_list_iter_new(HgList *list)
 	iter->top = list;
 	iter->last = hg_list_previous(list);
 	iter->current = list;
+	iter->index = 0;
 
 	return iter;
 }
@@ -536,6 +538,7 @@ hg_list_get_iter_first(HgList     *list,
 	g_return_val_if_fail (iter->last == hg_list_previous(list), FALSE);
 
 	iter->current = iter->top;
+	iter->index = 0;
 
 	return TRUE;
 }
@@ -548,10 +551,12 @@ hg_list_get_iter_next(HgList     *list,
 	g_return_val_if_fail (iter != NULL, FALSE);
 	g_return_val_if_fail (iter->top == list, FALSE);
 	g_return_val_if_fail (iter->last == hg_list_previous(list), FALSE);
+	g_return_val_if_fail (iter->index < G_MAXINT32, FALSE);
 
 	iter->current = hg_list_next(iter->current);
 	if (iter->current == iter->top)
 		return FALSE;
+	iter->index++;
 
 	return TRUE;
 }
@@ -564,10 +569,12 @@ hg_list_get_iter_previous(HgList     *list,
 	g_return_val_if_fail (iter != NULL, FALSE);
 	g_return_val_if_fail (iter->top == list, FALSE);
 	g_return_val_if_fail (iter->last == hg_list_previous(list), FALSE);
+	g_return_val_if_fail (iter->index != 0, FALSE);
 
 	iter->current = hg_list_previous(iter->current);
 	if (iter->current == iter->last)
 		return FALSE;
+	iter->index--;
 
 	return TRUE;
 }
@@ -582,6 +589,8 @@ hg_list_get_iter_last(HgList     *list,
 	g_return_val_if_fail (iter->last == hg_list_previous(list), FALSE);
 
 	iter->current = hg_list_last(iter->current);
+	/* postpone to calculate current index */
+	iter->index = -1;
 
 	return TRUE;
 }
@@ -633,10 +642,98 @@ hg_list_iter_delete_link(HgListIter iter)
 		iter->top = next;
 	list = iter->top;
 	iter->current = prev;
+	iter->index--;
 
 	return list;
 }
 
+gint32
+hg_list_iter_get_index(HgListIter iter)
+{
+	g_return_val_if_fail (iter != NULL, -1);
+
+	if (iter->index < 0)
+		iter->index += hg_list_length(iter->top);
+
+	return iter->index;
+}
+
+HgList *
+hg_list_iter_roll(HgListIter start,
+		  HgListIter end,
+		  guint      n)
+{
+	guint n_blocks, start_offset, end_offset;
+	HgList *l, *beginning = NULL, *ending = NULL, *out_beginning = NULL, *out_ending = NULL;
+
+	g_return_val_if_fail (start != NULL, NULL);
+	g_return_val_if_fail (end != NULL, NULL);
+	g_return_val_if_fail (start->top == end->top, NULL);
+	g_return_val_if_fail (start->last == end->last, NULL);
+
+	if (n == 0)
+		return start->top;
+
+	start_offset = hg_list_iter_get_index(start);
+	end_offset = hg_list_iter_get_index(end);
+	if (start_offset < end_offset)
+		n_blocks = end_offset - start_offset + 1;
+	else
+		n_blocks = start_offset - end_offset + 1;
+
+	if (n_blocks == 0)
+		return start->top;
+	n %= n_blocks;
+	if (n != 0) {
+		HG_LIST_SET_LAST_NODE (start->last, FALSE);
+		if (start_offset < end_offset) {
+			out_beginning = hg_list_previous(start->current);
+			out_ending = hg_list_next(end->current);
+			hg_list_next(end->current) = start->current;
+			hg_list_previous(start->current) = end->current;
+		} else {
+			out_beginning = hg_list_previous(end->current);
+			out_ending = hg_list_next(start->current);
+			hg_list_previous(end->current) = start->current;
+			hg_list_next(start->current) = end->current;
+		}
+		if (out_beginning == start->last &&
+		    out_ending == start->top) {
+			out_beginning = NULL;
+			out_ending = NULL;
+		}
+
+		if (start_offset > end_offset) {
+			for (l = start->current; n > 0; l = hg_list_next(l), n--);
+			beginning = hg_list_next(l);
+			ending = l;
+		} else {
+			for (l = start->current; n > 0; l = hg_list_previous(l), n--);
+			beginning = l;
+			ending = hg_list_previous(l);
+		}
+		if (out_beginning) {
+			hg_list_next(out_beginning) = beginning;
+			hg_list_previous(beginning) = out_beginning;
+		}
+		if (out_ending) {
+			hg_list_previous(out_ending) = ending;
+			hg_list_next(ending) = out_ending;
+		}
+		if (start_offset < end_offset) {
+			if (start->current == start->top)
+				start->top = end->top = beginning;
+		} else {
+			if (end->current == end->top)
+				start->top = end->top = beginning;
+		}
+		start->last = end->last = hg_list_previous(start->top);
+		HG_LIST_SET_LAST_NODE (start->last, TRUE);
+	}
+
+	return start->top;
+}
+
 HgListIter
 hg_list_find_iter(HgList        *list,
 		  gconstpointer  data)
diff --git a/hieroglyph/hglist.h b/hieroglyph/hglist.h
index c452aef..f25c146 100644
--- a/hieroglyph/hglist.h
+++ b/hieroglyph/hglist.h
@@ -69,6 +69,10 @@ void       hg_list_iter_set_data    (HgListIter     iter,
 void       hg_list_iter_set_object  (HgListIter     iter,
 				     HgObject      *hobject);
 HgList    *hg_list_iter_delete_link (HgListIter     iter);
+gint32     hg_list_iter_get_index   (HgListIter     iter);
+HgList    *hg_list_iter_roll        (HgListIter     start,
+				     HgListIter     end,
+				     guint          n);
 
 
 G_END_DECLS
diff --git a/hieroglyph/hgstack.c b/hieroglyph/hgstack.c
index 489e2d7..071c6d4 100644
--- a/hieroglyph/hgstack.c
+++ b/hieroglyph/hgstack.c
@@ -27,6 +27,7 @@
 
 #include <stdlib.h>
 #include "hgstack.h"
+#include "hglist.h"
 #include "hglog.h"
 #include "hgmem.h"
 #include "hgfile.h"
@@ -36,8 +37,7 @@
 
 struct _HieroGlyphStack {
 	HgObject  object;
-	GList    *stack;
-	GList    *last_stack;
+	HgList   *stack;
 	guint     max_depth;
 	guint     current_depth;
 	gboolean  use_validator;
@@ -69,7 +69,8 @@ _hg_stack_real_free(gpointer data)
 {
 	HgStack *stack = data;
 
-	g_list_free(stack->stack);
+	if (stack->stack)
+		hg_mem_free(stack->stack);
 }
 
 static void
@@ -77,17 +78,23 @@ _hg_stack_real_set_flags(gpointer data,
 			 guint    flags)
 {
 	HgStack *stack = data;
-	GList *list;
 	HgMemObject *obj;
-
-	for (list = stack->stack; list != NULL; list = g_list_next(list)) {
-		hg_mem_get_object__inline(list->data, obj);
-		if (obj == NULL) {
-			hg_log_warning("Invalid object %p to be marked: HgValueNode in stack.", list->data);
-		} else {
-			if (!hg_mem_is_flags__inline(obj, flags))
-				hg_mem_set_flags__inline(obj, flags, TRUE);
-		}
+	HgListIter iter;
+
+	if (stack->stack) {
+		iter = hg_list_iter_new(stack->stack);
+		do {
+			gpointer p = hg_list_iter_get_data(iter);
+
+			hg_mem_get_object__inline(p, obj);
+			if (obj == NULL) {
+				hg_log_warning("Invalid object %p to be marked: HgValueNode in stack.", p);
+			} else {
+				if (!hg_mem_is_flags__inline(obj, flags))
+					hg_mem_set_flags__inline(obj, flags, TRUE);
+			}
+		} while (hg_list_get_iter_next(stack->stack, iter));
+		hg_list_iter_free(iter);
 	}
 }
 
@@ -96,13 +103,19 @@ _hg_stack_real_relocate(gpointer           data,
 			HgMemRelocateInfo *info)
 {
 	HgStack *stack = data;
-	GList *list;
-
-	for (list = stack->stack; list != NULL; list = g_list_next(list)) {
-		if ((gsize)list->data >= info->start &&
-		    (gsize)list->data <= info->end) {
-			list->data = (gpointer)((gsize)list->data + info->diff);
-		}
+	HgListIter iter;
+
+	if (stack->stack) {
+		iter = hg_list_iter_new(stack->stack);
+		do {
+			gpointer p = hg_list_iter_get_data(iter);
+
+			if ((gsize)p >= info->start &&
+			    (gsize)p <= info->end) {
+				hg_list_iter_set_data(iter, (gpointer)((gsize)p + info->diff));
+			}
+		} while (hg_list_get_iter_next(stack->stack, iter));
+		hg_list_iter_free(iter);
 	}
 }
 
@@ -121,8 +134,7 @@ _hg_stack_real_dup(gpointer data)
 		hg_log_warning("Failed to duplicate a stack.");
 		return NULL;
 	}
-	retval->stack = g_list_copy(stack->stack);
-	retval->last_stack = g_list_last(retval->stack);
+	retval->stack = hg_object_dup((HgObject *)stack->stack);
 
 	return retval;
 }
@@ -150,7 +162,6 @@ hg_stack_new(HgMemPool *pool,
 	retval->current_depth = 0;
 	retval->max_depth = max_depth;
 	retval->stack = NULL;
-	retval->last_stack = NULL;
 	retval->use_validator = TRUE;
 
 	return retval;
@@ -177,20 +188,16 @@ gboolean
 _hg_stack_push(HgStack     *stack,
 	       HgValueNode *node)
 {
-	GList *list;
-
 	g_return_val_if_fail (stack != NULL, FALSE);
 	g_return_val_if_fail (node != NULL, FALSE);
 
-	list = g_list_alloc();
-	list->data = node;
 	if (stack->stack == NULL) {
-		stack->stack = stack->last_stack = list;
-	} else {
-		stack->last_stack->next = list;
-		list->prev = stack->last_stack;
-		stack->last_stack = list;
+		HgMemObject *obj;
+
+		hg_mem_get_object__inline(stack, obj);
+		stack->stack = hg_list_new(obj->pool);
 	}
+	stack->stack = hg_list_append(stack->stack, node);
 	stack->current_depth++;
 
 	return TRUE;
@@ -214,24 +221,18 @@ HgValueNode *
 hg_stack_pop(HgStack *stack)
 {
 	HgValueNode *retval;
-	GList *list;
+	HgListIter iter;
 
 	g_return_val_if_fail (stack != NULL, NULL);
 
-	if (stack->last_stack == NULL)
+	if (stack->stack == NULL)
 		return NULL;
 
-	list = stack->last_stack;
-	stack->last_stack = list->prev;
-	if (list->prev) {
-		list->prev->next = NULL;
-		list->prev = NULL;
-	}
-	if (stack->stack == list) {
-		stack->stack = NULL;
-	}
-	retval = list->data;
-	g_list_free_1(list);
+	iter = hg_list_iter_new(stack->stack);
+	hg_list_get_iter_last(stack->stack, iter);
+	retval = hg_list_iter_get_data(iter);
+	stack->stack = hg_list_iter_delete_link(iter);
+	hg_list_iter_free(iter);
 	stack->current_depth--;
 
 	return retval;
@@ -242,7 +243,8 @@ hg_stack_clear(HgStack *stack)
 {
 	g_return_if_fail (stack != NULL);
 
-	g_list_free(stack->stack);
+	if (stack->stack)
+		hg_mem_free(stack->stack);
 	stack->stack = NULL;
 	stack->current_depth = 0;
 }
@@ -251,14 +253,25 @@ HgValueNode *
 hg_stack_index(HgStack *stack,
 	       guint    index_from_top)
 {
-	GList *list;
+	HgListIter iter;
+	HgValueNode *retval;
 
 	g_return_val_if_fail (stack != NULL, NULL);
 	g_return_val_if_fail (index_from_top < stack->current_depth, NULL);
 
-	for (list = stack->last_stack; index_from_top > 0; list = g_list_previous(list), index_from_top--);
+	iter = hg_list_iter_new(stack->stack);
+	hg_list_get_iter_last(stack->stack, iter);
+	while (index_from_top > 0) {
+		if (!hg_list_get_iter_previous(stack->stack, iter)) {
+			hg_log_warning("Detected inconsistency of stack during getting with index.");
+			return NULL;
+		}
+		index_from_top--;
+	}
+	retval = hg_list_iter_get_data(iter);
+	hg_list_iter_free(iter);
 
-	return list->data;
+	return retval;
 }
 
 void
@@ -266,7 +279,7 @@ hg_stack_roll(HgStack *stack,
 	      guint    n_block,
 	      gint32   n_times)
 {
-	GList *notargeted_before, *notargeted_after, *beginning, *ending;
+	HgListIter start, end;
 	gint32 n, i;
 
 	g_return_if_fail (stack != NULL);
@@ -277,33 +290,20 @@ hg_stack_roll(HgStack *stack,
 		return;
 	n = abs(n_times) % n_block;
 	if (n != 0) {
-		/* find the place that isn't targeted for roll */
-		for (notargeted_before = stack->last_stack, i = n_block;
-		     i > 0;
-		     notargeted_before = g_list_previous(notargeted_before), i--);
-		if (!notargeted_before)
-			notargeted_after = stack->stack;
-		else
-			notargeted_after = notargeted_before->next;
-		/* try to find the place to cut off */
-		if (n_times > 0) {
-			for (beginning = stack->last_stack; n > 1; beginning = g_list_previous(beginning), n--);
-			ending = beginning->prev;
-		} else {
-			for (ending = notargeted_after; n > 1; ending = g_list_next(ending), n--);
-			beginning = ending->next;
-		}
-		stack->last_stack->next = notargeted_after;
-		stack->last_stack->next->prev = stack->last_stack;
-		if (notargeted_before) {
-			notargeted_before->next = beginning;
-			notargeted_before->next->prev = notargeted_before;
-		} else {
-			stack->stack = beginning;
-			stack->stack->prev = NULL;
+		start = hg_list_iter_new(stack->stack);
+		end = hg_list_iter_new(stack->stack);
+		hg_list_get_iter_last(stack->stack, start);
+		hg_list_get_iter_last(stack->stack, end);
+		for (i = n_block; i > 1; i--, hg_list_get_iter_previous(stack->stack, start));
+		if (n_times < 0) {
+			HgListIter tmp = start;
+
+			start = end;
+			end = tmp;
 		}
-		stack->last_stack = ending;
-		stack->last_stack->next = NULL;
+		stack->stack = hg_list_iter_roll(start, end, n);
+		hg_list_iter_free(start);
+		hg_list_iter_free(end);
 	}
 }
 
@@ -311,18 +311,22 @@ void
 hg_stack_dump(HgStack      *stack,
 	      HgFileObject *file)
 {
-	GList *l;
+	HgListIter iter;
 	HgValueNode *node;
 
 	g_return_if_fail (stack != NULL);
 
 	hg_file_object_printf(file, "   address|   type|content\n");
 	hg_file_object_printf(file, "----------+-------+-------------------------------\n");
-	for (l = stack->stack; l != NULL; l = g_list_next(l)) {
-		node = l->data;
-		hg_value_node_debug_print(file,
-					  HG_DEBUG_DUMP,
-					  HG_VALUE_GET_VALUE_TYPE (node),
-					  stack, node, NULL);
+	if (stack->stack) {
+		iter = hg_list_iter_new(stack->stack);
+		do {
+			node = hg_list_iter_get_data(iter);
+			hg_value_node_debug_print(file,
+						  HG_DEBUG_DUMP,
+						  HG_VALUE_GET_VALUE_TYPE (node),
+						  stack, node, NULL);
+		} while (hg_list_get_iter_next(stack->stack, iter));
+		hg_list_iter_free(iter);
 	}
 }
diff --git a/hieroglyph/version.h.in b/hieroglyph/version.h.in
index cfbe095..ca41a32 100644
--- a/hieroglyph/version.h.in
+++ b/hieroglyph/version.h.in
@@ -29,7 +29,7 @@
 G_BEGIN_DECLS
 
 #define HIEROGLYPH_VERSION	"@VERSION@"
-#define HIEROGLYPH_UUID		"9f44b1a6-671c-4534-9614-0ca1984d2d92"
+#define HIEROGLYPH_UUID		"a1e3d9a0-0e8a-430b-ad59-05e4b4c0393c"
 
 const char *__hg_rcsid G_GNUC_UNUSED = "$Rev$";
 
diff --git a/hieroglyph/vm.c b/hieroglyph/vm.c
index b0dcb4e..5b24eb7 100644
--- a/hieroglyph/vm.c
+++ b/hieroglyph/vm.c
@@ -1242,17 +1242,16 @@ hg_vm_main(HgVM *vm)
 			break;
 		}
 
-#ifdef DEBUG_VM
+#ifdef DEBUG
 		G_STMT_START {
 			HgString *s;
 
 			s = hg_object_to_string((HgObject *)node);
-			hg_file_object_printf(vm->stderr, "DEBUG: [%s] %s\n",
-					      hg_value_node_get_type_name(HG_VALUE_GET_VALUE_TYPE (node)),
-					      hg_string_get_string(s));
+			hg_log_debug(DEBUG_VM, "processing %s on %s", hg_string_get_string(s),
+				     hg_value_node_get_type_name(HG_VALUE_GET_VALUE_TYPE (node)));
 			hg_mem_free(s);
 		} G_STMT_END;
-#endif /* DEBUG_VM */
+#endif /* DEBUG */
 		switch (HG_VALUE_GET_VALUE_TYPE (node)) {
 		    case HG_TYPE_VALUE_BOOLEAN:
 		    case HG_TYPE_VALUE_INTEGER:
@@ -1377,13 +1376,15 @@ hg_vm_main(HgVM *vm)
 
 					    tmp_node = hg_scanner_get_object(vm, file);
 					    if (tmp_node != NULL) {
-#ifdef DEBUG_SCANNER
+#ifdef DEBUG
 						    G_STMT_START {
 							    HgString *__str__ = hg_object_to_string((HgObject *)tmp_node);
 
-							    g_print("SCANNER: %s\n", hg_string_get_string(__str__));
+							    hg_log_debug(DEBUG_SCANNER, "scanning %s",
+									 hg_string_get_string(__str__));
+							    hg_mem_free(__str__);
 						    } G_STMT_END;
-#endif /* DEBUG_SCANNER */
+#endif /* DEBUG */
 						    if (hg_object_is_executable((HgObject *)tmp_node) &&
 							(HG_IS_VALUE_NAME (tmp_node) ||
 							 HG_IS_VALUE_OPERATOR (tmp_node))) {
diff --git a/tests/hglist.c b/tests/hglist.c
index a76b925..4b8411b 100644
--- a/tests/hglist.c
+++ b/tests/hglist.c
@@ -10,11 +10,19 @@ main(void)
 	HgAllocator *allocator;
 	HgMemPool *pool;
 	HgList *list;
-	HgListIter iter;
+	HgListIter iter, iter2;
 	gint tc1[] = {1, 2, 3, 0};
 	gint tc2[] = {1, 3, 0};
 	gint tc3[] = {2, 3, 0};
 	gint tc4[] = {1, 2, 0};
+	gint tc5[] = {4, 1, 2, 3, 5, 0};
+	gint tc6[] = {4, 1, 2, 3, 0};
+	gint tc7[] = {1, 4, 2, 3, 5, 0};
+	gint tc8[] = {1, 5, 2, 3, 4, 0};
+	gint tc9[] = {2, 3, 4, 1, 5, 0};
+	gint tc10[] = {2, 3, 4, 1, 0};
+	gint tc11[] = {1, 3, 4, 2, 5, 0};
+	gint tc12[] = {1, 3, 4, 5, 2, 0};
 	gint i;
 
 	allocator = hg_allocator_new(hg_allocator_bfit_get_vtable());
@@ -145,6 +153,284 @@ main(void)
 		return 1;
 	}
 
+	/* testcase 5 */
+	list = hg_list_new(pool);
+	if (list == NULL) {
+		g_print("Failed to create an list.\n");
+		return 1;
+	}
+
+	list = hg_list_append(list, GINT_TO_POINTER (1));
+	list = hg_list_append(list, GINT_TO_POINTER (2));
+	list = hg_list_append(list, GINT_TO_POINTER (3));
+	list = hg_list_append(list, GINT_TO_POINTER (4));
+	list = hg_list_append(list, GINT_TO_POINTER (5));
+
+	iter = hg_list_iter_new(list);
+	iter2 = hg_list_iter_new(list);
+	hg_list_get_iter_last(list, iter2);
+	hg_list_get_iter_previous(list, iter2);
+	list = hg_list_iter_roll(iter, iter2, 1);
+	hg_list_get_iter_first(list, iter);
+	if (hg_list_length(list) != 5) {
+		g_print("Expected list size 5 but actually was %d\n", hg_list_length(list));
+		return 1;
+	}
+	for (i = 0; ; i++) {
+		if (tc5[i] != GPOINTER_TO_INT (hg_list_iter_get_data(iter))) {
+			g_print("Failed to compare: expected %d[%d], but actually %d\n",
+				tc5[i], i, GPOINTER_TO_INT (hg_list_iter_get_data(iter)));
+			return 1;
+		}
+		if (!hg_list_get_iter_next(list, iter))
+			break;
+	}
+	hg_list_iter_free(iter);
+	hg_list_iter_free(iter2);
+
+	/* testcase 6 */
+	list = hg_list_new(pool);
+	if (list == NULL) {
+		g_print("Failed to create an list.\n");
+		return 1;
+	}
+
+	list = hg_list_append(list, GINT_TO_POINTER (1));
+	list = hg_list_append(list, GINT_TO_POINTER (2));
+	list = hg_list_append(list, GINT_TO_POINTER (3));
+	list = hg_list_append(list, GINT_TO_POINTER (4));
+
+	iter = hg_list_iter_new(list);
+	iter2 = hg_list_iter_new(list);
+	hg_list_get_iter_last(list, iter2);
+	list = hg_list_iter_roll(iter, iter2, 1);
+	hg_list_get_iter_first(list, iter);
+	if (hg_list_length(list) != 4) {
+		g_print("Expected list size 4 but actually was %d\n", hg_list_length(list));
+		return 1;
+	}
+	for (i = 0; ; i++) {
+		if (tc6[i] != GPOINTER_TO_INT (hg_list_iter_get_data(iter))) {
+			g_print("Failed to compare: expected %d[%d], but actually %d\n",
+				tc6[i], i, GPOINTER_TO_INT (hg_list_iter_get_data(iter)));
+			return 1;
+		}
+		if (!hg_list_get_iter_next(list, iter))
+			break;
+	}
+	hg_list_iter_free(iter);
+	hg_list_iter_free(iter2);
+
+	/* testcase 7 */
+	list = hg_list_new(pool);
+	if (list == NULL) {
+		g_print("Failed to create an list.\n");
+		return 1;
+	}
+
+	list = hg_list_append(list, GINT_TO_POINTER (1));
+	list = hg_list_append(list, GINT_TO_POINTER (2));
+	list = hg_list_append(list, GINT_TO_POINTER (3));
+	list = hg_list_append(list, GINT_TO_POINTER (4));
+	list = hg_list_append(list, GINT_TO_POINTER (5));
+
+	iter = hg_list_iter_new(list);
+	hg_list_get_iter_next(list, iter);
+	iter2 = hg_list_iter_new(list);
+	hg_list_get_iter_last(list, iter2);
+	hg_list_get_iter_previous(list, iter2);
+	list = hg_list_iter_roll(iter, iter2, 1);
+	hg_list_get_iter_first(list, iter);
+	if (hg_list_length(list) != 5) {
+		g_print("Expected list size 5 but actually was %d\n", hg_list_length(list));
+		return 1;
+	}
+	for (i = 0; ; i++) {
+		if (tc7[i] != GPOINTER_TO_INT (hg_list_iter_get_data(iter))) {
+			g_print("Failed to compare: expected %d[%d], but actually %d\n",
+				tc7[i], i, GPOINTER_TO_INT (hg_list_iter_get_data(iter)));
+			return 1;
+		}
+		if (!hg_list_get_iter_next(list, iter))
+			break;
+	}
+	hg_list_iter_free(iter);
+	hg_list_iter_free(iter2);
+
+	/* testcase 8 */
+	list = hg_list_new(pool);
+	if (list == NULL) {
+		g_print("Failed to create an list.\n");
+		return 1;
+	}
+
+	list = hg_list_append(list, GINT_TO_POINTER (1));
+	list = hg_list_append(list, GINT_TO_POINTER (2));
+	list = hg_list_append(list, GINT_TO_POINTER (3));
+	list = hg_list_append(list, GINT_TO_POINTER (4));
+	list = hg_list_append(list, GINT_TO_POINTER (5));
+
+	iter = hg_list_iter_new(list);
+	hg_list_get_iter_next(list, iter);
+	iter2 = hg_list_iter_new(list);
+	hg_list_get_iter_last(list, iter2);
+	list = hg_list_iter_roll(iter, iter2, 1);
+	hg_list_get_iter_first(list, iter);
+	if (hg_list_length(list) != 5) {
+		g_print("Expected list size 5 but actually was %d\n", hg_list_length(list));
+		return 1;
+	}
+	for (i = 0; ; i++) {
+		if (tc8[i] != GPOINTER_TO_INT (hg_list_iter_get_data(iter))) {
+			g_print("Failed to compare: expected %d[%d], but actually %d\n",
+				tc8[i], i, GPOINTER_TO_INT (hg_list_iter_get_data(iter)));
+			return 1;
+		}
+		if (!hg_list_get_iter_next(list, iter))
+			break;
+	}
+	hg_list_iter_free(iter);
+	hg_list_iter_free(iter2);
+
+	/* testcase 9 */
+	list = hg_list_new(pool);
+	if (list == NULL) {
+		g_print("Failed to create an list.\n");
+		return 1;
+	}
+
+	list = hg_list_append(list, GINT_TO_POINTER (1));
+	list = hg_list_append(list, GINT_TO_POINTER (2));
+	list = hg_list_append(list, GINT_TO_POINTER (3));
+	list = hg_list_append(list, GINT_TO_POINTER (4));
+	list = hg_list_append(list, GINT_TO_POINTER (5));
+
+	iter = hg_list_iter_new(list);
+	iter2 = hg_list_iter_new(list);
+	hg_list_get_iter_last(list, iter2);
+	hg_list_get_iter_previous(list, iter2);
+	list = hg_list_iter_roll(iter2, iter, 1);
+	hg_list_get_iter_first(list, iter);
+	if (hg_list_length(list) != 5) {
+		g_print("Expected list size 5 but actually was %d\n", hg_list_length(list));
+		return 1;
+	}
+	for (i = 0; ; i++) {
+		if (tc9[i] != GPOINTER_TO_INT (hg_list_iter_get_data(iter))) {
+			g_print("Failed to compare: expected %d[%d], but actually %d\n",
+				tc9[i], i, GPOINTER_TO_INT (hg_list_iter_get_data(iter)));
+			return 1;
+		}
+		if (!hg_list_get_iter_next(list, iter))
+			break;
+	}
+	hg_list_iter_free(iter);
+	hg_list_iter_free(iter2);
+
+	/* testcase 10 */
+	list = hg_list_new(pool);
+	if (list == NULL) {
+		g_print("Failed to create an list.\n");
+		return 1;
+	}
+
+	list = hg_list_append(list, GINT_TO_POINTER (1));
+	list = hg_list_append(list, GINT_TO_POINTER (2));
+	list = hg_list_append(list, GINT_TO_POINTER (3));
+	list = hg_list_append(list, GINT_TO_POINTER (4));
+
+	iter = hg_list_iter_new(list);
+	iter2 = hg_list_iter_new(list);
+	hg_list_get_iter_last(list, iter2);
+	list = hg_list_iter_roll(iter2, iter, 1);
+	hg_list_get_iter_first(list, iter);
+	if (hg_list_length(list) != 4) {
+		g_print("Expected list size 4 but actually was %d\n", hg_list_length(list));
+		return 1;
+	}
+	for (i = 0; ; i++) {
+		if (tc10[i] != GPOINTER_TO_INT (hg_list_iter_get_data(iter))) {
+			g_print("Failed to compare: expected %d[%d], but actually %d\n",
+				tc10[i], i, GPOINTER_TO_INT (hg_list_iter_get_data(iter)));
+			return 1;
+		}
+		if (!hg_list_get_iter_next(list, iter))
+			break;
+	}
+	hg_list_iter_free(iter);
+	hg_list_iter_free(iter2);
+
+	/* testcase 11 */
+	list = hg_list_new(pool);
+	if (list == NULL) {
+		g_print("Failed to create an list.\n");
+		return 1;
+	}
+
+	list = hg_list_append(list, GINT_TO_POINTER (1));
+	list = hg_list_append(list, GINT_TO_POINTER (2));
+	list = hg_list_append(list, GINT_TO_POINTER (3));
+	list = hg_list_append(list, GINT_TO_POINTER (4));
+	list = hg_list_append(list, GINT_TO_POINTER (5));
+
+	iter = hg_list_iter_new(list);
+	hg_list_get_iter_next(list, iter);
+	iter2 = hg_list_iter_new(list);
+	hg_list_get_iter_last(list, iter2);
+	hg_list_get_iter_previous(list, iter2);
+	list = hg_list_iter_roll(iter2, iter, 1);
+	hg_list_get_iter_first(list, iter);
+	if (hg_list_length(list) != 5) {
+		g_print("Expected list size 5 but actually was %d\n", hg_list_length(list));
+		return 1;
+	}
+	for (i = 0; ; i++) {
+		if (tc11[i] != GPOINTER_TO_INT (hg_list_iter_get_data(iter))) {
+			g_print("Failed to compare: expected %d[%d], but actually %d\n",
+				tc11[i], i, GPOINTER_TO_INT (hg_list_iter_get_data(iter)));
+			return 1;
+		}
+		if (!hg_list_get_iter_next(list, iter))
+			break;
+	}
+	hg_list_iter_free(iter);
+	hg_list_iter_free(iter2);
+
+	/* testcase 12 */
+	list = hg_list_new(pool);
+	if (list == NULL) {
+		g_print("Failed to create an list.\n");
+		return 1;
+	}
+
+	list = hg_list_append(list, GINT_TO_POINTER (1));
+	list = hg_list_append(list, GINT_TO_POINTER (2));
+	list = hg_list_append(list, GINT_TO_POINTER (3));
+	list = hg_list_append(list, GINT_TO_POINTER (4));
+	list = hg_list_append(list, GINT_TO_POINTER (5));
+
+	iter = hg_list_iter_new(list);
+	hg_list_get_iter_next(list, iter);
+	iter2 = hg_list_iter_new(list);
+	hg_list_get_iter_last(list, iter2);
+	list = hg_list_iter_roll(iter2, iter, 1);
+	hg_list_get_iter_first(list, iter);
+	if (hg_list_length(list) != 5) {
+		g_print("Expected list size 5 but actually was %d\n", hg_list_length(list));
+		return 1;
+	}
+	for (i = 0; ; i++) {
+		if (tc12[i] != GPOINTER_TO_INT (hg_list_iter_get_data(iter))) {
+			g_print("Failed to compare: expected %d[%d], but actually %d\n",
+				tc12[i], i, GPOINTER_TO_INT (hg_list_iter_get_data(iter)));
+			return 1;
+		}
+		if (!hg_list_get_iter_next(list, iter))
+			break;
+	}
+	hg_list_iter_free(iter);
+	hg_list_iter_free(iter2);
+
 	hg_mem_pool_destroy(pool);
 	hg_allocator_destroy(allocator);
 	hg_mem_finalize();