hg_path_t APIs cleanup

7 files changed, 640 insertions, 377 deletions

diff --git a/hieroglyph/hgdevice.c b/hieroglyph/hgdevice.c
index ce19875..582ee85 100644
--- a/hieroglyph/hgdevice.c
+++ b/hieroglyph/hgdevice.c
@@ -36,7 +36,6 @@
 #include "hgmem.h"
 #include "hgnull.h"
 #include "hgoperator.h"
-#include "hgpath.h"
 #include "hgreal.h"
 #include "hgdevice.h"
 
@@ -619,13 +618,7 @@ hg_device_eofill(hg_device_t *device,
 
 	retval = device->eofill(device, gstate);
 	if (retval) {
-		hg_quark_t qpath = hg_path_new(gstate->o.mem, NULL);
-
-		if (qpath == Qnil) {
-			return FALSE;
-		} else {
-			hg_gstate_set_path(gstate, qpath);
-		}
+		retval = hg_gstate_newpath(gstate);
 	}
 
 	return retval;
@@ -652,13 +645,7 @@ hg_device_fill(hg_device_t *device,
 
 	retval = device->fill(device, gstate);
 	if (retval) {
-		hg_quark_t qpath = hg_path_new(gstate->o.mem, NULL);
-
-		if (qpath == Qnil) {
-			return FALSE;
-		} else {
-			hg_gstate_set_path(gstate, qpath);
-		}
+		retval = hg_gstate_newpath(gstate);
 	}
 
 	return retval;
@@ -685,13 +672,7 @@ hg_device_stroke(hg_device_t *device,
 
 	retval = device->stroke(device, gstate);
 	if (retval) {
-		hg_quark_t qpath = hg_path_new(gstate->o.mem, NULL);
-
-		if (qpath == Qnil) {
-			return FALSE;
-		} else {
-			hg_gstate_set_path(gstate, qpath);
-		}
+		retval = hg_gstate_newpath(gstate);
 	}
 
 	return retval;
diff --git a/hieroglyph/hggstate.c b/hieroglyph/hggstate.c
index e3f40cd..bb8608f 100644
--- a/hieroglyph/hggstate.c
+++ b/hieroglyph/hggstate.c
@@ -29,6 +29,7 @@
 #include "hgarray.h"
 #include "hgint.h"
 #include "hgmem.h"
+#include "hgpath.h"
 #include "hgreal.h"
 #include "hggstate.h"
 
@@ -227,30 +228,6 @@ hg_gstate_get_ctm(hg_gstate_t *gstate,
 }
 
 /**
- * hg_gstate_set_path:
- * @gstate:
- * @qpath:
- *
- * FIXME
- */
-void
-hg_gstate_set_path(hg_gstate_t *gstate,
-		   hg_quark_t   qpath)
-{
-	hg_uint_t mem_id;
-
-	hg_return_if_fail (gstate != NULL, HG_e_typecheck);
-	hg_return_if_fail (HG_IS_QPATH (qpath), HG_e_typecheck);
-
-	mem_id = hg_quark_get_mem_id(gstate->o.self);
-
-	hg_return_if_fail (hg_quark_has_mem_id(qpath, mem_id), HG_e_VMerror);
-
-	gstate->qpath = qpath;
-	hg_mem_unref(gstate->o.mem, qpath);
-}
-
-/**
  * hg_gstate_get_path:
  * @gstate:
  *
@@ -513,3 +490,484 @@ hg_gstate_set_dash(hg_gstate_t *gstate,
 
 	return HG_ERROR_IS_SUCCESS0 ();
 }
+
+/* hg_path_t wrappers */
+
+/**
+ * hg_gstate_newpath:
+ * @gstate:
+ *
+ * FIXME
+ *
+ * Returns:
+ */
+hg_bool_t
+hg_gstate_newpath(hg_gstate_t *gstate)
+{
+	hg_return_val_if_fail (gstate != NULL, FALSE, HG_e_typecheck);
+	hg_return_val_if_fail (gstate->o.type == HG_TYPE_GSTATE, FALSE, HG_e_typecheck);
+
+	gstate->qpath = hg_path_new(gstate->o.mem, NULL);
+
+	return gstate->qpath != Qnil;
+}
+
+/**
+ * hg_gstate_closepath:
+ * @gstate:
+ *
+ * FIXME
+ *
+ * Returns:
+ */
+hg_bool_t
+hg_gstate_closepath(hg_gstate_t *gstate)
+{
+	hg_path_t *p;
+	hg_bool_t retval = FALSE;
+
+	hg_return_val_if_fail (gstate != NULL, FALSE, HG_e_typecheck);
+	hg_return_val_if_fail (gstate->o.type == HG_TYPE_GSTATE, FALSE, HG_e_typecheck);
+
+	p = HG_MEM_LOCK (gstate->o.mem, gstate->qpath);
+	if (p) {
+		retval = hg_path_close(p);
+		hg_mem_unlock_object(gstate->o.mem, gstate->qpath);
+	}
+
+	return retval;
+}
+
+/**
+ * hg_gstate_moveto:
+ * @gstate:
+ * @x:
+ * @y:
+ *
+ * FIXME
+ *
+ * Returns:
+ */
+hg_bool_t
+hg_gstate_moveto(hg_gstate_t *gstate,
+		 hg_real_t    x,
+		 hg_real_t    y)
+{
+	hg_path_t *p;
+	hg_bool_t retval = FALSE;
+
+	hg_return_val_if_fail (gstate != NULL, FALSE, HG_e_typecheck);
+	hg_return_val_if_fail (gstate->o.type == HG_TYPE_GSTATE, FALSE, HG_e_typecheck);
+
+	if (gstate->qpath == Qnil) {
+		gstate->qpath = hg_path_new(gstate->o.mem, NULL);
+		if (gstate->qpath == Qnil)
+			hg_error_return (HG_STATUS_FAILED, HG_e_limitcheck);
+	}
+	p = HG_MEM_LOCK (gstate->o.mem, gstate->qpath);
+	if (p) {
+		retval = hg_path_moveto(p, x, y);
+		hg_mem_unlock_object(gstate->o.mem, gstate->qpath);
+	}
+
+	return retval;
+}
+
+/**
+ * hg_gstate_rmoveto:
+ * @gstate:
+ * @x:
+ * @y:
+ *
+ * FIXME
+ *
+ * Returns:
+ */
+hg_bool_t
+hg_gstate_rmoveto(hg_gstate_t *gstate,
+		  hg_real_t    rx,
+		  hg_real_t    ry)
+{
+	hg_path_t *p;
+	hg_bool_t retval = FALSE;
+
+	hg_return_val_if_fail (gstate != NULL, FALSE, HG_e_typecheck);
+	hg_return_val_if_fail (gstate->o.type == HG_TYPE_GSTATE, FALSE, HG_e_typecheck);
+
+	p = HG_MEM_LOCK (gstate->o.mem, gstate->qpath);
+	if (p) {
+		retval = hg_path_rmoveto(p, rx, ry);
+		hg_mem_unlock_object(gstate->o.mem, gstate->qpath);
+	}
+
+	return retval;
+}
+
+/**
+ * hg_gstate_lineto:
+ * @gstate:
+ * @x:
+ * @y:
+ *
+ * FIXME
+ *
+ * Returns:
+ */
+hg_bool_t
+hg_gstate_lineto(hg_gstate_t *gstate,
+		 hg_real_t    x,
+		 hg_real_t    y)
+{
+	hg_path_t *p;
+	hg_bool_t retval = FALSE;
+
+	hg_return_val_if_fail (gstate != NULL, FALSE, HG_e_typecheck);
+	hg_return_val_if_fail (gstate->o.type == HG_TYPE_GSTATE, FALSE, HG_e_typecheck);
+
+	p = HG_MEM_LOCK (gstate->o.mem, gstate->qpath);
+	if (p) {
+		retval = hg_path_lineto(p, x, y);
+		hg_mem_unlock_object(gstate->o.mem, gstate->qpath);
+	}
+
+	return retval;
+}
+
+/**
+ * hg_gstate_rlineto:
+ * @gstate:
+ * @x:
+ * @y:
+ *
+ * FIXME
+ *
+ * Returns:
+ */
+hg_bool_t
+hg_gstate_rlineto(hg_gstate_t *gstate,
+		  hg_real_t    rx,
+		  hg_real_t    ry)
+{
+	hg_path_t *p;
+	hg_bool_t retval = FALSE;
+
+	hg_return_val_if_fail (gstate != NULL, FALSE, HG_e_typecheck);
+	hg_return_val_if_fail (gstate->o.type == HG_TYPE_GSTATE, FALSE, HG_e_typecheck);
+
+	p = HG_MEM_LOCK (gstate->o.mem, gstate->qpath);
+	if (p) {
+		retval = hg_path_rlineto(p, rx, ry);
+		hg_mem_unlock_object(gstate->o.mem, gstate->qpath);
+	}
+
+	return retval;
+}
+
+/**
+ * hg_gstate_curveto:
+ * @gstate:
+ * @x1:
+ * @y1:
+ * @x2:
+ * @y2:
+ * @x3:
+ * @y3:
+ *
+ * FIXME
+ *
+ * Returns:
+ */
+hg_bool_t
+hg_gstate_curveto(hg_gstate_t *gstate,
+		  hg_real_t    x1,
+		  hg_real_t    y1,
+		  hg_real_t    x2,
+		  hg_real_t    y2,
+		  hg_real_t    x3,
+		  hg_real_t    y3)
+{
+	hg_path_t *p;
+	hg_bool_t retval = FALSE;
+
+	hg_return_val_if_fail (gstate != NULL, FALSE, HG_e_typecheck);
+	hg_return_val_if_fail (gstate->o.type == HG_TYPE_GSTATE, FALSE, HG_e_typecheck);
+
+	p = HG_MEM_LOCK (gstate->o.mem, gstate->qpath);
+	if (p) {
+		retval = hg_path_curveto(p, x1, y1, x2, y2, x3, y3);
+		hg_mem_unlock_object(gstate->o.mem, gstate->qpath);
+	}
+
+	return retval;
+}
+
+/**
+ * hg_gstate_rcurveto:
+ * @gstate:
+ * @x1:
+ * @y1:
+ * @x2:
+ * @y2:
+ * @x3:
+ * @y3:
+ *
+ * FIXME
+ *
+ * Returns:
+ */
+hg_bool_t
+hg_gstate_rcurveto(hg_gstate_t *gstate,
+		   hg_real_t    rx1,
+		   hg_real_t    ry1,
+		   hg_real_t    rx2,
+		   hg_real_t    ry2,
+		   hg_real_t    rx3,
+		   hg_real_t    ry3)
+{
+	hg_path_t *p;
+	hg_bool_t retval = FALSE;
+
+	hg_return_val_if_fail (gstate != NULL, FALSE, HG_e_typecheck);
+	hg_return_val_if_fail (gstate->o.type == HG_TYPE_GSTATE, FALSE, HG_e_typecheck);
+
+	p = HG_MEM_LOCK (gstate->o.mem, gstate->qpath);
+	if (p) {
+		retval = hg_path_rcurveto(p, rx1, ry1, rx2, ry2, rx3, ry3);
+		hg_mem_unlock_object(gstate->o.mem, gstate->qpath);
+	}
+
+	return retval;
+}
+
+/**
+ * hg_gstate_arc:
+ * @gstate:
+ * @x:
+ * @y:
+ * @r:
+ * @angle1:
+ * @angle2:
+ *
+ * FIXME
+ *
+ * Returns:
+ */
+hg_bool_t
+hg_gstate_arc(hg_gstate_t *gstate,
+	      hg_real_t    x,
+	      hg_real_t    y,
+	      hg_real_t    r,
+	      hg_real_t    angle1,
+	      hg_real_t    angle2)
+{
+	hg_path_t *p;
+	hg_bool_t retval = FALSE;
+
+	hg_return_val_if_fail (gstate != NULL, FALSE, HG_e_typecheck);
+	hg_return_val_if_fail (gstate->o.type == HG_TYPE_GSTATE, FALSE, HG_e_typecheck);
+
+	if (gstate->qpath == Qnil) {
+		gstate->qpath = hg_path_new(gstate->o.mem, NULL);
+		if (gstate->qpath == Qnil)
+			hg_error_return (HG_STATUS_FAILED, HG_e_limitcheck);
+	}
+	p = HG_MEM_LOCK (gstate->o.mem, gstate->qpath);
+	if (p) {
+		retval = hg_path_arc(p, x, y, r, angle1, angle2);
+		hg_mem_unlock_object(gstate->o.mem, gstate->qpath);
+	}
+
+	return retval;
+}
+
+/**
+ * hg_gstate_arcn:
+ * @gstate:
+ * @x:
+ * @y:
+ * @r:
+ * @angle1:
+ * @angle2:
+ *
+ * FIXME
+ *
+ * Returns:
+ */
+hg_bool_t
+hg_gstate_arcn(hg_gstate_t *gstate,
+	       hg_real_t    x,
+	       hg_real_t    y,
+	       hg_real_t    r,
+	       hg_real_t    angle1,
+	       hg_real_t    angle2)
+{
+	hg_path_t *p;
+	hg_bool_t retval = FALSE;
+
+	hg_return_val_if_fail (gstate != NULL, FALSE, HG_e_typecheck);
+	hg_return_val_if_fail (gstate->o.type == HG_TYPE_GSTATE, FALSE, HG_e_typecheck);
+
+	if (gstate->qpath == Qnil) {
+		gstate->qpath = hg_path_new(gstate->o.mem, NULL);
+		if (gstate->qpath == Qnil)
+			hg_error_return (HG_STATUS_FAILED, HG_e_limitcheck);
+	}
+	p = HG_MEM_LOCK (gstate->o.mem, gstate->qpath);
+	if (p) {
+		retval = hg_path_arcn(p, x, y, r, angle1, angle2);
+		hg_mem_unlock_object(gstate->o.mem, gstate->qpath);
+	}
+
+	return retval;
+}
+
+/**
+ * hg_gstate_arcto:
+ * @gstate:
+ * @x1:
+ * @y1:
+ * @x2:
+ * @y2:
+ * @r:
+ * @ret:
+ *
+ * FIXME
+ *
+ * Returns:
+ */
+hg_bool_t
+hg_gstate_arcto(hg_gstate_t *gstate,
+		hg_real_t    x1,
+		hg_real_t    y1,
+		hg_real_t    x2,
+		hg_real_t    y2,
+		hg_real_t    r,
+		hg_real_t    ret[4])
+{
+	hg_path_t *p;
+	hg_bool_t retval = FALSE;
+
+	hg_return_val_if_fail (gstate != NULL, FALSE, HG_e_typecheck);
+	hg_return_val_if_fail (gstate->o.type == HG_TYPE_GSTATE, FALSE, HG_e_typecheck);
+
+	p = HG_MEM_LOCK (gstate->o.mem, gstate->qpath);
+	if (p) {
+		retval = hg_path_arcto(p, x1, y1, x2, y2, r, ret);
+		hg_mem_unlock_object(gstate->o.mem, gstate->qpath);
+	}
+
+	return retval;
+}
+
+/**
+ * hg_gstate_pathbbox:
+ * @gstate:
+ * @ignore_last_moveto:
+ * @bbox:
+ *
+ * FIXME
+ *
+ * Returns:
+ */
+hg_bool_t
+hg_gstate_pathbbox(hg_gstate_t    *gstate,
+		   hg_bool_t       ignore_last_moveto,
+		   hg_path_bbox_t *bbox)
+{
+	hg_path_t *p;
+	hg_bool_t retval = FALSE;
+
+	hg_return_val_if_fail (gstate != NULL, FALSE, HG_e_typecheck);
+	hg_return_val_if_fail (gstate->o.type == HG_TYPE_GSTATE, FALSE, HG_e_typecheck);
+
+	p = HG_MEM_LOCK (gstate->o.mem, gstate->qpath);
+	if (p) {
+		retval = hg_path_get_bbox(p,
+					  ignore_last_moveto,
+					  bbox);
+		hg_mem_unlock_object(gstate->o.mem, gstate->qpath);
+	}
+
+	return retval;
+}
+
+/**
+ * hg_gstate_initclip:
+ * @gstate:
+ *
+ * FIXME
+ *
+ * Returns:
+ */
+hg_bool_t
+hg_gstate_initclip(hg_gstate_t *gstate)
+{
+	hg_return_val_if_fail (gstate != NULL, FALSE, HG_e_typecheck);
+	hg_return_val_if_fail (gstate->o.type == HG_TYPE_GSTATE, FALSE, HG_e_typecheck);
+
+	/* expecting the current path is properly set */
+	if (gstate->qpath == Qnil)
+		hg_error_return (HG_STATUS_FAILED, HG_e_VMerror);
+
+	gstate->qclippath = gstate->qpath;
+	gstate->qpath = hg_path_new(gstate->o.mem, NULL);
+	if (gstate->qpath == Qnil)
+		hg_error_return (HG_STATUS_FAILED, HG_e_limitcheck);
+
+	hg_error_return (HG_STATUS_SUCCESS, 0);
+}
+
+/**
+ * hg_gstate_clippath:
+ * @gstate:
+ *
+ * FIXME
+ *
+ * Returns:
+ */
+hg_bool_t
+hg_gstate_clippath(hg_gstate_t *gstate)
+{
+	hg_quark_t q;
+
+	hg_return_val_if_fail (gstate != NULL, FALSE, HG_e_typecheck);
+	hg_return_val_if_fail (gstate->o.type == HG_TYPE_GSTATE, FALSE, HG_e_typecheck);
+
+	q = hg_object_quark_copy(gstate->o.mem, gstate->qclippath, NULL);
+	if (q == Qnil)
+		hg_error_return (HG_STATUS_FAILED, HG_e_VMerror);
+
+	gstate->qpath = q;
+
+	hg_error_return (HG_STATUS_SUCCESS, 0);
+}
+
+/**
+ * hg_gstate_get_current_point:
+ * @gstate:
+ * @x:
+ * @y:
+ *
+ * FIXME
+ *
+ * Returns:
+ */
+hg_bool_t
+hg_gstate_get_current_point(hg_gstate_t *gstate,
+			    hg_real_t   *x,
+			    hg_real_t   *y)
+{
+	hg_path_t *p;
+	hg_bool_t retval = FALSE;
+
+	hg_return_val_if_fail (gstate != NULL, FALSE, HG_e_typecheck);
+	hg_return_val_if_fail (gstate->o.type == HG_TYPE_GSTATE, FALSE, HG_e_typecheck);
+
+	p = HG_MEM_LOCK (gstate->o.mem, gstate->qpath);
+	if (p) {
+		retval = hg_path_get_current_point(p, x, y);
+		hg_mem_unlock_object(gstate->o.mem, gstate->qpath);
+	}
+
+	return retval;
+}
diff --git a/hieroglyph/hggstate.h b/hieroglyph/hggstate.h
index 20a5ee4..15a36fb 100644
--- a/hieroglyph/hggstate.h
+++ b/hieroglyph/hggstate.h
@@ -30,7 +30,6 @@
 
 #include <hieroglyph/hgobject.h>
 #include <hieroglyph/hgmatrix.h>
-#include <hieroglyph/hgpath.h>
 
 HG_BEGIN_DECLS
 
@@ -100,8 +99,6 @@ void                hg_gstate_set_ctm          (hg_gstate_t   *gstate,
 						hg_matrix_t   *matrix);
 void                hg_gstate_get_ctm          (hg_gstate_t   *gstate,
 						hg_matrix_t   *matrix);
-void                hg_gstate_set_path         (hg_gstate_t   *gstate,
-                                                hg_quark_t     qpath);
 hg_quark_t          hg_gstate_get_path         (hg_gstate_t   *gstate);
 void                hg_gstate_set_clippath     (hg_gstate_t   *gstate,
                                                 hg_quark_t     qpath);
@@ -128,6 +125,64 @@ hg_bool_t           hg_gstate_set_dash         (hg_gstate_t   *gstate,
 						hg_quark_t     qpattern,
 						hg_real_t      offset);
 
+/** hg_path_t wrappers **/
+
+hg_bool_t hg_gstate_newpath          (hg_gstate_t    *gstate);
+hg_bool_t hg_gstate_closepath        (hg_gstate_t    *gstate);
+hg_bool_t hg_gstate_moveto           (hg_gstate_t    *gstate,
+                                      hg_real_t       x,
+                                      hg_real_t       y);
+hg_bool_t hg_gstate_rmoveto          (hg_gstate_t    *gstate,
+                                      hg_real_t       rx,
+                                      hg_real_t       ry);
+hg_bool_t hg_gstate_lineto           (hg_gstate_t    *gstate,
+                                      hg_real_t       x,
+                                      hg_real_t       y);
+hg_bool_t hg_gstate_rlineto          (hg_gstate_t    *gstate,
+                                      hg_real_t       rx,
+                                      hg_real_t       ry);
+hg_bool_t hg_gstate_curveto          (hg_gstate_t    *gstate,
+                                      hg_real_t       x1,
+                                      hg_real_t       y1,
+                                      hg_real_t       x2,
+                                      hg_real_t       y2,
+                                      hg_real_t       x3,
+                                      hg_real_t       y3);
+hg_bool_t hg_gstate_rcurveto         (hg_gstate_t    *gstate,
+                                      hg_real_t       rx1,
+                                      hg_real_t       ry1,
+                                      hg_real_t       rx2,
+                                      hg_real_t       ry2,
+                                      hg_real_t       rx3,
+                                      hg_real_t       ry3);
+hg_bool_t hg_gstate_arc              (hg_gstate_t    *gstate,
+                                      hg_real_t       x,
+                                      hg_real_t       y,
+                                      hg_real_t       r,
+                                      hg_real_t       angle1,
+                                      hg_real_t       angle2);
+hg_bool_t hg_gstate_arcn             (hg_gstate_t    *gstate,
+                                      hg_real_t       x,
+                                      hg_real_t       y,
+                                      hg_real_t       r,
+                                      hg_real_t       angle1,
+                                      hg_real_t       angle2);
+hg_bool_t hg_gstate_arcto            (hg_gstate_t    *gstate,
+                                      hg_real_t       x1,
+                                      hg_real_t       y1,
+                                      hg_real_t       x2,
+                                      hg_real_t       y2,
+                                      hg_real_t       r,
+                                      hg_real_t       ret[4]);
+hg_bool_t hg_gstate_pathbbox         (hg_gstate_t    *gstate,
+                                      hg_bool_t       ignore_last_moveto,
+                                      hg_path_bbox_t *bbox);
+hg_bool_t hg_gstate_initclip         (hg_gstate_t    *gstate);
+hg_bool_t hg_gstate_clippath         (hg_gstate_t    *gstate);
+hg_bool_t hg_gstate_get_current_point(hg_gstate_t    *gstate,
+                                      hg_real_t      *x,
+                                      hg_real_t      *y);
+
 
 HG_END_DECLS
 
diff --git a/hieroglyph/hgoperator.c b/hieroglyph/hgoperator.c
index 5905d37..f998cdd 100644
--- a/hieroglyph/hgoperator.c
+++ b/hieroglyph/hgoperator.c
@@ -38,7 +38,6 @@
 #include "hgmark.h"
 #include "hgmem.h"
 #include "hgnull.h"
-#include "hgpath.h"
 #include "hgreal.h"
 #include "hgsnapshot.h"
 #include "hgversion.h"
@@ -1554,9 +1553,8 @@ DEFUNC_OPER (and)
 /* <x> <y> <r> <angle1> <angle2> arc - */
 DEFUNC_OPER (arc)
 {
-	hg_quark_t arg0, arg1, arg2, arg3, arg4, q, qg = hg_vm_get_gstate(vm);
+	hg_quark_t arg0, arg1, arg2, arg3, arg4, qg = hg_vm_get_gstate(vm);
 	hg_gstate_t *gstate;
-	hg_path_t *path;
 	hg_real_t dx, dy, dr, dangle1, dangle2, dc = 2.0 * M_PI / 360;
 
 	CHECK_STACK (ostack, 5);
@@ -1613,26 +1611,11 @@ DEFUNC_OPER (arc)
 		hg_vm_set_error(vm, qself, HG_e_VMerror);
 		return FALSE;
 	}
-	q = hg_gstate_get_path(gstate);
-	if (q == Qnil) {
-		path = NULL;
-		q = hg_path_new(hg_vm_get_mem(vm), (hg_pointer_t *)&path);
-		if (q != Qnil)
-			hg_gstate_set_path(gstate, q);
-	} else {
-		path = HG_VM_LOCK (vm, q);
-	}
-	if (path == NULL) {
-		hg_vm_set_error(vm, qself, HG_e_VMerror);
+	retval = hg_gstate_arc(gstate, dx, dy, dr,
+			       dangle1 * dc,
+			       dangle2 * dc);
+	if (!retval)
 		goto error;
-	}
-	retval = hg_path_arc(path, dx, dy, dr,
-			     dangle1 * dc,
-			     dangle2 * dc);
-	if (!retval) {
-		hg_vm_set_error(vm, qself, HG_e_limitcheck);
-		goto error2;
-	}
 
 	hg_stack_drop(ostack);
 	hg_stack_drop(ostack);
@@ -1640,8 +1623,6 @@ DEFUNC_OPER (arc)
 	hg_stack_drop(ostack);
 	hg_stack_drop(ostack);
 	SET_EXPECTED_OSTACK_SIZE (-5);
-  error2:
-	HG_VM_UNLOCK (vm, q);
   error:
 	HG_VM_UNLOCK (vm, qg);
 } DEFUNC_OPER_END
@@ -1649,9 +1630,8 @@ DEFUNC_OPER (arc)
 /* <x> <y> <r> <angle1> <angle2> arcn - */
 DEFUNC_OPER (arcn)
 {
-	hg_quark_t arg0, arg1, arg2, arg3, arg4, q, qg = hg_vm_get_gstate(vm);
+	hg_quark_t arg0, arg1, arg2, arg3, arg4, qg = hg_vm_get_gstate(vm);
 	hg_gstate_t *gstate;
-	hg_path_t *path;
 	hg_real_t dx, dy, dr, dangle1, dangle2, dc = 2.0 * M_PI / 360;
 
 	CHECK_STACK (ostack, 5);
@@ -1708,26 +1688,11 @@ DEFUNC_OPER (arcn)
 		hg_vm_set_error(vm, qself, HG_e_VMerror);
 		return FALSE;
 	}
-	q = hg_gstate_get_path(gstate);
-	if (q == Qnil) {
-		path = NULL;
-		q = hg_path_new(hg_vm_get_mem(vm), (hg_pointer_t *)&path);
-		if (q != Qnil)
-			hg_gstate_set_path(gstate, q);
-	} else {
-		path = HG_VM_LOCK (vm, q);
-	}
-	if (path == NULL) {
-		hg_vm_set_error(vm, qself, HG_e_VMerror);
+	retval = hg_gstate_arcn(gstate, dx, dy, dr,
+				dangle1 * dc,
+				dangle2 * dc);
+	if (!retval)
 		goto error;
-	}
-	retval = hg_path_arcn(path, dx, dy, dr,
-			      dangle1 * dc,
-			      dangle2 * dc);
-	if (!retval) {
-		hg_vm_set_error(vm, qself, HG_e_limitcheck);
-		goto error2;
-	}
 
 	hg_stack_drop(ostack);
 	hg_stack_drop(ostack);
@@ -1735,8 +1700,6 @@ DEFUNC_OPER (arcn)
 	hg_stack_drop(ostack);
 	hg_stack_drop(ostack);
 	SET_EXPECTED_OSTACK_SIZE (-5);
-  error2:
-	HG_VM_UNLOCK (vm, q);
   error:
 	HG_VM_UNLOCK (vm, qg);
 } DEFUNC_OPER_END
@@ -1744,9 +1707,8 @@ DEFUNC_OPER (arcn)
 /* <x1> <y1> <x2> <y2> <r> arct - */
 DEFUNC_OPER (arct)
 {
-	hg_quark_t arg0, arg1, arg2, arg3, arg4, q, qg = hg_vm_get_gstate(vm);
+	hg_quark_t arg0, arg1, arg2, arg3, arg4, qg = hg_vm_get_gstate(vm);
 	hg_gstate_t *gstate;
-	hg_path_t *path;
 	hg_real_t dx1, dy1, dx2, dy2, dr;
 
 	CHECK_STACK (ostack, 5);
@@ -1803,21 +1765,9 @@ DEFUNC_OPER (arct)
 		hg_vm_set_error(vm, qself, HG_e_VMerror);
 		return FALSE;
 	}
-	q = hg_gstate_get_path(gstate);
-	path = HG_VM_LOCK (vm, q);
-	if (path == NULL) {
-		hg_vm_set_error(vm, qself, HG_e_VMerror);
+	retval = hg_gstate_arcto(gstate, dx1, dy1, dx2, dy2, dr, NULL);
+	if (!retval)
 		goto error;
-	}
-	if (!hg_path_get_current_point(path, NULL, NULL)) {
-		hg_vm_set_error(vm, qself, HG_e_nocurrentpoint);
-		goto error2;
-	}
-	retval = hg_path_arcto(path, dx1, dy1, dx2, dy2, dr, NULL);
-	if (!retval) {
-		hg_vm_set_error(vm, qself, HG_e_limitcheck);
-		goto error2;
-	}
 
 	hg_stack_drop(ostack);
 	hg_stack_drop(ostack);
@@ -1825,8 +1775,6 @@ DEFUNC_OPER (arct)
 	hg_stack_drop(ostack);
 	hg_stack_drop(ostack);
 	SET_EXPECTED_OSTACK_SIZE (-5);
-  error2:
-	HG_VM_UNLOCK (vm, q);
   error:
 	HG_VM_UNLOCK (vm, qg);
 } DEFUNC_OPER_END
