#96: replace g_free with free

src/gig_arg_map.c

@@ -64,7 +64,7 @@ gig_amap_new(const gchar *name, GICallableInfo *function_info)
 
     n = g_callable_info_get_n_args(function_info);
     amap = arg_map_allocate(n);
-    g_free(amap->name);
+    free(amap->name);
     amap->name = xstrdup(g_base_info_get_name(function_info));
     arg_map_apply_function_info(amap, function_info);
     if (amap->is_invalid) {
@@ -106,14 +106,14 @@ arg_map_apply_function_info(GigArgMap *amap, GIFunctionInfo *func_info)
     for (i = 0; i < n; i++) {
         arg_info = g_callable_info_get_arg(func_info, i);
         gig_type_meta_init_from_arg_info(&amap->pdata[i].meta, arg_info);
-        g_free(amap->pdata[i].name);
+        free(amap->pdata[i].name);
         amap->pdata[i].name = xstrdup(g_base_info_get_name(arg_info));
         g_base_info_unref(arg_info);
         amap->is_invalid |= amap->pdata[i].meta.is_invalid;
     }
 
     gig_type_meta_init_from_callable_info(&amap->return_val.meta, func_info);
-    g_free(amap->return_val.name);
+    free(amap->return_val.name);
     amap->return_val.name = xstrdup("%return");
     amap->is_invalid |= amap->return_val.meta.is_invalid;
 }
@@ -282,14 +282,14 @@ gig_amap_free(GigArgMap *amap)
 
     for (gint i = 0; i < amap->len; i++) {
         gig_data_type_free(&amap->pdata[i].meta);
-        g_free(amap->pdata[i].name);
+        free(amap->pdata[i].name);
     }
     gig_data_type_free(&amap->return_val.meta);
-    g_free(amap->return_val.name);
-    g_free(amap->pdata);
-    g_free(amap->name);
+    free(amap->return_val.name);
+    free(amap->pdata);
+    free(amap->name);
     amap->pdata = NULL;
-    g_free(amap);
+    free(amap);
 }
 
 void

src/gig_argument.c

@@ -828,13 +828,13 @@ scm_to_c_ghashtable(S2C_ARG_DECL)
             key_type = GIG_HASH_INT64;
             hash_func = g_int64_hash;
             equal_func = g_int64_equal;
-            key_destroy_func = g_free;
+            key_destroy_func = free;
         }
         else if (type == G_TYPE_DOUBLE || type == G_TYPE_FLOAT) {
             key_type = GIG_HASH_REAL;
             hash_func = g_double_hash;
             equal_func = g_double_equal;
-            key_destroy_func = g_free;
+            key_destroy_func = free;
         }
         else {
             // Should be unreachable
@@ -852,7 +852,7 @@ scm_to_c_ghashtable(S2C_ARG_DECL)
             key_type = GIG_HASH_STRING;
             hash_func = g_str_hash;
             equal_func = g_str_equal;
-            key_destroy_func = g_free;
+            key_destroy_func = free;
         }
         else {
             // All other pointer type are a straight pointer comparison
@@ -874,17 +874,17 @@ scm_to_c_ghashtable(S2C_ARG_DECL)
         else if (type == G_TYPE_INT || type == G_TYPE_UINT || type == G_TYPE_INT64 ||
                  type == G_TYPE_UINT64) {
             val_type = GIG_HASH_INT64;
-            val_destroy_func = g_free;
+            val_destroy_func = free;
         }
         else if (type == G_TYPE_DOUBLE || type == G_TYPE_FLOAT) {
             val_type = GIG_HASH_REAL;
-            val_destroy_func = g_free;
+            val_destroy_func = free;
         }
     }
     else {
         if (type == G_TYPE_STRING) {
             val_type = GIG_HASH_STRING;
-            val_destroy_func = g_free;
+            val_destroy_func = free;
         }
         else
             val_type = GIG_HASH_POINTER;
@@ -1366,7 +1366,7 @@ c_string_to_scm(C2S_ARG_DECL)
                     *object = scm_from_locale_string(arg->v_string);
             }
             if (meta->transfer == GI_TRANSFER_EVERYTHING) {
-                g_free(arg->v_string);
+                free(arg->v_string);
                 arg->v_string = NULL;
             }
         }
@@ -1600,7 +1600,7 @@ static void
 deep_free(void *x)
 {
     char *p = *(char **)x;
-    g_free(p);
+    free(p);
 }
 
 static void

src/gig_callback.c

@@ -292,7 +292,7 @@ callback_binding_inner(struct callback_binding_args *args)
             }
         }
     }
-    g_free(callback_name);
+    free(callback_name);
     return (void *)1;
 }
 
