void grg_recent_dox_push (const guchar * file) { GSList *cur, *tmp; if (file == NULL) return; tmp = grg_recent_dox; while (tmp) { cur = tmp; tmp = tmp->next; if (STR_EQ (cur->data, file) || (g_slist_position (grg_recent_dox, cur) >= GRG_RECENT_LIMIT - 1)) { grg_recent_dox = g_slist_remove_link (grg_recent_dox, cur); g_free (cur->data); g_slist_free_1 (cur); } } grg_recent_dox = g_slist_prepend (grg_recent_dox, g_strdup ((guchar *) file)); recent_dox_save (); grg_menu_update (); }
/** * g_slist_remove_all: * @list: a #GSList * @data: data to remove * * Removes all list nodes with data equal to @data. * Returns the new head of the list. Contrast with * g_slist_remove() which removes only the first node * matching the given data. * * Returns: new head of @list */ GSList* g_slist_remove_all (GSList *list, gconstpointer data) { GSList *tmp, *prev = NULL; tmp = list; while (tmp) { if (tmp->data == data) { GSList *next = tmp->next; if (prev) prev->next = next; else list = next; g_slist_free_1 (tmp); tmp = next; } else { prev = tmp; tmp = prev->next; } } return list; }
/* Called by gdk_x11_display_finalize to flush any cached cursors * for a dead display. */ void _gdk_x11_cursor_display_finalize (GdkDisplay *display) { GSList* item; GSList** itemp; /* Pointer to the thing to fix when we delete an item */ item = cursor_cache; itemp = &cursor_cache; while (item) { GdkX11Cursor* cursor = (GdkX11Cursor*)(item->data); if (gdk_cursor_get_display (GDK_CURSOR (cursor)) == display) { GSList* olditem; gdk_cursor_unref ((GdkCursor*) cursor); /* Remove this item from the list */ *(itemp) = item->next; olditem = item; item = g_slist_next (item); g_slist_free_1 (olditem); } else { itemp = &(item->next); item = g_slist_next (item); } } }
/** * gts_bb_tree_point_closest_bboxes: * @tree: a bounding box tree. * @p: a #GtsPoint. * * Returns: a list of #GtsBBox. One of the bounding boxes is assured to contain * the object of @tree closest to @p. */ GSList * gts_bb_tree_point_closest_bboxes (GNode * tree, GtsPoint * p) { gdouble min, min_max; GSList * list = NULL, * i, * prev = NULL; g_return_val_if_fail (tree != NULL, NULL); g_return_val_if_fail (p != NULL, NULL); gts_bbox_point_distance2 (tree->data, p, &min, &min_max); min_max = bb_tree_min_max (tree, p, min_max, &list); i = list; while (i) { GSList * next = i->next; gdouble min, max; gts_bbox_point_distance2 (i->data, p, &min, &max); if (min > min_max) { if (prev == NULL) list = next; else prev->next = next; g_slist_free_1 (i); } else prev = i; i = next; } return list; }
/* remove all command callbacks with a given data pointer */ void sieve_sessions_discard_callbacks(gpointer user_data) { GSList *item; GSList *queue; GSList *prev = NULL; SieveSession *session; SieveCommand *cmd; for (item = sessions; item; item = item->next) { session = (SieveSession *)item->data; cmd = session->current_cmd; /* abort current command handler */ if (cmd && cmd->data == user_data) { command_abort(cmd); session->current_cmd = NULL; } /* abort queued command handlers */ for (queue = session->send_queue; queue; queue = queue->next) { cmd = (SieveCommand *)queue->data; if (cmd && cmd->data == user_data) { if (prev) prev->next = queue->next; else session->send_queue = NULL; command_abort(cmd); g_slist_free_1(queue); } else { prev = queue; } } } }
static size_t gstreamer_read_frames(struct input_handle* ih) { size_t buf_pos = 0; GSList *next; while (ih->current_bytes < BUFFER_SIZE) { GstBuffer *buf = gst_app_sink_pull_buffer(GST_APP_SINK(ih->appsink)); if (!buf) { break; } ih->buffer_list = g_slist_append(ih->buffer_list, buf); ih->current_bytes += buf->size; } while (ih->buffer_list && GST_BUFFER(ih->buffer_list->data)->size + buf_pos <= BUFFER_SIZE) { memcpy((guint8 *) ih->buffer + buf_pos, GST_BUFFER(ih->buffer_list->data)->data, GST_BUFFER(ih->buffer_list->data)->size); buf_pos += GST_BUFFER(ih->buffer_list->data)->size; ih->current_bytes -= GST_BUFFER(ih->buffer_list->data)->size; gst_buffer_unref(GST_BUFFER(ih->buffer_list->data)); next = ih->buffer_list->next; g_slist_free_1(ih->buffer_list); ih->buffer_list = next; } return buf_pos / sizeof(float) / gstreamer_get_channels(ih); }
static void _tarif_clear(gint tarif_id) { GSList **tarif = NULL; GSList *link = NULL; CCL_tarifpart *tp = NULL; GData *freed = NULL; tarif = g_new0(GSList *, 1); *tarif = g_datalist_id_get_data(&ccl->tarifs, tarif_id); g_assert(NULL != tarif); g_datalist_init(&freed); while ((link = g_slist_last(*tarif)) && *tarif) { *tarif = g_slist_remove_link(*tarif, link); tp = (CCL_tarifpart *) link->data; if (!g_datalist_id_get_data(&freed, GPOINTER_TO_INT(tp->prices))) { g_datalist_clear(tp->prices); g_datalist_id_set_data(&freed, GPOINTER_TO_INT(tp->prices), (void *)tp->prices); g_free(tp->prices); } g_slist_free_1(link); g_free(tp); } g_datalist_clear(&freed); *tarif = NULL; g_datalist_id_remove_data(&ccl->tarifs, tarif_id); g_free(tarif); }
GSList* g_slist_remove_all (GSList *list, gconstpointer data) { GSList *next = list; GSList *prev = NULL; GSList *current; while (next) { GSList *tmp_prev = find_prev (next, data); if (tmp_prev) prev = tmp_prev; current = prev ? prev->next : list; if (!current) break; next = current->next; if (prev) prev->next = next; else list = next; g_slist_free_1 (current); } return list; }
/** * g_thread_foreach: * @thread_func: function to call for all #GThread structures * @user_data: second argument to @thread_func * * Call @thread_func on all #GThreads that have been * created with g_thread_create(). * * Note that threads may decide to exit while @thread_func is * running, so without intimate knowledge about the lifetime of * foreign threads, @thread_func shouldn't access the GThread* * pointer passed in as first argument. However, @thread_func will * not be called for threads which are known to have exited already. * * Due to thread lifetime checks, this function has an execution complexity * which is quadratic in the number of existing threads. * * Since: 2.10 * * Deprecated:2.32: There aren't many things you can do with a #GThread, * except comparing it with one that was returned from g_thread_create(). * There are better ways to find out if your thread is still alive. */ void g_thread_foreach (GFunc thread_func, gpointer user_data) { GSList *slist = NULL; GRealThread *thread; g_return_if_fail (thread_func != NULL); /* snapshot the list of threads for iteration */ G_LOCK (g_thread); slist = g_slist_copy (g_thread_all_threads); G_UNLOCK (g_thread); /* walk the list, skipping non-existent threads */ while (slist) { GSList *node = slist; slist = node->next; /* check whether the current thread still exists */ G_LOCK (g_thread); if (g_slist_find (g_thread_all_threads, node->data)) thread = node->data; else thread = NULL; G_UNLOCK (g_thread); if (thread) thread_func (thread, user_data); g_slist_free_1 (node); } }
static void impl_MateComponent_EventSource_removeListener (PortableServer_Servant servant, const MateComponent_Listener listener, CORBA_Environment *ev) { GSList *l, *next; MateComponentEventSourcePrivate *priv; priv = matecomponent_event_source_from_servant (servant)->priv; for (l = priv->listeners; l; l = next) { ListenerDesc *desc = l->data; next = l->next; if (CORBA_Object_is_equivalent (listener, desc->listener, ev)) { priv->listeners = g_slist_remove_link ( priv->listeners, l); g_slist_free_1 (l); desc_free (desc, ev); return; } } CORBA_exception_set (ev, CORBA_USER_EXCEPTION, ex_MateComponent_EventSource_UnknownListener, NULL); }
/** * main: Starts with an RPTable of 10 resources and fetches * them randomly by the ResourceId and compares them against the original * resource. A failed comparison means the test failed, * otherwise the test passed. * * Return value: 0 on success, 1 on failure **/ int main(int argc, char **argv) { RPTable *rptable = (RPTable *)g_malloc0(sizeof(RPTable)); guint i = 0, k = 0; GSList *resources = NULL; for (i = 0; rptentries[i].ResourceId != 0; i++) { if (oh_add_resource(rptable, rptentries + i, NULL, 0)) return 1; else resources = g_slist_append(resources, rptentries + i); } for (; resources; i--) { SaHpiRptEntryT *randentry = NULL, *tmpentry = NULL; GSList *tmpnode = NULL; k = (guint) (((gfloat)i)*rand()/(RAND_MAX+1.0)); tmpnode = g_slist_nth(resources, k); randentry = (SaHpiRptEntryT *)tmpnode->data; tmpentry = oh_get_resource_by_id(rptable, randentry->ResourceId); if (!tmpentry || memcmp(randentry, tmpentry, sizeof(SaHpiRptEntryT))) return 1; else { resources = g_slist_remove_link(resources, tmpnode); g_slist_free_1(tmpnode); } } return 0; }
/* Purge server output, either all or for specified target */ void irc_server_purge_output(IRC_SERVER_REC *server, const char *target) { GSList *tmp, *next, *link; REDIRECT_REC *redirect; char *cmd; if (target != NULL && *target == '\0') target = NULL; for (tmp = server->cmdqueue; tmp != NULL; tmp = next) { next = tmp->next->next; cmd = tmp->data; redirect = tmp->next->data; if ((target == NULL || command_has_target(cmd, target)) && g_ascii_strncasecmp(cmd, "PONG ", 5) != 0) { /* remove the redirection */ link = tmp->next; server->cmdqueue = g_slist_remove_link(server->cmdqueue, link); g_slist_free_1(link); if (redirect != NULL) server_redirect_destroy(redirect); /* remove the command */ server->cmdqueue = g_slist_remove(server->cmdqueue, cmd); g_free(cmd); server->cmdcount--; } } }
static void remove_selected_layout (GtkWidget * button, GtkBuilder * dialog) { gint idx = find_selected_layout_idx (dialog); if (idx != -1) { GSList *layouts_list = xkb_layouts_get_selected_list (); char *id = NULL; GSList *node2Remove = g_slist_nth (layouts_list, idx); layouts_list = g_slist_remove_link (layouts_list, node2Remove); id = (char *) node2Remove->data; g_slist_free_1 (node2Remove); g_free (id); if (default_group > idx) xkb_save_default_group (default_group - 1); else if (default_group == idx) xkb_save_default_group (-1); xkb_layouts_set_selected_list (layouts_list); clear_xkb_elements_list (layouts_list); } }
/** * Deliver all the signals queued so far for the task. */ static void bg_task_deliver_signals(struct bgtask *bt) { bg_task_check(bt); g_assert(bt->flags & TASK_F_RUNNING); /* * Stop when list is empty or task has exited. * * Note that it is possible for a task to enqueue another signal * whilst it is processing another. */ while (bt->signals != NULL) { GSList *lnk = bt->signals; bgsig_t sig = (bgsig_t) GPOINTER_TO_UINT(lnk->data); /* * If signal kills the thread (it calls bg_task_exit() from the * handler), then we won't come back. */ bg_task_kill(bt, sig); bt->signals = g_slist_remove_link(bt->signals, lnk); g_slist_free_1(lnk); } }
static void message_cancelled (NaTrayManager *manager, GtkWidget *icon, glong id, TraysScreen *trays_screen) { IconTip *icontip; IconTipBuffer find_buffer; GSList *cancel_buffer_l; IconTipBuffer *cancel_buffer; icontip = g_hash_table_lookup (trays_screen->tip_table, icon); if (icontip == NULL) return; if (icontip->id == id) { icon_tip_show_next (icontip); return; } find_buffer.id = id; cancel_buffer_l = g_slist_find_custom (icontip->buffer, &find_buffer, icon_tip_buffer_compare); if (cancel_buffer_l == NULL) return; cancel_buffer = cancel_buffer_l->data; icon_tip_buffer_free (cancel_buffer, NULL); icontip->buffer = g_slist_remove_link (icontip->buffer, cancel_buffer_l); g_slist_free_1 (cancel_buffer_l); }
static void cb_pm_button_directory_delete_clicked (PluginManagerGUI *pm_gui) { GtkTreeIter iter; char *dir_name = NULL; gboolean is_system = TRUE; GSList *extra_dirs, *res; if (!gtk_tree_selection_get_selected (pm_gui->selection_directory, NULL, &iter)) return; gtk_tree_model_get (GTK_TREE_MODEL (pm_gui->model_directories), &iter, DIR_NAME, &dir_name, DIR_IS_SYSTEM, &is_system, -1); extra_dirs = go_string_slist_copy (gnm_conf_get_plugins_extra_dirs ()); res = is_system ? NULL : g_slist_find_custom (extra_dirs, dir_name, go_str_compare); if (res) { extra_dirs = g_slist_remove_link (extra_dirs, res); g_free (res->data); g_slist_free_1 (res); gnm_conf_set_plugins_extra_dirs (extra_dirs); pm_gui_load_directory_page (pm_gui); cb_pm_button_rescan_directories_clicked (pm_gui); } g_slist_free_full (extra_dirs, g_free); g_free (dir_name); }
static void cb_find_entry (GtkMenuItem *w, struct cb_find_entry *cl) { GtkWidget *sub; if (cl->found) return; sub = gtk_menu_item_get_submenu (w); if (sub) { GSList *tmp = cl->path = g_slist_prepend (cl->path, GINT_TO_POINTER (cl->i)); cl->i = 0; gtk_container_foreach (GTK_CONTAINER (sub), (GtkCallback)cb_find_entry, cl); if (cl->found) return; cl->i = GPOINTER_TO_INT (cl->path->data); cl->path = cl->path->next; g_slist_free_1 (tmp); } else { const char *this_locale = g_object_get_data (G_OBJECT (w), LOCALE_NAME_KEY); if (this_locale && strcmp (this_locale, cl->locale) == 0) { cl->found = TRUE; cl->path = g_slist_prepend (cl->path, GINT_TO_POINTER (cl->i)); cl->path = g_slist_reverse (cl->path); return; } } cl->i++; }
static gint sieve_pop_send_queue(SieveSession *session) { SieveCommand *cmd; GSList *send_queue = session->send_queue; if (session->current_cmd) { command_free(session->current_cmd); session->current_cmd = NULL; } if (!send_queue) return SE_OK; cmd = (SieveCommand *)send_queue->data; session->send_queue = g_slist_next(send_queue); g_slist_free_1(send_queue); log_send(session, cmd); session->state = cmd->next_state; session->current_cmd = cmd; if (session_send_msg(SESSION(session), SESSION_SEND, cmd->msg) < 0) return SE_ERROR; return SE_OK; }
GSList * gnm_slist_sort_merge (GSList *l1, GSList *l2) { GSList list, *l; l = &list; while (l1 && l2) { if (GPOINTER_TO_UINT (l1->data) <= GPOINTER_TO_UINT (l2->data)) { if (GPOINTER_TO_UINT (l1->data) == GPOINTER_TO_UINT (l2->data)) { /* remove duplicates */ GSList *m = l2; l2 = l2->next; m->next = NULL; g_slist_free_1 (m); } l = l->next = l1; l1 = l1->next; } else { l = l->next = l2; l2 = l2->next; } } l->next = l1 ? l1 : l2; return list.next; }
GSList* g_slist_delete_link (GSList *list, GSList *link) { list = g_slist_remove_link (list, link); g_slist_free_1 (link); return list; }
static size_t ffmpeg_read_frames(struct input_handle* ih) { size_t buf_pos = 0, nr_frames_read; GSList *next; struct buffer_list_node *buf_node; size_t frames_return; if (ih->mp3_stop) return 0; while (ih->current_bytes < BUFFER_SIZE * 2) { nr_frames_read = ffmpeg_read_one_packet(ih); if (!nr_frames_read) { break; } buf_node = g_new(struct buffer_list_node, 1); buf_node->size = nr_frames_read * ffmpeg_get_channels(ih) * sizeof(float); buf_node->data = g_memdup(ih->buffer, (guint) buf_node->size); ih->buffer_list = g_slist_append(ih->buffer_list, buf_node); ih->current_bytes += buf_node->size; } while (ih->buffer_list && ((struct buffer_list_node *) ih->buffer_list->data)->size + buf_pos <= BUFFER_SIZE) { memcpy((guint8 *) ih->buffer + buf_pos, ((struct buffer_list_node *) ih->buffer_list->data)->data, ((struct buffer_list_node *) ih->buffer_list->data)->size); buf_pos += ((struct buffer_list_node *) ih->buffer_list->data)->size; ih->current_bytes -= ((struct buffer_list_node *) ih->buffer_list->data)->size; g_free(((struct buffer_list_node *) ih->buffer_list->data)->data); next = ih->buffer_list->next; g_slist_free_1(ih->buffer_list); ih->buffer_list = next; } frames_return = buf_pos / sizeof(float) / ffmpeg_get_channels(ih); if (frames_return == 0) return 0; if (ih->codec_context->codec_id == CODEC_ID_MP3 || ih->codec_context->codec_id == CODEC_ID_AAC) { if (!ih->mp3_has_skipped_beginning) { memmove(ih->buffer, ih->buffer + ih->mp3_padding_start * ffmpeg_get_channels(ih), buf_pos - ih->mp3_padding_start * sizeof(float) * ffmpeg_get_channels(ih)); frames_return -= ih->mp3_padding_start; ih->mp3_has_skipped_beginning = 1; } if (!ih->buffer_list) { frames_return -= ih->mp3_padding_end; } else if (ih->mp3_padding_end > ih->current_bytes / sizeof(float) / ffmpeg_get_channels(ih)) { frames_return -= ih->mp3_padding_end - ih->current_bytes / sizeof(float) / ffmpeg_get_channels(ih); ih->mp3_stop = 1; } } return frames_return; }
void g_slist_free (GSList *list) { while (list) { GSList *next = list->next; g_slist_free_1 (list); list = next; } }
static void reflow_columns (EReflow *reflow) { GSList *list; int count; int start; int i; int column_count, column_start; double running_height; if (reflow->reflow_from_column <= 1) { start = 0; column_count = 1; column_start = 0; } else { /* we start one column before the earliest new entry, so we can handle the case where the new entry is inserted at the start of the column */ column_start = reflow->reflow_from_column - 1; start = reflow->columns[column_start]; column_count = column_start + 1; } list = NULL; running_height = E_REFLOW_BORDER_WIDTH; count = reflow->count - start; for (i = start; i < count; i++) { int unsorted = e_sorter_sorted_to_model (E_SORTER (reflow->sorter), i); if (i != 0 && running_height + reflow->heights[unsorted] + E_REFLOW_BORDER_WIDTH > reflow->height) { list = g_slist_prepend (list, GINT_TO_POINTER(i)); column_count ++; running_height = E_REFLOW_BORDER_WIDTH * 2 + reflow->heights[unsorted]; } else running_height += reflow->heights[unsorted] + E_REFLOW_BORDER_WIDTH; } reflow->column_count = column_count; reflow->columns = g_renew (int, reflow->columns, column_count); column_count --; for (; column_count > column_start; column_count--) { GSList *to_free; reflow->columns[column_count] = GPOINTER_TO_INT(list->data); to_free = list; list = list->next; g_slist_free_1 (to_free); } reflow->columns[column_start] = start; queue_incarnate (reflow); reflow->need_reflow_columns = FALSE; reflow->reflow_from_column = -1; }
GIOPSendBuffer * giop_send_buffer_use (GIOPVersion giop_version) { GIOPSendBuffer *buf; g_return_val_if_fail ( ((int) giop_version) >= 0 && giop_version < GIOP_NUM_VERSIONS, NULL); LINK_MUTEX_LOCK (send_buffer_list_lock); if (send_buffer_list) { GSList *ltmp; ltmp = send_buffer_list; send_buffer_list = g_slist_remove_link ( send_buffer_list, ltmp); LINK_MUTEX_UNLOCK (send_buffer_list_lock); buf = ltmp->data; g_slist_free_1 (ltmp); buf->num_used = buf->indirect_left = 0; if (giop_blank_wire_data) { int i; for (i = 0; i < buf->num_indirects_used; i++) memset (buf->indirects [i].ptr, 0, buf->indirects [i].size); } buf->num_indirects_used = 0; } else { LINK_MUTEX_UNLOCK (send_buffer_list_lock); buf = g_new0 (GIOPSendBuffer, 1); memcpy (buf->msg.header.magic, "GIOP", 4); buf->msg.header.flags = GIOP_FLAG_ENDIANNESS; buf->num_alloced = 8; buf->iovecs = g_new (struct iovec, 8); } memcpy (buf->msg.header.version, giop_version_ids [giop_version], 2); buf->giop_version = giop_version; g_assert (sizeof (buf->msg.header) == 12); giop_send_buffer_append_real ( buf, (guchar *)&buf->msg.header, 12); buf->msg.header.message_size = 0; buf->header_size = 12; return buf; }
void uri_scope_pop_uri(UriScope *u) { if (!u->uri_stack) return; GSList *head = u->uri_stack; _free_uri(head->data); u->uri_stack = g_slist_next(u->uri_stack); g_slist_free_1(head); }
const IE_MimeConfidence * IE_ImpGraphicGdkPixbuf_Sniffer::getMimeConfidence () { static IE_MimeConfidence *mimeConfidence = NULL; if (mimeConfidence) { return mimeConfidence; } GSList *formatList = gdk_pixbuf_get_formats (); GSList *formatIter; GdkPixbufFormat *format; gsize idx; std::vector<std::string> all_mime_types; // dry run to count entries formatIter = formatList; while (formatIter) { gchar **mime_types; format = (GdkPixbufFormat *) formatIter->data; mime_types = gdk_pixbuf_format_get_mime_types (format); gchar **tmp = mime_types; while (*tmp) { all_mime_types.push_back(*tmp); tmp++; } g_strfreev(mime_types); GSList *node; node = formatIter; formatIter = formatIter->next; g_slist_free_1(node); } mimeConfidence = new IE_MimeConfidence[all_mime_types.size() + 1]; idx = 0; for(std::vector<std::string>::iterator iter = all_mime_types.begin(); iter != all_mime_types.end(); ++iter) { mimeConfidence[idx].match = IE_MIME_MATCH_FULL; mimeConfidence[idx].mimetype = *iter; if(*iter == "image/x-wmf") { UT_DEBUGMSG(("WMF mime is only good\n")); mimeConfidence[idx].confidence = UT_CONFIDENCE_GOOD; } else { mimeConfidence[idx].confidence = UT_CONFIDENCE_PERFECT; } idx++; } // null-terminator mimeConfidence[idx].match = IE_MIME_MATCH_BOGUS; mimeConfidence[idx].confidence = UT_CONFIDENCE_ZILCH; return mimeConfidence; }
void clear_xkb_elements_list (GSList * list) { while (list != NULL) { GSList *p = list; list = list->next; g_free (p->data); g_slist_free_1 (p); } }
/*! * Get the null terminated array of recognized suffixes. */ static const SuffixInfo * s_getSuffixInfo (void) { static SuffixInfo suffixInfo = { NULL, 0 }; static gboolean isInitialized = FALSE; if (isInitialized) { return &suffixInfo; } GSList *formatList = gdk_pixbuf_get_formats (); GSList *formatIter; GSList *tmp; GdkPixbufFormat *format; gchar **extensions; gchar **extensionsIter; gsize idx; // dry run to count entries formatIter = formatList; while (formatIter) { format = (GdkPixbufFormat *) formatIter->data; extensionsIter = extensions = gdk_pixbuf_format_get_extensions (format); while (*extensionsIter) { suffixInfo.count++; extensionsIter++; } g_strfreev(extensions); formatIter = formatIter->next; } suffixInfo.suffixes = (const gchar **) new gchar*[suffixInfo.count + 1]; // build list formatIter = formatList; idx = 0; while (formatIter) { format = (GdkPixbufFormat *) formatIter->data; extensionsIter = extensions = gdk_pixbuf_format_get_extensions (format); while (*extensionsIter) { suffixInfo.suffixes[idx] = g_strdup(*extensionsIter); idx++; extensionsIter++; } g_strfreev(extensions); tmp = formatIter; formatIter = formatIter->next; g_slist_free_1 (tmp); } // null-terminator suffixInfo.suffixes[idx] = NULL; isInitialized = TRUE; return &suffixInfo; }
static PyObject* replace(PygtsVertex *self, PyObject *args) { PyObject *p2_; PygtsVertex *p2; GSList *parents=NULL, *i, *cur; SELF_CHECK /* Parse the args */ if(! PyArg_ParseTuple(args, "O", &p2_) ) { return NULL; } /* Convert to PygtsObjects */ if(!pygts_vertex_check(p2_)) { PyErr_SetString(PyExc_TypeError,"expected a Vertex"); return NULL; } p2 = PYGTS_VERTEX(p2_); if( self != p2 ) { /* (Ignore self-replacement) */ /* Detach and save any parent segments */ i = PYGTS_VERTEX_AS_GTS_VERTEX(self)->segments; while(i!=NULL) { cur = i; i = g_slist_next(i); if(PYGTS_IS_PARENT_SEGMENT(cur->data)) { PYGTS_VERTEX_AS_GTS_VERTEX(self)->segments = g_slist_remove_link(PYGTS_VERTEX_AS_GTS_VERTEX(self)->segments, cur); parents = g_slist_prepend(parents,cur->data); g_slist_free_1(cur); } } /* Perform the replace operation */ gts_vertex_replace(PYGTS_VERTEX_AS_GTS_VERTEX(self), PYGTS_VERTEX_AS_GTS_VERTEX(p2)); /* Reattach the parent segments */ i = parents; while(i!=NULL) { PYGTS_VERTEX_AS_GTS_VERTEX(self)->segments = g_slist_prepend(PYGTS_VERTEX_AS_GTS_VERTEX(self)->segments,i->data); i = g_slist_next(i); } g_slist_free(parents); } Py_INCREF(Py_None); return Py_None; }
GSList* sixtp_pop_and_destroy_frame (GSList* frame_stack) { sixtp_stack_frame* dead_frame = (sixtp_stack_frame*) frame_stack->data; GSList* result; result = g_slist_next (frame_stack); sixtp_stack_frame_destroy (dead_frame); g_slist_free_1 (frame_stack); return (result); }