API changes around object copying

16 files changed, 248 insertions, 373 deletions

diff --git a/hieroglyph/hgarray.c b/hieroglyph/hgarray.c
index beb2a98..9b728c7 100644
--- a/hieroglyph/hgarray.c
+++ b/hieroglyph/hgarray.c
@@ -89,13 +89,11 @@ static hg_quark_t
 _hg_object_array_copy(hg_object_t              *object,
 		      hg_quark_iterate_func_t   func,
 		      hg_pointer_t              user_data,
-		      hg_pointer_t             *ret,
-		      GError                  **error)
+		      hg_pointer_t             *ret)
 {
-	hg_array_t *array = (hg_array_t *)object, *a;
+	hg_array_t *array = (hg_array_t *)object, *a = NULL;
 	hg_quark_t retval, q, qr;
 	hg_usize_t i, len;
-	GError *err = NULL;
 
 	hg_return_val_if_fail (object->type == HG_TYPE_ARRAY, Qnil);
 
@@ -105,46 +103,39 @@ _hg_object_array_copy(hg_object_t              *object,
 	len = hg_array_maxlength(array);
 	object->on_copying = retval = hg_array_new(array->o.mem,
 						   len,
-						   (gpointer *)&a);
+						   (hg_pointer_t *)&a);
 	if (retval != Qnil) {
 		for (i = 0; i < len; i++) {
-			q = hg_array_get(array, i, &err);
-			if (err)
-				goto finalize;
-			qr = func(q, user_data, NULL, &err);
-			if (err)
-				goto finalize;
-			hg_array_set(a, qr, i, TRUE, &err);
-			if (err)
-				goto finalize;
+			q = hg_array_get(array, i, NULL);
+			if (q == Qnil)
+				goto bail;
+			qr = func(q, user_data, NULL);
+			if (qr == Qnil)
+				goto bail;
+			if (!hg_array_set(a, qr, i, TRUE, NULL))
+				goto bail;
+		}
+		if (array->qname == Qnil) {
+			a->qname = Qnil;
+		} else {
+			a->qname = func(array->qname, user_data, NULL);
+			if (a->qname == Qnil)
+				goto bail;
 		}
-		a->qname = func(array->qname, user_data, NULL, &err);
-		if (err)
-			goto finalize;
 		if (ret)
 			*ret = a;
 		else
 			hg_mem_unlock_object(a->o.mem, retval);
 	} else {
-		g_set_error(&err, HG_ERROR, HG_VM_e_VMerror,
-			    "Out of memory");
+		hg_warning("Out of memory");
 	}
-  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);
-		if (a)
-			hg_object_free(a->o.mem, retval);
+	goto finalize;
+  bail:
+	if (a)
+		hg_object_free(a->o.mem, retval);
 
-		retval = Qnil;
-	}
+	retval = Qnil;
+  finalize:
 	object->on_copying = Qnil;
 
 	return retval;
@@ -190,7 +181,7 @@ _hg_object_array_to_cstr(hg_object_t              *object,
 			g_clear_error(&err);
 			continue;
 		}