@@ -530,7 +530,7 @@ gig_callback_to_scm(const char *name, GICallbackInfo *info, gpointer callback)
         return SCM_BOOL_F;
     char *subr_name = g_strdup_printf("c-callback:%s", name);
     SCM subr = scm_c_make_gsubr(subr_name, 0, 0, 1, gcb->callback_ptr);
-    g_free(subr_name);
+    free(subr_name);
     return subr;
 }
 
@@ -678,18 +678,18 @@ callback_free(GigCallback *gcb)
 
     gig_amap_free(gcb->amap);
     g_base_info_unref(gcb->callback_info);
-    g_free(gcb->atypes);
+    free(gcb->atypes);
     gcb->atypes = NULL;
 
     if (gcb->name) {
-        g_free(gcb->name);
+        free(gcb->name);
         gcb->name = NULL;
         // only Scheme callbacks have names and those callbacks need to
         // be GC'd.
         scm_gc_unprotect_object(gcb->s_func);
     }
 
-    g_free(gcb);
+    free(gcb);
 }
 
 static void

src/gig_closure.c

@@ -125,14 +125,14 @@ invoke_closure(SCM closure, SCM return_type, SCM inout_mask, SCM args)
 
     g_value_init(retval, scm_to_gtype(return_type));
     if (G_VALUE_TYPE(retval) == G_TYPE_INVALID) {
-        g_free(retval);
+        free(retval);
         goto out;
     }
 
     for (gsize narg = 0; narg < nargs; narg++, iter = scm_cdr(iter)) {
         const GValue *arg = gig_type_peek_typed_object(scm_car(iter), gig_value_type);
         if (arg == NULL) {
-            g_free(retval);
+            free(retval);
             goto out;
         }
         g_value_init(params + narg, G_VALUE_TYPE(arg));
@@ -179,7 +179,7 @@ invoke_closure(SCM closure, SCM return_type, SCM inout_mask, SCM args)
   out:
     for (gsize narg = 0; narg < nargs; narg++)
         g_value_unset(params + narg);
-    g_free(params);
+    free(params);
     return ret;
 }
 

src/gig_data_type.c

@@ -292,7 +292,7 @@ gig_data_type_free(GigTypeMeta *meta)
     for (gint i = 0; i < meta->n_params; i++)
         gig_data_type_free(&meta->params[i]);
     if (meta->n_params > 0)
-        g_free(meta->params);
+        free(meta->params);
 
     if ((meta->gtype == G_TYPE_POINTER) && (meta->pointer_type == GIG_DATA_CALLBACK) &&
         meta->callable_info)

src/gig_document.c

@@ -128,12 +128,12 @@ do_document(GIBaseInfo *info, const gchar *_namespace)
             if (entry->parent) {
                 gchar *parent = gig_gname_to_scm_name(entry->parent->name);
                 scm_printf(SCM_UNDEFINED, "<inferred parent=\"%s\"/>", parent);
-                g_free(parent);
+                free(parent);
             }
             else {
                 gchar *arg = gig_gname_to_scm_name(entry->name);
                 scm_printf(SCM_UNDEFINED, "<inferred argument=\"%s\"/>", arg);
-                g_free(arg);
+                free(arg);
             }
             scm_printf(SCM_UNDEFINED, "</parameter>");
         }

src/gig_flag.c

@@ -103,7 +103,7 @@ define_conversion(const gchar *fmt, const gchar *name, SCM proc)
 {
     gchar *_sym = g_strdup_printf(fmt, name);
     SCM sym = scm_from_utf8_symbol(_sym);
-    g_free(_sym);
+    free(_sym);
     scm_define(sym, proc);
     return sym;
 }
@@ -202,15 +202,15 @@ gig_define_enum(GIEnumInfo *info, SCM defs)
         scm_hashq_set_x(obarray, key, val);
 
         g_base_info_unref(vi);
-        g_free(_key);
+        free(_key);
         i++;
     }
 
     scm_class_set_x(_class, sym_obarray, obarray);
 
     scm_define(scm_class_name(_class), _class);
     defs = scm_cons(scm_class_name(_class), defs);
-    g_free(_class_name);
+    free(_class_name);
 
     return defs;
 }

src/gig_function.c

