/** * soup_message_body_truncate: * @body: a #SoupMessageBody * * Deletes all of the data in @body. **/ void soup_message_body_truncate (SoupMessageBody *body) { SoupMessageBodyPrivate *priv = (SoupMessageBodyPrivate *)body; g_slist_free_full (priv->chunks, (GDestroyNotify)soup_buffer_free); priv->chunks = priv->last = NULL; priv->base_offset = 0; if (priv->flattened) { soup_buffer_free (priv->flattened); priv->flattened = NULL; body->data = NULL; } body->length = 0; }
static void media_endpoint_destroy(struct media_endpoint *endpoint) { DBG("sender=%s path=%s", endpoint->sender, endpoint->path); media_endpoint_cancel_all(endpoint); g_slist_free_full(endpoint->transports, (GDestroyNotify) media_transport_destroy); g_dbus_remove_watch(btd_get_dbus_connection(), endpoint->watch); g_free(endpoint->capabilities); g_free(endpoint->sender); g_free(endpoint->path); g_free(endpoint->uuid); g_free(endpoint); }
static void deviceinfo_free(gpointer user_data) { struct deviceinfo *d = user_data; if (d->attioid > 0) btd_device_remove_attio_callback(d->dev, d->attioid); if (d->attrib != NULL) g_attrib_unref(d->attrib); g_slist_free_full(d->chars, g_free); btd_device_unref(d->dev); g_free(d->svc_range); g_free(d); }
static void kms_sdp_media_handler_finalize (GObject * object) { KmsSdpMediaHandler *self = KMS_SDP_MEDIA_HANDLER (object); GST_DEBUG_OBJECT (self, "finalize"); g_free (self->priv->proto); g_free (self->priv->addr); g_free (self->priv->addr_type); g_array_free (self->priv->bwtypes, TRUE); g_slist_free_full (self->priv->extensions, g_object_unref); G_OBJECT_CLASS (parent_class)->finalize (object); }
/* Must be called with the agent lock released as it could dispose of * NiceIOStreams. */ static void nice_stream_finalize (GObject *obj) { NiceStream *stream; stream = NICE_STREAM (obj); g_free (stream->name); g_slist_free_full (stream->components, (GDestroyNotify) g_object_unref); g_atomic_int_inc (&n_streams_destroyed); nice_debug ("Destroyed NiceStream (%u created, %u destroyed)", n_streams_created, n_streams_destroyed); G_OBJECT_CLASS (nice_stream_parent_class)->finalize (obj); }
static void gtk_css_animated_style_dispose (GObject *object) { GtkCssAnimatedStyle *style = GTK_CSS_ANIMATED_STYLE (object); if (style->animated_values) { g_ptr_array_unref (style->animated_values); style->animated_values = NULL; } g_slist_free_full (style->animations, g_object_unref); style->animations = NULL; G_OBJECT_CLASS (gtk_css_animated_style_parent_class)->dispose (object); }
void test_file_in_directory_to_gslist() { GSList *list = file_in_directory_to_gslist("./tests", "lines"); GSList *list_iterator; gchar *data = (gchar*) list->data; g_assert_cmpstr(data, ==, "foo"); list_iterator = list->next; data = (gchar*) list_iterator->data; g_assert_cmpstr(data, ==, "bar"); list_iterator = list_iterator->next; data = (gchar*) list_iterator->data; g_assert_cmpstr(data, ==, "foo2"); list_iterator = list_iterator->next; g_assert_null(list_iterator); g_slist_free_full(list, g_free); }
static void hev_scgi_task_dispatcher_finalize(GObject * obj) { HevSCGITaskDispatcher * self = HEV_SCGI_TASK_DISPATCHER_CAST(obj); HevSCGITaskDispatcherPrivate * priv = HEV_SCGI_TASK_DISPATCHER_GET_PRIVATE(self); g_debug("%s:%d[%s]", __FILE__, __LINE__, __FUNCTION__); if(priv->handler_slist) { g_slist_free_full(priv->handler_slist, g_object_unref); priv->handler_slist = NULL; } G_OBJECT_CLASS(hev_scgi_task_dispatcher_parent_class)->finalize(obj); }
void cons_show_received_subs(void) { GSList *received = presence_get_subscription_requests(); if (received == NULL) { cons_show("No outstanding subscription requests."); } else { cons_show("Outstanding subscription requests from:", g_slist_length(received)); while (received != NULL) { cons_show(" %s", received->data); received = g_slist_next(received); } g_slist_free_full(received, g_free); } }
static void start_ra(int ifindex, GSList *prefix) { if (prefixes) g_slist_free_full(prefixes, g_free); prefixes = g_dhcpv6_copy_prefixes(prefix); enable_ipv6_forward(true); if (timer_ra > 0) g_source_remove(timer_ra); send_ra(NULL); timer_ra = g_timeout_add_seconds(DEFAULT_RA_INTERVAL, send_ra, NULL); }
void dt_control_cleanup(dt_control_t *s) { // vacuum TODO: optional? // DT_DEBUG_SQLITE3_EXEC(dt_database_get(darktable.db), "PRAGMA incremental_vacuum(0)", NULL, NULL, NULL); // DT_DEBUG_SQLITE3_EXEC(dt_database_get(darktable.db), "vacuum", NULL, NULL, NULL); dt_pthread_mutex_destroy(&s->queue_mutex); dt_pthread_mutex_destroy(&s->cond_mutex); dt_pthread_mutex_destroy(&s->log_mutex); dt_pthread_mutex_destroy(&s->run_mutex); dt_pthread_mutex_destroy(&s->progress_system.mutex); pthread_rwlock_destroy(&s->xprofile_lock); if(s->accelerator_list) { g_slist_free_full(s->accelerator_list, g_free); } }
static void deviceinfo_driver_remove(struct btd_service *service) { struct deviceinfo *d = btd_service_get_user_data(service); if (d->attioid > 0) btd_device_remove_attio_callback(d->dev, d->attioid); if (d->attrib != NULL) g_attrib_unref(d->attrib); g_slist_free_full(d->chars, g_free); btd_device_unref(d->dev); g_free(d->svc_range); g_free(d); }
static void stop_ra(int ifindex) { __connman_inet_ipv6_send_ra(ifindex, NULL, prefixes, 0); if (timer_ra > 0) { g_source_remove(timer_ra); timer_ra = 0; } enable_ipv6_forward(false); if (prefixes) { g_slist_free_full(prefixes, g_free); prefixes = NULL; } }
void rm_buffer_pool_destroy(RmBufferPool *pool) { rm_log_debug_line("had %" G_GSIZE_FORMAT " unused read buffers", pool->min_kept_buffers); /* Wait for all buffers to come back */ g_mutex_lock(&pool->lock); { /* Free 'em */ g_slist_free_full(pool->stack, (GDestroyNotify)rm_buffer_free); } g_mutex_unlock(&pool->lock); g_mutex_clear(&pool->lock); g_cond_clear(&pool->change); g_slice_free(RmBufferPool, pool); }
void audio_service_free(struct audio_service *service) { LSError error; LSErrorInit(&error); if (service->handle != NULL && LSUnregister(service->handle, &error) < 0) { g_warning("Could not unregister service: %s", error.message); LSErrorFree(&error); } g_slist_free_full(sample_list, g_free); g_free(service->default_sink_name); g_free(service); }
static void write_chunks_to_output_stream (GioDownload *download) { if (download->priv->chunks == NULL) return; GError *error = NULL; download->priv->chunks = g_slist_reverse (download->priv->chunks); /* Important */ MemChunk *chunk = flatten_mem_chunks (download->priv->chunks); g_output_stream_write (G_OUTPUT_STREAM (download->priv->output), chunk->data, chunk->size, NULL, &error); handle_critical_error (error); g_slist_free_full (download->priv->chunks, (GDestroyNotify)mem_chunk_free); download->priv->chunks = NULL; mem_chunk_free (chunk); }
int main(int argc, char **argv) { setlocale(LC_ALL, ""); g_test_init(&argc, &argv, NULL); GSList *slist = NULL; std::vector<bool> reverse; reverse.push_back(false); reverse.push_back(true); for(std::vector<bool>::iterator it_reverse = reverse.begin(); it_reverse != reverse.end(); ++it_reverse) { std::vector<float> scale; scale.push_back(0.75f); scale.push_back(1.25f); for(std::vector<float>::iterator it_scale = scale.begin(); it_scale != scale.end(); ++it_scale) { std::vector<size_t> align; align.push_back(0); align.push_back(4 * sizeof(float)); // SSE //align.push_back(8 * sizeof(float)); // AVX //align.push_back(16 * sizeof(float)); // AVX512 for(std::vector<size_t>::iterator it_align = align.begin(); it_align != align.end(); ++it_align) { lfTestParams *p = (lfTestParams *)g_malloc(sizeof(lfTestParams)); p->reverse = *it_reverse; p->scale = *it_scale; p->alignment = *it_align; add_set_item(p); slist = g_slist_append(slist, p); } } } const int res = g_test_run(); g_slist_free_full(slist, (GDestroyNotify)g_free); return res; }
static void test_trie_multi_replace(void) { PurpleTrie *trie1, *trie2, *trie3; GSList *tries = NULL; const gchar *in; gchar *out; trie1 = purple_trie_new(); trie2 = purple_trie_new(); trie3 = purple_trie_new(); /* appending is not efficient, but we have only 3 elements */ tries = g_slist_append(tries, trie1); tries = g_slist_append(tries, trie2); tries = g_slist_append(tries, trie3); purple_trie_add(trie1, "test", (gpointer)0x5011); purple_trie_add(trie1, "trie1", (gpointer)0x5012); purple_trie_add(trie1, "Alice", (gpointer)0x5013); purple_trie_add(trie2, "test", (gpointer)0x5021); purple_trie_add(trie2, "trie2", (gpointer)0x5022); purple_trie_add(trie2, "example", (gpointer)0x5023); purple_trie_add(trie2, "Ali", (gpointer)0x5024); /* "tester" without last (accepting) letter of "test" */ purple_trie_add(trie3, "teser", (gpointer)0x5031); purple_trie_add(trie3, "trie3", (gpointer)0x5032); purple_trie_add(trie3, "tester", (gpointer)0x5033); purple_trie_add(trie3, "example", (gpointer)0x5034); purple_trie_add(trie3, "Al", (gpointer)0x5035); in = "test tester trie trie1 trie2 trie3 example Alice"; out = purple_trie_multi_replace(tries, in, test_trie_replace_cb, (gpointer)5); g_assert_cmpstr( "[5:5011] [5:5011]er trie [5:5012] [5:5022] " "[5:5032] [5:5023] [5:5035]ice", ==, out ); g_slist_free_full(tries, g_object_unref); g_free(out); }
static GtkWidget * csv_get_preview (EImport *ei, EImportTarget *target, EImportImporter *im) { GtkWidget *preview; GSList *contacts = NULL; EContact *contact; EImportTargetURI *s = (EImportTargetURI *) target; gchar *filename; FILE *file; CSVImporter *gci; filename = g_filename_from_uri (s->uri_src, NULL, NULL); if (filename == NULL) { g_message (G_STRLOC ": Couldn't get filename from URI '%s'", s->uri_src); return NULL; } file = g_fopen (filename, "r"); g_free (filename); if (file == NULL) { g_message (G_STRLOC ": Can't open .csv file"); return NULL; } gci = g_malloc0 (sizeof (*gci)); gci->file = file; gci->fields_map = NULL; gci->count = 0; fseek (file, 0, SEEK_END); gci->size = ftell (file); fseek (file, 0, SEEK_SET); while (contact = getNextCSVEntry (gci, gci->file), contact != NULL) { contacts = g_slist_prepend (contacts, contact); } contacts = g_slist_reverse (contacts); preview = evolution_contact_importer_get_preview_widget (contacts); g_slist_free_full (contacts, (GDestroyNotify) g_object_unref); fclose (file); g_free (gci); return preview; }
static void server_free(struct network_server *ns) { if (!ns) return; /* FIXME: Missing release/free all bnepX interfaces */ if (ns->record_id) remove_record_from_server(ns->record_id); g_free(ns->iface); g_free(ns->name); g_free(ns->bridge); g_slist_free_full(ns->sessions, session_free); g_free(ns); }
static void server_remove_sessions(struct network_server *ns) { GSList *list; for (list = ns->sessions; list; list = list->next) { struct network_session *session = list->data; if (*session->dev == '\0') continue; bnep_server_delete(ns->bridge, session->dev, &session->dst); } g_slist_free_full(ns->sessions, session_free); ns->sessions = NULL; }
int main(int argc, char *argv[]) { GOptionContext *context; GError *err = NULL; struct sigaction sa; guint server_id; context = g_option_context_new(NULL); g_option_context_add_main_entries(context, options, NULL); g_option_context_parse(context, &argc, &argv, &err); if (err != NULL) { g_printerr("%s\n", err->message); g_error_free(err); exit(EXIT_FAILURE); } if (option_root && chdir(option_root) < 0) { perror("chdir:"); exit(EXIT_FAILURE); } if (option_bluetooth) server_id = bluetooth_listen(); else server_id = unix_listen(); if (server_id == 0) exit(EXIT_FAILURE); memset(&sa, 0, sizeof(sa)); sa.sa_handler = sig_term; sigaction(SIGINT, &sa, NULL); sigaction(SIGTERM, &sa, NULL); main_loop = g_main_loop_new(NULL, FALSE); g_main_loop_run(main_loop); g_source_remove(server_id); g_slist_free_full(clients, (GDestroyNotify) g_obex_unref); g_option_context_free(context); g_main_loop_unref(main_loop); exit(EXIT_SUCCESS); }
static void gtk_file_chooser_native_finalize (GObject *object) { GtkFileChooserNative *self = GTK_FILE_CHOOSER_NATIVE (object); g_clear_pointer (&self->current_name, g_free); g_clear_object (&self->current_file); g_clear_object (&self->current_folder); g_clear_pointer (&self->accept_label, g_free); g_clear_pointer (&self->cancel_label, g_free); gtk_widget_destroy (self->dialog); g_slist_free_full (self->custom_files, g_object_unref); G_OBJECT_CLASS (gtk_file_chooser_native_parent_class)->finalize (object); }
static void cleanup(void) { if (timer_uplink != 0) { g_source_remove(timer_uplink); timer_uplink = 0; } if (timer_hash) { g_hash_table_destroy(timer_hash); timer_hash = NULL; } if (prefixes) { g_slist_free_full(prefixes, g_free); prefixes = NULL; } }
static void test_trie_multi_find(void) { PurpleTrie *trie1, *trie2, *trie3; GSList *tries = NULL; const gchar *in; int out; trie1 = purple_trie_new(); trie2 = purple_trie_new(); trie3 = purple_trie_new(); purple_trie_set_reset_on_match(trie1, FALSE); purple_trie_set_reset_on_match(trie2, TRUE); purple_trie_set_reset_on_match(trie3, FALSE); /* appending is not efficient, but we have only 3 elements */ tries = g_slist_append(tries, trie1); tries = g_slist_append(tries, trie2); tries = g_slist_append(tries, trie3); purple_trie_add(trie1, "test", (gpointer)0x10011); purple_trie_add(trie1, "trie1", (gpointer)0x10012); purple_trie_add(trie1, "Alice", (gpointer)0x10013); purple_trie_add(trie2, "test", (gpointer)0x10021); purple_trie_add(trie2, "trie2", (gpointer)0x10022); purple_trie_add(trie2, "example", (gpointer)0x10023); purple_trie_add(trie2, "Ali", (gpointer)0x10024); /* "tester" without last (accepting) letter of "test" */ purple_trie_add(trie3, "teser", (gpointer)0x10031); purple_trie_add(trie3, "trie3", (gpointer)0x10032); purple_trie_add(trie3, "tester", (gpointer)0x10033); purple_trie_add(trie3, "example", (gpointer)0x10034); purple_trie_add(trie3, "Al", (gpointer)0x10035); in = "test tester trie trie1 trie2 trie3 example Alice"; out = purple_trie_multi_find(tries, in, test_trie_find_cb, (gpointer)0x10); g_assert_cmpint(9, ==, out); g_assert_cmpint(2 * 0x11 + 0x33 + 0x12 + 0x22 + 0x32 + 0x23 + 0x35 + 0x13, ==, find_sum); g_slist_free_full(tries, g_object_unref); }
static void kms_sdp_group_manager_finalize (GObject * object) { KmsSdpGroupManager *self = KMS_SDP_GROUP_MANAGER (object); GST_DEBUG_OBJECT (self, "finalize"); g_hash_table_foreach (self->priv->connected_signals, disconnect_pending_signals, NULL); g_hash_table_unref (self->priv->connected_signals); g_hash_table_unref (self->priv->mids); g_hash_table_unref (self->priv->groups); g_hash_table_unref (self->priv->handlers); g_slist_free_full (self->priv->used_mids, g_free); G_OBJECT_CLASS (parent_class)->finalize (object); }
/** * Shutdown libsigrokdecode. * * This frees all the memory allocated for protocol decoders and shuts down * the Python interpreter. * * This function should only be called if there was a (successful!) invocation * of srd_init() before. Calling this function multiple times in a row, without * any successful srd_init() calls in between, is not allowed. * * @return SRD_OK upon success, a (negative) error code otherwise. * * @since 0.1.0 */ SRD_API int srd_exit(void) { srd_dbg("Exiting libsigrokdecode."); g_slist_foreach(sessions, (GFunc)srd_session_destroy, NULL); srd_decoder_unload_all(); g_slist_free_full(searchpaths, g_free); searchpaths = NULL; /* Py_Finalize() returns void, any finalization errors are ignored. */ Py_Finalize(); max_session_id = -1; return SRD_OK; }
static void kms_webrtc_data_session_bin_finalize (GObject * object) { KmsWebRtcDataSessionBin *self = KMS_WEBRTC_DATA_SESSION_BIN (object); GST_DEBUG_OBJECT (self, "finalize"); g_rec_mutex_clear (&self->priv->mutex); g_hash_table_unref (self->priv->channels); g_hash_table_unref (self->priv->data_channels); g_slist_free_full (self->priv->pending, g_object_unref); g_thread_pool_free (self->priv->pool, FALSE, FALSE); /* chain up */ G_OBJECT_CLASS (parent_class)->finalize (object); }
static void timeserver_stop(void) { DBG(" "); if (resolv) { g_resolv_unref(resolv); resolv = NULL; } g_slist_free_full(ts_list, g_free); ts_list = NULL; __connman_ntp_stop(); ts_recheck_disable(); }
static void _caps_destroy(Capabilities *caps) { if (caps != NULL) { free(caps->category); free(caps->type); free(caps->name); free(caps->software); free(caps->software_version); free(caps->os); free(caps->os_version); if (caps->features != NULL) { g_slist_free_full(caps->features, free); } free(caps); } }