@@ -1834,9 +1782,8 @@ DEFUNC_OPER (arct)
 /* <x1> <y1> <x2> <y2> <r> arcto <xt1> <yt1> <xt2> <yt2> */
 DEFUNC_OPER (arcto)
 {
-	hg_quark_t arg0, arg1, arg2, arg3, arg4, q, qg = hg_vm_get_gstate(vm);
+	hg_quark_t arg0, arg1, arg2, arg3, arg4, qg = hg_vm_get_gstate(vm);
 	hg_gstate_t *gstate;
-	hg_path_t *path;
 	hg_real_t dx1, dy1, dx2, dy2, dr, dt[4];
 
 	CHECK_STACK (ostack, 5);
@@ -1893,21 +1840,9 @@ DEFUNC_OPER (arcto)
 		hg_vm_set_error(vm, qself, HG_e_VMerror);
 		return FALSE;
 	}
-	q = hg_gstate_get_path(gstate);
-	path = HG_VM_LOCK (vm, q);
-	if (path == NULL) {
-		hg_vm_set_error(vm, qself, HG_e_VMerror);
+	retval = hg_gstate_arcto(gstate, dx1, dy1, dx2, dy2, dr, dt);
+	if (!retval)
 		goto error;
-	}
-	if (!hg_path_get_current_point(path, NULL, NULL)) {
-		hg_vm_set_error(vm, qself, HG_e_nocurrentpoint);
-		goto error2;
-	}
-	retval = hg_path_arcto(path, dx1, dy1, dx2, dy2, dr, dt);
-	if (!retval) {
-		hg_vm_set_error(vm, qself, HG_e_limitcheck);
-		goto error2;
-	}
 
 	hg_stack_drop(ostack);
 	hg_stack_drop(ostack);
