fix memory leaks and clean up

21 files changed, 357 insertions, 175 deletions

diff --git a/devices/cairo/cairo-main.c b/devices/cairo/cairo-main.c
index 7c09409..287d190 100644
--- a/devices/cairo/cairo-main.c
+++ b/devices/cairo/cairo-main.c
@@ -38,6 +38,7 @@
 #include "hgmem.h"
 #include "hgpath.h"
 #include "hgreal.h"
+#include "hgutils.h"
 #include "hgvm.h"
 #include "hgdevice.h"
 
@@ -323,7 +324,7 @@ _hg_cairo_device_set_dash(hg_cairo_device_t *device,
 	hg_return_if_lock_fail (a, m, qdash);
 
 	len = hg_array_length(a);
-	dashes = g_new(hg_real_t, len);
+	dashes = (hg_real_t *)hg_malloc(sizeof (hg_real_t) * len);
 
 	for (i = 0; i < len; i++) {
 		q = hg_array_get(a, i);
@@ -335,7 +336,7 @@ _hg_cairo_device_set_dash(hg_cairo_device_t *device,
 	}
 	cairo_set_dash(device->cr, dashes, len, dash_offset);
 
-	g_free(dashes);
+	hg_free(dashes);
 	hg_mem_unlock_object(m, qdash);
 }
 
@@ -628,7 +629,7 @@ _hg_cairo_device_stroke(hg_device_t  *device,
 hg_device_t *
 hg_module_init(void)
 {
-	hg_cairo_device_t *retval = g_new0(hg_cairo_device_t, 1);
+	hg_cairo_device_t *retval = (hg_cairo_device_t *)hg_malloc0(sizeof (hg_cairo_device_t));
 	hg_device_t *dev = (hg_device_t *)retval;
 
 	dev->install         = _hg_cairo_device_install;
@@ -645,5 +646,5 @@ hg_module_init(void)
 void
 hg_module_finalize(hg_device_t *device)
 {
-	g_free(device);
+	hg_free(device);
 }
diff --git a/hieroglyph/hg.h b/hieroglyph/hg.h
index ec64557..1e74528 100644
--- a/hieroglyph/hg.h
+++ b/hieroglyph/hg.h
@@ -55,6 +55,7 @@
 #include <hieroglyph/hgsnapshot.h>
 #include <hieroglyph/hgstack.h>
 #include <hieroglyph/hgstring.h>
+#include <hieroglyph/hgutils.h>
 #include <hieroglyph/hgversion.h>
 #include <hieroglyph/hgvm.h>
 
diff --git a/hieroglyph/hgallocator.c b/hieroglyph/hgallocator.c
index 5b1b2bc..edb2c55 100644
--- a/hieroglyph/hgallocator.c
+++ b/hieroglyph/hgallocator.c
@@ -32,6 +32,7 @@
 #include "hgerror.h"
 #include "hgmessages.h"
 #include "hgquark.h"
+#include "hgutils.h"
 #include "hgallocator.h"
 #include "hgallocator-private.h"
 
@@ -112,11 +113,11 @@ _hg_allocator_bitmap_new(hg_usize_t size)
 
 	aligned_size = HG_ALIGNED_TO (size, BLOCK_SIZE);
 	bitmap_size = HG_ALIGNED_TO (aligned_size / BLOCK_SIZE, sizeof (hg_uint_t));
-	retval = g_new0(hg_allocator_bitmap_t, 1);
+	retval = (hg_allocator_bitmap_t *)hg_malloc0(sizeof (hg_allocator_bitmap_t));
 	if (retval) {
-		retval->bitmaps = g_new0(hg_uint_t *, max_page);
-		retval->size = g_new0(gsize, max_page);
-		retval->last_index = g_new0(hg_quark_t, max_page);
+		retval->bitmaps = (hg_uint_t **)hg_malloc0(sizeof (hg_uint_t *) * max_page);
+		retval->size = (hg_usize_t *)hg_malloc0(sizeof (hg_usize_t) * max_page);
+		retval->last_index = (hg_quark_t *)hg_malloc0(sizeof (hg_quark_t) * max_page);
 		page = _hg_allocator_bitmap_get_free_page(retval);
 		if (!retval->bitmaps ||
 		    !retval->size ||
@@ -125,7 +126,7 @@ _hg_allocator_bitmap_new(hg_usize_t size)
 			_hg_allocator_bitmap_destroy(retval);
 			return NULL;
 		}
-		retval->bitmaps[page] = g_new0(hg_uint_t, bitmap_size / sizeof (hg_uint_t));
+		retval->bitmaps[page] = (hg_uint_t *)hg_malloc0(sizeof (hg_uint_t) * (bitmap_size / sizeof (hg_uint_t)));
 		retval->size[page] = bitmap_size;
 	}
 
@@ -154,12 +155,12 @@ _hg_allocator_bitmap_destroy(hg_pointer_t data)
 	if (!data)
 		return;
 	for (i = 0; i < max_page; i++) {
-		g_free(bitmap->bitmaps[i]);
+		hg_free(bitmap->bitmaps[i]);
 	}
-	g_free(bitmap->bitmaps);
-	g_free(bitmap->size);
-	g_free(bitmap->last_index);
-	g_free(bitmap);
+	hg_free(bitmap->bitmaps);
+	hg_free(bitmap->size);
+	hg_free(bitmap->last_index);
+	hg_free(bitmap);
 }
 
 HG_INLINE_FUNC hg_int_t
@@ -193,7 +194,7 @@ _hg_allocator_bitmap_add_page_to(hg_allocator_bitmap_t *bitmap,
 	aligned_size = HG_ALIGNED_TO (size, BLOCK_SIZE);
 	bitmap_size = HG_ALIGNED_TO (aligned_size / BLOCK_SIZE, sizeof (hg_uint_t));
 	if (page >= 0) {
-		bitmap->bitmaps[page] = g_new0(hg_uint_t, bitmap_size / sizeof (hg_uint_t));
+		bitmap->bitmaps[page] = (hg_uint_t *)hg_malloc0(sizeof (hg_uint_t) * (bitmap_size / sizeof (hg_uint_t)));
 		bitmap->size[page] = bitmap_size;
 	}
 
@@ -429,7 +430,7 @@ _hg_allocator_bitmap_copy(hg_allocator_bitmap_t *bitmap)
 	for (i = 0; i < max_page; i++) {
 		if (bitmap->bitmaps[i]) {
 			if (!retval->bitmaps[i]) {
-				retval->bitmaps[i] = g_new0(hg_uint_t, bitmap->size[i] / sizeof (hg_uint_t));
+				retval->bitmaps[i] = (hg_uint_t *)hg_malloc0(sizeof (hg_uint_t) * (bitmap->size[i] / sizeof (hg_uint_t)));
 				bitmap->size[i] = bitmap->size[i];
 			}
 			memcpy(retval->bitmaps[i], bitmap->bitmaps[i], bitmap->size[i]);
@@ -478,7 +479,7 @@ _hg_allocator_initialize(void)
 {
 	hg_allocator_private_t *retval;
 
-	retval = g_new0(hg_allocator_private_t, 1);
+	retval = (hg_allocator_private_t *)hg_malloc0(sizeof (hg_allocator_private_t));
 
 	return retval;
 }
@@ -495,17 +496,17 @@ _hg_allocator_finalize(hg_allocator_data_t *data)
 	priv = (hg_allocator_private_t *)data;
 	if (priv->heaps) {
 		for (i = 0; i < max_page; i++) {
-			g_free(priv->heaps[i]);
+			hg_free(priv->heaps[i]);
 		}
-		g_free(priv->heaps);
+		hg_free(priv->heaps);
 	}
 	if (priv->gc_marker)
-		free(priv->gc_marker);
+		hg_free(priv->gc_marker);
 	if (priv->finalizer)
-		free(priv->finalizer);
+		hg_free(priv->finalizer);
 	_hg_allocator_bitmap_destroy(priv->bitmap);
 
-	g_free(priv);
+	hg_free(priv);
 }
 
 static hg_bool_t
@@ -516,7 +517,7 @@ _hg_allocator_expand_heap(hg_allocator_data_t *data,
 	hg_int_t page = 0;
 
 	if (!priv->heaps) {
-		priv->heaps = g_new0(hg_pointer_t, hg_allocator_get_max_page());
+		priv->heaps = (hg_pointer_t *)hg_malloc0(sizeof (hg_pointer_t) * hg_allocator_get_max_page());
 		if (!priv->heaps)
 			return FALSE;
 	}
@@ -528,7 +529,7 @@ _hg_allocator_expand_heap(hg_allocator_data_t *data,
 		if (!priv->bitmap)
 			return FALSE;
 	}
-	priv->heaps[page] = g_malloc(priv->bitmap->size[page] * BLOCK_SIZE);
+	priv->heaps[page] = hg_malloc(priv->bitmap->size[page] * BLOCK_SIZE);
 	if (!priv->heaps[page])
 		return FALSE;
 	data->total_size = priv->bitmap->size[page] * BLOCK_SIZE;
@@ -847,7 +848,7 @@ _hg_allocator_add_gc_marker(hg_allocator_data_t *data,
 
 	priv = (hg_allocator_private_t *)data;
 
-	freespace = malloc(sizeof (hg_int_t) * priv->max_gc_marker);
+	freespace = (hg_int_t *)hg_malloc(sizeof (hg_int_t) * priv->max_gc_marker);
 	if (freespace == NULL) {
 		hg_fatal("Unrecoverable error happened.");
 		/* shouldn't be reached */
@@ -873,7 +874,7 @@ _hg_allocator_add_gc_marker(hg_allocator_data_t *data,
 				priv->max_gc_marker = GC_MARKER_SIZE;
 			else
 				priv->max_gc_marker *= 2;
-			priv->gc_marker = realloc(priv->gc_marker, sizeof (hg_gc_mark_func_t) * priv->max_gc_marker);
+			priv->gc_marker = hg_realloc(priv->gc_marker, sizeof (hg_gc_mark_func_t) * priv->max_gc_marker);
 			if (priv->gc_marker == NULL) {
 				hg_fatal("Unrecoverable error happened.");
 				/* shouldn't be reached */
@@ -888,7 +889,7 @@ _hg_allocator_add_gc_marker(hg_allocator_data_t *data,
 		retval = priv->gc_marker_count++;
 	}
   finalize:
-	free(freespace);
+	hg_free(freespace);
 
 	return retval;
 }
@@ -938,7 +939,7 @@ _hg_allocator_add_finalizer(hg_allocator_data_t *data,
 
 	priv = (hg_allocator_private_t *)data;
 
-	freespace = malloc(sizeof (hg_int_t) * priv->max_finalizer);
+	freespace = (hg_int_t *)hg_malloc(sizeof (hg_int_t) * priv->max_finalizer);
 	if (freespace == NULL) {
 		hg_fatal("Unrecoverable error happened.");
 		/* shouldn't be reached */
@@ -964,7 +965,7 @@ _hg_allocator_add_finalizer(hg_allocator_data_t *data,
 				priv->max_finalizer = FINALIZER_SIZE;
 			else
 				priv->max_finalizer *= 2;
-			priv->finalizer = realloc(priv->finalizer, sizeof (hg_finalizer_func_t) * priv->max_finalizer);
+			priv->finalizer = hg_realloc(priv->finalizer, sizeof (hg_finalizer_func_t) * priv->max_finalizer);
 			if (priv->finalizer == NULL) {
 				hg_fatal("Unrecoverable error happened.");
 				/* shouldn't be reached */
@@ -979,7 +980,7 @@ _hg_allocator_add_finalizer(hg_allocator_data_t *data,
 		retval = priv->finalizer_count++;
 	}
   finalize:
-	free(freespace);
+	hg_free(freespace);
 
 	return retval;
 }
@@ -1161,7 +1162,7 @@ _hg_allocator_gc_finish(hg_allocator_data_t *data)
 	if (HG_ERROR_IS_SUCCESS0 ()) {
 		hg_usize_t used_size, max_size = data->total_size / BLOCK_SIZE, k = 0, l;
 		hg_uint_t i, j, max_page = hg_allocator_get_max_page();
-		hg_quark_t *failed = malloc(sizeof (hg_quark_t) * max_size);
+		hg_quark_t *failed = (hg_quark_t *)hg_malloc(sizeof (hg_quark_t) * max_size);
 		hg_allocator_block_t *block;
 
 		used_size = data->used_size - priv->slave.used_size;
@@ -1196,7 +1197,7 @@ _hg_allocator_gc_finish(hg_allocator_data_t *data)
 								/* evaluate later. there might be a block that is referring the early blocks */
 								if (k >= max_size) {
 									max_size *= 2;
-									failed = realloc(failed, max_size);
+									failed = hg_realloc(failed, max_size);
 									if (!failed) {
 										hg_fatal("Unrecoverable error happened.");
 										/* shouldn't be reached */
@@ -1236,7 +1237,7 @@ _hg_allocator_gc_finish(hg_allocator_data_t *data)
 			}
 		}
   finalize:
-		free(failed);
+		hg_free(failed);
 	}
 
 	if (HG_ERROR_IS_SUCCESS0 ()) {
@@ -1269,13 +1270,13 @@ _hg_allocator_save_snapshot(hg_allocator_data_t *data)
 
 	G_LOCK (allocator);
 
-	snapshot = g_new0(hg_allocator_snapshot_private_t, 1);
+	snapshot = (hg_allocator_snapshot_private_t *)hg_malloc0(sizeof (hg_allocator_snapshot_private_t));
 	if (snapshot) {
 		snapshot->bitmap = _hg_allocator_bitmap_copy(priv->bitmap);
-		snapshot->heaps = g_new0(gpointer, max_page);
+		snapshot->heaps = (hg_pointer_t *)hg_malloc0(sizeof (hg_pointer_t) * max_page);
 		for (i = 0; i < max_page; i++) {
 			if (priv->heaps[i]) {
-				snapshot->heaps[i] = g_malloc(priv->bitmap->size[i] * BLOCK_SIZE);
+				snapshot->heaps[i] = hg_malloc(priv->bitmap->size[i] * BLOCK_SIZE);
 				memcpy(snapshot->heaps[i], priv->heaps[i], priv->bitmap->size[i] * BLOCK_SIZE);
 			}
 		}
@@ -1390,13 +1391,13 @@ _hg_allocator_restore_snapshot(hg_allocator_data_t          *data,
 	_hg_allocator_bitmap_destroy(priv->bitmap);
 	priv->bitmap = spriv->bitmap;
 	for (i = 0; i < max_page; i++) {
-		g_free(spriv->heaps[i]);
+		hg_free(spriv->heaps[i]);
 	}
-	g_free(spriv->heaps);
+	hg_free(spriv->heaps);
 	data->total_size = snapshot->total_size;
 	data->used_size = snapshot->used_size;
 	priv->snapshot_age = spriv->age;
-	g_free(snapshot);
+	hg_free(snapshot);
 	retval = TRUE;
 
   error:
@@ -1414,10 +1415,10 @@ _hg_allocator_destroy_snapshot(hg_allocator_data_t          *data,
 
 	_hg_allocator_bitmap_destroy(spriv->bitmap);
 	for (i = 0; i < max_page; i++) {
-		g_free(spriv->heaps[i]);
+		hg_free(spriv->heaps[i]);
 	}
-	g_free(spriv->heaps);
-	g_free(spriv);
+	hg_free(spriv->heaps);
+	hg_free(spriv);
 }
 
 /*< public >*/
diff --git a/hieroglyph/hgarray.c b/hieroglyph/hgarray.c
index a757201..403824f 100644
--- a/hieroglyph/hgarray.c
+++ b/hieroglyph/hgarray.c
@@ -33,6 +33,7 @@
 #include "hgmark.h"
 #include "hgnull.h"
 #include "hgreal.h"
+#include "hgutils.h"
 #include "hgarray.h"
 
 #include "hgarray.proto.h"
@@ -167,15 +168,15 @@ _hg_object_array_to_cstr(hg_object_t             *object,
 
 		p = HG_MEM_LOCK (array->o.mem, array->qname);
 		if (!HG_ERROR_IS_SUCCESS0 ())
-			return g_strdup("[FAILED]");
-		s = g_strdup(p);
+			return hg_strdup("[FAILED]");
+		s = hg_strdup(p);
 		hg_mem_unlock_object(array->o.mem, array->qname);
 
 		return s;
 	}
 
 	if (object->on_to_cstr)
-		return g_strdup("[...]");
+		return hg_strdup("[...]");
 	object->on_to_cstr = TRUE;
 
 	g_string_append_c(retval, '[');
@@ -195,14 +196,17 @@ _hg_object_array_to_cstr(hg_object_t             *object,
 			continue;
 		} else {
 			g_string_append(retval, s);
-			g_free(s);
+			hg_free(s);
 		}
 	}
 	g_string_append_c(retval, ']');
 
 	object->on_to_cstr = FALSE;
 
-	return g_string_free(retval, FALSE);
+	s = hg_strdup(retval->str);
+	g_string_free(retval, TRUE);
+
+	return s;
 }
 
 static hg_bool_t
diff --git a/hieroglyph/hgdevice.c b/hieroglyph/hgdevice.c
index 582ee85..5fb0b75 100644
--- a/hieroglyph/hgdevice.c
+++ b/hieroglyph/hgdevice.c
@@ -37,6 +37,7 @@
 #include "hgnull.h"
 #include "hgoperator.h"
 #include "hgreal.h"
+#include "hgutils.h"
 #include "hgdevice.h"
 
 #include "hgdevice.proto.h"
@@ -232,7 +233,7 @@ hg_device_open(hg_mem_t        *mem,
 	hg_return_val_if_fail (name != NULL, NULL, HG_e_VMerror);
 
 	basename = g_path_get_basename(name);
-	modulename = g_strdup_printf("libhgdev-%s.so", basename);
+	modulename = hg_strdup_printf("libhgdev-%s.so", basename);
 	if ((modpath = g_getenv("HIEROGLYPH_DEVICE_PATH")) != NULL) {
 		hg_char_t **path_list = g_strsplit(modpath, G_SEARCHPATH_SEPARATOR_S, -1);
 		hg_char_t *p, *path;
@@ -269,7 +270,7 @@ hg_device_open(hg_mem_t        *mem,
 		hg_warning("No such device module: %s", basename);
 	}
 
-	g_free(modulename);
+	hg_free(modulename);
 	g_free(basename);
 
 	return retval;
@@ -699,7 +700,7 @@ _hg_device_null_destroy(hg_device_t *device)
 {
 	hg_null_device_t *devnul = (hg_null_device_t *)device;
 
-	g_free(devnul);
+	hg_free(devnul);
 }
 
 static hg_bool_t
@@ -715,7 +716,7 @@ _hg_device_null_get_ctm(hg_device_t *device,
 hg_device_t *
 hg_device_null_new(hg_mem_t *mem)
 {
-	hg_null_device_t *retval = g_new0(hg_null_device_t, 1);
+	hg_null_device_t *retval = (hg_null_device_t *)hg_malloc0(sizeof (hg_null_device_t));
 
 	retval->parent.finalizer = _hg_device_null_destroy;
 	retval->parent.get_ctm = _hg_device_null_get_ctm;
@@ -723,7 +724,7 @@ hg_device_null_new(hg_mem_t *mem)
 	retval->parent.stroke = _hg_device_null_nop;
 
 	if (!_hg_device_init_page_params((hg_device_t *)retval, mem)) {
-		g_free(retval);
+		hg_free(retval);
 		return NULL;
 	}
 
diff --git a/hieroglyph/hgdict.c b/hieroglyph/hgdict.c
index 44d6920..7115bb9 100644
--- a/hieroglyph/hgdict.c
+++ b/hieroglyph/hgdict.c
@@ -28,6 +28,7 @@
 #include "hgerror.h"
 #include "hgmem.h"
 #include "hgstring.h"
+#include "hgutils.h"
 #include "hgdict-private.h"
 #include "hgdict.h"
 
@@ -101,7 +102,7 @@ _hg_object_dict_to_cstr(hg_object_t             *object,
 {
 	hg_return_val_if_fail (object->type == HG_TYPE_DICT, NULL, HG_e_typecheck);
 
-	return g_strdup("-dict-");
+	return hg_strdup("-dict-");
 }
 
 static hg_bool_t
@@ -285,7 +286,7 @@ _hg_object_dict_node_to_cstr(hg_object_t             *object,
 {
 	hg_return_val_if_fail (object->type == HG_TYPE_DICT_NODE, NULL, HG_e_typecheck);
 
-	return g_strdup("-dnode-");
+	return hg_strdup("-dnode-");
 }
 
 static hg_bool_t
diff --git a/hieroglyph/hgfile.c b/hieroglyph/hgfile.c
index 1d1e071..4947cf7 100644
--- a/hieroglyph/hgfile.c
+++ b/hieroglyph/hgfile.c
@@ -34,6 +34,7 @@
 #include <unistd.h>
 #include "hglineedit.h"
 #include "hgmem.h"
+#include "hgutils.h"
 #include "hgfile.h"
 
 #include "hgfile.proto.h"
@@ -205,7 +206,7 @@ _hg_object_file_to_cstr(hg_object_t             *object,
 {
 	hg_return_val_if_fail (object->type == HG_TYPE_FILE, NULL, HG_e_typecheck);
 
-	return g_strdup("-file-");
+	return hg_strdup("-file-");
 }
 
 static hg_bool_t
@@ -411,7 +412,7 @@ _hg_file_io_real_file_open(hg_file_t    *file,
 	hg_file_io_data_t *data = user_data;
 	hg_quark_t qdata;
 	hg_string_t *sfilename;
-	hg_char_t *filename;
+	hg_char_t *filename = NULL;
 	struct stat st;
 	int fd;
 	hg_pointer_t buffer = NULL;
@@ -461,7 +462,7 @@ _hg_file_io_real_file_open(hg_file_t    *file,
 	if ((fd = open(filename, flags[file->mode], S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) == -1) {
 		goto exception;
 	}
-	g_free(filename);
+	hg_free(filename);
 	data->fd = fd;
 	if ((buffer = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0)) != MAP_FAILED) {
 		data->mmapped_buffer = buffer;
@@ -471,6 +472,7 @@ _hg_file_io_real_file_open(hg_file_t    *file,
 
 	return TRUE;
   exception:
+	hg_free(filename);
 	hg_file_set_error(__PRETTY_FUNCTION__);
 
 	return FALSE;
@@ -739,7 +741,7 @@ _hg_file_io_real_buffered_read(hg_file_t    *file,
 	    file->position == file->size)
 		bd->data.is_eof = TRUE;
 	file->position += retval;
-	g_free(cstr);
+	hg_free(cstr);
 
 	return retval;
   exception:
@@ -1374,9 +1376,9 @@ hg_file_append_vprintf(hg_file_t       *file,
 	hg_return_val_if_fail (file->o.type == HG_TYPE_FILE, -1, HG_e_typecheck);
 	hg_return_val_if_fail (format != NULL, -1, HG_e_VMerror);
 
-	buffer = g_strdup_vprintf(format, args);
+	buffer = hg_strdup_vprintf(format, args);
 	retval = hg_file_write(file, buffer, sizeof (hg_char_t), strlen(buffer));
-	g_free(buffer);
+	hg_free(buffer);
 
 	return retval;
 }
@@ -1488,7 +1490,7 @@ hg_file_set_error(const hg_char_t  *function)
 	hg_error_t e = 0;
 
 	hg_fileerrno = errno;
-	msg = g_strdup_printf("%s: %s", function, g_strerror(hg_fileerrno));
+	msg = hg_strdup_printf("%s: %s", function, g_strerror(hg_fileerrno));
 
 	switch (hg_fileerrno) {
 	    case 0:
@@ -1529,5 +1531,5 @@ hg_file_set_error(const hg_char_t  *function)
 	if (e > 0) {
 		hg_errno = HG_ERROR_ (HG_STATUS_FAILED, e);
 	}
-	g_free(msg);
+	hg_free(msg);
 }
diff --git a/hieroglyph/hggstate.c b/hieroglyph/hggstate.c
index bb8608f..6de8103 100644
--- a/hieroglyph/hggstate.c
+++ b/hieroglyph/hggstate.c
@@ -31,6 +31,7 @@
 #include "hgmem.h"
 #include "hgpath.h"
 #include "hgreal.h"
+#include "hgutils.h"
 #include "hggstate.h"
 
 #include "hggstate.proto.h"
@@ -137,7 +138,7 @@ _hg_object_gstate_to_cstr(hg_object_t             *object,
 			  hg_quark_iterate_func_t  func,
 			  hg_pointer_t             user_data)
 {
-	return g_strdup("-gstate-");
+	return hg_strdup("-gstate-");
 }
 
 static hg_bool_t
diff --git a/hieroglyph/hglineedit.l b/hieroglyph/hglineedit.l
index 5811b96..d54b74e 100644
--- a/hieroglyph/hglineedit.l
+++ b/hieroglyph/hglineedit.l
@@ -158,7 +158,7 @@ HEXDIGITS	[0-9a-fA-F]
 static hg_char_t *
 _hg_lineedit_real_get_line(hg_lineedit_t   *lineedit,
 			   const hg_char_t *prompt,
-			   hg_pointer_t         user_data)
+			   hg_pointer_t     user_data)
 {
 	GString *buf = g_string_new(NULL);
 	hg_char_t c;
diff --git a/hieroglyph/hgmem.c b/hieroglyph/hgmem.c
index 227d1b4..329f8ee 100644
--- a/hieroglyph/hgmem.c
+++ b/hieroglyph/hgmem.c
@@ -29,6 +29,7 @@
 #include "hgallocator.h"
 #include "hgquark.h"
 #include "hgtypebit-private.h"
+#include "hgutils.h"
 #include "hgmem.h"
 #include "hgmem-private.h"
 
@@ -104,7 +105,7 @@ hg_mem_spool_new_with_allocator(hg_mem_vtable_t *allocator,
 	hg_return_val_if_fail (__hg_mem_id >= 0, NULL, HG_e_VMerror);
 	hg_return_val_if_fail (__hg_mem_id < HG_MAX_MEM, NULL, HG_e_VMerror);
 
-	retval = g_new0(hg_mem_t, 1);
+	retval = (hg_mem_t *)hg_malloc0(sizeof (hg_mem_t));
 	retval->allocator = allocator;
 	retval->type = type;
 	id = retval->id = __hg_mem_id++;
@@ -112,7 +113,7 @@ hg_mem_spool_new_with_allocator(hg_mem_vtable_t *allocator,
 				    HG_TYPEBIT_MEM_ID,
 				    HG_TYPEBIT_MEM_ID_END) != retval->id) {
 		hg_warning("too many memory spooler being created.");
-		g_free(retval);
+		hg_free(retval);
 
 		hg_error_return_val (NULL, HG_STATUS_FAILED, HG_e_VMerror);
 	}
@@ -157,7 +158,7 @@ hg_mem_spool_destroy(hg_pointer_t data)
 	if (mem->type == HG_MEM_TYPE_MASTER)
 		__hg_mem_master = NULL;
 
-	g_free(mem);
+	hg_free(mem);
 }
 
 /**
diff --git a/hieroglyph/hgname.c b/hieroglyph/hgname.c
index 3f40ce8..32e70ae 100644
--- a/hieroglyph/hgname.c
+++ b/hieroglyph/hgname.c
@@ -31,6 +31,7 @@
 #include "hgerror.h"
 #include "hgquark.h"
 #include "hgtypebit-private.h"
+#include "hgutils.h"
 #include "hgname.h"
 
 #include "hgname.proto.h"
@@ -59,10 +60,9 @@ _hg_name_new(const hg_char_t *string)
 	hg_return_val_if_fail (__hg_name_pool.seq_id != 0, Qnil, HG_e_VMerror);
 
 	if ((__hg_name_pool.seq_id - HG_enc_POSTSCRIPT_RESERVED_END) % HG_NAME_BLOCK_SIZE == 0)
-		__hg_name_pool.quarks = g_renew(hg_char_t *,
-						 __hg_name_pool.quarks,
-						 __hg_name_pool.seq_id - HG_enc_POSTSCRIPT_RESERVED_END + HG_NAME_BLOCK_SIZE);
-	s = g_strdup(string);
+		__hg_name_pool.quarks = (hg_char_t **)hg_realloc(__hg_name_pool.quarks,
+								 sizeof (hg_char_t *) * (__hg_name_pool.seq_id - HG_enc_POSTSCRIPT_RESERVED_END + HG_NAME_BLOCK_SIZE));
+	s = hg_strdup(string);
 	retval = g_atomic_int_exchange_and_add(&__hg_name_pool.seq_id, 1);
 	__hg_name_pool.quarks[retval - HG_enc_POSTSCRIPT_RESERVED_END] = s;
 	g_hash_table_insert(__hg_name_pool.name_spool,
@@ -81,9 +81,9 @@ void
 hg_name_init(void)
 {
 	if (g_atomic_int_exchange_and_add(&__hg_name_pool.ref_count, 1) == 0) {
-		__hg_name_pool.name_spool = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
+		__hg_name_pool.name_spool = g_hash_table_new_full(g_str_hash, g_str_equal, hg_free, NULL);
 		__hg_name_pool.seq_id = HG_enc_POSTSCRIPT_RESERVED_END + 1;
-		__hg_name_pool.quarks = g_new0(hg_char_t *, HG_NAME_BLOCK_SIZE);
+		__hg_name_pool.quarks = (hg_char_t **)hg_malloc0(sizeof (hg_char_t *) * HG_NAME_BLOCK_SIZE);
 	}
 	if (!hg_encoding_init()) {
 		hg_name_tini();
@@ -106,7 +106,7 @@ hg_name_tini(void)
 	if (oldval == 1) {
 		g_hash_table_destroy(__hg_name_pool.name_spool);
 		__hg_name_pool.name_spool = NULL;
-		g_free(__hg_name_pool.quarks);
+		hg_free(__hg_name_pool.quarks);
 		__hg_name_pool.quarks = NULL;
 		hg_encoding_tini();
 	}
@@ -154,7 +154,7 @@ hg_name_new_with_string(const hg_char_t *string,
 	if (len < 0)
 		len = strlen(string);
 
-	s = g_strndup(string, len);
+	s = hg_strndup(string, len);
 	enc = hg_encoding_lookup_system_encoding(s);
 	if (enc == HG_enc_END) {
 		hg_pointer_t p = NULL;
@@ -174,7 +174,7 @@ hg_name_new_with_string(const hg_char_t *string,
 	} else {
 		retval = enc;
 	}
-	g_free(s);
+	hg_free(s);
 
 	return hg_quark_new(HG_TYPE_NAME, retval);
 }
diff --git a/hieroglyph/hgoperator.c b/hieroglyph/hgoperator.c
index eebbc14..c475a5c 100644
--- a/hieroglyph/hgoperator.c
+++ b/hieroglyph/hgoperator.c
@@ -669,7 +669,7 @@ DEFUNC_OPER (private_findlibfile)
 	}
 
 	filename = hg_find_libfile(cstr);
-	g_free(cstr);
+	hg_free(cstr);
 
 	if (filename) {
 		q = HG_QSTRING (hg_vm_get_mem(vm),
@@ -940,7 +940,7 @@ DEFUNC_OPER (private_write_eqeq_only)
 		      sizeof (hg_char_t), hg_string_length(s));
 	HG_VM_UNLOCK (vm, arg0);
 	hg_string_free(s, TRUE);
-	g_free(cstr);
+	hg_free(cstr);
 
 	if (!HG_ERROR_IS_SUCCESS0 ()) {
 		return FALSE;
@@ -2888,7 +2888,7 @@ DEFUNC_OPER (cvn)
 		return FALSE;
 	}
 	if (hg_vm_string_length(vm, arg0) > 127) {
-		g_free(cstr);
+		hg_free(cstr);
 		hg_error_return (HG_STATUS_FAILED, HG_e_limitcheck);
 	}
 	if (!HG_ERROR_IS_SUCCESS0 ()) {
@@ -2898,7 +2898,7 @@ DEFUNC_OPER (cvn)
 	*ret = HG_QNAME (cstr);
 	hg_vm_quark_set_executable(vm, ret,
 				   hg_vm_quark_is_executable(vm, &arg0));
-	g_free(cstr);
+	hg_free(cstr);
 
 	retval = TRUE;
 } DEFUNC_OPER_END
@@ -3014,9 +3014,9 @@ DEFUNC_OPER (cvrs)
 	}
 	if (radix == 10) {
 		if (is_real) {
-			cstr = g_strdup_printf("%f", d1);
+			cstr = hg_strdup_printf("%f", d1);
 		} else {
-			cstr = g_strdup_printf("%d", (hg_int_t)d1);
+			cstr = hg_strdup_printf("%d", (hg_int_t)d1);
 		}
 	} else {
 		const hg_char_t __radix_to_c[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
@@ -3033,8 +3033,9 @@ DEFUNC_OPER (cvrs)
 		for (i = 0; i < str->len; i++) {
 			g_string_append_c(rstr, str->str[str->len - i - 1]);
 		}
+		cstr = hg_strdup(rstr->str);
 		g_string_free(str, TRUE);
-		cstr = g_string_free(rstr, FALSE);
+		g_string_free(rstr, TRUE);
 	}
 	s = HG_VM_LOCK (vm, arg2);
 	if (s == NULL) {
@@ -3080,7 +3081,7 @@ DEFUNC_OPER (cvrs)
   error:
 	if (s)
 		HG_VM_UNLOCK (vm, arg2);
-	g_free(cstr);
+	hg_free(cstr);
 	if (e)
 		hg_error_return (HG_STATUS_FAILED, e);
 } DEFUNC_OPER_END
@@ -3382,7 +3383,7 @@ DEFUNC_OPER (eq)
 
 			if (HG_IS_QNAME (arg0) ||
 			    HG_IS_QEVALNAME (arg0)) {
-				s1 = g_strdup(HG_NAME (arg0));
+				s1 = hg_strdup(HG_NAME (arg0));
 			} else {
 				s1 = hg_vm_string_get_cstr(vm, arg0);
 				if (!HG_ERROR_IS_SUCCESS0 ()) {
@@ -3391,7 +3392,7 @@ DEFUNC_OPER (eq)
 			}
 			if (HG_IS_QNAME (arg1) ||
 			    HG_IS_QEVALNAME (arg1)) {
-				s2 = g_strdup(HG_NAME (arg1));
+				s2 = hg_strdup(HG_NAME (arg1));
 			} else {
 				s2 = hg_vm_string_get_cstr(vm, arg1);
 				if (!HG_ERROR_IS_SUCCESS0 ()) {
@@ -3401,8 +3402,8 @@ DEFUNC_OPER (eq)
 			if (s1 != NULL && s2 != NULL)
 				ret = (strcmp(s1, s2) == 0);
 		  s_error:
-			g_free(s1);
-			g_free(s2);
+			hg_free(s1);
+			hg_free(s2);
 		} else if ((HG_IS_QINT (arg0) ||
 			    HG_IS_QREAL (arg0)) &&
 			   (HG_IS_QINT (arg1) ||
@@ -3749,8 +3750,8 @@ DEFUNC_OPER (file)
 	retval = TRUE;
 	SET_EXPECTED_OSTACK_SIZE (-1);
   error:
-	g_free(filename);
-	g_free(fmode);
+	hg_free(filename);
+	hg_free(fmode);
 	if (e)
 		hg_error_return (HG_STATUS_FAILED, e);
 } DEFUNC_OPER_END
@@ -4038,8 +4039,8 @@ DEFUNC_OPER (ge)
 		q = HG_QBOOL (strcmp(cs1, cs2) >= 0);
 
 	  s_error:
-		g_free(cs1);
-		g_free(cs2);
+		hg_free(cs1);
+		hg_free(cs2);
 	} else {
 		hg_error_return (HG_STATUS_FAILED, HG_e_typecheck);
 	}
@@ -4325,8 +4326,8 @@ DEFUNC_OPER (gt)
 		q = HG_QBOOL (strcmp(cs1, cs2) > 0);
 
 	  s_error:
-		g_free(cs1);
-		g_free(cs2);
+		hg_free(cs1);
+		hg_free(cs2);
 	} else {
 		hg_error_return (HG_STATUS_FAILED, HG_e_typecheck);
 	}
@@ -4666,8 +4667,8 @@ DEFUNC_OPER (le)
 		q = HG_QBOOL (strcmp(cs1, cs2) <= 0);
 
 	  s_error:
-		g_free(cs1);
-		g_free(cs2);
+		hg_free(cs1);
+		hg_free(cs2);
 	} else {
 		hg_error_return (HG_STATUS_FAILED, HG_e_typecheck);
 	}
@@ -4908,8 +4909,8 @@ DEFUNC_OPER (lt)
 		q = HG_QBOOL (strcmp(cs1, cs2) < 0);
 
 	  s_error:
-		g_free(cs1);
-		g_free(cs2);
+		hg_free(cs1);
+		hg_free(cs2);
 	} else {
 		hg_error_return (HG_STATUS_FAILED, HG_e_typecheck);
 	}
@@ -5087,7 +5088,7 @@ DEFUNC_OPER (ne)
 
 			if (HG_IS_QNAME (arg0) ||
 			    HG_IS_QEVALNAME (arg0)) {
-				s1 = g_strdup(HG_NAME (arg0));
+				s1 = hg_strdup(HG_NAME (arg0));
 			} else {
 				s1 = hg_vm_string_get_cstr(vm, arg0);
 				if (!HG_ERROR_IS_SUCCESS0 ()) {
@@ -5096,7 +5097,7 @@ DEFUNC_OPER (ne)
 			}
 			if (HG_IS_QNAME (arg1) ||
 			    HG_IS_QEVALNAME (arg1)) {
-				s2 = g_strdup(HG_NAME (arg1));
+				s2 = hg_strdup(HG_NAME (arg1));
 			} else {
 				s2 = hg_vm_string_get_cstr(vm, arg1);
 				if (!HG_ERROR_IS_SUCCESS0 ()) {
@@ -5106,8 +5107,8 @@ DEFUNC_OPER (ne)
 			if (s1 != NULL && s2 != NULL)
 				ret = (strcmp(s1, s2) != 0);
 		  s_error:
-			g_free(s1);
-			g_free(s2);
+			hg_free(s1);
+			hg_free(s2);
 		} else if ((HG_IS_QINT (arg0) ||
 			    HG_IS_QREAL (arg0)) &&
 			   (HG_IS_QINT (arg1) ||
@@ -5331,7 +5332,7 @@ DEFUNC_OPER (print)
 	HG_VM_UNLOCK (vm, qstdout);
 	SET_EXPECTED_OSTACK_SIZE (-1);
   error:
-	g_free(cstr);
+	hg_free(cstr);
 } DEFUNC_OPER_END
 
 DEFUNC_UNIMPLEMENTED_OPER (printobject);
@@ -6284,8 +6285,8 @@ DEFUNC_OPER (search)
 
 	retval = TRUE;
   finalize:
-	g_free(cs0);
-	g_free(cs1);
+	hg_free(cs0);
+	hg_free(cs1);
 	if (s)
 		HG_VM_UNLOCK (vm, arg0);
 	if (seek)
@@ -6823,6 +6824,7 @@ DEFUNC_OPER (status)
 
 			SET_EXPECTED_OSTACK_SIZE (5 - 1);
 		}
+		hg_free(filename);
 	} else {
 		hg_error_return (HG_STATUS_FAILED, HG_e_typecheck);
 	}
@@ -7439,7 +7441,7 @@ DEFUNC_OPER (writehexstring)
 	hg_quark_t arg0, arg1;
 	hg_file_t *f;
 	hg_string_t *s;
-	hg_char_t *cstr;
+	hg_char_t *cstr = NULL;
 	hg_usize_t length, i;
 	hg_error_reason_t e = 0;
 
@@ -7478,6 +7480,7 @@ DEFUNC_OPER (writehexstring)
   error:
 	HG_VM_UNLOCK (vm, arg0);
 	HG_VM_UNLOCK (vm, arg1);
+	hg_free(cstr);
 	if (e)
 		hg_error_return (HG_STATUS_FAILED, e);
 } DEFUNC_OPER_END
@@ -7516,6 +7519,7 @@ DEFUNC_OPER (writestring)
 	cstr = hg_string_get_cstr(s);
 	hg_file_write(f, cstr,
 		      sizeof (hg_char_t), hg_string_length(s));
+	hg_free(cstr);
 	if (HG_ERROR_IS_SUCCESS0 ()) {
 		retval = TRUE;
 		hg_stack_drop(ostack);
@@ -8070,14 +8074,14 @@ hg_operator_init(void)
 {
 #define DECL_OPER(_n_)							\
 	HG_STMT_START {							\
-		__hg_operator_name_table[HG_enc_ ## _n_] = g_strdup("--" #_n_ "--"); \
+		__hg_operator_name_table[HG_enc_ ## _n_] = hg_strdup("--" #_n_ "--"); \
 		if (__hg_operator_name_table[HG_enc_ ## _n_] == NULL)	\
 			return FALSE;					\
 		__hg_operator_func_table[HG_enc_ ## _n_] = OPER_FUNC_NAME (_n_); \
 	} HG_STMT_END
 #define DECL_PRIV_OPER(_on_,_n_)						\
 	HG_STMT_START {							\
-		__hg_operator_name_table[HG_enc_ ## _n_] = g_strdup("--" #_on_ "--"); \
+		__hg_operator_name_table[HG_enc_ ## _n_] = hg_strdup("--" #_on_ "--"); \
 		if (__hg_operator_name_table[HG_enc_ ## _n_] == NULL)	\
 			return FALSE;					\
 		__hg_operator_func_table[HG_enc_ ## _n_] = OPER_FUNC_NAME (_n_); \
@@ -8479,11 +8483,11 @@ hg_operator_init(void)
 void
 hg_operator_tini(void)
 {
-#define UNDECL_OPER(_n_)					\
-	HG_STMT_START {						\
-		g_free(__hg_operator_name_table[HG_enc_ ## _n_]);	\
-		__hg_operator_name_table[HG_enc_ ## _n_] = NULL;		\
-		__hg_operator_func_table[HG_enc_ ## _n_] = NULL;		\
+#define UNDECL_OPER(_n_)						\
+	HG_STMT_START {							\
+		hg_free(__hg_operator_name_table[HG_enc_ ## _n_]);	\
+		__hg_operator_name_table[HG_enc_ ## _n_] = NULL;	\
+		__hg_operator_func_table[HG_enc_ ## _n_] = NULL;	\
 	} HG_STMT_END
 
 	UNDECL_OPER (private_abort);
@@ -8884,7 +8888,7 @@ hg_operator_tini(void)
  * Returns:
  */
 hg_quark_t
-hg_operator_add_dynamic(const hg_char_t        *string,
+hg_operator_add_dynamic(const hg_char_t    *string,
 			hg_operator_func_t  func)
 {
 	hg_quark_t n = HG_QNAME (string);
@@ -8892,7 +8896,7 @@ hg_operator_add_dynamic(const hg_char_t        *string,
 	if (hg_quark_get_value(n) < HG_enc_builtin_HIEROGLYPH_END)
 		return Qnil;
 
-	__hg_operator_name_table[hg_quark_get_value(n)] = g_strdup_printf("--%s--", string);
+	__hg_operator_name_table[hg_quark_get_value(n)] = hg_strdup_printf("--%s--", string);
 	__hg_operator_func_table[hg_quark_get_value(n)] = func;
 
 	return n;
@@ -8909,7 +8913,7 @@ hg_operator_remove_dynamic(hg_uint_t encoding)
 {
 	hg_return_if_fail (encoding >= HG_enc_builtin_HIEROGLYPH_END, HG_e_VMerror);
 
-	g_free(__hg_operator_name_table[encoding]);
+	hg_free(__hg_operator_name_table[encoding]);
 	__hg_operator_name_table[encoding] = NULL;
 	__hg_operator_func_table[encoding] = NULL;
 }
diff --git a/hieroglyph/hgplugin.c b/hieroglyph/hgplugin.c
index efec39d..173d3a4 100644
--- a/hieroglyph/hgplugin.c
+++ b/hieroglyph/hgplugin.c
@@ -27,6 +27,7 @@
 
 #include <string.h>
 #include "hgmem.h"
+#include "hgutils.h"
 #include "hgplugin.h"
 
 #include "hgplugin.proto.h"
@@ -97,10 +98,10 @@ hg_plugin_open(hg_mem_t         *mem,
 	realname = g_path_get_basename(name);
 	switch (type) {
 	    case HG_PLUGIN_EXTENSION:
-		    modulename = g_strdup_printf("libext-%s.so", realname);
+		    modulename = hg_strdup_printf("libext-%s.so", realname);
 		    break;
 	    case HG_PLUGIN_DEVICE:
-		    modulename = g_strdup_printf("libdevice-%s.so", realname);
+		    modulename = hg_strdup_printf("libdevice-%s.so", realname);
 		    break;
 	    default:
 		    hg_warning("Unknown plugin type: %d", type);
@@ -146,7 +147,7 @@ hg_plugin_open(hg_mem_t         *mem,
 	}
   finalize:
 	g_free(realname);
-	g_free(modulename);
+	hg_free(modulename);
 
 	return retval;
 }
diff --git a/hieroglyph/hgscanner.l b/hieroglyph/hgscanner.l
index 478f73c..938eb3c 100644
--- a/hieroglyph/hgscanner.l
+++ b/hieroglyph/hgscanner.l
@@ -35,6 +35,7 @@
 #include "hgint.h"
 #include "hgname.h"
 #include "hgreal.h"
+#include "hgutils.h"
 #include "hgvm.h"
 #include "hgscanner.h"
 
@@ -396,14 +397,14 @@ HEXDIGITS	[0-9a-fA-F]
 		hg_usize_t radix, len, i, index;
 		hg_char_t *s, *p;
 
-		s = g_new(hg_char_t, yyleng);
+		s = (hg_char_t *)hg_malloc(sizeof (hg_char_t) * yyleng);
 		sscanf(yytext, "%lf#%s", &fradix, s);
 		radix = fradix;
 		if (fradix > HG_MAXINT ||
 		    fradix < HG_MININT ||
 		    radix < 2 ||
 		    radix > 36) {
-			g_free(s);
+			hg_free(s);
 			REJECT;
 		}
 		len = strlen(s);
@@ -411,20 +412,20 @@ HEXDIGITS	[0-9a-fA-F]
 			p = strchr(radix_index, tolower(s[i]));
 			index = p - radix_index;
 			if (index >= radix) {
-				g_free(s);
+				hg_free(s);
 				REJECT;
 			}
 			if ((result > 0 && (result * radix) < 0) ||
 			    (result < 0 && (result * radix) > 0)) {
 				hg_debug(HG_MSGCAT_SCAN, "Digit is too big");
 				hg_errno = HG_ERROR_ (HG_STATUS_FAILED, HG_e_syntaxerror);
-				g_free(s);
+				hg_free(s);
 				yyterminate();
 			}
 			result *= radix;
 			result += index;
 		}
-		g_free(s);
+		hg_free(s);
 		scanner->result = HG_QINT (result);
 		return TRUE;
 	}
diff --git a/hieroglyph/hgsnapshot.c b/hieroglyph/hgsnapshot.c
index a5befbb..d469f28 100644
--- a/hieroglyph/hgsnapshot.c
+++ b/hieroglyph/hgsnapshot.c
@@ -29,6 +29,7 @@
 #include <glib.h>
 #include "hgmem.h"
 #include "hgmem-private.h"
+#include "hgutils.h"
 #include "hgsnapshot.h"
 
 #include "hgsnapshot.proto.h"
@@ -100,7 +101,7 @@ _hg_object_snapshot_to_cstr(hg_object_t             *object,
 {
 	hg_return_val_if_fail (object->type == HG_TYPE_SNAPSHOT, NULL, HG_e_typecheck);
 
-	return g_strdup("-save-");
+	return hg_strdup("-save-");
 }
 
 static hg_bool_t
diff --git a/hieroglyph/hgstack.c b/hieroglyph/hgstack.c
index 0aa437c..af9eb8e 100644
--- a/hieroglyph/hgstack.c
+++ b/hieroglyph/hgstack.c
@@ -28,6 +28,7 @@
 #include <stdlib.h>
 #include "hgerror.h"
 #include "hgmem.h"
+#include "hgutils.h"
 #include "hgstack.h"
 #include "hgstack-private.h"
 #include "hgvm.h"
@@ -133,7 +134,7 @@ _hg_object_stack_to_cstr(hg_object_t             *object,
 			 hg_quark_iterate_func_t  func,
 			 hg_pointer_t             user_data)
 {
-	return g_strdup("-stack-");
+	return hg_strdup("-stack-");
 }
 
 static hg_bool_t
@@ -625,7 +626,7 @@ hg_stack_foreach(hg_stack_t               *stack,
 		return;
 
 	if (is_forwarded) {
-		hg_pointer_t *p = g_new0(hg_pointer_t, stack->depth + 1);
+		hg_pointer_t *p = (hg_pointer_t *)hg_malloc0(sizeof (hg_pointer_t) * (stack->depth + 1));
 		hg_size_t i;
 
 		for (l = stack->last_stack, i = stack->depth;
@@ -636,7 +637,7 @@ hg_stack_foreach(hg_stack_t               *stack,
 			if (!func(stack->o.mem, ((hg_slist_t *)p[i])->data, data))
 				break;
 		}
-		g_free(p);
+		hg_free(p);
 	} else {
 		for (l = stack->last_stack; l != NULL; l = l->next) {
 			if (!func(stack->o.mem, l->data, data))
diff --git a/hieroglyph/hgstring.c b/hieroglyph/hgstring.c
index 4c5aa85..683340e 100644
--- a/hieroglyph/hgstring.c
+++ b/hieroglyph/hgstring.c
@@ -33,6 +33,7 @@
 #include "hgerror.h"
 #include "hgmem.h"
 #include "hgquark.h"
+#include "hgutils.h"
 #include "hgstring.h"
 
 #include "hgstring.proto.h"
@@ -97,7 +98,7 @@ _hg_object_string_copy(hg_object_t             *object,
 	hg_return_val_if_fail (object->type == HG_TYPE_STRING, Qnil, HG_e_typecheck);
 
 	retval = HG_QSTRING_LEN (s->o.mem, cstr, hg_string_length(s));
-	g_free(cstr);
+	hg_free(cstr);
 
 	return retval;
 }
@@ -109,12 +110,13 @@ _hg_object_string_to_cstr(hg_object_t             *object,
 {
 	GString *retval = g_string_new(NULL);
 	hg_string_t *s = (hg_string_t *)object;
-	hg_char_t *cstr = hg_string_get_cstr(s);
+	hg_char_t *cstr;
 	hg_char_t buffer[8];
 	hg_usize_t i;
 
 	hg_return_val_if_fail (object->type == HG_TYPE_STRING, NULL, HG_e_typecheck);
 
+	cstr = hg_string_get_cstr(s);
 	g_string_append_c(retval, '(');
 	for (i = 0; i < hg_string_maxlength(s); i++) {
 		if (cstr == NULL) {
@@ -146,7 +148,7 @@ _hg_object_string_to_cstr(hg_object_t             *object,
 			}
 		}
 	}
-	g_free(cstr);
+	hg_free(cstr);
 	g_string_append_c(retval, ')');
 
 	return g_string_free(retval, FALSE);
@@ -661,7 +663,7 @@ hg_string_get_cstr(hg_string_t *string)
 				    string->qstring,
 				    NULL);
 
-	retval = g_new0(hg_char_t, string->length + 1);
+	retval = (hg_char_t *)hg_malloc0(sizeof (hg_char_t) * (string->length + 1));
 	memcpy(retval, &cstr[string->offset], string->length);
 	retval[string->length] = 0;
 
@@ -747,7 +749,7 @@ hg_string_ncompare(hg_string_t *a,
 
 	retval = hg_string_ncompare_with_cstr(a, sb, length);
 
-	g_free(sb);
+	hg_free(sb);
 
 	return retval;
 }
@@ -783,7 +785,7 @@ hg_string_ncompare_with_cstr(hg_string_t     *a,
 
 	retval = memcmp(sa, b, length) == 0;
 
-	g_free(sa);
+	hg_free(sa);
 
 	return retval;
 }
@@ -812,9 +814,9 @@ hg_string_append_printf(hg_string_t     *string,
 
 	va_start(ap, format);
 
-	ret = g_strdup_vprintf(format, ap);
+	ret = hg_strdup_vprintf(format, ap);
 	retval = hg_string_append(string, ret, -1);
-	g_free(ret);
+	hg_free(ret);
 
 	va_end(ap);
 
diff --git a/hieroglyph/hgutils.h b/hieroglyph/hgutils.h
index 83a8eb5..6e42fa0 100644
--- a/hieroglyph/hgutils.h
+++ b/hieroglyph/hgutils.h
@@ -28,10 +28,169 @@
 #ifndef __HIEROGLYPH_HGUTILS_H__
 #define __HIEROGLYPH_HGUTILS_H__
 
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 #include <hieroglyph/hgtypes.h>
 
 HG_BEGIN_DECLS
 
+HG_INLINE_FUNC hg_pointer_t  hg_malloc        (hg_usize_t       size);
+HG_INLINE_FUNC hg_pointer_t  hg_malloc0       (hg_usize_t       size);
+HG_INLINE_FUNC void          hg_free          (hg_pointer_t     data);
+HG_INLINE_FUNC hg_char_t    *hg_strdup        (const hg_char_t *string);
+HG_INLINE_FUNC hg_char_t    *hg_strndup       (const hg_char_t *string,
+					       hg_usize_t       len);
+HG_INLINE_FUNC hg_char_t    *hg_strdup_printf (const hg_char_t *format,
+					       ...);
+HG_INLINE_FUNC hg_char_t    *hg_strdup_vprintf(const hg_char_t *format,
+					       va_list          args);
+
+/**
+ * hg_malloc:
+ * @size:
+ *
+ * FIXME
+ *
+ * Returns:
+ */
+HG_INLINE_FUNC hg_pointer_t
+hg_malloc(hg_usize_t size)
+{
+	return malloc(size);
+}
+
+/**
+ * hg_malloc0:
+ * @size:
+ *
+ * FIXME
+ *
+ * Returns:
+ */
+HG_INLINE_FUNC hg_pointer_t
+hg_malloc0(hg_usize_t size)
+{
+	return calloc(1, size);
+}
+
+/**
+ * hg_realloc:
+ * @data:
+ * @size:
+ *
+ * FIXME
+ *
+ * Returns:
+ */
+HG_INLINE_FUNC hg_pointer_t
+hg_realloc(hg_pointer_t data,
+	   hg_usize_t   size)
+{
+	return realloc(data, size);
+}
+
+/**
+ * hg_free:
+ * @data:
+ *
+ * FIXME
+ *
+ * Returns:
+ */
+HG_INLINE_FUNC void
+hg_free(hg_pointer_t data)
+{
+	if (data)
+		free(data);
+}
+
+/**
+ * hg_strdup:
+ * @string:
+ *
+ * FIXME
+ *
+ * Returns:
+ */
+HG_INLINE_FUNC hg_char_t *
+hg_strdup(const hg_char_t *string)
+{
+	return strdup(string);
+}
+
+/**
+ * hg_strndup:
+ * @string:
+ * @len:
+ *
+ * FIXME
+ *
+ * Returns:
+ */
+HG_INLINE_FUNC hg_char_t *
+hg_strndup(const hg_char_t *string,
+	   hg_usize_t       len)
+{
+	return strndup(string, len);
+}
+
+/**
+ * hg_strdup_printf:
+ * @format:
+ *
+ * FIXME
+ *
+ * Returns:
+ */
+HG_INLINE_FUNC hg_char_t *
+hg_strdup_printf(const hg_char_t *format,
+		 ...)
+{
+	va_list args;
+	hg_char_t *retval;
+
+	va_start(args, format);
+
+	retval = hg_strdup_vprintf(format, args);
+
+	va_end(args);
+
+	return retval;
+}
+
+/**
+ * hg_strdup_vprintf:
+ * @format:
+ * @args:
+ *
+ * FIXME
+ *
+ * Returns:
+ */
+HG_INLINE_FUNC hg_char_t *
+hg_strdup_vprintf(const hg_char_t *format,
+		  va_list          args)
+{
+	char c;
+	int size;
+	hg_char_t *retval;
+	va_list ap;
+
+	va_copy(ap, args);
+
+	size = vsnprintf(&c, 1, format, ap) + 1;
+
+	va_end(ap);
+
+	retval = hg_malloc(sizeof (hg_char_t) * size);
+	if (retval) {
+		vsprintf(retval, format, args);
+	}
+
+	return retval;
+}
+
 hg_char_t *hg_find_libfile(const hg_char_t *file);
 
 HG_END_DECLS
diff --git a/hieroglyph/hgvm.c b/hieroglyph/hgvm.c
index cde5dfb..913a133 100644
--- a/hieroglyph/hgvm.c
+++ b/hieroglyph/hgvm.c
@@ -209,7 +209,7 @@ _hg_vm_stack_real_dump(hg_mem_t     *mem,
 			      (hg_quark_is_executable(qdata) ? 'x' : '-'),
 			      q == Qnil ? "..." : cstr);
 
-	g_free(cstr);
+	hg_free(cstr);
 	/* this is an instant object.
 	 * surely no reference to the container.
 	 * so it can be safely destroyed.
@@ -948,7 +948,7 @@ _hg_vm_set_error(hg_vm_t           *vm,
 		_HG_VM_UNLOCK (vm, vm->qerror);
 
 		if (qresult_cmd == Qnil) {
-			scommand = g_strdup("-%unknown%-");
+			scommand = hg_strdup("-%unknown%-");
 		} else {
 			hg_string_t *s = NULL;
 
@@ -957,7 +957,7 @@ _hg_vm_set_error(hg_vm_t           *vm,
 						  TRUE,
 						  (hg_pointer_t *)&s);
 			if (q == Qnil)
-				scommand = g_strdup("-%ENOMEM%-");
+				scommand = hg_strdup("-%ENOMEM%-");
 			else
 				scommand = hg_string_get_cstr(s);
 			/* this is an instant object.
@@ -971,7 +971,7 @@ _hg_vm_set_error(hg_vm_t           *vm,
 					       TRUE,
 					       (hg_pointer_t *)&where);
 		if (qwhere == Qnil)
-			swhere = g_strdup("-%ENOMEM%-");
+			swhere = hg_strdup("-%ENOMEM%-");
 		else
 			swhere = hg_string_get_cstr(where);
 		_hg_vm_quark_free(vm, qwhere);
@@ -992,8 +992,8 @@ _hg_vm_set_error(hg_vm_t           *vm,
 				   hg_name_lookup(vm->qerror_name[error]),
 				   swhere);
 		}
-		g_free(swhere);
-		g_free(scommand);
+		hg_free(swhere);
+		hg_free(scommand);
 
 		hg_operator_invoke(HG_QOPER (HG_enc_private_abort), vm);
 	}
@@ -1130,9 +1130,9 @@ hg_vm_new(void)
 	g_get_current_time(&retval->initiation_time);
 
 	retval->params = g_hash_table_new_full(g_str_hash, g_str_equal,
-					       g_free, hg_vm_value_free);
+					       hg_free, hg_vm_value_free);
 	retval->plugin_table = g_hash_table_new_full(g_str_hash, g_str_equal,
-						     g_free, NULL);
+						     hg_free, NULL);
 	retval->mem[HG_VM_MEM_GLOBAL] = hg_mem_spool_new(HG_MEM_TYPE_GLOBAL,
 							 HG_VM_GLOBAL_MEM_SIZE);
 	retval->mem[HG_VM_MEM_LOCAL] = hg_mem_spool_new(HG_MEM_TYPE_LOCAL,
@@ -1891,13 +1891,13 @@ hg_vm_eval_cstring(hg_vm_t         *vm,
 		clen = strlen(cstring);
 
 	/* add \n at the end to avoid failing on scanner */
-	str = g_new0(hg_char_t, clen + 2);
+	str = (hg_char_t *)hg_malloc0(sizeof (hg_char_t) * (clen + 2));
 	memcpy(str, cstring, clen);
 	str[clen] = '\n';
 	str[clen + 1] = 0;
 	qstring = HG_QSTRING_LEN (_hg_vm_get_mem(vm),
 				  str, clen + 1);
-	g_free(str);
+	hg_free(str);
 	if (qstring == Qnil) {
 		goto error;
 	}
@@ -2078,11 +2078,11 @@ hg_vm_startjob(hg_vm_t           *vm,
 		/* XXX: initialize device */
 
 		if (initializer) {
-			hg_char_t *s = g_strdup_printf("{(%s)(r)file dup type/filetype eq{cvx exec}if}stopped{$error/newerror get{errordict/handleerror get exec 1 .quit}if}if", initializer);
+			hg_char_t *s = hg_strdup_printf("{(%s)(r)file dup type/filetype eq{cvx exec}if}stopped{$error/newerror get{errordict/handleerror get exec 1 .quit}if}if", initializer);
 
 			retval = hg_vm_eval_cstring(vm, s, -1, FALSE);
 
-			g_free(s);
+			hg_free(s);
 
 			return retval;
 		}
@@ -2489,7 +2489,7 @@ hg_vm_add_plugin(hg_vm_t         *vm,
 
 		l->data = plugin;
 		g_hash_table_insert(vm->plugin_table,
-				    g_strdup(name), l);
+				    hg_strdup(name), l);
 		vm->plugin_list = g_list_concat(vm->plugin_list, l);
 	}
 
@@ -2621,7 +2621,7 @@ hg_vm_add_param(hg_vm_t         *vm,
 	hg_return_if_fail (name != NULL, HG_e_VMerror);
 	hg_return_if_fail (value != NULL, HG_e_VMerror);
 
-	g_hash_table_insert(vm->params, g_strdup(name), value);
+	g_hash_table_insert(vm->params, hg_strdup(name), value);
 }
 
 /* hg_array_t */
@@ -2749,7 +2749,7 @@ hg_vm_dstack_lookup(hg_vm_t    *vm,
 		str = hg_string_get_cstr(s);
 		quark = hg_name_new_with_string(str, -1);
 
-		g_free(str);
+		hg_free(str);
 		_HG_VM_UNLOCK (vm, qname);
 	} else if (HG_IS_QEVALNAME (qname)) {
 		quark = hg_quark_new(HG_TYPE_NAME, qname);
@@ -2799,7 +2799,7 @@ hg_vm_dstack_remove(hg_vm_t    *vm,
 		str = hg_string_get_cstr(s);
 		quark = hg_name_new_with_string(str, -1);
 
-		g_free(str);
+		hg_free(str);
 		_HG_VM_UNLOCK (vm, qname);
 	} else {
 		quark = qname;
@@ -3212,7 +3212,7 @@ hg_vm_quark_to_string(hg_vm_t      *vm,
 						    _HG_VM_UNLOCK (vm, qdata);
 
 						    hg_string_append(s, cstr, -1);
-						    g_free(cstr);
+						    hg_free(cstr);
 						    break;
 					    }
 				    }
@@ -3231,7 +3231,7 @@ hg_vm_quark_to_string(hg_vm_t      *vm,
 						    }
 					    }
 					    hg_string_append(s, cstr, -1);
-					    g_free(cstr);
+					    hg_free(cstr);
 
 					    _HG_VM_UNLOCK (vm, qdata);
 				    }
@@ -3828,9 +3828,9 @@ hg_vm_value_free(hg_pointer_t data)
 	hg_vm_value_t *v = (hg_vm_value_t *)data;
 
 	if (v->type == HG_TYPE_STRING)
-		g_free(v->u.string);
+		hg_free(v->u.string);
 
-	g_free(v);
+	hg_free(v);
 }
 
 /**
@@ -3846,7 +3846,7 @@ hg_vm_value_boolean_new(hg_bool_t value)
 {
 	hg_vm_value_t *retval;
 
-	retval = g_new(hg_vm_value_t, 1);
+	retval = (hg_vm_value_t *)hg_malloc(sizeof (hg_vm_value_t));
 	if (retval) {
 		retval->type = HG_TYPE_BOOL;
 		retval->u.bool = value;
@@ -3868,7 +3868,7 @@ hg_vm_value_integer_new(hg_int_t value)
 {
 	hg_vm_value_t *retval;
 
-	retval = g_new(hg_vm_value_t, 1);
+	retval = (hg_vm_value_t *)hg_malloc(sizeof (hg_vm_value_t));
 	if (retval) {
 		retval->type = HG_TYPE_INT;
 		retval->u.integer = value;
@@ -3890,7 +3890,7 @@ hg_vm_value_real_new(hg_real_t value)
 {
 	hg_vm_value_t *retval;
 
-	retval = g_new(hg_vm_value_t, 1);
+	retval = (hg_vm_value_t *)hg_malloc(sizeof (hg_vm_value_t));
 	if (retval) {
 		retval->type = HG_TYPE_REAL;
 		retval->u.real = value;
@@ -3912,10 +3912,10 @@ hg_vm_value_string_new(const hg_char_t *value)
 {
 	hg_vm_value_t *retval;
 
-	retval = g_new(hg_vm_value_t, 1);
+	retval = (hg_vm_value_t *)hg_malloc(sizeof (hg_vm_value_t));
 	if (retval) {
 		retval->type = HG_TYPE_STRING;
-		retval->u.string = g_strdup(value);
+		retval->u.string = hg_strdup(value);
 	}
 
 	return retval;
diff --git a/plugins/libedit/libedit-main.c b/plugins/libedit/libedit-main.c
index 7c6e2b1..93fd1e0 100644
--- a/plugins/libedit/libedit-main.c
+++ b/plugins/libedit/libedit-main.c
@@ -150,7 +150,7 @@ DEFUNC_OPER (private_loadhistory)
 
 	g_free(histfile);
 	g_free(filename);
-	g_free(cstr);
+	hg_free(cstr);
 
 	hg_stack_drop(ostack);
 	SET_EXPECTED_OSTACK_SIZE (-1);
@@ -188,7 +188,7 @@ DEFUNC_OPER (private_savehistory)
 
 	g_free(histfile);
 	g_free(filename);
-	g_free(cstr);
+	hg_free(cstr);
 
 	hg_stack_drop(ostack);
 	SET_EXPECTED_OSTACK_SIZE (-1);
diff --git a/plugins/unittest/unittest-main.c b/plugins/unittest/unittest-main.c
index 9f21357..a1ef7b4 100644
--- a/plugins/unittest/unittest-main.c
+++ b/plugins/unittest/unittest-main.c
@@ -74,7 +74,7 @@ DEFUNC_OPER (private_validatetestresult)
 	qexp = hg_dict_lookup(d, HG_QNAME ("expression"));
 	q = hg_vm_quark_to_string(vm, qexp, TRUE, (hg_pointer_t *)&sexp);
 	if (q == Qnil) {
-		cexp = g_strdup("--%unknown--");
+		cexp = hg_strdup("--%unknown--");
 	} else {
 		cexp = hg_string_get_cstr(sexp);
 	}
@@ -95,21 +95,21 @@ DEFUNC_OPER (private_validatetestresult)
 
 			qa = hg_vm_quark_to_string(vm, qaerror, TRUE, (hg_pointer_t *)&sa);
 			if (qa == Qnil) {
-				csa = g_strdup("--%unknown--");
+				csa = hg_strdup("--%unknown--");
 			} else {
 				csa = hg_string_get_cstr(sa);
 			}
 			hg_string_free(sa, TRUE);
 			qe = hg_vm_quark_to_string(vm, qeerror, TRUE, (hg_pointer_t *)&se);
 			if (qe == Qnil) {
-				cse = g_strdup("--%unknown--");
+				cse = hg_strdup("--%unknown--");
 			} else {
 				cse = hg_string_get_cstr(se);
 			}
 			hg_string_free(se, TRUE);
 			qp = hg_vm_quark_to_string(vm, qerrorat, TRUE, (hg_pointer_t *)&sp);
 			if (qp == Qnil) {
-				csp = g_strdup("--%unknown--");
+				csp = hg_strdup("--%unknown--");
 			} else {
 				csp = hg_string_get_cstr(sp);
 			}
@@ -120,9 +120,9 @@ DEFUNC_OPER (private_validatetestresult)
 			hg_file_append_printf(f, "Expression: %s - expected error is %s, but actual error was %s at %s\n",
 					      cexp, cse, csa, csp);
 			HG_VM_UNLOCK (vm, qf);
-			g_free(csa);
-			g_free(cse);
-			g_free(csp);
+			hg_free(csa);
+			hg_free(cse);
+			hg_free(csp);
 		}
 		result = FALSE;
 	}
@@ -142,14 +142,14 @@ DEFUNC_OPER (private_validatetestresult)
 
 		qa = hg_vm_quark_to_string(vm, qastack, TRUE, (hg_pointer_t *)&sa);
 		if (qa == Qnil) {
-			csa = g_strdup("--%unknown--");
+			csa = hg_strdup("--%unknown--");
 		} else {
 			csa = hg_string_get_cstr(sa);
 		}
 		hg_string_free(sa, TRUE);
 		qe = hg_vm_quark_to_string(vm, qestack, TRUE, (hg_pointer_t *)&se);
 		if (qe == Qnil) {
-			cse = g_strdup("--%unknown--");
+			cse = hg_strdup("--%unknown--");
 		} else {
 			cse = hg_string_get_cstr(se);
 		}
@@ -166,12 +166,12 @@ DEFUNC_OPER (private_validatetestresult)
 		}
 		retval = TRUE;
 
-		g_free(cse);
-		g_free(csa);
+		hg_free(cse);
+		hg_free(csa);
 	}
 
   error:
-	g_free(cexp);
+	hg_free(cexp);
 	HG_VM_UNLOCK (vm, arg0);
 
 	hg_stack_drop(ostack);