-		qr = func(q, user_data, NULL, NULL);
+		qr = func(q, user_data, NULL);
 		s = (gchar *)HGQUARK_TO_POINTER (qr);
 		if (s == NULL) {
 			g_string_append(retval, "...");
diff --git a/hieroglyph/hgdevice.c b/hieroglyph/hgdevice.c
index 69e1cd5..8a2645d 100644
--- a/hieroglyph/hgdevice.c
+++ b/hieroglyph/hgdevice.c
@@ -354,11 +354,13 @@ hg_device_get_page_params(hg_device_t                 *device,
 		q = Qnil;
 		switch (i) {
 		    case HG_pdev_InputAttributes:
-			    q = hg_object_quark_copy(mem, device->params->qinput_attributes, NULL, &err);
-			    if (err)
-				    goto finalize;
-			    if (q == Qnil)
+			    if (device->params->qinput_attributes == Qnil) {
 				    q = HG_QNULL;
+			    } else {
+				    q = hg_object_quark_copy(mem, device->params->qinput_attributes, NULL);
+				    if (q == Qnil)
+					    goto finalize;
+			    }
 			    break;
 		    case HG_pdev_PageSize:
 			    q = hg_array_new(mem, 2, (gpointer *)&a);
@@ -374,21 +376,25 @@ hg_device_get_page_params(hg_device_t                 *device,
 			    hg_mem_unlock_object(mem, q);
 			    break;
 		    case HG_pdev_MediaColor:
-			    q = hg_object_quark_copy(mem, device->params->qmedia_color, NULL, &err);
-			    if (err)
-				    goto finalize;
-			    if (q == Qnil)
+			    if (device->params->qmedia_color == Qnil) {
 				    q = HG_QNULL;
+			    } else {
+				    q = hg_object_quark_copy(mem, device->params->qmedia_color, NULL);
+				    if (q == Qnil)
+					    goto finalize;
+			    }
 			    break;
 		    case HG_pdev_MediaWeight:
 			    q = HG_QREAL (device->params->media_weight);
 			    break;
 		    case HG_pdev_MediaType:
-			    q = hg_object_quark_copy(mem, device->params->qmedia_type, NULL, &err);
-			    if (err)
-				    goto finalize;
-			    if (q == Qnil)
+			    if (device->params->qmedia_type == Qnil) {
 				    q = HG_QNULL;
+			    } else {
+				    q = hg_object_quark_copy(mem, device->params->qmedia_type, NULL);
+				    if (q == Qnil)
+					    goto finalize;
+			    }
 			    break;
 		    case HG_pdev_ManualFeed:
 			    q = HG_QBOOL (device->params->manual_feed);
@@ -468,11 +474,13 @@ hg_device_get_page_params(hg_device_t                 *device,
 			    q = HG_QBOOL (device->params->tumble);
 			    break;
 		    case HG_pdev_OutputType:
-			    q = hg_object_quark_copy(mem, device->params->qoutput_type, NULL, &err);
-			    if (err)
-				    goto finalize;
-			    if (q == Qnil)
+			    if (device->params->qoutput_type == Qnil) {
 				    q = HG_QNULL;
+			    } else {
+				    q = hg_object_quark_copy(mem, device->params->qoutput_type, NULL);
+				    if (q == Qnil)
+					    goto finalize;
+			    }
 			    break;
 		    case HG_pdev_NumCopies:
 			    if (device->params->num_copies < 0)
@@ -493,18 +501,18 @@ hg_device_get_page_params(hg_device_t                 *device,
 			    q = HG_QBOOL (device->params->separations);
 			    break;
 		    case HG_pdev_Install:
-			    q = hg_object_quark_copy(mem, device->params->qinstall, NULL, &err);
-			    if (err)
+			    q = hg_object_quark_copy(mem, device->params->qinstall, NULL);
+			    if (q == Qnil)
 				    goto finalize;
 			    break;
 		    case HG_pdev_BeginPage:
-			    q = hg_object_quark_copy(mem, device->params->qbegin_page, NULL, &err);
-			    if (err)
+			    q = hg_object_quark_copy(mem, device->params->qbegin_page, NULL);
+			    if (q == Qnil)
 				    goto finalize;
 			    break;
 		    case HG_pdev_EndPage:
-			    q = hg_object_quark_copy(mem, device->params->qend_page, NULL, &err);
-			    if (err)
+			    q = hg_object_quark_copy(mem, device->params->qend_page, NULL);
+			    if (q == Qnil)
 				    goto finalize;
 			    break;
 		    default:
diff --git a/hieroglyph/hgdict.c b/hieroglyph/hgdict.c
index 9f78022..522983c 100644
--- a/hieroglyph/hgdict.c
+++ b/hieroglyph/hgdict.c
@@ -87,9 +87,8 @@ _hg_object_dict_initialize(hg_object_t *object,
 static hg_quark_t
 _hg_object_dict_copy(hg_object_t              *object,
 		     hg_quark_iterate_func_t   func,
-		     gpointer                  user_data,
-		     gpointer                 *ret,
-		     GError                  **error)
+		     hg_pointer_t              user_data,
+		     hg_pointer_t             *ret)
 {
 	hg_return_val_if_fail (object->type == HG_TYPE_DICT, Qnil);
 
@@ -273,9 +272,8 @@ _hg_object_dict_node_initialize(hg_object_t *object,
 static hg_quark_t
 _hg_object_dict_node_copy(hg_object_t              *object,
 			  hg_quark_iterate_func_t   func,
-			  gpointer                  user_data,
-			  gpointer                 *ret,
-			  GError                  **error)
+			  hg_pointer_t              user_data,
+			  hg_pointer_t             *ret)
 {
 	hg_return_val_if_fail (object->type == HG_TYPE_DICT_NODE, Qnil);
 
diff --git a/hieroglyph/hgfile.c b/hieroglyph/hgfile.c
index 98b7422..41014b5 100644
--- a/hieroglyph/hgfile.c
+++ b/hieroglyph/hgfile.c
@@ -213,9 +213,8 @@ _hg_object_file_free(hg_object_t *object)
 static hg_quark_t
 _hg_object_file_copy(hg_object_t              *object,
 		     hg_quark_iterate_func_t   func,
-		     gpointer                  user_data,
-		     gpointer                 *ret,
-		     GError                  **error)
+		     hg_pointer_t              user_data,
+		     hg_pointer_t             *ret)
 {
 	hg_return_val_if_fail (object->type == HG_TYPE_FILE, Qnil);
 
diff --git a/hieroglyph/hggstate.c b/hieroglyph/hggstate.c
index df7c2c7..0234329 100644
--- a/hieroglyph/hggstate.c
+++ b/hieroglyph/hggstate.c
@@ -67,13 +67,11 @@ _hg_object_gstate_initialize(hg_object_t *object,
 static hg_quark_t
 _hg_object_gstate_copy(hg_object_t              *object,
 		       hg_quark_iterate_func_t   func,
-		       gpointer                  user_data,
-		       gpointer                 *ret,
-		       GError                  **error)
+		       hg_pointer_t              user_data,
+		       hg_pointer_t             *ret)
 {
-	hg_gstate_t *gstate = (hg_gstate_t *)object, *g;
+	hg_gstate_t *gstate = (hg_gstate_t *)object, *g = NULL;
 	hg_quark_t retval;
-	GError *err = NULL;
 
 	hg_return_val_if_fail (object->type == HG_TYPE_GSTATE, Qnil);
 
@@ -83,42 +81,47 @@ _hg_object_gstate_copy(hg_object_t              *object,
 	object->on_copying = retval = hg_gstate_new(gstate->o.mem, (gpointer *)&g);
 	if (retval != Qnil) {
 		memcpy(&g->ctm, &gstate->ctm, sizeof (hg_gstate_t) - sizeof (hg_object_t) - (sizeof (hg_quark_t) * 3));
-		g->qpath = func(gstate->qpath, user_data, NULL, &err);
-		if (err)
-			goto finalize;
-		hg_mem_reserved_spool_remove(gstate->o.mem,
-					     g->qpath);
-		g->qclippath = func(gstate->qclippath, user_data, NULL, &err);
-		if (err)
-			goto finalize;
-		hg_mem_reserved_spool_remove(gstate->o.mem,
-					     g->qclippath);
-		g->qdashpattern = func(gstate->qdashpattern, user_data, NULL, &err);
-		if (err)
-			goto finalize;
-		hg_mem_reserved_spool_remove(gstate->o.mem,
-					     g->qdashpattern);
+		if (gstate->qpath == Qnil) {
+			g->qpath = Qnil;
+		} else {
+			g->qpath = func(gstate->qpath, user_data, NULL);
+			if (g->qpath == Qnil)
+				goto bail;
+			hg_mem_reserved_spool_remove(gstate->o.mem,
+						     g->qpath);
+		}
+		if (gstate->qclippath == Qnil) {
+			g->qclippath = Qnil;
+		} else {
+			g->qclippath = func(gstate->qclippath, user_data, NULL);
+			if (g->qclippath == Qnil)
+				goto bail;
+			hg_mem_reserved_spool_remove(gstate->o.mem,
+						     g->qclippath);
+		}
+		if (gstate->qdashpattern == Qnil) {
+			g->qdashpattern = Qnil;
+		} else {
+			g->qdashpattern = func(gstate->qdashpattern, user_data, NULL);
+			if (g->qdashpattern == Qnil)
+				goto bail;
+			hg_mem_reserved_spool_remove(gstate->o.mem,
+						     g->qdashpattern);
+		}
 
 		if (ret)
 			*ret = g;
 		else
 			hg_mem_unlock_object(g->o.mem, retval);
 	}
-  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);
+	goto finalize;
+  bail:
+	if (g) {
 		hg_object_free(g->o.mem, retval);
 
 		retval = Qnil;
 	}
+  finalize:
 	object->on_copying = Qnil;
 
 	return retval;
@@ -165,28 +168,6 @@ _hg_object_gstate_compare(hg_object_t             *o1,
 	return FALSE;
 }
 
-static hg_quark_t
-_hg_gstate_iterate_copy(hg_quark_t   qdata,
-			gpointer     user_data,
-			gpointer    *ret,
-			GError     **error)
-{
-	hg_quark_t retval;
-	hg_object_t *o;
-	hg_gstate_t *gstate = (hg_gstate_t *)user_data;
-
-	if (hg_quark_is_simple_object(qdata))
-		return qdata;
-
-	hg_return_val_with_gerror_if_lock_fail (o, gstate->o.mem, qdata, error, Qnil);
-
-	retval = hg_object_copy(o, _hg_gstate_iterate_copy, user_data, NULL, error);
-
-	hg_mem_unlock_object(gstate->o.mem, qdata);
-
-	return retval;
-}
-
 /*< public >*/
 /**
  * hg_gstate_new:
@@ -331,50 +312,6 @@ hg_gstate_get_clippath(hg_gstate_t *gstate)
 }
 
 /**
- * hg_gstate_save:
- * @gstate:
- * @is_snapshot:
- *
- * FIXME
- *
- * Returns:
- */
-hg_quark_t
-hg_gstate_save(hg_gstate_t *gstate,
-	       hg_quark_t   is_snapshot)
-{
-	hg_quark_t retval;
-	GError *err = NULL;
-	hg_gstate_t *g;
-
-	hg_return_val_if_fail (gstate != NULL, Qnil);
-
-	retval = hg_object_copy((hg_object_t *)gstate,
-				_hg_gstate_iterate_copy,
-				gstate, (gpointer *)&g, &err);
-	if (retval == Qnil)
-		goto error;
-
-	g->is_snapshot = is_snapshot;
-
-	hg_mem_unlock_object(gstate->o.mem, retval);
-  error:
-	if (err) {
-		hg_warning("%s: %s (code: %d)",
-			   __PRETTY_FUNCTION__,
-			   err->message,
-			   err->code);
-		g_error_free(err);
-
-		hg_object_free(gstate->o.mem,
-			       retval);
-		retval = Qnil;
-	}
-
-	return retval;
-}
-
-/**
  * hg_gstate_set_rgbcolor:
  * @gstate:
  * @red:
diff --git a/hieroglyph/hggstate.h b/hieroglyph/hggstate.h
index 6d562ad..a75417f 100644
--- a/hieroglyph/hggstate.h
+++ b/hieroglyph/hggstate.h
@@ -106,8 +106,6 @@ hg_quark_t          hg_gstate_get_path         (hg_gstate_t    *gstate);
 void                hg_gstate_set_clippath     (hg_gstate_t    *gstate,
                                                 hg_quark_t      qpath);
 hg_quark_t          hg_gstate_get_clippath     (hg_gstate_t    *gstate);
-hg_quark_t          hg_gstate_save             (hg_gstate_t    *gstate,
-						hg_quark_t      is_snapshot);
 void                hg_gstate_set_rgbcolor     (hg_gstate_t    *gstate,
 						gdouble         red,
 						gdouble         green,
diff --git a/hieroglyph/hgobject.c b/hieroglyph/hgobject.c
index 457e5db..c3155bf 100644
--- a/hieroglyph/hgobject.c
+++ b/hieroglyph/hgobject.c
@@ -79,13 +79,12 @@ _hg_object_new(hg_mem_t     *mem,
 }
 
 static hg_quark_t
-_hg_object_quark_iterate_copy(hg_quark_t   qdata,
-			      gpointer     user_data,
-			      gpointer    *ret,
-			      GError     **error)
+_hg_object_quark_iterate_copy(hg_quark_t    qdata,
+			      hg_pointer_t  user_data,
+			      hg_pointer_t *ret)
 {
 	return hg_object_quark_copy((hg_mem_t *)user_data,
-				    qdata, ret, error);
+				    qdata, ret);
 }
 
 /*< public >*/
@@ -241,21 +240,20 @@ hg_object_free(hg_mem_t   *mem,
 hg_quark_t
 hg_object_copy(hg_object_t              *object,
 	       hg_quark_iterate_func_t   func,
-	       gpointer                  user_data,
-	       gpointer                 *ret,
-	       GError                  **error)
+	       hg_pointer_t              user_data,
+	       hg_pointer_t             *ret)
 {
 	hg_object_vtable_t *v;
 
-	hg_return_val_with_gerror_if_fail (__hg_object_is_initialized, Qnil, error, HG_VM_e_VMerror);
-	hg_return_val_with_gerror_if_fail (object != NULL, Qnil, error, HG_VM_e_VMerror);
-	hg_return_val_with_gerror_if_fail (object->type < HG_TYPE_END, Qnil, error, HG_VM_e_VMerror);
-	hg_return_val_with_gerror_if_fail (__hg_object_vtables[object->type] != NULL, Qnil, error, HG_VM_e_VMerror);
-	hg_return_val_with_gerror_if_fail (func != NULL, Qnil, error, HG_VM_e_VMerror);
+	hg_return_val_if_fail (__hg_object_is_initialized, Qnil);
+	hg_return_val_if_fail (object != NULL, Qnil);
+	hg_return_val_if_fail (object->type < HG_TYPE_END, Qnil);
+	hg_return_val_if_fail (__hg_object_vtables[object->type] != NULL, Qnil);
+	hg_return_val_if_fail (func != NULL, Qnil);
 
 	v = __hg_object_vtables[object->type];
 
-	return v->copy(object, func, user_data, ret, error);
+	return v->copy(object, func, user_data, ret);
 }
 
 /**
@@ -449,50 +447,37 @@ hg_object_get_acl(hg_object_t *object)
  * Returns:
  */
 hg_quark_t
-hg_object_quark_copy(hg_mem_t    *mem,
-		     hg_quark_t   qdata,
-		     gpointer    *ret,
-		     GError     **error)
+hg_object_quark_copy(hg_mem_t     *mem,
+		     hg_quark_t    qdata,
+		     hg_pointer_t *ret)
 {
 	hg_quark_t retval = Qnil;
 	hg_object_t *o;
-	GError *err = NULL;
 
-	hg_return_val_with_gerror_if_fail (mem != NULL, Qnil, error, HG_VM_e_VMerror);
+	hg_return_val_if_fail (mem != NULL, Qnil);
+	hg_return_val_if_fail (qdata != Qnil, Qnil);
 
-	if (qdata == Qnil)
-		return Qnil;
 	if (hg_quark_is_simple_object(qdata) ||
 	    hg_quark_get_type(qdata) == HG_TYPE_OPER)
 		return qdata;
 
-	o = HG_MEM_LOCK (mem, qdata, &err);
+	o = HG_MEM_LOCK (mem, qdata, NULL);
 	if (o) {
 		hg_quark_acl_t acl = 0;
 
-		retval = hg_object_copy(o, _hg_object_quark_iterate_copy, mem, ret, &err);
-		hg_mem_unlock_object(mem, qdata);
-		if (hg_quark_is_readable(qdata))
-			acl |= HG_ACL_READABLE;
-		if (hg_quark_is_writable(qdata))
-			acl |= HG_ACL_WRITABLE;
-		if (hg_quark_is_executable(qdata))
-			acl |= HG_ACL_EXECUTABLE;
-		if (hg_quark_is_accessible(qdata))
-			acl |= HG_ACL_ACCESSIBLE;
-		hg_quark_set_acl(&retval, acl);
-	}
-	if (err) {
-		if (error) {
-			*error = g_error_copy(err);
-		} else {
-			hg_warning("%s: %s (code: %d)",
-				   __PRETTY_FUNCTION__,
-				   err->message,
-				   err->code);
+		retval = hg_object_copy(o, _hg_object_quark_iterate_copy, mem, ret);
+		if (retval != Qnil) {
+			hg_mem_unlock_object(mem, qdata);
+			if (hg_quark_is_readable(qdata))
+				acl |= HG_ACL_READABLE;
+			if (hg_quark_is_writable(qdata))
+				acl |= HG_ACL_WRITABLE;
+			if (hg_quark_is_executable(qdata))
+				acl |= HG_ACL_EXECUTABLE;
+			if (hg_quark_is_accessible(qdata))
+				acl |= HG_ACL_ACCESSIBLE;
+			hg_quark_set_acl(&retval, acl);
 		}
-		g_error_free(err);
-		retval = Qnil;
 	}
 
 	return retval;
diff --git a/hieroglyph/hgobject.h b/hieroglyph/hgobject.h
index 020a2ab..ada155e 100644
--- a/hieroglyph/hgobject.h
+++ b/hieroglyph/hgobject.h
@@ -54,8 +54,7 @@ HG_BEGIN_DECLS
 	static hg_quark_t      _hg_object_ ## _name_ ## _copy                (hg_object_t              *object, \
 									      hg_quark_iterate_func_t   func, \
 									      gpointer                  user_data, \
-									      gpointer                 *ret, \
-									      GError                  **error); \
+									      gpointer                 *ret); \
 	static gchar          *_hg_object_ ## _name_ ## _to_cstr             (hg_object_t              *object, \
 									      hg_quark_iterate_func_t   func, \
 									      gpointer                  user_data, \
@@ -103,9 +102,8 @@ struct _hg_object_vtable_t {
 	void             (* free)                 (hg_object_t              *object);
 	hg_quark_t       (* copy)                 (hg_object_t              *object,
 						   hg_quark_iterate_func_t   func,
-						   gpointer                  user_data,
-						   gpointer                 *ret,
-						   GError                  **error);
+						   hg_pointer_t              user_data,
+						   hg_pointer_t             *ret);
 	gchar          * (* to_cstr)              (hg_object_t              *object,
 						   hg_quark_iterate_func_t   func,
 						   gpointer                  user_data,
@@ -149,9 +147,8 @@ void            hg_object_free      (hg_mem_t                 *mem,
 				     hg_quark_t                index);
 hg_quark_t      hg_object_copy      (hg_object_t              *object,
 				     hg_quark_iterate_func_t   func,
-				     gpointer                  user_data,
-				     gpointer                 *ret,
-				     GError                  **error);
+				     hg_pointer_t              user_data,
+				     hg_pointer_t             *ret);
 gchar          *hg_object_to_cstr   (hg_object_t              *object,
 				     hg_quark_iterate_func_t   func,
 				     gpointer                  user_data,
@@ -171,8 +168,7 @@ void            hg_object_set_acl   (hg_object_t              *object,
 hg_quark_acl_t  hg_object_get_acl   (hg_object_t              *object);
 hg_quark_t      hg_object_quark_copy(hg_mem_t                 *mem,
 				     hg_quark_t                qdata,
-				     gpointer                 *ret,
-				     GError                  **error);
+				     hg_pointer_t             *ret);
 
 HG_END_DECLS
 
diff --git a/hieroglyph/hgoperator.c b/hieroglyph/hgoperator.c
index 38df5b1..7cb796a 100644
--- a/hieroglyph/hgoperator.c
+++ b/hieroglyph/hgoperator.c
@@ -1082,7 +1082,7 @@ DEFUNC_OPER (protected_for_yield_int_continue)
 		SET_EXPECTED_STACK_SIZE (1, 2, 0);
 	}
 
-	qq = hg_vm_quark_copy(vm, proc, NULL, error);
+	qq = hg_vm_quark_copy(vm, proc, NULL);
 	if (qq == Qnil) {
 		hg_vm_set_error(vm, qself, HG_VM_e_VMerror);
 		return FALSE;
@@ -1129,7 +1129,7 @@ DEFUNC_OPER (protected_for_yield_real_continue)
 		SET_EXPECTED_STACK_SIZE (1, 2, 0);
 	}
 
-	qq = hg_vm_quark_copy(vm, proc, NULL, error);
+	qq = hg_vm_quark_copy(vm, proc, NULL);
 	if (qq == Qnil) {
 		hg_vm_set_error(vm, qself, HG_VM_e_VMerror);
 		return FALSE;
@@ -1181,7 +1181,7 @@ DEFUNC_OPER (protected_forall_array_continue)
 	qq = hg_array_get(a, i, error);
 	HG_VM_UNLOCK (vm, val);
 
-	q = hg_vm_quark_copy(vm, proc, NULL, error);
+	q = hg_vm_quark_copy(vm, proc, NULL);
 	if (q == Qnil) {
 		hg_vm_set_error(vm, qself, HG_VM_e_VMerror);
 		return FALSE;
@@ -1238,7 +1238,7 @@ DEFUNC_OPER (protected_forall_dict_continue)
 	hg_dict_remove(d, qk, error);
 	HG_VM_UNLOCK (vm, val);
 
-	q = hg_vm_quark_copy(vm, proc, NULL, error);
+	q = hg_vm_quark_copy(vm, proc, NULL);
 	if (q == Qnil) {
 		hg_vm_set_error(vm, qself, HG_VM_e_VMerror);
 		return FALSE;
@@ -1290,7 +1290,7 @@ DEFUNC_OPER (protected_forall_string_continue)
 	qq = HG_QINT (hg_string_index(s, i));
 	HG_VM_UNLOCK (vm, val);
 
-	q = hg_vm_quark_copy(vm, proc, NULL, error);
+	q = hg_vm_quark_copy(vm, proc, NULL);
 	if (q == Qnil) {
 		hg_vm_set_error(vm, qself, HG_VM_e_VMerror);
 		return FALSE;
@@ -1312,7 +1312,7 @@ DEFUNC_OPER (protected_loop_continue)
 	self = hg_stack_index(estack, 0, error);
 	qproc = hg_stack_index(estack, 1, error);
 
-	q = hg_vm_quark_copy(vm, qproc, NULL, error);
+	q = hg_vm_quark_copy(vm, qproc, NULL);
 	if (q == Qnil) {
 		hg_vm_set_error(vm, qself, HG_VM_e_VMerror);
 		return FALSE;
@@ -1339,7 +1339,7 @@ DEFUNC_OPER (protected_repeat_continue)
 	if (HG_INT (*arg0) > 0) {
 		*arg0 = HG_QINT (HG_INT (*arg0) - 1);
 
-		q = hg_vm_quark_copy(vm, arg1, NULL, error);
+		q = hg_vm_quark_copy(vm, arg1, NULL);
 		if (q == Qnil) {
 			hg_vm_set_error(vm, qself, HG_VM_e_VMerror);
 			return FALSE;
@@ -2271,7 +2271,7 @@ DEFUNC_OPER (clippath)
 		return FALSE;
 	}
 	q = hg_gstate_get_clippath(gstate);
-	qq = hg_vm_quark_copy(vm, q, NULL, error);
+	qq = hg_vm_quark_copy(vm, q, NULL);
 	if (qq == Qnil) {
 		hg_vm_set_error(vm, qself, HG_VM_e_VMerror);
 		goto finalize;
@@ -3706,7 +3706,7 @@ DEFUNC_OPER (exec)
 			return FALSE;
 		}
 
-		q = hg_vm_quark_copy(vm, arg0, NULL, error);
+		q = hg_vm_quark_copy(vm, arg0, NULL);
 		if (q == Qnil) {
 			hg_vm_set_error(vm, qself, HG_VM_e_VMerror);
 			return FALSE;
@@ -4598,17 +4598,12 @@ DEFUNC_OPER (grestoreall)
 DEFUNC_OPER (gsave)
 {
 	hg_quark_t q, qg = hg_vm_get_gstate(vm);
-	hg_gstate_t *gstate;
 
-	gstate = HG_VM_LOCK (vm, qg, error);
-	if (gstate == NULL) {
+	q = hg_vm_quark_copy(vm, qg, NULL);
+	if (q == Qnil) {
 		hg_vm_set_error(vm, qself, HG_VM_e_VMerror);
 		return FALSE;
 	}
-	q = hg_gstate_save(gstate, Qnil);
-
-	HG_VM_UNLOCK (vm, qg);
-
 	STACK_PUSH (vm->stacks[HG_VM_STACK_GSTATE], qg);
 	hg_vm_set_gstate(vm, q);
 
@@ -4757,8 +4752,8 @@ DEFUNC_OPER (if)
 		return FALSE;
 	}
 	if (HG_BOOL (arg0)) {
-		q = hg_vm_quark_copy(vm, arg1, NULL, error);
-		if (error && *error) {
+		q = hg_vm_quark_copy(vm, arg1, NULL);
+		if (q == Qnil) {
 			hg_vm_set_error(vm, qself, HG_VM_e_VMerror);
 			return FALSE;
 		}
@@ -4806,11 +4801,11 @@ DEFUNC_OPER (ifelse)
 		return FALSE;
 	}
 	if (HG_BOOL (arg0)) {
-		q = hg_vm_quark_copy(vm, arg1, NULL, error);
+		q = hg_vm_quark_copy(vm, arg1, NULL);
 	} else {
-		q = hg_vm_quark_copy(vm, arg2, NULL, error);
+		q = hg_vm_quark_copy(vm, arg2, NULL);
 	}
-	if (error && *error) {
+	if (q == Qnil) {
 		hg_vm_set_error(vm, qself, HG_VM_e_VMerror);
 		return FALSE;
 	}
diff --git a/hieroglyph/hgpath.c b/hieroglyph/hgpath.c
index 90d0c1b..b772381 100644
--- a/hieroglyph/hgpath.c
+++ b/hieroglyph/hgpath.c
@@ -81,28 +81,26 @@ _hg_object_path_initialize(hg_object_t *object,
 static hg_quark_t
 _hg_object_path_copy(hg_object_t              *object,
 		     hg_quark_iterate_func_t   func,
-		     gpointer                  user_data,
-		     gpointer                 *ret,
-		     GError                  **error)
+		     hg_pointer_t              user_data,
+		     hg_pointer_t             *ret)
 {
 	hg_path_t *path = (hg_path_t *)object, *p = NULL;
 	hg_path_node_t *on, *nn;
 	hg_quark_t retval;
-	GError *err = NULL;
 
 	hg_return_val_if_fail (object->type == HG_TYPE_PATH, Qnil);
 
 	if (object->on_copying != Qnil)
 		return object->on_copying;
 
-	object->on_copying = retval = hg_path_new(path->o.mem, (gpointer *)&p);
+	object->on_copying = retval = hg_path_new(path->o.mem, (hg_pointer_t *)&p);
 	if (retval != Qnil) {
 		p->length = path->length;
-		on = HG_MEM_LOCK (path->o.mem, path->qnode, &err);
-		nn = HG_MEM_LOCK (path->o.mem, p->qnode, &err);
+		on = HG_MEM_LOCK (path->o.mem, path->qnode, NULL);
+		nn = HG_MEM_LOCK (path->o.mem, p->qnode, NULL);
 		if (on == NULL ||
 		    nn == NULL) {
-			goto finalize;
+			goto bail;
 		}
 		memcpy(nn, on, sizeof (hg_path_node_t) * path->length);
 		hg_mem_unlock_object(path->o.mem, path->qnode);
@@ -113,20 +111,13 @@ _hg_object_path_copy(hg_object_t              *object,
 		else
 			hg_mem_unlock_object(path->o.mem, retval);
 	}
-  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);
+	goto finalize;
+  bail:
+	if (p) {
 		hg_object_free(p->o.mem, retval);
 		retval = Qnil;
 	}
+  finalize:
 	
 	return retval;
 }
diff --git a/hieroglyph/hgquark.h b/hieroglyph/hgquark.h
index d942c3b..3817f87 100644
--- a/hieroglyph/hgquark.h
+++ b/hieroglyph/hgquark.h
@@ -34,8 +34,7 @@ HG_BEGIN_DECLS
 
 typedef hg_quark_t (* hg_quark_iterate_func_t)	(hg_quark_t     qdata,
 						 hg_pointer_t   user_data,
-						 hg_pointer_t  *ret,
-						 GError       **error);
+						 hg_pointer_t  *ret);
 typedef hg_bool_t  (* hg_quark_compare_func_t)  (hg_quark_t     q1,
 						 hg_quark_t     q2,
 						 hg_pointer_t   user_data);
diff --git a/hieroglyph/hgsnapshot.c b/hieroglyph/hgsnapshot.c
index a7af105..d64c822 100644
--- a/hieroglyph/hgsnapshot.c
+++ b/hieroglyph/hgsnapshot.c
@@ -70,11 +70,10 @@ _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,
-			 hg_pointer_t              user_data,
-			 hg_pointer_t             *ret,
-			 GError                  **error)
+_hg_object_snapshot_copy(hg_object_t             *object,
+			 hg_quark_iterate_func_t  func,
+			 hg_pointer_t             user_data,
+			 hg_pointer_t            *ret)
 {
 	hg_return_val_if_fail (object->type == HG_TYPE_SNAPSHOT, Qnil);
 
diff --git a/hieroglyph/hgstack.c b/hieroglyph/hgstack.c
index 47c4cea..32139f2 100644
--- a/hieroglyph/hgstack.c
+++ b/hieroglyph/hgstack.c
@@ -124,11 +124,10 @@ _hg_object_stack_initialize(hg_object_t *object,
 }
 
 static hg_quark_t
-_hg_object_stack_copy(hg_object_t              *object,
-		      hg_quark_iterate_func_t   func,
-		      gpointer                  user_data,
-		      gpointer                 *ret,
-		      GError                  **error)
+_hg_object_stack_copy(hg_object_t             *object,
+		      hg_quark_iterate_func_t  func,
+		      hg_pointer_t             user_data,
+		      hg_pointer_t            *ret)
 {
 	return Qnil;
 }
diff --git a/hieroglyph/hgstring.c b/hieroglyph/hgstring.c
index ddf8c0e..1c17e27 100644
--- a/hieroglyph/hgstring.c
+++ b/hieroglyph/hgstring.c
@@ -83,15 +83,13 @@ _hg_object_string_initialize(hg_object_t *object,
 }
 
 static hg_quark_t
-_hg_object_string_copy(hg_object_t              *object,
-		       hg_quark_iterate_func_t   func,
-		       gpointer                  user_data,
-		       gpointer                 *ret,
-		       GError                  **error)
+_hg_object_string_copy(hg_object_t             *object,
+		       hg_quark_iterate_func_t  func,
+		       hg_pointer_t             user_data,
+		       hg_pointer_t            *ret)
 {
 	hg_string_t *s = (hg_string_t *)object;
-	hg_quark_t retval;
-	GError *err = NULL;
+	hg_quark_t retval = Qnil;
 	gchar *cstr = hg_string_get_cstr(s);
 
 	hg_return_val_if_fail (object->type == HG_TYPE_STRING, Qnil);
@@ -99,19 +97,7 @@ _hg_object_string_copy(hg_object_t              *object,
 	retval = HG_QSTRING_LEN (s->o.mem, cstr, hg_string_length(s));
 	g_free(cstr);
 	if (retval == Qnil) {
-		g_set_error(&err, HG_ERROR, HG_VM_e_VMerror,
-			    "Out of memory");
-	}
-	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);
+		hg_warning("Out of memory");
 	}
 
 	return retval;
diff --git a/hieroglyph/hgvm.c b/hieroglyph/hgvm.c
index cea1273..68ae9f9 100644
--- a/hieroglyph/hgvm.c
+++ b/hieroglyph/hgvm.c
@@ -526,26 +526,24 @@ _hg_vm_quark_iterate_gc_mark(hg_quark_t   qdata,
 }
 
 static hg_quark_t
-_hg_vm_quark_iterate_copy(hg_quark_t   qdata,
-			  gpointer     user_data,
-			  gpointer    *ret,
-			  GError     **error)
+_hg_vm_quark_iterate_copy(hg_quark_t    qdata,
+			  hg_pointer_t  user_data,
+			  hg_pointer_t *ret)
 {
-	return hg_vm_quark_copy((hg_vm_t *)user_data, qdata, ret, error);
+	return hg_vm_quark_copy((hg_vm_t *)user_data, qdata, ret);
 }
 
 static hg_quark_t
-_hg_vm_quark_iterate_to_cstr(hg_quark_t   qdata,
-			     gpointer     user_data,
-			     gpointer    *ret,
-			     GError     **error)
+_hg_vm_quark_iterate_to_cstr(hg_quark_t    qdata,
+			     hg_pointer_t  user_data,
+			     hg_pointer_t *ret)
 {
 	hg_vm_t *vm = (hg_vm_t *)user_data;
 	hg_string_t *s = NULL;
 	hg_quark_t q;
 	gchar *cstr = NULL;
 
-	q = hg_vm_quark_to_string(vm, qdata, TRUE, (gpointer *)&s, error);
+	q = hg_vm_quark_to_string(vm, qdata, TRUE, (gpointer *)&s, NULL);
 	if (s) {
 		cstr = hg_string_get_cstr(s);
 	}
@@ -1544,7 +1542,13 @@ hg_vm_setup(hg_vm_t           *vm,
 	}
 
 	for (i = 0; i < HG_VM_MEM_END; i++) {
-		hg_mem_set_resizable(vm->mem[i], (lang_level >= HG_LANG_LEVEL_2));
+		/* Even if the memory spool expansion wasn't supported in PS1,
+		 * following up on that spec here isn't a good idea because
+		 * this isn't entire clone of Adobe's and the memory management
+		 * should be totally different.
+		 * So OOM is likely happening on only hieroglyph.
+		 */
+		hg_mem_set_resizable(vm->mem[i], TRUE);
 	}
 
 	hg_vm_quark_set_acl(vm, &vm->qsystemdict, HG_ACL_READABLE|HG_ACL_WRITABLE|HG_ACL_ACCESSIBLE);
@@ -1850,8 +1854,8 @@ hg_vm_stepi(hg_vm_t  *vm,
 				    return TRUE;
 			    }
 			    if (hg_vm_quark_is_executable(vm, &qresult)) {
-				    q = hg_vm_quark_copy(vm, qresult, NULL, &err);
-				    if (err) {
+				    q = hg_vm_quark_copy(vm, qresult, NULL);
+				    if (q == Qnil) {
 					    hg_vm_set_error(vm, qexecobj,
 							    HG_VM_e_VMerror);
 					    return TRUE;
@@ -3032,8 +3036,8 @@ hg_vm_set_error(hg_vm_t       *vm,
 		goto fatal_error;
 	}
 
-	q = hg_vm_quark_copy(vm, qhandler, NULL, &err);
-	if (err)
+	q = hg_vm_quark_copy(vm, qhandler, NULL);
+	if (q == Qnil)
 		goto fatal_error;
 	hg_stack_push(vm->stacks[HG_VM_STACK_ESTACK], q);
 	hg_stack_push(vm->stacks[HG_VM_STACK_OSTACK], qdata);
@@ -3791,41 +3795,27 @@ hg_vm_quark_gc_mark(hg_vm_t     *vm,
  * Returns:
  */
 hg_quark_t
-hg_vm_quark_copy(hg_vm_t     *vm,
-		 hg_quark_t   qdata,
-		 gpointer    *ret,
-		 GError     **error)
+hg_vm_quark_copy(hg_vm_t      *vm,
+		 hg_quark_t    qdata,
+		 hg_pointer_t *ret)
 {
 	hg_object_t *o;
 	hg_quark_t retval = Qnil;
-	GError *err = NULL;
 
-	hg_return_val_with_gerror_if_fail (vm != NULL, Qnil, error, HG_VM_e_VMerror);
-
-	if (qdata == Qnil)
-		return Qnil;
+	hg_return_val_if_fail (vm != NULL, Qnil);
+	hg_return_val_if_fail (qdata != Qnil, Qnil);
 
 	if (hg_quark_is_simple_object(qdata) ||
 	    HG_IS_QOPER (qdata))
 		return qdata;
 
-	o = _HG_VM_LOCK (vm, qdata, &err);
+	o = _HG_VM_LOCK (vm, qdata, NULL);
 	if (o) {
-		retval = hg_object_copy(o, _hg_vm_quark_iterate_copy, vm, ret, &err);
+		retval = hg_object_copy(o, _hg_vm_quark_iterate_copy, vm, ret);
 
 		_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);
-	} else {
+	if (retval != Qnil) {
 		hg_quark_acl_t acl = 0;
 
 		if (hg_vm_quark_is_readable(vm, &qdata))
@@ -4429,17 +4419,22 @@ hg_vm_snapshot_save(hg_vm_t *vm)
 
 	q = hg_snapshot_new(vm->mem[HG_VM_MEM_LOCAL],
 			    (hg_pointer_t *)&sn);
-	if (q == Qnil)
+	if (q == Qnil) {
+		hg_debug(HG_MSGCAT_SNAPSHOT, "Unable to create a snapshot object");
 		return HG_ERROR_ (HG_STATUS_FAILED, HG_e_VMerror);
+	}
 	if (!hg_snapshot_save(sn)) {
+		hg_debug(HG_MSGCAT_SNAPSHOT, "Unable to take a snapshot.");
 		_HG_VM_UNLOCK (vm, q);
 		return HG_ERROR_ (HG_STATUS_FAILED, HG_e_VMerror);
 	}
 	_HG_VM_UNLOCK (vm, q);
 
-	qg = hg_vm_quark_copy(vm, qgg, NULL, NULL);
-	if (qg == Qnil)
+	qg = hg_vm_quark_copy(vm, qgg, NULL);
+	if (qg == Qnil) {
+		hg_debug(HG_MSGCAT_SNAPSHOT, "Unable to copy the gstate.");
 		return HG_ERROR_ (HG_STATUS_FAILED, HG_e_VMerror);
+	}
 
 	gstate = _HG_VM_LOCK (vm, qgg, NULL);
 	if (gstate == NULL)
diff --git a/hieroglyph/hgvm.h b/hieroglyph/hgvm.h
index fbe7022..0276fc9 100644
--- a/hieroglyph/hgvm.h
+++ b/hieroglyph/hgvm.h
@@ -305,48 +305,47 @@ hg_quark_t hg_vm_dict_lookup    (hg_vm_t     *vm,
                                  GError     **error);
 
 /* hg_quark_t */
-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,
-                                              GError     **error);
-hg_quark_t hg_vm_quark_to_string             (hg_vm_t     *vm,
-                                              hg_quark_t   qdata,
-                                              gboolean     ps_like_syntax,
-                                              gpointer    *ret,
-                                              GError     **error);
-gboolean   hg_vm_quark_compare               (hg_vm_t     *vm,
-                                              hg_quark_t   qdata1,
-                                              hg_quark_t   qdata2);
-gboolean   hg_vm_quark_compare_content       (hg_vm_t     *vm,
-                                              hg_quark_t   qdata1,
-                                              hg_quark_t   qdata2);
-void       hg_vm_quark_set_default_acl       (hg_vm_t     *vm,
-                                              hg_quark_t  *qdata);
-void       hg_vm_quark_set_acl               (hg_vm_t     *vm,
-                                              hg_quark_t  *qdata,
+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,
+                                              hg_pointer_t   *ret);
+hg_quark_t hg_vm_quark_to_string             (hg_vm_t        *vm,
+                                              hg_quark_t      qdata,
+                                              gboolean        ps_like_syntax,
+                                              gpointer       *ret,
+                                              GError        **error);
+gboolean   hg_vm_quark_compare               (hg_vm_t        *vm,
+                                              hg_quark_t      qdata1,
+                                              hg_quark_t      qdata2);
+gboolean   hg_vm_quark_compare_content       (hg_vm_t        *vm,
+                                              hg_quark_t      qdata1,
+                                              hg_quark_t      qdata2);
+void       hg_vm_quark_set_default_acl       (hg_vm_t        *vm,
+                                              hg_quark_t     *qdata);
+void       hg_vm_quark_set_acl               (hg_vm_t        *vm,
+                                              hg_quark_t     *qdata,
 					      hg_quark_acl_t  acl);
-void       hg_vm_quark_set_readable          (hg_vm_t     *vm,
-                                              hg_quark_t  *qdata,
-                                              gboolean     flag);
-gboolean   hg_vm_quark_is_readable           (hg_vm_t     *vm,
-                                              hg_quark_t  *qdata);
-void       hg_vm_quark_set_writable          (hg_vm_t     *vm,
-                                              hg_quark_t  *qdata,
-                                              gboolean     flag);
-gboolean   hg_vm_quark_is_writable           (hg_vm_t     *vm,
-                                              hg_quark_t  *qdata);
-void       hg_vm_quark_set_executable        (hg_vm_t     *vm,
-                                              hg_quark_t  *qdata,
-                                              gboolean     flag);
-gboolean   hg_vm_quark_is_executable         (hg_vm_t     *vm,
-                                              hg_quark_t  *qdata);
-void       hg_vm_quark_set_accessible        (hg_vm_t     *vm,
-                                              hg_quark_t  *qdata,
-                                              gboolean     flag);
-gboolean   hg_vm_quark_is_accessible         (hg_vm_t     *vm,
-                                              hg_quark_t  *qdata);
+void       hg_vm_quark_set_readable          (hg_vm_t        *vm,
+                                              hg_quark_t     *qdata,
+                                              gboolean        flag);
+gboolean   hg_vm_quark_is_readable           (hg_vm_t        *vm,
+                                              hg_quark_t     *qdata);
+void       hg_vm_quark_set_writable          (hg_vm_t        *vm,
+                                              hg_quark_t     *qdata,
+                                              gboolean        flag);
+gboolean   hg_vm_quark_is_writable           (hg_vm_t        *vm,
+                                              hg_quark_t     *qdata);
+void       hg_vm_quark_set_executable        (hg_vm_t        *vm,
+                                              hg_quark_t     *qdata,
+                                              gboolean        flag);
+gboolean   hg_vm_quark_is_executable         (hg_vm_t        *vm,
+                                              hg_quark_t     *qdata);
+void       hg_vm_quark_set_accessible        (hg_vm_t        *vm,
+                                              hg_quark_t     *qdata,
+                                              gboolean        flag);
+gboolean   hg_vm_quark_is_accessible         (hg_vm_t        *vm,
+                                              hg_quark_t     *qdata);
 
 /* hg_snapshot_t */
 hg_error_t hg_vm_snapshot_save   (hg_vm_t    *vm);