@@ -1920,8 +1855,6 @@ DEFUNC_OPER (arcto)
 	STACK_PUSH (ostack, HG_QREAL (dt[2]));
 	STACK_PUSH (ostack, HG_QREAL (dt[3]));
 	SET_EXPECTED_OSTACK_SIZE (-1);
-  error2:
-	HG_VM_UNLOCK (vm, q);
   error:
 	HG_VM_UNLOCK (vm, qg);
 } DEFUNC_OPER_END
@@ -2259,22 +2192,14 @@ DEFUNC_UNIMPLEMENTED_OPER (clip);
 /* - clippath - */
 DEFUNC_OPER (clippath)
 {
-	hg_quark_t q, qq, qg = hg_vm_get_gstate(vm);
+	hg_quark_t qg = hg_vm_get_gstate(vm);
 	hg_gstate_t *gstate = HG_VM_LOCK (vm, qg);
 
 	if (gstate == NULL) {
 		hg_vm_set_error(vm, qself, HG_e_VMerror);
 		return FALSE;
 	}
-	q = hg_gstate_get_clippath(gstate);
-	qq = hg_vm_quark_copy(vm, q, NULL);
-	if (qq == Qnil) {
-		hg_vm_set_error(vm, qself, HG_e_VMerror);
-		goto finalize;
-	}
-	hg_gstate_set_path(gstate, qq);
-	retval = TRUE;
-  finalize:
+	retval = hg_gstate_clippath(gstate);
 	HG_VM_UNLOCK (vm, qg);
 } DEFUNC_OPER_END
 
