API changes around GC

25 files changed, 398 insertions, 530 deletions

diff --git a/hieroglyph/hgallocator.c b/hieroglyph/hgallocator.c
index c499c71..8bddb5e 100644
--- a/hieroglyph/hgallocator.c
+++ b/hieroglyph/hgallocator.c
@@ -785,22 +785,19 @@ _hg_allocator_gc_init(hg_allocator_data_t *data)
 	return TRUE;
 }
 
-static gboolean
+static hg_error_t
 _hg_allocator_gc_mark(hg_allocator_data_t  *data,
-		      hg_quark_t            index_,
-		      GError              **error)
+		      hg_quark_t            index_)
 {
 	hg_allocator_private_t *priv = (hg_allocator_private_t *)data;
 	hg_allocator_block_t *block;
 	gint32 page;
 	guint32 idx;
-	gboolean retval = TRUE;
-	GError *err = NULL;
 	gsize aligned_size;
 
 	/* this isn't the object in the targeted spool */
 	if (!priv->slave_bitmap)
-		return TRUE;
+		return HG_ERROR_ (HG_STATUS_SUCCESS, 0);
 
 	block = _hg_allocator_real_lock_object(data, index_);
 	if (block) {
@@ -818,40 +815,29 @@ _hg_allocator_gc_mark(hg_allocator_data_t  *data,
 		}
 		_hg_allocator_real_unlock_object(block);
 	} else {
-		g_set_error(&err, HG_ERROR, HG_VM_e_VMerror,
-			    "%lx isn't an allocated object from this spool", index_);
-	}
-	if (err) {
-		if (error) {
-			*error = g_error_copy(err);
-		} else {
-			hg_warning("%s: %s (code: %d)",
-				   __PRETTY_FUNCTION__,
-				   err->message,
-				   err->code);
-		}
-		g_error_free(err);
-		retval = FALSE;
+		hg_critical("%lx is not an allocated object from this spool", index_);
+
+		return HG_ERROR_ (HG_STATUS_FAILED, HG_e_VMerror);
 	}
 
-	return retval;
+	return HG_ERROR_ (HG_STATUS_SUCCESS, 0);
 }
 