@@ -384,7 +384,7 @@ create_gsubr(GIFunctionInfo *function_info, const gchar *name, SCM self_type,
     gfn = xcalloc(1, sizeof(GigFunction));
     gfn->function_info = function_info;
     gfn->amap = amap;
-    g_free(gfn->name);
+    free(gfn->name);
     gfn->name = xstrdup(name);
     g_base_info_ref(function_info);
 
@@ -459,7 +459,7 @@ gig_callable_prepare_invoke(GigArgMap *amap,
 {
     *cinvoke_input_arg_array = g_array_new(FALSE, TRUE, sizeof(GIArgument));
     *cinvoke_output_arg_array = g_array_new(FALSE, TRUE, sizeof(GIArgument));
-    *cinvoke_free_array = g_ptr_array_new_with_free_func(g_free);
+    *cinvoke_free_array = g_ptr_array_new_with_free_func(free);
 
     // Convert the scheme arguments into C.
     object_list_to_c_args(amap, name, args, *cinvoke_input_arg_array,
@@ -892,19 +892,19 @@ gig_init_function(void)
 static void
 function_free(GigFunction *gfn)
 {
-    g_free(gfn->name);
+    free(gfn->name);
     gfn->name = NULL;
 
     ffi_closure_free(gfn->closure);
     gfn->closure = NULL;
 
     g_base_info_unref(gfn->function_info);
-    g_free(gfn->atypes);
+    free(gfn->atypes);
     gfn->atypes = NULL;
 
     gig_amap_free(gfn->amap);
 
-    g_free(gfn);
+    free(gfn);
 }
 
 static void

src/gig_logging.c

@@ -106,7 +106,7 @@ gig_log_writer(GLogLevelFlags flags, const GLogField *fields, gsize n_fields, gp
             scm_c_write(port, ": ", 2);
             scm_c_write(port, message->value, strlen(message->value));
             scm_newline(port);
-            g_free(colored_prefix);
+            free(colored_prefix);
         }
         else
             scm_printf(port, "%s: %s\n", prefix, (const gchar *)message->value);
@@ -181,9 +181,9 @@ gig_log_custom_helper(GLogLevelFlags log_level, const GLogField *fields, gsize n
             it = scm_cddr(it);
             scm_set_car_x(it, scm_from_utf8_keyword(length));
             scm_set_car_x(scm_cdr(it), scm_from_size_t(fields[i].length));
-            g_free(length);
+            free(length);
         }
-        g_free(key);
+        free(key);
     }
     scm_set_cdr_x(scm_cdr(it), SCM_EOL);
     scm_apply_0(SCM_PACK_POINTER(user_data), args);

src/gig_object.c

@@ -412,7 +412,7 @@ signal_lookup(const char *proc, GObject *self,
     gchar *name = scm_to_utf8_string(s_name);
 
     *c_signal = g_signal_lookup(name, G_OBJECT_TYPE(self));
-    g_free(name);
+    free(name);
 
     if (c_signal == 0)
         scm_misc_error(proc, "~A: unknown signal name ~A",
@@ -424,7 +424,7 @@ signal_lookup(const char *proc, GObject *self,
         SCM detail_str = scm_symbol_to_string(detail);
         gchar *_detail = scm_to_utf8_string(detail_str);
         *c_detail = g_quark_from_string(_detail);
-        g_free(_detail);
+        free(_detail);
     }
     else
         *c_detail = 0;
@@ -525,7 +525,7 @@ gig_i_scm_emit(SCM self, SCM signal, SCM s_detail, SCM args)
     }
     for (gsize narg = 0; narg < query_info.n_params + 1; narg++)
         g_value_unset(values + narg);
-    g_free(values);
+    free(values);
     if (scm_is_null(ret))
         return SCM_UNSPECIFIED;
     else

src/gig_repository.c

@@ -379,7 +379,7 @@ prepend_search_path(SCM s_dir)
 
     dir = scm_to_utf8_string(s_dir);
     g_irepository_prepend_search_path(dir);
-    g_free(dir);
+    free(dir);
 
     return SCM_UNSPECIFIED;
 }
@@ -402,10 +402,10 @@ get_dependencies(SCM namespace)
     while (_dependencies[i] != NULL) {
         SCM entry = scm_from_utf8_string(_dependencies[i]);
         dependencies = scm_cons(entry, dependencies);
-        g_free(_dependencies[i]);
+        free(_dependencies[i]);
         i++;
     }
-    g_free(_dependencies);
+    free(_dependencies);
     return scm_reverse_x(dependencies, SCM_EOL);
 }
 

src/gig_signal.c

@@ -66,7 +66,7 @@ scm_signal_accu(GSignalInvocationHint * ihint,
         scm_dynwind_begin(0);
         if (scm_is_true(scm_symbol_p(name))) {
             _name = scm_to_utf8_string(scm_symbol_to_string(name));
-            scm_dynwind_unwind_handler(g_free, _name, SCM_F_WIND_EXPLICITLY);
+            scm_dynwind_unwind_handler(free, _name, SCM_F_WIND_EXPLICITLY);
         }
         scm_misc_error(_name,
                        "callback accumulator returned ~S when 0, 1, or 2 values were expected",
@@ -152,13 +152,13 @@ gig_free_signalspec(GigSignalSpec *spec)
 {
     if (spec) {
         if (spec->param_types) {
-            g_free(spec->param_types);
+            free(spec->param_types);
             spec->param_types = NULL;
         }
-        g_free(spec->signal_name);
+        free(spec->signal_name);
         spec->signal_name = NULL;
     }
-    g_free(spec);
+    free(spec);
 }
 
 SCM