@@ -2314,29 +2239,15 @@ DEFUNC_OPER (closefile)
 /* - closepath - */
 DEFUNC_OPER (closepath)
 {
-	hg_quark_t q = Qnil, qg = hg_vm_get_gstate(vm);
+	hg_quark_t qg = hg_vm_get_gstate(vm);
 	hg_gstate_t *gstate;
-	hg_path_t *path;
 
 	gstate = HG_VM_LOCK (vm, qg);
 	if (gstate == NULL) {
 		hg_vm_set_error(vm, qself, HG_e_VMerror);
 		return FALSE;
 	}
-	q = hg_gstate_get_path(gstate);
-	path = HG_VM_LOCK (vm, q);
-	if (path == NULL) {
-		hg_vm_set_error(vm, qself, HG_e_VMerror);
-		goto error;
-	}
-	if (!hg_path_close(path)) {
-		hg_vm_set_error(vm, qself, HG_e_limitcheck);
-		goto error;
-	}
-	retval = TRUE;
-  error:
-	if (q != Qnil)
-		HG_VM_UNLOCK (vm, q);
+	retval = hg_gstate_closepath(gstate);
 	HG_VM_UNLOCK (vm, qg);
 } DEFUNC_OPER_END
 
@@ -2839,30 +2750,21 @@ DEFUNC_UNIMPLEMENTED_OPER (currentpagedevice);
 /* - currentpoint <x> <y> */
 DEFUNC_OPER (currentpoint)
 {
-	hg_quark_t qg = hg_vm_get_gstate(vm), qpath;
+	hg_quark_t qg = hg_vm_get_gstate(vm);
 	hg_gstate_t *gstate = HG_VM_LOCK (vm, qg);
-	hg_path_t *path = NULL;
 	hg_real_t x, y;
 
 	if (!gstate)
 		return FALSE;
-	qpath = hg_gstate_get_path(gstate);
-	path = HG_VM_LOCK (vm, qpath);
-	if (!path)
-		goto finalize;
-	if (!hg_path_get_current_point(path, &x, &y)) {
-		hg_vm_set_error(vm, qself, HG_e_nocurrentpoint);
+	retval = hg_gstate_get_current_point(gstate, &x, &y);
+	if (!retval)
 		goto finalize;
-	}
 
 	STACK_PUSH (ostack, HG_QREAL (x));
 	STACK_PUSH (ostack, HG_QREAL (y));
 
-	retval = TRUE;
 	SET_EXPECTED_OSTACK_SIZE (2);
   finalize:
-	if (path)
-		HG_VM_UNLOCK (vm, qpath);
 	if (gstate)
 		HG_VM_UNLOCK (vm, qg);
 } DEFUNC_OPER_END