-static gboolean
+static hg_error_t
 _hg_allocator_gc_finish(hg_allocator_data_t *data,
-			gboolean             was_error)
+			hg_error_t           error)
 {
 	hg_allocator_private_t *priv = (hg_allocator_private_t *)data;
 
 	if (G_UNLIKELY (!priv->slave_bitmap)) {
 		hg_warning("GC isn't yet started.");
-		return FALSE;
+		return HG_ERROR_ (HG_STATUS_FAILED, HG_e_VMerror);
 	}
 
 	G_LOCK (allocator);
 
 	/* XXX: this has to be dropped in the future */
-	if (!was_error) {
+	if (HG_ERROR_IS_SUCCESS (error)) {
 		gsize used_size;
 		guint32 i, j, max_page = hg_allocator_get_max_page();
 
@@ -870,7 +856,7 @@ _hg_allocator_gc_finish(hg_allocator_data_t *data,
 												     i, j + 1, FALSE);
 
 					if (block == NULL) {
-						was_error = TRUE;
+						error = HG_ERROR_ (HG_STATUS_FAILED, HG_e_VMerror);
 						break;
 					}
 					if (!_hg_allocator_bitmap_is_marked(priv->slave_bitmap, i, j + 1)) {
@@ -881,8 +867,8 @@ _hg_allocator_gc_finish(hg_allocator_data_t *data,
 #if defined (HG_DEBUG)
 							abort();
 #endif
-							was_error = !_hg_allocator_gc_mark(data, _hg_allocator_quark_build(i, j + 1), NULL);
-							if (was_error)
+							error = _hg_allocator_gc_mark(data, _hg_allocator_quark_build(i, j + 1));
+							if (!HG_ERROR_IS_SUCCESS (error))
 								break;
 						}
 					}
@@ -893,28 +879,24 @@ _hg_allocator_gc_finish(hg_allocator_data_t *data,
 		}
 	}
 
-	if (!was_error) {
+	if (HG_ERROR_IS_SUCCESS (error)) {
 		hg_debug(HG_MSGCAT_GC, "%ld -> %ld (%ld bytes freed) / %ld",
 			 data->used_size, priv->slave.used_size,
 			 data->used_size - priv->slave.used_size,
 			 data->total_size);
-	} else {
-		hg_debug(HG_MSGCAT_GC, "the garbage collection failed");
-	}
-
-	if (was_error) {
-		_hg_allocator_bitmap_destroy(priv->slave_bitmap);
-		priv->slave_bitmap = NULL;
-	} else {
 		_hg_allocator_bitmap_destroy(priv->bitmap);
 		priv->bitmap = priv->slave_bitmap;
 		priv->slave_bitmap = NULL;
 		data->used_size = priv->slave.used_size;
+	} else {
+		hg_debug(HG_MSGCAT_GC, "the garbage collection failed");
+		_hg_allocator_bitmap_destroy(priv->slave_bitmap);
+		priv->slave_bitmap = NULL;
 	}
 
 	G_UNLOCK (allocator);
 
-	return !was_error;
+	return error;
 }
 
 static hg_allocator_snapshot_data_t *
diff --git a/hieroglyph/hgallocator.h b/hieroglyph/hgallocator.h
index f2338c9..118163b 100644
--- a/hieroglyph/hgallocator.h
+++ b/hieroglyph/hgallocator.h
@@ -29,6 +29,7 @@
 #define __HIEROGLYPH_HGALLOCATOR_H__
 
 #include <hieroglyph/hgtypes.h>
+#include <hieroglyph/hgerror.h>
 /* XXX: GLib is still needed to satisfy the GHashTable dependency */
 #include <glib.h>
 
@@ -113,11 +114,10 @@ struct _hg_mem_vtable_t {
 	void                           (* unlock_object)     (hg_allocator_data_t           *data,
 							      hg_quark_t                     quark);
 	hg_bool_t                      (* gc_init)           (hg_allocator_data_t           *data);
-	hg_bool_t                      (* gc_mark)           (hg_allocator_data_t           *data,
-							      hg_quark_t                     quark,
-							      GError                       **error);
-	hg_bool_t                      (* gc_finish)         (hg_allocator_data_t           *data,
-							      hg_bool_t                      was_error);
+	hg_error_t                     (* gc_mark)           (hg_allocator_data_t           *data,
+							      hg_quark_t                     quark);
+	hg_error_t                     (* gc_finish)         (hg_allocator_data_t           *data,
+							      hg_error_t                     error);
 	hg_allocator_snapshot_data_t * (* save_snapshot)     (hg_allocator_data_t           *data);
 	hg_bool_t                      (* restore_snapshot)  (hg_allocator_data_t           *data,
 							      hg_allocator_snapshot_data_t  *snapshot,
diff --git a/hieroglyph/hgarray.c b/hieroglyph/hgarray.c
index 9e66103..beb2a98 100644
--- a/hieroglyph/hgarray.c
+++ b/hieroglyph/hgarray.c
@@ -207,51 +207,38 @@ _hg_object_array_to_cstr(hg_object_t              *object,
 	return g_string_free(retval, FALSE);
 }
 
-static gboolean
+static hg_error_t
 _hg_object_array_gc_mark(hg_object_t           *object,
 			 hg_gc_iterate_func_t   func,
-			 hg_pointer_t           user_data,
-			 GError               **error)
+			 hg_pointer_t           user_data)
 {
 	hg_array_t *array = (hg_array_t *)object;
 	hg_quark_t q;
 	hg_usize_t i, len;
-	GError *err = NULL;
-	hg_bool_t retval = TRUE;
+	hg_error_t error = 0;
 
-	hg_return_val_if_fail (object->type == HG_TYPE_ARRAY, FALSE);
+	hg_return_val_if_fail (object->type == HG_TYPE_ARRAY, HG_ERROR_ (HG_STATUS_FAILED, HG_e_typecheck));
 
 	hg_debug(HG_MSGCAT_GC, "array: marking container");
-	if (!hg_mem_gc_mark(array->o.mem, array->qcontainer, &err))
+	error = hg_mem_gc_mark(array->o.mem, array->qcontainer);
+	if (!HG_ERROR_IS_SUCCESS (error))
 		goto finalize;
 	hg_debug(HG_MSGCAT_GC, "array: marking name");
-	if (!hg_mem_gc_mark(array->o.mem, array->qname, &err))
+	error = hg_mem_gc_mark(array->o.mem, array->qname);
+	if (!HG_ERROR_IS_SUCCESS (error))
 		goto finalize;
 
 	len = hg_array_length(array);
 
 	for (i = 0; i < len; i++) {
-		q = hg_array_get(array, i, &err);
-		if (err)
-			goto finalize;
-		if (!func(q, user_data, &err))
+		q = hg_array_get(array, i, NULL);
+		error = func(q, user_data);
+		if (!HG_ERROR_IS_SUCCESS (error))
 			goto finalize;
 	}
   finalize:
-	if (err) {
-		if (error) {
-			*error = g_error_copy(err);
-		} else {
-			hg_warning("%s: %s (code: %d)",
-				   __PRETTY_FUNCTION__,
-				   err->message,
-				   err->code);
-		}
-		g_error_free(err);
-		retval = FALSE;
-	}
 
-	return retval;
+	return error;
 }
 
 static hg_bool_t
diff --git a/hieroglyph/hgdevice.c b/hieroglyph/hgdevice.c
index 02abdf8..69e1cd5 100644
--- a/hieroglyph/hgdevice.c
+++ b/hieroglyph/hgdevice.c
@@ -174,41 +174,51 @@ _hg_device_open(hg_mem_t    *mem,
  *
  * Returns:
  */
-gboolean
+hg_error_t
 hg_device_gc_mark(hg_device_t           *device,
 		  hg_gc_iterate_func_t   func,
-		  gpointer               user_data,
-		  GError               **error)
+		  gpointer               user_data)
 {
-	hg_return_val_with_gerror_if_fail (device != NULL, FALSE, error, HG_VM_e_VMerror);
-	hg_return_val_with_gerror_if_fail (func != NULL, FALSE, error, HG_VM_e_VMerror);
+	hg_error_t error = 0;
+
+	hg_return_val_if_fail (device != NULL, HG_ERROR_ (HG_STATUS_FAILED, HG_e_VMerror));
+	hg_return_val_if_fail (func != NULL, HG_ERROR_ (HG_STATUS_FAILED, HG_e_VMerror));
 
 	if (device->params) {
 		hg_mem_t *mem = hg_mem_get(hg_quark_get_mem_id(device->params->self));
 
-		if (!hg_mem_gc_mark(mem, device->params->self, error))
-			return FALSE;
-		if (!func(device->params->qinput_attributes, user_data, error))
-			return FALSE;
-		if (!func(device->params->qmedia_color, user_data, error))
-			return FALSE;
-		if (!func(device->params->qmedia_type, user_data, error))
-			return FALSE;
-		if (!func(device->params->qoutput_type, user_data, error))
-			return FALSE;
-		if (!func(device->params->qinstall, user_data, error))
-			return FALSE;
-		if (!func(device->params->qbegin_page, user_data, error))
-			return FALSE;
-		if (!func(device->params->qend_page, user_data, error))
-			return FALSE;
-
-		if (device->gc_mark)
-			if (!device->gc_mark(device, func, user_data, error))
-				return FALSE;
+		error = hg_mem_gc_mark(mem, device->params->self);
+		if (!HG_ERROR_IS_SUCCESS (error))
+			goto finalize;
+		error = func(device->params->qinput_attributes, user_data);
+		if (!HG_ERROR_IS_SUCCESS (error))
+			goto finalize;
+		error = func(device->params->qmedia_color, user_data);
+		if (!HG_ERROR_IS_SUCCESS (error))
+			goto finalize;
+		error = func(device->params->qmedia_type, user_data);
+		if (!HG_ERROR_IS_SUCCESS (error))
+			goto finalize;
+		error = func(device->params->qoutput_type, user_data);
+		if (!HG_ERROR_IS_SUCCESS (error))
+			goto finalize;
+		error = func(device->params->qinstall, user_data);
+		if (!HG_ERROR_IS_SUCCESS (error))
+			goto finalize;
+		error = func(device->params->qbegin_page, user_data);
+		if (!HG_ERROR_IS_SUCCESS (error))
+			goto finalize;
+		error = func(device->params->qend_page, user_data);
+		if (!HG_ERROR_IS_SUCCESS (error))
+			goto finalize;
+
+		if (device->gc_mark) {
+			error = device->gc_mark(device, func, user_data);
+		}
 	}
+  finalize:
 
-	return TRUE;
+	return error;
 }
 
 /**
diff --git a/hieroglyph/hgdevice.h b/hieroglyph/hgdevice.h
index 6512145..7e58b92 100644
--- a/hieroglyph/hgdevice.h
+++ b/hieroglyph/hgdevice.h
@@ -148,10 +148,9 @@ struct _hg_device_t {
 	hg_pdev_params_t          *params;
 
 	hg_usize_t (* get_page_params_size) (hg_device_t           *device);
-	hg_bool_t  (* gc_mark)              (hg_device_t           *device,
+	hg_error_t (* gc_mark)              (hg_device_t           *device,
 					     hg_gc_iterate_func_t   func,
-					     hg_pointer_t           user_data,
-					     GError               **error);
+					     hg_pointer_t           user_data);
 	hg_quark_t (* get_page_param)       (hg_device_t           *device,
 					     hg_uint_t              index);
 	void       (* install)              (hg_device_t           *device,
@@ -171,10 +170,9 @@ struct _hg_device_t {
 };
 
 
-hg_bool_t    hg_device_gc_mark        (hg_device_t                 *device,
+hg_error_t   hg_device_gc_mark        (hg_device_t                 *device,
 				       hg_gc_iterate_func_t         func,
-				       hg_pointer_t                 user_data,
-				       GError                     **error);
+				       hg_pointer_t                 user_data);
 hg_device_t *hg_device_open           (hg_mem_t                    *mem,
 				       const gchar                 *name);
 void         hg_device_close          (hg_device_t                 *device);
diff --git a/hieroglyph/hgdict.c b/hieroglyph/hgdict.c
index 990fdbe..9f78022 100644
--- a/hieroglyph/hgdict.c
+++ b/hieroglyph/hgdict.c
@@ -107,22 +107,18 @@ _hg_object_dict_to_cstr(hg_object_t              *object,
 	return g_strdup("-dict-");
 }
 
-static gboolean
+static hg_error_t
 _hg_object_dict_gc_mark(hg_object_t           *object,
 			hg_gc_iterate_func_t   func,
-			gpointer               user_data,
-			GError               **error)
+			gpointer               user_data)
 {
 	hg_dict_t *dict;
-	gboolean retval = FALSE;
 
-	hg_return_val_if_fail (object->type == HG_TYPE_DICT, FALSE);
+	hg_return_val_if_fail (object->type == HG_TYPE_DICT, HG_ERROR_ (HG_STATUS_FAILED, HG_e_VMerror));
 
 	dict = (hg_dict_t *)object;
 
-	retval = func(dict->qroot, user_data, error);
-
-	return retval;
+	return func(dict->qroot, user_data);
 }
 
 static gboolean
@@ -297,28 +293,29 @@ _hg_object_dict_node_to_cstr(hg_object_t              *object,
 	return g_strdup("-dnode-");
 }
 
-static gboolean
+static hg_error_t
 _hg_object_dict_node_gc_mark(hg_object_t           *object,
 			     hg_gc_iterate_func_t   func,
-			     gpointer               user_data,
-			     GError               **error)
+			     gpointer               user_data)
 {
 	hg_dict_node_t *dnode = (hg_dict_node_t *)object;
-	GError *err = NULL;
+	hg_error_t error = 0;
 	gsize i;
 	hg_quark_t *qnode_keys = NULL, *qnode_vals = NULL, *qnode_nodes = NULL;
-	gboolean retval = FALSE;
 
-	hg_return_val_if_fail (object->type == HG_TYPE_DICT_NODE, FALSE);
+	hg_return_val_if_fail (object->type == HG_TYPE_DICT_NODE, HG_ERROR_ (HG_STATUS_FAILED, HG_e_typecheck));
 
 	hg_debug(HG_MSGCAT_GC, "dict: marking key container");
-	if (!hg_mem_gc_mark(dnode->o.mem, dnode->qkey, &err))
+	error = hg_mem_gc_mark(dnode->o.mem, dnode->qkey);
+	if (!HG_ERROR_IS_SUCCESS (error))
 		goto finalize;
 	hg_debug(HG_MSGCAT_GC, "dict: marking value container");
-	if (!hg_mem_gc_mark(dnode->o.mem, dnode->qval, &err))
+	error = hg_mem_gc_mark(dnode->o.mem, dnode->qval);
+	if (!HG_ERROR_IS_SUCCESS (error))
 		goto finalize;
 	hg_debug(HG_MSGCAT_GC, "dict: marking node container");
-	if (!hg_mem_gc_mark(dnode->o.mem, dnode->qnodes, &err))
+	error = hg_mem_gc_mark(dnode->o.mem, dnode->qnodes);
+	if (!HG_ERROR_IS_SUCCESS (error))
 		goto finalize;
 
 	qnode_keys = hg_mem_lock_object(dnode->o.mem, dnode->qkey);
@@ -327,28 +324,30 @@ _hg_object_dict_node_gc_mark(hg_object_t           *object,
 	if (qnode_keys == NULL ||
 	    qnode_vals == NULL ||
 	    qnode_nodes == NULL) {
-		g_set_error(&err, HG_ERROR, HG_VM_e_VMerror,
-			    "%s: Invalid quark to obtain the actual object in dnode", __PRETTY_FUNCTION__);
+		hg_critical("%s: Invalid quark to obtain the actual object in dnode",
+			    __PRETTY_FUNCTION__);
+		error = HG_ERROR_ (HG_STATUS_FAILED, HG_e_VMerror);
 		goto qfinalize;
 	}
 
 	for (i = 0; i < dnode->n_data; i++) {
 		hg_debug(HG_MSGCAT_GC, "dict: marking node[%ld]", i);
-		if (!func(qnode_nodes[i], user_data, &err))
+		error = func(qnode_nodes[i], user_data);
+		if (!HG_ERROR_IS_SUCCESS (error))
 			goto qfinalize;
 		hg_debug(HG_MSGCAT_GC, "dict: marking key[%ld]", i);
-		if (!func(qnode_keys[i], user_data, &err))
+		error = func(qnode_keys[i], user_data);
+		if (!HG_ERROR_IS_SUCCESS (error))
 			goto qfinalize;
 		hg_debug(HG_MSGCAT_GC, "dict: marking value[%ld]", i);
-		if (!func(qnode_vals[i], user_data, &err))
+		error = func(qnode_vals[i], user_data);
+		if (!HG_ERROR_IS_SUCCESS (error))
 			goto qfinalize;
 	}
 	hg_debug(HG_MSGCAT_GC, "dict: marking node[%ld]", dnode->n_data);
-	if (!func(qnode_nodes[dnode->n_data], user_data, &err))
+	error = func(qnode_nodes[dnode->n_data], user_data);
+	if (!HG_ERROR_IS_SUCCESS (error))
 		goto qfinalize;
-
-	retval = TRUE;
-
   qfinalize:
 	if (qnode_keys)
 		hg_mem_unlock_object(dnode->o.mem, dnode->qkey);
@@ -358,20 +357,7 @@ _hg_object_dict_node_gc_mark(hg_object_t           *object,
 		hg_mem_unlock_object(dnode->o.mem, dnode->qnodes);
 
   finalize:
-	if (err) {
-		if (error) {
-			*error = g_error_copy(err);
-		} else {
-			hg_warning("%s: %s (code: %d)",
-				   __PRETTY_FUNCTION__,
-				   err->message,
-				   err->code);
-		}
-		g_error_free(err);
-		retval = FALSE;
-	}
-
-	return retval;
+	return error;
 }
 
 static gboolean
diff --git a/hieroglyph/hgerror.h b/hieroglyph/hgerror.h
index 54bc218..c5db8f1 100644
--- a/hieroglyph/hgerror.h
+++ b/hieroglyph/hgerror.h
@@ -56,7 +56,6 @@ HG_BEGIN_DECLS
 	(hg_error_t)(HG_ERROR_SET_STATUS (0, (_status_)) |	\
 		     HG_ERROR_SET_REASON (0, (_reason_)))
 
-typedef hg_int_t		hg_error_t;
 typedef enum _hg_vm_error_t	hg_vm_error_t;
 typedef enum _hg_error_status_t	hg_error_status_t;
 typedef enum _hg_error_reason_t	hg_error_reason_t;
diff --git a/hieroglyph/hgfile.c b/hieroglyph/hgfile.c
index c0eea61..98b7422 100644
--- a/hieroglyph/hgfile.c
+++ b/hieroglyph/hgfile.c
@@ -233,51 +233,35 @@ _hg_object_file_to_cstr(hg_object_t              *object,
 	return g_strdup("-file-");
 }
 
-static gboolean
+static hg_error_t
 _hg_object_file_gc_mark(hg_object_t           *object,
 			hg_gc_iterate_func_t   func,
-			gpointer               user_data,
-			GError               **error)
+			gpointer               user_data)
 {
 	hg_file_t *file = (hg_file_t *)object;
-	GError *err = NULL;
-	gboolean retval = FALSE;
 	hg_file_gc_t g;
+	hg_error_t error = 0;
 
-	hg_return_val_if_fail (object->type == HG_TYPE_FILE, FALSE);
+	hg_return_val_if_fail (object->type == HG_TYPE_FILE, HG_ERROR_ (HG_STATUS_FAILED, HG_e_typecheck));
 
-	if (!func(file->qfilename, user_data, &err))
+	error = func(file->qfilename, user_data);
+	if (!HG_ERROR_IS_SUCCESS (error))
 		goto finalize;
 	if (file->user_data) {
 		if (!file->user_data->gc_func) {
-			if (!hg_mem_gc_mark(file->o.mem, file->user_data->self, &err))
-				goto finalize;
+			error = hg_mem_gc_mark(file->o.mem, file->user_data->self);
 		} else {
 			g.func = func;
 			g.user_data = user_data;
 			g.mem = file->o.mem;
 			g.data = file->user_data;
 
-			if (!file->user_data->gc_func(file->user_data->self, &g, &err))
-				goto finalize;
+			error = file->user_data->gc_func(file->user_data->self, &g);
 		}
 	}
-
-	retval = TRUE;
   finalize:
-	if (err) {
-		if (error) {
-			*error = g_error_copy(err);
-		} else {
-			hg_warning("%s: %s (code: %d)",
-				   __PRETTY_FUNCTION__,
-				   err->message,
-				   err->code);
-		}
-		g_error_free(err);
-	}
 
-	return retval;
+	return error;
 }
 
 static gboolean
@@ -289,14 +273,13 @@ _hg_object_file_compare(hg_object_t             *o1,
 	return o1->self == o2->self;
 }
 
-static gboolean
+static hg_error_t
 _hg_file_io_data_gc_mark(hg_quark_t   qdata,
-			 gpointer     user_data,
-			 GError     **error)
+			 gpointer     user_data)
 {
 	hg_file_gc_t *g = user_data;
 
-	return hg_mem_gc_mark(g->mem, qdata, error);
+	return hg_mem_gc_mark(g->mem, qdata);
 }
 
 static void
@@ -308,22 +291,29 @@ _hg_file_io_data_free(hg_mem_t *mem,
 	hg_mem_free(mem, data->self);
 }
 
-static gboolean
+static hg_error_t
 _hg_file_io_buffered_data_gc_mark(hg_quark_t   qdata,
-				  gpointer     user_data,
-				  GError     **error)
+				  gpointer     user_data)
 {
 	hg_file_gc_t *g = user_data;
 	hg_file_io_buffered_data_t *bd = (hg_file_io_buffered_data_t *)g->data;
+	hg_error_t error = 0;
 
-	if (bd->in &&
-	    !g->func(bd->in->o.self, g->user_data, error))
-		return FALSE;
-	if (bd->out &&
-	    !g->func(bd->out->o.self, g->user_data, error))
-		return FALSE;
+	if (bd->in) {
+		error = g->func(bd->in->o.self, g->user_data);
+		if (!HG_ERROR_IS_SUCCESS (error))
+			goto finalize;
+	}
+	if (bd->out) {
+		error = g->func(bd->out->o.self, g->user_data);
+		if (!HG_ERROR_IS_SUCCESS (error))
+			goto finalize;
+	}
+
+	error = hg_mem_gc_mark(g->mem, qdata);
+  finalize:
 
-	return hg_mem_gc_mark(g->mem, qdata, error);
+	return error;
 }
 
 static void
diff --git a/hieroglyph/hggstate.c b/hieroglyph/hggstate.c
index ccfb19f..df7c2c7 100644
--- a/hieroglyph/hggstate.c
+++ b/hieroglyph/hggstate.c
@@ -133,38 +133,27 @@ _hg_object_gstate_to_cstr(hg_object_t              *object,
 	return g_strdup("-gstate-");
 }
 
-static gboolean
+static hg_error_t
 _hg_object_gstate_gc_mark(hg_object_t           *object,
 			  hg_gc_iterate_func_t   func,
-			  gpointer               user_data,
-			  GError               **error)
+			  gpointer               user_data)
 {
 	hg_gstate_t *gstate = (hg_gstate_t *)object;
-	GError *err = NULL;
-	gboolean retval = TRUE;
+	hg_error_t error = 0;
 
-	if (!func(gstate->qpath, user_data, &err))
+	error = func(gstate->qpath, user_data);
+	if (!HG_ERROR_IS_SUCCESS (error))
 		goto finalize;
-	if (!func(gstate->qclippath, user_data, &err))
+	error = func(gstate->qclippath, user_data);
+	if (!HG_ERROR_IS_SUCCESS (error))
 		goto finalize;
-	if (!func(gstate->qdashpattern, user_data, &err))
+	error = func(gstate->qdashpattern, user_data);
+	if (!HG_ERROR_IS_SUCCESS (error))
 		goto finalize;
 
   finalize:
-	if (err) {
-		if (error) {
-			*error = g_error_copy(err);
-		} else {
-			hg_warning("%s: %s (code: %d)",
-				   __PRETTY_FUNCTION__,
-				   err->message,
-				   err->code);
-		}
-		g_error_free(err);
-		retval = FALSE;
-	}
 
-	return retval;
+	return error;
 }
 
 static gboolean
diff --git a/hieroglyph/hglineedit.h b/hieroglyph/hglineedit.h
index 33c3a47..8e369b7 100644
--- a/hieroglyph/hglineedit.h
+++ b/hieroglyph/hglineedit.h
@@ -29,6 +29,7 @@
 #define __HIEROGLYPH_HGLINEEDIT_H__
 
 #include <hieroglyph/hgtypes.h>
+#include <hieroglyph/hgerror.h>
 #include <hieroglyph/hgfile.h>
 
 HG_BEGIN_DECLS
@@ -72,8 +73,7 @@ void                  hg_lineedit_set_infile        (hg_lineedit_t
                                                      hg_file_t                   *infile);
 void                  hg_lineedit_set_outfile       (hg_lineedit_t               *lineedit,
                                                      hg_file_t                   *outfile);
-hg_bool_t             hg_lineedit_gc_mark           (hg_lineedit_t               *lineedit,
-						     GError                     **error);
+hg_error_t            hg_lineedit_gc_mark           (hg_lineedit_t               *lineedit);
 
 HG_END_DECLS
 
diff --git a/hieroglyph/hglineedit.l b/hieroglyph/hglineedit.l
index ff67a58..e25ca2c 100644
--- a/hieroglyph/hglineedit.l
+++ b/hieroglyph/hglineedit.l
@@ -27,7 +27,6 @@
 #endif
 
 #include <glib.h>
-#include "hgerror.h"
 #include "hgmem.h"
 #include "hglineedit.h"
 
@@ -488,17 +487,15 @@ hg_lineedit_set_outfile(hg_lineedit_t *lineedit,
 /**
  * hg_lineedit_gc_mark:
  * @lineedit:
- * @error:
  *
  * FIXME
  *
  * Returns:
  */
-hg_bool_t
-hg_lineedit_gc_mark(hg_lineedit_t  *lineedit,
-		    GError        **error)
+hg_error_t
+hg_lineedit_gc_mark(hg_lineedit_t  *lineedit)
 {
-	hg_return_val_if_fail (lineedit != NULL, FALSE);
+	hg_return_val_if_fail (lineedit != NULL, HG_ERROR_ (HG_STATUS_FAILED, HG_e_VMerror));
 
-	return hg_mem_gc_mark(lineedit->mem, lineedit->qself, error);
+	return hg_mem_gc_mark(lineedit->mem, lineedit->qself);
 }
diff --git a/hieroglyph/hgmem.c b/hieroglyph/hgmem.c
index a85714e..b948de2 100644
--- a/hieroglyph/hgmem.c
+++ b/hieroglyph/hgmem.c
@@ -28,7 +28,6 @@
 #include <math.h>
 #include <glib.h>
 #include "hgallocator.h"
-#include "hgerror.h"
 #include "hgquark.h"
 #include "hgtypebit-private.h"
 #include "hgmem.h"
@@ -67,14 +66,14 @@ _hg_mem_call_gc_finalizer(gpointer key,
 }
 
 HG_INLINE_FUNC void
-_hg_mem_gc_finish(hg_mem_t *mem,
-		  gboolean  was_error)
+_hg_mem_gc_finish(hg_mem_t   *mem,
+		  hg_error_t  error)
 {
 	if (!mem->slave_finalizer_table) {
 		hg_warning("%s: no slave instance created.", __PRETTY_FUNCTION__);
 		return;
 	}
-	if (!was_error) {
+	if (HG_ERROR_IS_SUCCESS (error)) {
 		GList *lk, *lv, *llk, *llv;
 
 		/* NOTE: do not use g_hash_foreach().
@@ -573,19 +572,21 @@ hg_mem_collect_garbage(hg_mem_t *mem)
 	    mem->allocator->gc_finish &&
 	    mem->enable_gc) {
 		if (mem->allocator->gc_init(mem->data)) {
-			gboolean ret = TRUE;
+			hg_error_t error = 0;
 
 			hg_debug(HG_MSGCAT_GC, "starting [mem_id: %d]", mem->id);
 			_hg_mem_gc_init(mem);
 			if (mem->gc_func)
-				ret = mem->gc_func(mem, mem->gc_data);
-			if (ret && mem->rs_gc_func)
-				ret = hg_mem_reserved_spool_foreach(mem,
-								    mem->rs_gc_func,
-								    mem->rs_gc_data,
-								    NULL);
-			_hg_mem_gc_finish(mem, !ret);
-			if (!mem->allocator->gc_finish(mem->data, !ret))
+				error = mem->gc_func(mem, mem->gc_data);
+			if (HG_ERROR_IS_SUCCESS (error) &&
+			    mem->rs_gc_func) {
+				error = hg_mem_reserved_spool_foreach(mem,
+								      mem->rs_gc_func,
+								      mem->rs_gc_data);
+			}
+			_hg_mem_gc_finish(mem, error);
+			error = mem->allocator->gc_finish(mem->data, error);
+			if (!HG_ERROR_IS_SUCCESS (error))
 				return -1;
 		}
 	}
@@ -603,22 +604,21 @@ hg_mem_collect_garbage(hg_mem_t *mem)
  *
  * Returns:
  */
-gboolean
+hg_error_t
 hg_mem_gc_mark(hg_mem_t    *mem,
-	       hg_quark_t   qdata,
-	       GError     **error)
+	       hg_quark_t   qdata)
 {
 	hg_mem_finalizer_func_t func;
 
-	hg_return_val_if_fail (mem != NULL, FALSE);
-	hg_return_val_if_fail (mem->allocator != NULL, FALSE);
-	hg_return_val_if_fail (mem->allocator->gc_mark != NULL, FALSE);
-	hg_return_val_if_fail (mem->data != NULL, FALSE);
+	hg_return_val_if_fail (mem != NULL, HG_ERROR_ (HG_STATUS_FAILED, HG_e_VMerror));
+	hg_return_val_if_fail (mem->allocator != NULL, HG_ERROR_ (HG_STATUS_FAILED, HG_e_VMerror));
+	hg_return_val_if_fail (mem->allocator->gc_mark != NULL, HG_ERROR_ (HG_STATUS_FAILED, HG_e_VMerror));
+	hg_return_val_if_fail (mem->data != NULL, HG_ERROR_ (HG_STATUS_FAILED, HG_e_VMerror));
 
 	if (qdata == Qnil)
-		return TRUE;
+		return HG_ERROR_ (HG_STATUS_SUCCESS, 0);
 
-	hg_return_val_if_fail (hg_quark_has_mem_id(qdata, mem->id), FALSE);
+	hg_return_val_if_fail (hg_quark_has_mem_id(qdata, mem->id), HG_ERROR_ (HG_STATUS_FAILED, HG_e_VMerror));
 
 	if (mem->slave_finalizer_table &&
 	    (func = g_hash_table_lookup(mem->finalizer_table,
@@ -631,8 +631,7 @@ hg_mem_gc_mark(hg_mem_t    *mem,
 	}
 
 	return mem->allocator->gc_mark(mem->data,
-				       hg_quark_get_value(qdata),
-				       error);
+				       hg_quark_get_value(qdata));
 }
 
 /**
@@ -841,7 +840,9 @@ hg_mem_reserved_spool_remove(hg_mem_t   *mem,
 	gint count;
 
 	hg_return_if_fail (mem != NULL);
-	hg_return_if_fail (qdata != Qnil);
+
+	if (qdata == Qnil)
+		return;
 
 	p = HGQUARK_TO_POINTER (hg_quark_get_hash(qdata));
 	count = GPOINTER_TO_INT (g_hash_table_lookup(mem->reserved_spool, p));
@@ -884,16 +885,15 @@ hg_mem_reserved_spool_set_garbage_collector(hg_mem_t        *mem,
  *
  * Returns:
  */
-gboolean
+hg_error_t
 hg_mem_reserved_spool_foreach(hg_mem_t         *mem,
 			      hg_rs_gc_func_t   func,
-			      gpointer          user_data,
-			      GError          **error)
+			      hg_pointer_t      user_data)
 {
 	GList *lk, *lv, *llk, *llv;
-	gboolean retval = TRUE;
+	hg_error_t error = 0;
 
-	hg_return_val_if_fail (mem != NULL, FALSE);
+	hg_return_val_if_fail (mem != NULL, HG_ERROR_ (HG_STATUS_FAILED, HG_e_VMerror));
 
 	lk = g_hash_table_get_keys(mem->reserved_spool);
 	lv = g_hash_table_get_values(mem->reserved_spool);
@@ -901,18 +901,16 @@ hg_mem_reserved_spool_foreach(hg_mem_t         *mem,
 	for (llk = lk, llv = lv;
 	     llk != NULL && llv != NULL;
 	     llk = g_list_next(llk), llv = g_list_next(llv)) {
-		if (!func(mem,
-			  HGPOINTER_TO_QUARK (llk->data),
-			  HGPOINTER_TO_QUARK (llv->data),
-			  user_data,
-			  error)) {
-			retval = FALSE;
+		error = func(mem,
+			     HGPOINTER_TO_QUARK (llk->data),
+			     HGPOINTER_TO_QUARK (llv->data),
+			     user_data);
+		if (!HG_ERROR_IS_SUCCESS (error))
 			break;
-		}
 	}
 
 	g_list_free(lk);
 	g_list_free(lv);
 
-	return retval;
+	return error;
 }
diff --git a/hieroglyph/hgmem.h b/hieroglyph/hgmem.h
index 5459932..cd87c3b 100644
--- a/hieroglyph/hgmem.h
+++ b/hieroglyph/hgmem.h
@@ -39,13 +39,13 @@ HG_BEGIN_DECLS
 #define HG_MEM_FLAGS_DEFAULT_WITHOUT_RESTORABLE	(HG_MEM_FLAGS_DEFAULT & ~HG_MEM_RESTORABLE)
 
 typedef enum _hg_mem_type_t		hg_mem_type_t;
-typedef hg_cb_BOOL__QUARK_QUARK_t	hg_rs_gc_func_t;
+typedef hg_cb_ERROR__QUARK_QUARK_t	hg_rs_gc_func_t;
 typedef hg_allocator_snapshot_data_t	hg_mem_snapshot_data_t;
 
 typedef void (* hg_mem_finalizer_func_t) (hg_mem_t    *mem,
 					  hg_quark_t  index);
-typedef gboolean (* hg_gc_func_t)	(hg_mem_t *mem,
-					 gpointer  user_data);
+typedef hg_error_t (* hg_gc_func_t)	(hg_mem_t     *mem,
+					 hg_pointer_t  user_data);
 
 /* hgmem.h */
 enum _hg_mem_type_t {
@@ -96,9 +96,8 @@ void                          hg_mem_set_garbage_collector               (hg_mem
                                                                           hg_gc_func_t                  func,
                                                                           gpointer                      user_data);
 gssize                        hg_mem_collect_garbage                     (hg_mem_t                     *mem);
-gboolean                      hg_mem_gc_mark                             (hg_mem_t                     *mem,
-                                                                          hg_quark_t                    qdata,
-                                                                          GError                       **error);
+hg_error_t                    hg_mem_gc_mark                             (hg_mem_t                     *mem,
+                                                                          hg_quark_t                    qdata);
 hg_allocator_snapshot_data_t *hg_mem_save_snapshot                       (hg_mem_t                     *mem);
 gboolean                      hg_mem_restore_snapshot                    (hg_mem_t                     *mem,
                                                                           hg_allocator_snapshot_data_t *snapshot,
@@ -118,10 +117,9 @@ void                          hg_mem_reserved_spool_remove               (hg_mem
 void                          hg_mem_reserved_spool_set_garbage_collector(hg_mem_t                     *mem,
                                                                           hg_rs_gc_func_t               func,
                                                                           gpointer                      user_data);
-gboolean                      hg_mem_reserved_spool_foreach              (hg_mem_t                     *mem,
+hg_error_t                    hg_mem_reserved_spool_foreach              (hg_mem_t                     *mem,
                                                                           hg_rs_gc_func_t               func,
-                                                                          gpointer                      user_data,
-                                                                          GError                       **error);
+                                                                          gpointer                      user_data);
 
 HG_INLINE_FUNC gpointer hg_mem_lock_object_with_gerror(hg_mem_t     *mem,
 						       hg_quark_t    quark,
diff --git a/hieroglyph/hgobject.c b/hieroglyph/hgobject.c
index 3268ec2..457e5db 100644
--- a/hieroglyph/hgobject.c
+++ b/hieroglyph/hgobject.c
@@ -299,35 +299,35 @@ hg_object_to_cstr(hg_object_t              *object,
  *
  * Returns:
  */
-gboolean
+hg_error_t
 hg_object_gc_mark(hg_object_t           *object,
 		  hg_gc_iterate_func_t   func,
-		  gpointer               user_data,
-		  GError               **error)
+		  gpointer               user_data)
 {
 	hg_object_vtable_t *v;
-	gboolean retval = FALSE;
+	hg_error_t error = 0;
 
-	hg_return_val_with_gerror_if_fail (__hg_object_is_initialized, FALSE, error, HG_VM_e_VMerror);
-	hg_return_val_with_gerror_if_fail (object != NULL, FALSE, error, HG_VM_e_VMerror);
-	hg_return_val_with_gerror_if_fail (object->type < HG_TYPE_END, FALSE, error, HG_VM_e_VMerror);
-	hg_return_val_with_gerror_if_fail (__hg_object_vtables[object->type] != NULL, FALSE, error, HG_VM_e_VMerror);
-	hg_return_val_with_gerror_if_fail (func != NULL, FALSE, error, HG_VM_e_VMerror);
+	hg_return_val_if_fail (__hg_object_is_initialized, HG_ERROR_ (HG_STATUS_FAILED, HG_e_VMerror));
+	hg_return_val_if_fail (object != NULL, HG_ERROR_ (HG_STATUS_FAILED, HG_e_VMerror));
+	hg_return_val_if_fail (object->type < HG_TYPE_END, HG_ERROR_ (HG_STATUS_FAILED, HG_e_VMerror));
+	hg_return_val_if_fail (__hg_object_vtables[object->type] != NULL, HG_ERROR_ (HG_STATUS_FAILED, HG_e_VMerror));
+	hg_return_val_if_fail (func != NULL, HG_ERROR_ (HG_STATUS_FAILED, HG_e_VMerror));
 
 	if (object->on_gc)
-		return TRUE;
+		return HG_ERROR_ (HG_STATUS_SUCCESS, 0);
 
 	object->on_gc = TRUE;
 
-	if (hg_mem_gc_mark(object->mem, object->self, error)) {
+	error = hg_mem_gc_mark(object->mem, object->self);
+	if (HG_ERROR_IS_SUCCESS (error)) {
 		v = __hg_object_vtables[object->type];
 
-		retval = v->gc_mark(object, func, user_data, error);
+		error = v->gc_mark(object, func, user_data);
 	}
 
 	object->on_gc = FALSE;
 
-	return retval;
+	return error;
 }
 
 /**
diff --git a/hieroglyph/hgobject.h b/hieroglyph/hgobject.h
index 388bcc0..020a2ab 100644
--- a/hieroglyph/hgobject.h
+++ b/hieroglyph/hgobject.h
@@ -29,6 +29,7 @@
 #define __HIEROGLYPH_HGOBJECT_H__
 
 #include <stdarg.h>
+#include <hieroglyph/hgerror.h>
 #include <hieroglyph/hgquark.h>
 
 HG_BEGIN_DECLS
@@ -59,10 +60,9 @@ HG_BEGIN_DECLS
 									      hg_quark_iterate_func_t   func, \
 									      gpointer                  user_data, \
 									      GError                  **error); \
-	static gboolean        _hg_object_ ## _name_ ## _gc_mark             (hg_object_t              *object, \
+	static hg_error_t      _hg_object_ ## _name_ ## _gc_mark             (hg_object_t              *object, \
 									      hg_gc_iterate_func_t      func, \
-									      gpointer                  user_data, \
-									      GError                  **error); \
+									      gpointer                  user_data); \
 	static gboolean        _hg_object_ ## _name_ ## _compare             (hg_object_t              *o1,	\
 									      hg_object_t              *o2, \
 									      hg_quark_compare_func_t   func, \
@@ -89,9 +89,8 @@ HG_BEGIN_DECLS
 
 typedef struct _hg_object_vtable_t		hg_object_vtable_t;
 typedef struct _hg_object_t			hg_object_t;
-typedef gboolean (* hg_gc_iterate_func_t)	(hg_quark_t   qdata,
-						 gpointer     user_data,
-						 GError     **error);
+typedef hg_error_t (* hg_gc_iterate_func_t)	(hg_quark_t   qdata,
+						 gpointer     user_data);
 typedef void (* hg_destroy_func_t)		(hg_mem_t    *mem,
 						 gpointer     user_data);
 
@@ -111,10 +110,9 @@ struct _hg_object_vtable_t {
 						   hg_quark_iterate_func_t   func,
 						   gpointer                  user_data,
 						   GError                  **error);
-	gboolean         (* gc_mark)              (hg_object_t              *object,
+	hg_error_t       (* gc_mark)              (hg_object_t              *object,
 						   hg_gc_iterate_func_t      func,
-						   gpointer                  user_data,
-						   GError                  **error);
+						   gpointer                  user_data);
 	gboolean         (* compare)              (hg_object_t              *o1,
 						   hg_object_t              *o2,
 						   hg_quark_compare_func_t   func,
@@ -158,10 +156,9 @@ gchar          *hg_object_to_cstr   (hg_object_t              *object,
 				     hg_quark_iterate_func_t   func,
 				     gpointer                  user_data,
 				     GError                  **error);
-gboolean        hg_object_gc_mark   (hg_object_t              *object,
+hg_error_t      hg_object_gc_mark   (hg_object_t              *object,
 				     hg_gc_iterate_func_t      func,
-				     gpointer                  user_data,
-				     GError                  **error);
+				     gpointer                  user_data);
 gboolean        hg_object_compare   (hg_object_t              *o1,
 				     hg_object_t              *o2,
 				     hg_quark_compare_func_t   func,
diff --git a/hieroglyph/hgpath.c b/hieroglyph/hgpath.c
index 8f7d9a7..90d0c1b 100644
--- a/hieroglyph/hgpath.c
+++ b/hieroglyph/hgpath.c
@@ -140,39 +140,18 @@ _hg_object_path_to_cstr(hg_object_t              *object,
 	return NULL;
 }
 
-static gboolean
+static hg_error_t
 _hg_object_path_gc_mark(hg_object_t           *object,
 			hg_gc_iterate_func_t   func,
-			gpointer               user_data,
-			GError               **error)
+			gpointer               user_data)
 {
 	hg_path_t *path = (hg_path_t *)object;
-	GError *err = NULL;
-	gboolean retval = TRUE;
 
-	hg_return_val_if_fail (object->type == HG_TYPE_PATH, FALSE);
-
-#if defined(HG_DEBUG) && defined(HG_GC_DEBUG)
-	g_print("GC: (path) marking node\n");
-#endif
-	if (!hg_mem_gc_mark(path->o.mem, path->qnode, &err))
-		goto finalize;
+	hg_return_val_if_fail (object->type == HG_TYPE_PATH, HG_ERROR_ (HG_STATUS_FAILED, HG_e_typecheck));
 
-  finalize:
-	if (err) {
-		if (error) {
-			*error = g_error_copy(err);
-		} else {
-			hg_warning("%s: %s (code: %d)",
-				   __PRETTY_FUNCTION__,
-				   err->message,
-				   err->code);
-		}
-		g_error_free(err);
-		retval = FALSE;
-	}
+	hg_debug(HG_MSGCAT_GC, "path: marking node");
 
-	return retval;
+	return hg_mem_gc_mark(path->o.mem, path->qnode);
 }
 
 static gboolean
diff --git a/hieroglyph/hgsnapshot.c b/hieroglyph/hgsnapshot.c
index 87dbb18..a7af105 100644
--- a/hieroglyph/hgsnapshot.c
+++ b/hieroglyph/hgsnapshot.c
@@ -25,7 +25,6 @@
 #include "config.h"
 #endif
 
-#include <glib.h>
 #include "hgmem.h"
 #include "hgsnapshot.h"
 
@@ -51,7 +50,7 @@ _hg_object_snapshot_get_allocation_flags(void)
 	return HG_MEM_FLAGS_DEFAULT_WITHOUT_RESTORABLE;
 }
 
-static gboolean
+static hg_bool_t
 _hg_object_snapshot_initialize(hg_object_t *object,
 			       va_list      args)
 {
@@ -73,8 +72,8 @@ _hg_object_snapshot_free(hg_object_t *object)
 static hg_quark_t
 _hg_object_snapshot_copy(hg_object_t              *object,
 			 hg_quark_iterate_func_t   func,
-			 gpointer                  user_data,
-			 gpointer                 *ret,
+			 hg_pointer_t              user_data,
+			 hg_pointer_t             *ret,
 			 GError                  **error)
 {
 	hg_return_val_if_fail (object->type == HG_TYPE_SNAPSHOT, Qnil);
@@ -85,7 +84,7 @@ _hg_object_snapshot_copy(hg_object_t              *object,
 static gchar *
 _hg_object_snapshot_to_cstr(hg_object_t              *object,
 			    hg_quark_iterate_func_t   func,
-			    gpointer                  user_data,
+			    hg_pointer_t              user_data,
 			    GError                  **error)
 {
 	hg_return_val_if_fail (object->type == HG_TYPE_SNAPSHOT, NULL);
@@ -93,22 +92,21 @@ _hg_object_snapshot_to_cstr(hg_object_t              *object,
 	return g_strdup("-save-");
 }
 
-static gboolean
+static hg_error_t
 _hg_object_snapshot_gc_mark(hg_object_t           *object,
 			    hg_gc_iterate_func_t   func,
-			    gpointer               user_data,
-			    GError               **error)
+			    hg_pointer_t           user_data)
 {
-	hg_return_val_if_fail (object->type == HG_TYPE_SNAPSHOT, FALSE);
+	hg_return_val_if_fail (object->type == HG_TYPE_SNAPSHOT, HG_ERROR_ (HG_STATUS_FAILED, HG_e_typecheck));
 
-	return TRUE;
+	return HG_ERROR_ (HG_STATUS_SUCCESS, 0);
 }
 
-static gboolean
+static hg_bool_t
 _hg_object_snapshot_compare(hg_object_t             *o1,
 			    hg_object_t             *o2,
 			    hg_quark_compare_func_t  func,
-			    gpointer                 user_data)
+			    hg_pointer_t             user_data)
 {
 	hg_return_val_if_fail (o1->type == HG_TYPE_SNAPSHOT, FALSE);
 	hg_return_val_if_fail (o2->type == HG_TYPE_SNAPSHOT, FALSE);
@@ -126,15 +124,15 @@ _hg_object_snapshot_compare(hg_object_t             *o1,
  * Returns:
  */
 hg_quark_t
-hg_snapshot_new(hg_mem_t *mem,
-		gpointer *ret)
+hg_snapshot_new(hg_mem_t     *mem,
+		hg_pointer_t *ret)
 {
 	hg_quark_t retval;
 	hg_snapshot_t *s = NULL;
 
 	hg_return_val_if_fail (mem != NULL, Qnil);
 
-	retval = hg_object_new(mem, (gpointer *)&s, HG_TYPE_SNAPSHOT, 0);
+	retval = hg_object_new(mem, (hg_pointer_t *)&s, HG_TYPE_SNAPSHOT, 0);
 	if (retval != Qnil) {
 		if (ret)
 			*ret = s;
@@ -153,7 +151,7 @@ hg_snapshot_new(hg_mem_t *mem,
  *
  * Returns:
  */
-gboolean
+hg_bool_t
 hg_snapshot_save(hg_snapshot_t *snapshot)
 {
 	hg_return_val_if_fail (snapshot != NULL, FALSE);
@@ -175,12 +173,12 @@ hg_snapshot_save(hg_snapshot_t *snapshot)
  *
  * Returns:
  */
-gboolean
+hg_bool_t
 hg_snapshot_restore(hg_snapshot_t *snapshot,
 		    hg_gc_func_t   func,
-		    gpointer       data)
+		    hg_pointer_t   data)
 {
-	gboolean retval;
+	hg_bool_t retval;
 
 	hg_return_val_if_fail (snapshot != NULL, FALSE);
 	hg_return_val_if_fail (snapshot->snapshot != NULL, FALSE);
diff --git a/hieroglyph/hgstack.c b/hieroglyph/hgstack.c
index 76d6289..47c4cea 100644
--- a/hieroglyph/hgstack.c
+++ b/hieroglyph/hgstack.c
@@ -75,22 +75,25 @@ _hg_stack_spooler_free_node(hg_stack_spool_t *spool,
 	hg_mem_reserved_spool_remove(spool->mem, node->self);
 }
 
-static gboolean
-_hg_stack_spooler_gc_mark(hg_stack_spool_t  *spool,
-			  GError           **error)
+static hg_error_t
+_hg_stack_spooler_gc_mark(hg_stack_spool_t  *spool)
 {
 	hg_slist_t *l;
+	hg_error_t error = 0;
 
 	if (spool) {
-		if (!hg_mem_gc_mark(spool->mem, spool->self, error))
-			return FALSE;
+		error = hg_mem_gc_mark(spool->mem, spool->self);
+		if (!HG_ERROR_IS_SUCCESS (error))
+			goto finalize;
 		for (l = spool->spool; l != NULL; l = l->next) {
-			if (!hg_mem_gc_mark(spool->mem, l->self, error))
-				return FALSE;
+			error = hg_mem_gc_mark(spool->mem, l->self);
+			if (!HG_ERROR_IS_SUCCESS (error))
+				goto finalize;
 		}
 	}
+  finalize:
 
-	return TRUE;
+	return error;
 }
 
 static gsize
@@ -139,30 +142,27 @@ _hg_object_stack_to_cstr(hg_object_t              *object,
 	return g_strdup("-stack-");
 }
 
-static gboolean
+static hg_error_t
 _hg_object_stack_gc_mark(hg_object_t           *object,
 			 hg_gc_iterate_func_t   func,
-			 gpointer               user_data,
-			 GError               **error)
+			 gpointer               user_data)
 {
 	hg_stack_t *stack = (hg_stack_t *)object;
 	hg_slist_t *l;
-	gboolean retval = TRUE;
+	hg_error_t error = 0;
 
 	for (l = stack->last_stack; l != NULL; l = l->next) {
-		if (!hg_mem_gc_mark(object->mem, l->self, error)) {
-			retval = FALSE;
-			break;
-		}
-		if (!func(l->data, user_data, error)) {
-			retval = FALSE;
-			break;
-		}
+		error = hg_mem_gc_mark(object->mem, l->self);
+		if (!HG_ERROR_IS_SUCCESS (error))
+			goto finalize;
+		error = func(l->data, user_data);
+		if (!HG_ERROR_IS_SUCCESS (error))
+			goto finalize;
 	}
-	if (!_hg_stack_spooler_gc_mark(stack->spool, error))
-		retval = FALSE;
+	error = _hg_stack_spooler_gc_mark(stack->spool);
+  finalize:
 
-	return retval;
+	return error;
 }
 
 static gboolean
diff --git a/hieroglyph/hgstring.c b/hieroglyph/hgstring.c
index c5b3e09..ddf8c0e 100644
--- a/hieroglyph/hgstring.c
+++ b/hieroglyph/hgstring.c
@@ -168,17 +168,16 @@ _hg_object_string_to_cstr(hg_object_t              *object,
 	return g_string_free(retval, FALSE);
 }
 
-static gboolean
+static hg_error_t
 _hg_object_string_gc_mark(hg_object_t           *object,
 			  hg_gc_iterate_func_t   func,
-			  gpointer               user_data,
-			  GError               **error)
+			  gpointer               user_data)
 {
 	hg_string_t *string = (hg_string_t *)object;
 
-	hg_return_val_if_fail (object->type == HG_TYPE_STRING, FALSE);
+	hg_return_val_if_fail (object->type == HG_TYPE_STRING, HG_ERROR_ (HG_STATUS_FAILED, HG_e_typecheck));
 
-	return hg_mem_gc_mark(string->o.mem, string->qstring, error);
+	return hg_mem_gc_mark(string->o.mem, string->qstring);
 }
 
 static gboolean
diff --git a/hieroglyph/hgtypes.h b/hieroglyph/hgtypes.h
index d4534d3..4adcde8 100644
--- a/hieroglyph/hgtypes.h
+++ b/hieroglyph/hgtypes.h
@@ -81,6 +81,7 @@ typedef enum _hg_type_t {
 /* types commonly used in libarry */
 typedef struct _hg_mem_t	hg_mem_t;
 typedef struct _hg_vm_t		hg_vm_t;
+typedef hg_int_t		hg_error_t;
 
 /* types of callback functions */
 typedef hg_bool_t (* hg_cb_BOOL__QUARK_t)       (hg_mem_t      *mem,
@@ -92,6 +93,10 @@ typedef hg_bool_t (* hg_cb_BOOL__QUARK_QUARK_t) (hg_mem_t      *mem,
 						 hg_quark_t     q2,
 						 hg_pointer_t   data,
 						 GError       **error);
+typedef hg_error_t (* hg_cb_ERROR__QUARK_QUARK_t) (hg_mem_t      *mem,
+						   hg_quark_t     q1,
+						   hg_quark_t     q2,
+						   hg_pointer_t   data);
 
 HG_END_DECLS
 
diff --git a/hieroglyph/hgvm.c b/hieroglyph/hgvm.c
index ed16509..cea1273 100644
--- a/hieroglyph/hgvm.c
+++ b/hieroglyph/hgvm.c
@@ -31,7 +31,6 @@
 #include "hgbool.h"
 #include "hgdevice.h"
 #include "hgdict.h"
-#include "hgerror.h"
 #include "hggstate.h"
 #include "hgint.h"
 #include "hgmark.h"
@@ -234,12 +233,11 @@ _hg_vm_stack_real_dump(hg_mem_t    *mem,
 	return TRUE;
 }
 
-static gboolean
-_hg_vm_rs_real_dump(hg_mem_t    *mem,
-		    hg_quark_t   qkey,
-		    hg_quark_t   qval,
-		    gpointer     data,
-		    GError     **error)
+static hg_error_t
+_hg_vm_rs_real_dump(hg_mem_t     *mem,
+		    hg_quark_t    qkey,
+		    hg_quark_t    qval,
+		    hg_pointer_t  data)
 {
 	hg_vm_rs_dump_data_t *ddata = data;
 	hg_quark_t q;
@@ -247,7 +245,7 @@ _hg_vm_rs_real_dump(hg_mem_t    *mem,
 	gchar *cstr = NULL;
 	gchar mc;
 
-	q = hg_vm_quark_to_string(ddata->vm, qkey, TRUE, (gpointer *)&s, error);
+	q = hg_vm_quark_to_string(ddata->vm, qkey, TRUE, (hg_pointer_t *)&s, NULL);
 	if (q != Qnil)
 		cstr = hg_string_get_cstr(s);
 
@@ -277,7 +275,7 @@ _hg_vm_rs_real_dump(hg_mem_t    *mem,
 	 */
 	hg_string_free(s, TRUE);
 
-	return TRUE;
+	return HG_ERROR_ (HG_STATUS_SUCCESS, 0);
 }
 
 static gboolean
@@ -520,12 +518,11 @@ hg_vm_step_in_exec_array(hg_vm_t    *vm,
 	return retval;
 }
 
-static gboolean
+static hg_error_t
 _hg_vm_quark_iterate_gc_mark(hg_quark_t   qdata,
-			     gpointer     user_data,
-			     GError     **error)
+			     gpointer     user_data)
 {
-	return hg_vm_quark_gc_mark((hg_vm_t *)user_data, qdata, error);
+	return hg_vm_quark_gc_mark((hg_vm_t *)user_data, qdata);
 }
 
 static hg_quark_t
@@ -632,152 +629,129 @@ _hg_vm_quark_complex_compare_content(hg_quark_t q1,
 	return retval;
 }
 
-static gboolean
-_hg_vm_vm_rs_gc(hg_mem_t    *mem,
-		hg_quark_t   qkey,
-		hg_quark_t   qval,
-		gpointer     data,
-		GError     **error)
+static hg_error_t
+_hg_vm_vm_rs_gc(hg_mem_t     *mem,
+		hg_quark_t    qkey,
+		hg_quark_t    qval,
+		hg_pointer_t  data)
 {
-	return hg_mem_gc_mark(mem, qkey, error);
+	return hg_mem_gc_mark(mem, qkey);
 }
 
-static gboolean
-_hg_vm_rs_gc(hg_mem_t    *mem,
-	     hg_quark_t   qkey,
-	     hg_quark_t   qval,
-	     gpointer     data,
-	     GError     **error)
+static hg_error_t
+_hg_vm_rs_gc(hg_mem_t     *mem,
+	     hg_quark_t    qkey,
+	     hg_quark_t    qval,
+	     hg_pointer_t  data)
 {
 	hg_vm_t *vm = data;
-	GError *err = NULL;
-	gboolean retval;
 
-	retval = hg_vm_quark_gc_mark(vm, qkey, &err);
-	if (!retval && err == NULL) {
-		g_set_error(&err, HG_ERROR, HG_VM_e_VMerror,
-			    "GC failed");
-	}
-	if (err) {
-		if (error) {
-			*error = g_error_copy(err);
-		} else {
-			hg_warning("%s: %s (code: %d)",
-				   __PRETTY_FUNCTION__,
-				   err->message,
-				   err->code);
-		}
-		g_error_free(err);
-	}
-
-	return retval;
+	return hg_vm_quark_gc_mark(vm, qkey);
 }
 
-static gboolean
+static hg_error_t
 _hg_vm_run_gc(hg_mem_t *mem,
 	      gpointer  user_data)
 {
 	hg_vm_t *vm = user_data;
 	hg_file_t *f;
 	gsize i;
-	GError *err = NULL;
+	hg_error_t error = 0;
 	GList *l;
 
-	hg_return_val_if_fail (mem != NULL, FALSE);
-	hg_return_val_if_fail (vm != NULL, FALSE);
+	hg_return_val_if_fail (mem != NULL, HG_ERROR_ (HG_STATUS_FAILED, HG_e_VMerror));
+	hg_return_val_if_fail (vm != NULL, HG_ERROR_ (HG_STATUS_FAILED, HG_e_VMerror));
 
 	/* marking objects */
 	/** marking I/O **/
-#if defined(HG_DEBUG) && defined(HG_GC_DEBUG)
-	g_print("GC: marking file objects\n");
-#endif
+	hg_debug(HG_MSGCAT_GC, "VM: marking file objects");
 	for (i = 0; i < HG_FILE_IO_END; i++) {
-		if (!hg_vm_quark_gc_mark(vm, vm->qio[i], &err))
-			goto error;
+		error = hg_vm_quark_gc_mark(vm, vm->qio[i]);
+		if (!HG_ERROR_IS_SUCCESS (error))
+			goto finalize;
+	}
+	if (vm->lineedit) {
+		error = hg_lineedit_gc_mark(vm->lineedit);
+		if (!HG_ERROR_IS_SUCCESS (error))
+			goto finalize;
 	}
-	if (vm->lineedit &&
-	    !hg_lineedit_gc_mark(vm->lineedit, &err))
-		goto error;
 	/* marking I/O in scanner */
 	f = hg_scanner_get_infile(vm->scanner);
-	if (f && !hg_object_gc_mark((hg_object_t *)f,
-				    _hg_vm_quark_iterate_gc_mark,
-				    vm, &err))
-		goto error;
+	if (f) {
+		error = hg_object_gc_mark((hg_object_t *)f,
+					  _hg_vm_quark_iterate_gc_mark,
+					  vm);
+		if (!HG_ERROR_IS_SUCCESS (error))
+			goto finalize;
+	}
 
 	/** marking in stacks **/
-#if defined(HG_DEBUG) && defined(HG_GC_DEBUG)
-	g_print("GC: marking objects in stacks\n");
-#endif
+	hg_debug(HG_MSGCAT_GC, "VM: marking objects in stacks");
 	for (i = 0; i < HG_VM_STACK_END; i++) {
 		hg_stack_t *s = vm->stacks[i];
 
-		if (!hg_object_gc_mark((hg_object_t *)s,
-				       _hg_vm_quark_iterate_gc_mark,
-				       vm, &err))
-			goto error;
+		error = hg_object_gc_mark((hg_object_t *)s,
+					  _hg_vm_quark_iterate_gc_mark,
+					  vm);
+		if (!HG_ERROR_IS_SUCCESS (error))
+			goto finalize;
 	}
 	for (i = 0; i < vm->stacks_stack->len; i++) {
 		gpointer p = g_ptr_array_index(vm->stacks_stack, i);
 
-		if (!hg_object_gc_mark((hg_object_t *)p,
-				       _hg_vm_quark_iterate_gc_mark,
-				       vm, &err))
-			goto error;
+		error = hg_object_gc_mark((hg_object_t *)p,
+					  _hg_vm_quark_iterate_gc_mark,
+					  vm);
+		if (!HG_ERROR_IS_SUCCESS (error))
+			goto finalize;
 	}
 	/** marking plugins **/
 	for (l = vm->plugin_list; l != NULL; l = g_list_next(l)) {
 		hg_plugin_t *p = l->data;
 
-		if (!hg_mem_gc_mark(p->mem, p->self, &err))
-			goto error;
+		error = hg_mem_gc_mark(p->mem, p->self);
+		if (!HG_ERROR_IS_SUCCESS (error))
+			goto finalize;
 	}
 	/** marking miscellaneous **/
-#if defined(HG_DEBUG) && defined(HG_GC_DEBUG)
-	g_print("GC: marking objects in vm state\n");
-#endif
-	if (!hg_mem_gc_mark(vm->mem[HG_VM_MEM_LOCAL], vm->vm_state->self, &err))
-		goto error;
-#if defined(HG_DEBUG) && defined(HG_GC_DEBUG)
-	g_print("GC: marking objects in $error\n");
-#endif
-	if (!hg_vm_quark_gc_mark(vm, vm->qerror, &err))
-		goto error;
-#if defined(HG_DEBUG) && defined(HG_GC_DEBUG)
-	g_print("GC: marking objects in systemdict\n");
-#endif
-	if (!hg_vm_quark_gc_mark(vm, vm->qsystemdict, &err))
-		goto error;
-#if defined(HG_DEBUG) && defined(HG_GC_DEBUG)
-	g_print("GC: marking objects in globaldict\n");
-#endif
-	if (!hg_vm_quark_gc_mark(vm, vm->qglobaldict, &err))
-		goto error;
-#if defined(HG_DEBUG) && defined(HG_GC_DEBUG)
-	g_print("GC: marking objects in internaldict\n");
-#endif
-	if (!hg_vm_quark_gc_mark(vm, vm->qinternaldict, &err))
-		goto error;
-#if defined(HG_DEBUG) && defined(HG_GC_DEBUG)
-	g_print("GC: marking objects in gstate\n");
-#endif
-	if (!hg_vm_quark_gc_mark(vm, vm->qgstate, &err))
-		goto error;
-#if defined(HG_DEBUG) && defined(HG_GC_DEBUG)
-	g_print("GC: marking objects in device\n");
-#endif
-	if (vm->device &&
-	    !hg_device_gc_mark(vm->device,
-			       _hg_vm_quark_iterate_gc_mark,
-			       vm, &err))
-		goto error;
+	hg_debug(HG_MSGCAT_GC, "VM: marking objects in vm state");
+	error = hg_mem_gc_mark(vm->mem[HG_VM_MEM_LOCAL], vm->vm_state->self);
+	if (!HG_ERROR_IS_SUCCESS (error))
+		goto finalize;
+	hg_debug(HG_MSGCAT_GC, "VM: marking objects in $error");
+	error = hg_vm_quark_gc_mark(vm, vm->qerror);
+	if (!HG_ERROR_IS_SUCCESS (error))
+		goto finalize;
+	hg_debug(HG_MSGCAT_GC, "VM: marking objects in systemdict");
+	error = hg_vm_quark_gc_mark(vm, vm->qsystemdict);
+	if (!HG_ERROR_IS_SUCCESS (error))
+		goto finalize;
+	hg_debug(HG_MSGCAT_GC, "VM: marking objects in globaldict");
+	error = hg_vm_quark_gc_mark(vm, vm->qglobaldict);
+	if (!HG_ERROR_IS_SUCCESS (error))
+		goto finalize;
+	hg_debug(HG_MSGCAT_GC, "VM: marking objects in internaldict");
+	error = hg_vm_quark_gc_mark(vm, vm->qinternaldict);
+	if (!HG_ERROR_IS_SUCCESS (error))
+		goto finalize;
+	hg_debug(HG_MSGCAT_GC, "VM: marking objects in gstate");
+	error = hg_vm_quark_gc_mark(vm, vm->qgstate);
+	if (!HG_ERROR_IS_SUCCESS (error))
+		goto finalize;
+	hg_debug(HG_MSGCAT_GC, "VM: marking objects in device");
+	if (vm->device) {
+		error = hg_device_gc_mark(vm->device,
+					  _hg_vm_quark_iterate_gc_mark,
+					  vm);
+		if (!HG_ERROR_IS_SUCCESS (error))
+			goto finalize;
+	}
 
 
 	/* sweeping objects */
 
-	return TRUE;
-  error:
-	return FALSE;
+  finalize:
+	return error;
 }
 
 static gboolean
@@ -3135,7 +3109,7 @@ hg_vm_reserved_spool_dump(hg_vm_t   *vm,
 
 	hg_file_append_printf(ofile, "       value      |    type    |refcnt|M|attr|content\n");
 	hg_file_append_printf(ofile, "----------========+------------+------+-+----+---------------------------------\n");
-	hg_mem_reserved_spool_foreach(mem, _hg_vm_rs_real_dump, &data, NULL);
+	hg_mem_reserved_spool_foreach(mem, _hg_vm_rs_real_dump, &data);
 }
 
 /**
@@ -3773,49 +3747,36 @@ hg_vm_dict_lookup(hg_vm_t     *vm,
  * hg_vm_quark_gc_mark:
  * @vm:
  * @qdata:
- * @error:
  *
  * FIXME
  *
  * Returns:
  */
-gboolean
+hg_error_t
 hg_vm_quark_gc_mark(hg_vm_t     *vm,
-		    hg_quark_t   qdata,
-		    GError     **error)
+		    hg_quark_t   qdata)
 {
 	hg_object_t *o;
-	GError *err = NULL;
-	gboolean retval = FALSE;
+	hg_error_t error = 0;
 
-	hg_return_val_with_gerror_if_fail (vm != NULL, FALSE, error, HG_VM_e_VMerror);
+	hg_return_val_if_fail (vm != NULL, HG_ERROR_ (HG_STATUS_FAILED, HG_e_VMerror));
 
 	if (qdata == Qnil)
-		return TRUE;
+		return HG_ERROR_ (HG_STATUS_SUCCESS, 0);
 
 	if (hg_quark_is_simple_object(qdata) ||
 	    HG_IS_QOPER (qdata))
-		return TRUE;
+		return HG_ERROR_ (HG_STATUS_SUCCESS, 0);
 
-	o = _HG_VM_LOCK (vm, qdata, &err);
-	if (o) {
-		retval = hg_object_gc_mark(o, _hg_vm_quark_iterate_gc_mark, vm, &err);
+	o = _HG_VM_LOCK (vm, qdata, NULL);
+	if (o == NULL)
+		return HG_ERROR_ (HG_STATUS_FAILED, HG_e_VMerror);
 
-		_HG_VM_UNLOCK (vm, qdata);
-	}
-	if (err) {
-		if (error) {
-			*error = g_error_copy(err);
-		} else {
-			hg_warning("%s: %s (code: %d)",
-				   __PRETTY_FUNCTION__,
-				   err->message,
-				   err->code);
-		}
-		g_error_free(err);
-	}
+	error = hg_object_gc_mark(o, _hg_vm_quark_iterate_gc_mark, vm);
 
-	return retval;
+	_HG_VM_UNLOCK (vm, qdata);
+
+	return error;
 }
 
 /**
diff --git a/hieroglyph/hgvm.h b/hieroglyph/hgvm.h
index 0d09fb6..fbe7022 100644
--- a/hieroglyph/hgvm.h
+++ b/hieroglyph/hgvm.h
@@ -305,9 +305,8 @@ hg_quark_t hg_vm_dict_lookup    (hg_vm_t     *vm,
                                  GError     **error);
 
 /* hg_quark_t */
-gboolean   hg_vm_quark_gc_mark               (hg_vm_t     *vm,
-                                              hg_quark_t   qdata,
-                                              GError     **error);
+hg_error_t hg_vm_quark_gc_mark               (hg_vm_t     *vm,
+                                              hg_quark_t   qdata);
 hg_quark_t hg_vm_quark_copy                  (hg_vm_t     *vm,
                                               hg_quark_t   qdata,
                                               gpointer    *ret,
diff --git a/tests/hgarray.c b/tests/hgarray.c
index 225b563..155bcbf 100644
--- a/tests/hgarray.c
+++ b/tests/hgarray.c
@@ -67,27 +67,25 @@ TDEF (get_capsulated_size)
 	fail_unless(size == sizeof (hg_array_t), "Obtaining the different size: expect: %" G_GSIZE_FORMAT " actual: %" G_GSIZE_FORMAT, sizeof (hg_array_t), size);
 } TEND
 
-static gboolean
+static hg_error_t
 _gc_iter_func(hg_quark_t   qdata,
-	      gpointer     data,
-	      GError     **error)
+	      gpointer     data)
 {
-	return TRUE;
+	return HG_ERROR_ (HG_STATUS_SUCCESS, 0);
 }
 
-static gboolean
+static hg_error_t
 _gc_func(hg_mem_t    *mem,
 	 hg_quark_t   qkey,
 	 hg_quark_t   qval,
-	 gpointer     data,
-	 GError     **error)
+	 gpointer     data)
 {
 	hg_array_t *a = data;
 
 	if (data == NULL)
-		return TRUE;
+		return HG_ERROR_ (HG_STATUS_SUCCESS, 0);
 
-	return hg_object_gc_mark((hg_object_t *)a, _gc_iter_func, NULL, NULL);
+	return hg_object_gc_mark((hg_object_t *)a, _gc_iter_func, NULL);
 }
 
 TDEF (gc_mark)
diff --git a/tests/hgdict.c b/tests/hgdict.c
index 0066564..0405921 100644
--- a/tests/hgdict.c
+++ b/tests/hgdict.c
@@ -122,35 +122,34 @@ TDEF (get_capsulated_size)
 	fail_unless(size == sizeof (hg_dict_node_t), "Obtaining the different size: expect: %" G_GSIZE_FORMAT " actual: %" G_GSIZE_FORMAT, sizeof (hg_dict_node_t), size);
 } TEND
 
-static gboolean
+static hg_error_t
 _gc_iter_func(hg_quark_t   qdata,
-	      gpointer     data,
-	      GError     **error)
+	      gpointer     data)
 {
 	hg_object_t *o = data;
 
 	if (hg_quark_get_type(qdata) == HG_TYPE_DICT_NODE) {
 		hg_object_t *dnode = hg_mem_lock_object(o->mem, qdata);
-		gboolean ret = hg_object_gc_mark(dnode, _gc_iter_func, o, NULL);
+		hg_error_t error = hg_object_gc_mark(dnode, _gc_iter_func, o);
 
 		hg_mem_unlock_object(o->mem, qdata);
 
-		return ret;
+		return error;
 	}
 
-	return TRUE;
+	return HG_ERROR_ (HG_STATUS_SUCCESS, 0);
 }
 
-static gboolean
-_gc_func(hg_mem_t *mem,
-	 gpointer  data)
+static hg_error_t
+_gc_func(hg_mem_t     *mem,
+	 hg_pointer_t  data)
 {
 	hg_dict_t *d = data;
 
 	if (data == NULL)
-		return TRUE;
+		return HG_ERROR_ (HG_STATUS_SUCCESS, 0);
 
-	return hg_object_gc_mark((hg_object_t *)d, _gc_iter_func, d, NULL);
+	return hg_object_gc_mark((hg_object_t *)d, _gc_iter_func, d);
 }
 
 TDEF (gc_mark)
diff --git a/tests/hgstring.c b/tests/hgstring.c
index 151a650..0af4722 100644
--- a/tests/hgstring.c
+++ b/tests/hgstring.c
@@ -65,24 +65,23 @@ TDEF (get_capsulated_size)
 	fail_unless(size == sizeof (hg_string_t), "Obtaining the different size: expect: %" G_GSIZE_FORMAT " actual: %" G_GSIZE_FORMAT, sizeof (hg_string_t), size);
 } TEND
 
-static gboolean
+static hg_error_t
 _gc_iter_func(hg_quark_t   qdata,
-	      gpointer     data,
-	      GError     **error)
+	      gpointer     data)
 {
-	return TRUE;
+	return HG_ERROR_ (HG_STATUS_SUCCESS, 0);
 }
 
-static gboolean
-_gc_func(hg_mem_t *mem,
-	 gpointer  data)
+static hg_error_t
+_gc_func(hg_mem_t     *mem,
+	 hg_pointer_t  data)
 {
 	hg_string_t *s = data;
 
 	if (data == NULL)
-		return TRUE;
+		return HG_ERROR_ (HG_STATUS_SUCCESS, 0);
 
-	return hg_object_gc_mark((hg_object_t *)s, _gc_iter_func, NULL, NULL);
+	return hg_object_gc_mark((hg_object_t *)s, _gc_iter_func, NULL);
 }
 
 TDEF (gc_mark)