@@ -2896,9 +2798,8 @@ DEFUNC_OPER (currentuserparams)
 /* <x1> <y1> <x2> <y2> <x3> <y3> curveto - */
 DEFUNC_OPER (curveto)
 {
-	hg_quark_t arg0, arg1, arg2, arg3, arg4, arg5, q, qg = hg_vm_get_gstate(vm);
+	hg_quark_t arg0, arg1, arg2, arg3, arg4, arg5, qg = hg_vm_get_gstate(vm);
 	hg_gstate_t *gstate;
-	hg_path_t *path;
 	hg_real_t dx1, dy1, dx2, dy2, dx3, dy3;
 
 	CHECK_STACK (ostack, 6);
@@ -2964,21 +2865,9 @@ DEFUNC_OPER (curveto)
 		hg_vm_set_error(vm, qself, HG_e_VMerror);
 		return FALSE;
 	}
-	q = hg_gstate_get_path(gstate);
-	path = HG_VM_LOCK (vm, q);
-	if (path == NULL) {
-		hg_vm_set_error(vm, qself, HG_e_VMerror);
+	retval = hg_gstate_curveto(gstate, dx1, dy1, dx2, dy2, dx3, dy3);
+	if (!retval)
 		goto error;
-	}
-	if (!hg_path_get_current_point(path, NULL, NULL)) {
-		hg_vm_set_error(vm, qself, HG_e_nocurrentpoint);
-		goto error2;
-	}
-	retval = hg_path_curveto(path, dx1, dy1, dx2, dy2, dx3, dy3);
-	if (!retval) {
-		hg_vm_set_error(vm, qself, HG_e_limitcheck);
-		goto error2;
-	}
 
 	hg_stack_drop(ostack);
 	hg_stack_drop(ostack);
@@ -2987,8 +2876,6 @@ DEFUNC_OPER (curveto)
 	hg_stack_drop(ostack);
 	hg_stack_drop(ostack);
 	SET_EXPECTED_OSTACK_SIZE (-6);
-  error2:
-	HG_VM_UNLOCK (vm, q);
   error:
 	HG_VM_UNLOCK (vm, qg);
 } DEFUNC_OPER_END
@@ -4853,27 +4740,14 @@ DEFUNC_OPER (initclip)
 
 	if (hg_vm_eval_from_cstring(vm, ".currentpagedevice /PageSize get 0 0 moveto dup 0 get 0 lineto dup aload pop lineto 1 get 0 exch lineto closepath", -1,
 				    NULL, es, NULL, TRUE)) {
-		hg_quark_t qg = hg_vm_get_gstate(vm), qpath;
+		hg_quark_t qg = hg_vm_get_gstate(vm);
 		hg_gstate_t *gstate = HG_VM_LOCK (vm, qg);
 
-		if (gstate == NULL) {
-			hg_vm_set_error(vm, qself, HG_e_VMerror);
-			goto finalize;
+		if (gstate) {
+			retval = hg_gstate_initclip(gstate);
+			HG_VM_UNLOCK (vm, qg);
 		}
-		qpath = hg_gstate_get_path(gstate);
-		hg_gstate_set_clippath(gstate, qpath);
-		qpath = hg_path_new(gstate->o.mem, NULL);
-		if (qpath == Qnil) {
-			hg_vm_set_error(vm, qself, HG_e_VMerror);
-			goto e_finalize;
-		}
-		hg_gstate_set_path(gstate, qpath);
-
-		retval = TRUE;
-	  e_finalize:
-		HG_VM_UNLOCK (vm, qg);
 	}
-  finalize:
 	hg_stack_free(es);
 } DEFUNC_OPER_END
 
@@ -5104,10 +4978,9 @@ DEFUNC_OPER (length)
 /* <x> <y> lineto - */
 DEFUNC_OPER (lineto)
 {
-	hg_quark_t arg0, arg1, q, qg = hg_vm_get_gstate(vm);
+	hg_quark_t arg0, arg1, qg = hg_vm_get_gstate(vm);
 	hg_real_t dx, dy;
 	hg_gstate_t *gstate;
-	hg_path_t *path;
 
 	CHECK_STACK (ostack, 2);
 
@@ -5136,27 +5009,13 @@ DEFUNC_OPER (lineto)
 		hg_vm_set_error(vm, qself, HG_e_VMerror);
 		return FALSE;
 	}
-	q = hg_gstate_get_path(gstate);
-	path = HG_VM_LOCK (vm, q);
-	if (path == NULL) {
-		hg_vm_set_error(vm, qself, HG_e_VMerror);
+	retval = hg_gstate_lineto(gstate, dx, dy);
+	if (!retval)
 		goto error;
-	}
-	if (!hg_path_get_current_point(path, NULL, NULL)) {
-		hg_vm_set_error(vm, qself, HG_e_nocurrentpoint);
-		goto error2;
-	}
-	retval = hg_path_lineto(path, dx, dy);
-	if (!retval) {
-		hg_vm_set_error(vm, qself, HG_e_limitcheck);
-		goto error2;
-	}
 
 	hg_stack_drop(ostack);
 	hg_stack_drop(ostack);
 	SET_EXPECTED_OSTACK_SIZE (-2);
-  error2:
-	HG_VM_UNLOCK (vm, q);
   error:
 	HG_VM_UNLOCK (vm, qg);
 } DEFUNC_OPER_END
@@ -5376,10 +5235,9 @@ DEFUNC_UNIMPLEMENTED_OPER (monitor);
 /* <x> <y> moveto - */
 DEFUNC_OPER (moveto)
 {
-	hg_quark_t arg0, arg1, q, qg = hg_vm_get_gstate(vm);
+	hg_quark_t arg0, arg1, qg = hg_vm_get_gstate(vm);
 	hg_real_t dx, dy;
 	hg_gstate_t *gstate;
-	hg_path_t *path;
 
 	CHECK_STACK (ostack, 2);
 
@@ -5408,30 +5266,13 @@ DEFUNC_OPER (moveto)
 		hg_vm_set_error(vm, qself, HG_e_VMerror);
 		return FALSE;
 	}
-	q = hg_gstate_get_path(gstate);
-	if (q == Qnil) {
-		path = NULL;
-		q = hg_path_new(hg_vm_get_mem(vm), (hg_pointer_t *)&path);
-		if (q != Qnil)
-			hg_gstate_set_path(gstate, q);
-	} else {
-		path = HG_VM_LOCK (vm, q);
-	}
-	if (path == NULL) {
-		hg_vm_set_error(vm, qself, HG_e_VMerror);
+	retval = hg_gstate_moveto(gstate, dx, dy);
+	if (!retval)
 		goto error;
-	}
-	retval = hg_path_moveto(path, dx, dy);
-	if (!retval) {
-		hg_vm_set_error(vm, qself, HG_e_limitcheck);
-		goto error2;
-	}
 
 	hg_stack_drop(ostack);
 	hg_stack_drop(ostack);
 	SET_EXPECTED_OSTACK_SIZE (-2);
-  error2:
-	HG_VM_UNLOCK (vm, q);
   error:
 	HG_VM_UNLOCK (vm, qg);
 } DEFUNC_OPER_END
@@ -5594,24 +5435,17 @@ DEFUNC_OPER (neg)
 /* - newpath - */
 DEFUNC_OPER (newpath)
 {
-	hg_quark_t q, qg = hg_vm_get_gstate(vm);
+	hg_quark_t qg = hg_vm_get_gstate(vm);
 	hg_gstate_t *gstate;
 
-	q = hg_path_new(vm->mem[HG_VM_MEM_LOCAL], NULL);
-	if (q == Qnil) {
-		hg_vm_set_error(vm, qself, HG_e_VMerror);
-		return FALSE;
-	}
 	gstate = HG_VM_LOCK (vm, qg);
 	if (gstate == NULL) {
 		hg_vm_set_error(vm, qself, HG_e_VMerror);
 		return FALSE;
 	}
-	hg_gstate_set_path(gstate, q);
+	retval = hg_gstate_newpath(gstate);
 
 	HG_VM_UNLOCK (vm, qg);
-
-	retval = TRUE;
 } DEFUNC_OPER_END
 
 /* <array> noaccess <array>
@@ -5700,8 +5534,7 @@ DEFUNC_UNIMPLEMENTED_OPER (packedarray);
 /* - pathbbox <llx> <lly> <urx> <ury> */
 DEFUNC_OPER (pathbbox)
 {
-	hg_quark_t q, qg = hg_vm_get_gstate(vm);
-	hg_path_t *path = NULL;
+	hg_quark_t qg = hg_vm_get_gstate(vm);
 	hg_path_bbox_t bbox;
 	hg_gstate_t *gstate = HG_VM_LOCK (vm, qg);
 
@@ -5709,32 +5542,19 @@ DEFUNC_OPER (pathbbox)
 		hg_vm_set_error(vm, qself, HG_e_VMerror);
 		return FALSE;
 	}
-	q = hg_gstate_get_path(gstate);
-	if (q == Qnil) {
-		hg_vm_set_error(vm, qself, HG_e_nocurrentpoint);
-		goto finalize;
-	}
-	path = HG_VM_LOCK (vm, q);
-	if (path == NULL) {
-		hg_vm_set_error(vm, qself, HG_e_VMerror);
-		goto finalize;
-	}
-	if (!hg_path_get_bbox(path,
-			      hg_vm_get_language_level(vm) != HG_LANG_LEVEL_1,
-			      &bbox)) {
-		hg_vm_set_error0(vm, qself);
+	retval = hg_gstate_pathbbox(gstate,
+				    hg_vm_get_language_level(vm) != HG_LANG_LEVEL_1,
+				    &bbox);
+	if (!retval)
 		goto finalize;
-	}
+
 	STACK_PUSH (ostack, HG_QREAL (bbox.llx));
 	STACK_PUSH (ostack, HG_QREAL (bbox.lly));
 	STACK_PUSH (ostack, HG_QREAL (bbox.urx));
 	STACK_PUSH (ostack, HG_QREAL (bbox.ury));
 
-	retval = TRUE;
 	SET_EXPECTED_OSTACK_SIZE (4);
   finalize:
-	if (path)
-		HG_VM_UNLOCK (vm, q);
 	HG_VM_UNLOCK (vm, qg);
 } DEFUNC_OPER_END
 
@@ -5907,9 +5727,8 @@ DEFUNC_OPER (rcheck)
 /* <dx1> <dy1> <dx2> <dy2> <dx3> <dy3> rcurveto - */
 DEFUNC_OPER (rcurveto)
 {
-	hg_quark_t arg0, arg1, arg2, arg3, arg4, arg5, q, qg = hg_vm_get_gstate(vm);
+	hg_quark_t arg0, arg1, arg2, arg3, arg4, arg5, qg = hg_vm_get_gstate(vm);
 	hg_gstate_t *gstate;
-	hg_path_t *path;
 	hg_real_t dx1, dy1, dx2, dy2, dx3, dy3;
 
 	CHECK_STACK (ostack, 6);
@@ -5975,21 +5794,9 @@ DEFUNC_OPER (rcurveto)
 		hg_vm_set_error(vm, qself, HG_e_VMerror);
 		return FALSE;
 	}
-	q = hg_gstate_get_path(gstate);
-	path = HG_VM_LOCK (vm, q);
-	if (path == NULL) {
-		hg_vm_set_error(vm, qself, HG_e_VMerror);
+	retval = hg_gstate_rcurveto(gstate, dx1, dy1, dx2, dy2, dx3, dy3);
+	if (!retval)
 		goto error;
-	}
-	if (!hg_path_get_current_point(path, NULL, NULL)) {
-		hg_vm_set_error(vm, qself, HG_e_nocurrentpoint);
-		goto error2;
-	}
-	retval = hg_path_rcurveto(path, dx1, dy1, dx2, dy2, dx3, dy3);
-	if (!retval) {
-		hg_vm_set_error(vm, qself, HG_e_limitcheck);
-		goto error2;
-	}
 
 	hg_stack_drop(ostack);
 	hg_stack_drop(ostack);
@@ -5998,8 +5805,6 @@ DEFUNC_OPER (rcurveto)
 	hg_stack_drop(ostack);
 	hg_stack_drop(ostack);
 	SET_EXPECTED_OSTACK_SIZE (-6);
-  error2:
-	HG_VM_UNLOCK (vm, q);
   error:
 	HG_VM_UNLOCK (vm, qg);
 } DEFUNC_OPER_END
@@ -6468,10 +6273,9 @@ DEFUNC_UNIMPLEMENTED_OPER (reversepath);
 /* <dx> <dy> rlineto - */
 DEFUNC_OPER (rlineto)
 {
-	hg_quark_t arg0, arg1, q, qg = hg_vm_get_gstate(vm);
+	hg_quark_t arg0, arg1, qg = hg_vm_get_gstate(vm);
 	hg_real_t dx, dy;
 	hg_gstate_t *gstate;
-	hg_path_t *path;
 
 	CHECK_STACK (ostack, 2);
 
@@ -6500,27 +6304,13 @@ DEFUNC_OPER (rlineto)
 		hg_vm_set_error(vm, qself, HG_e_VMerror);
 		return FALSE;
 	}
-	q = hg_gstate_get_path(gstate);
-	path = HG_VM_LOCK (vm, q);
-	if (path == NULL) {
-		hg_vm_set_error(vm, qself, HG_e_VMerror);
+	retval = hg_gstate_rlineto(gstate, dx, dy);
+	if (!retval)
 		goto error;
-	}
-	if (!hg_path_get_current_point(path, NULL, NULL)) {
-		hg_vm_set_error(vm, qself, HG_e_nocurrentpoint);
-		goto error2;
-	}
-	retval = hg_path_rlineto(path, dx, dy);
-	if (!retval) {
-		hg_vm_set_error(vm, qself, HG_e_limitcheck);
-		goto error2;
-	}
 
 	hg_stack_drop(ostack);
 	hg_stack_drop(ostack);
 	SET_EXPECTED_OSTACK_SIZE (-2);
-  error2:
-	HG_VM_UNLOCK (vm, q);
   error:
 	HG_VM_UNLOCK (vm, qg);
 } DEFUNC_OPER_END
@@ -6528,10 +6318,9 @@ DEFUNC_OPER (rlineto)
 /* <dx> <dy> rmoveto - */
 DEFUNC_OPER (rmoveto)
 {
-	hg_quark_t arg0, arg1, q, qg = hg_vm_get_gstate(vm);
+	hg_quark_t arg0, arg1, qg = hg_vm_get_gstate(vm);
 	hg_real_t dx, dy;
 	hg_gstate_t *gstate;
-	hg_path_t *path;
 
 	CHECK_STACK (ostack, 2);
 
@@ -6560,27 +6349,13 @@ DEFUNC_OPER (rmoveto)
 		hg_vm_set_error(vm, qself, HG_e_VMerror);
 		return FALSE;
 	}
-	q = hg_gstate_get_path(gstate);
-	path = HG_VM_LOCK (vm, q);
-	if (path == NULL) {
-		hg_vm_set_error(vm, qself, HG_e_VMerror);
+	retval = hg_gstate_rmoveto(gstate, dx, dy);
+	if (!retval)
 		goto error;
-	}
-	if (!hg_path_get_current_point(path, NULL, NULL)) {
-		hg_vm_set_error(vm, qself, HG_e_nocurrentpoint);
-		goto error2;
-	}
-	retval = hg_path_rmoveto(path, dx, dy);
-	if (!retval) {
-		hg_vm_set_error(vm, qself, HG_e_limitcheck);
-		goto error2;
-	}
 
 	hg_stack_drop(ostack);
 	hg_stack_drop(ostack);
 	SET_EXPECTED_OSTACK_SIZE (-2);
-  error2:
-	HG_VM_UNLOCK (vm, q);
   error:
 	HG_VM_UNLOCK (vm, qg);
 } DEFUNC_OPER_END
diff --git a/hieroglyph/hgpath.c b/hieroglyph/hgpath.c
index c300e51..665751d 100644
--- a/hieroglyph/hgpath.c
+++ b/hieroglyph/hgpath.c
@@ -164,11 +164,6 @@ _hg_path_add(hg_path_t      *path,
 	hg_return_val_if_fail (type < HG_PATH_END, FALSE, HG_e_rangecheck);
 	hg_return_val_if_fail (path->length < HG_PATH_MAX, FALSE, HG_e_limitcheck);
 
-	hg_return_val_if_lock_fail (node,
-				    path->o.mem,
-				    path->qnode,
-				    FALSE);
-
 	if (path->length == 0) {
 		switch (type) {
 		    case HG_PATH_CURVETO:
@@ -177,16 +172,20 @@ _hg_path_add(hg_path_t      *path,
 		    case HG_PATH_RMOVETO:
 		    case HG_PATH_RLINETO:
 			    /* /nocurrentpoint would be raised. */
-			    retval = FALSE;
-			    goto finalize;
+			    hg_error_return (HG_STATUS_FAILED, HG_e_nocurrentpoint);
 		    case HG_PATH_CLOSEPATH:
 			    /* no errors */
-			    goto finalize;
+			    hg_error_return (HG_STATUS_SUCCESS, 0);
 		    default:
 			    break;
 		}
 	}
 
+	hg_return_val_if_lock_fail (node,
+				    path->o.mem,
+				    path->qnode,
+				    FALSE);
+
 	if (path->length > 0) {
 		cx = node[path->length - 1].cx;
 		cy = node[path->length - 1].cy;
@@ -376,9 +375,11 @@ hg_path_new(hg_mem_t     *mem,
 			*ret = path;
 		else
 			hg_mem_unlock_object(mem, retval);
+	} else {
+		hg_error_return_val (Qnil, HG_STATUS_FAILED, HG_e_limitcheck);
 	}
 
-	return retval;
+	hg_error_return_val (retval, HG_STATUS_SUCCESS, 0);
 }
 
 /**
@@ -401,7 +402,7 @@ hg_path_get_current_point(hg_path_t *path,
 	hg_return_val_if_fail (path != NULL, FALSE, HG_e_typecheck);
 
 	if (path->length == 0)
-		return FALSE;
+		hg_error_return (HG_STATUS_FAILED, HG_e_nocurrentpoint);
 
 	hg_return_val_if_lock_fail (node,
 				    path->o.mem,
@@ -415,7 +416,7 @@ hg_path_get_current_point(hg_path_t *path,
 
 	hg_mem_unlock_object(path->o.mem, path->qnode);
 
-	return TRUE;
+	hg_error_return (HG_STATUS_SUCCESS, 0);
 }
 
 /**
@@ -542,12 +543,7 @@ hg_path_rmoveto(hg_path_t *path,
 		hg_real_t  x,
 		hg_real_t  y)
 {
-	hg_bool_t retval = hg_path_get_current_point(path, NULL, NULL);
-
-	if (retval)
-		return _hg_path_add(path, HG_PATH_RMOVETO, x, y);
-
-	return retval;
+	return _hg_path_add(path, HG_PATH_RMOVETO, x, y);
 }
 
 /**
@@ -565,12 +561,7 @@ hg_path_lineto(hg_path_t *path,
 	       hg_real_t  x,
 	       hg_real_t  y)
 {
-	hg_bool_t retval = hg_path_get_current_point(path, NULL, NULL);
-
-	if (retval)
-		return _hg_path_add(path, HG_PATH_LINETO, x, y);
-
-	return retval;
+	return _hg_path_add(path, HG_PATH_LINETO, x, y);
 }
 
 /**
@@ -588,12 +579,7 @@ hg_path_rlineto(hg_path_t *path,
 		hg_real_t  x,
 		hg_real_t  y)
 {
-	hg_bool_t retval = hg_path_get_current_point(path, NULL, NULL);
-
-	if (retval)
-		return _hg_path_add(path, HG_PATH_RLINETO, x, y);
-
-	return retval;
+	return _hg_path_add(path, HG_PATH_RLINETO, x, y);
 }
 
 /**
@@ -619,13 +605,11 @@ hg_path_curveto(hg_path_t *path,
 		hg_real_t  x3,
 		hg_real_t  y3)
 {
-	hg_bool_t retval = !hg_path_get_current_point(path, NULL, NULL);
+	hg_bool_t retval = FALSE;
 
-	if (!retval) {
-		retval |= !_hg_path_add(path, HG_PATH_CURVETO, x1, y1);
-		retval |= !_hg_path_add(path, HG_PATH_CURVETO, x2, y2);
-		retval |= !_hg_path_add(path, HG_PATH_CURVETO, x3, y3);
-	}
+	retval |= !_hg_path_add(path, HG_PATH_CURVETO, x1, y1);
+	retval |= !_hg_path_add(path, HG_PATH_CURVETO, x2, y2);
+	retval |= !_hg_path_add(path, HG_PATH_CURVETO, x3, y3);
 
 	return !retval;
 }
@@ -653,13 +637,11 @@ hg_path_rcurveto(hg_path_t *path,
 		 hg_real_t  x3,
 		 hg_real_t  y3)
 {
-	hg_bool_t retval = !hg_path_get_current_point(path, NULL, NULL);
+	hg_bool_t retval = FALSE;
 
-	if (!retval) {
-		retval |= !_hg_path_add(path, HG_PATH_RCURVETO, x1, y1);
-		retval |= !_hg_path_add(path, HG_PATH_RCURVETO, x2, y2);
-		retval |= !_hg_path_add(path, HG_PATH_RCURVETO, x3, y3);
-	}
+	retval |= !_hg_path_add(path, HG_PATH_RCURVETO, x1, y1);
+	retval |= !_hg_path_add(path, HG_PATH_RCURVETO, x2, y2);
+	retval |= !_hg_path_add(path, HG_PATH_RCURVETO, x3, y3);
 
 	return !retval;
 }
@@ -830,6 +812,8 @@ hg_path_arcto(hg_path_t *path,
 		retval |= !_hg_path_add(path, HG_PATH_CURVETO, t2x, t2y);
 		/* XXX: end */
 		retval |= !_hg_path_add(path, HG_PATH_CURVETO, t2x, t2y);
+	} else {
+		hg_error_return (HG_STATUS_FAILED, HG_e_nocurrentpoint);
 	}
 
 	return !retval;
@@ -960,8 +944,8 @@ hg_path_get_bbox(hg_path_t      *path,
 
 	if (path->length == 0) {
 		hg_debug(HG_MSGCAT_PATH, "no current point");
-		hg_errno = HG_ERROR_ (HG_STATUS_FAILED, HG_e_nocurrentpoint);
-		return FALSE;
+
+		hg_error_return (HG_STATUS_FAILED, HG_e_nocurrentpoint);
 	}
 	memset(&priv, 0, sizeof (hg_path_bbox_private_t));
 
diff --git a/hieroglyph/hgpath.h b/hieroglyph/hgpath.h
index d38f43d..ea029cc 100644
--- a/hieroglyph/hgpath.h
+++ b/hieroglyph/hgpath.h
@@ -39,7 +39,6 @@ HG_BEGIN_DECLS
 	(hg_quark_get_type((_q_)) == HG_TYPE_PATH)
 
 typedef struct _hg_path_t			hg_path_t;
-typedef struct _hg_path_bbox_t			hg_path_bbox_t;
 typedef enum _hg_path_type_t			hg_path_type_t;
 typedef struct _hg_path_node_t			hg_path_node_t;
 typedef struct _hg_path_operate_vtable_t	hg_path_operate_vtable_t;
@@ -74,12 +73,6 @@ struct _hg_path_node_t {
 	hg_real_t      cx;
 	hg_real_t      cy;
 };
-struct _hg_path_bbox_t {
-	hg_real_t llx;
-	hg_real_t lly;
-	hg_real_t urx;
-	hg_real_t ury;
-};
 struct _hg_path_operate_vtable_t {
 	void (* new_path)   (hg_pointer_t user_data);
 	void (* close_path) (hg_pointer_t user_data);
diff --git a/hieroglyph/hgtypes.h b/hieroglyph/hgtypes.h
index 1eb6ed3..a6d6ad7 100644
--- a/hieroglyph/hgtypes.h
+++ b/hieroglyph/hgtypes.h
@@ -83,6 +83,23 @@ typedef enum _hg_type_t {
 typedef struct _hg_mem_t	hg_mem_t;
 typedef struct _hg_vm_t		hg_vm_t;
 typedef hg_int_t		hg_error_t;
+typedef struct _hg_path_bbox_t	hg_path_bbox_t;
+
+/**
+ * hg_path_bbox_t:
+ * @llx:
+ * @lly:
+ * @urx:
+ * @ury:
+ *
+ * FIXME
+ */
+struct _hg_path_bbox_t {
+	hg_real_t llx;
+	hg_real_t lly;
+	hg_real_t urx;
+	hg_real_t ury;
+};
 
 /* types of callback functions */
 typedef hg_bool_t (* hg_cb_BOOL__QUARK_t)       (hg_mem_t      *mem,