/** * Checks if the supplied path is a known directory. * * The path argument is fully qualified, so it should start with a '/'. * * Returns 1 if the path is a directory, or 0 if not. */ static int isDirectory(const char *path) { if ((path == NULL) || (path[0] != '/')) { return 0; } // Eliminate the starting '/' path++; // Checking for the '/' directory if (path[0] == '\0') { return 1; } // Need to check if it's a known directory if (g_slist_find_custom(dir_list, path, (GCompareFunc) strcmp) != NULL) { return 1; } return 0; }
libspectrum_error libspectrum_rzx_rollback_to( libspectrum_rzx *rzx, libspectrum_snap **snap, size_t which ) { GSList *previous = NULL, *list; rzx_block_t *block; size_t i; /* Find the nth snapshot block in the file */ for( i = 0, list = rzx->blocks; i <= which; i++, list = list->next ) { list = g_slist_find_custom( list, GINT_TO_POINTER( LIBSPECTRUM_RZX_SNAPSHOT_BLOCK ), find_block ); if( !list ) { libspectrum_print_error( LIBSPECTRUM_ERROR_CORRUPT, "snapshot block %lu not found in recording", (unsigned long)which ); return LIBSPECTRUM_ERROR_CORRUPT; } previous = list; } if( rzx->current_input ) { libspectrum_error error; error = libspectrum_rzx_stop_input( rzx ); if( error ) return error; } /* Delete all blocks after the snapshot */ g_slist_foreach( previous->next, block_free_wrapper, NULL ); previous->next = NULL; block = previous->data; *snap = block->types.snap.snap; return LIBSPECTRUM_ERROR_NONE; }
GSList* mono_w32process_get_modules (pid_t pid) { GSList *ret = NULL; MonoW32ProcessModule *mod; GPtrArray *dlarray = g_ptr_array_new(); gint i; if (dl_iterate_phdr (mono_w32process_get_modules_callback, dlarray) < 0) return NULL; for (i = 0; i < dlarray->len; i++) { struct dl_phdr_info *info = g_ptr_array_index (dlarray, i); mod = g_new0 (MonoW32ProcessModule, 1); mod->address_start = (gpointer)(info->dlpi_addr + info->dlpi_phdr[0].p_vaddr); mod->address_end = (gpointer)(info->dlpi_addr + info->dlpi_phdr[info->dlpi_phnum - 1].p_vaddr); mod->perms = g_strdup ("r--p"); mod->address_offset = 0; mod->inode = i; mod->filename = g_strdup (info->dlpi_name); mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER_PROCESS, "%s: inode=%d, filename=%s, address_start=%p, address_end=%p", __func__, mod->inode, mod->filename, mod->address_start, mod->address_end); g_free (info); if (g_slist_find_custom (ret, mod, mono_w32process_module_equals) == NULL) { ret = g_slist_prepend (ret, mod); } else { mono_w32process_module_free (mod); } } g_ptr_array_free (dlarray, TRUE); return g_slist_reverse (ret); }
static int gap_driver_accept(struct btd_service *service) { struct btd_device *device = btd_service_get_device(service); struct gatt_db *db = btd_device_get_gatt_db(device); struct bt_gatt_client *client = btd_device_get_gatt_client(device); struct gas *gas; GSList *l; char addr[18]; bt_uuid_t gap_uuid; ba2str(device_get_address(device), addr); DBG("GAP profile accept (%s)", addr); l = g_slist_find_custom(devices, device, cmp_device); if (!l) { error("GAP service not handled by profile"); return -1; } gas = l->data; /* Clean-up any old client/db and acquire the new ones */ gas->attr = NULL; gatt_db_unregister(gas->db, gas->db_id); gatt_db_unref(gas->db); bt_gatt_client_unref(gas->client); gas->db = gatt_db_ref(db); gas->client = bt_gatt_client_ref(client); gas->db_id = gatt_db_register(db, service_added, service_removed, gas, NULL); /* Handle the GAP services */ bt_uuid16_create(&gap_uuid, GAP_UUID16); gatt_db_foreach_service(db, &gap_uuid, foreach_gap_service, gas); return 0; }
/** * hildon_program_add_window: * @self: The @HildonProgram to which the window should be registered * @window: A @HildonWindow to be added * * Registers a @HildonWindow as belonging to a given @HildonProgram. This * allows to apply program-wide settings as all the registered windows, * such as hildon_program_set_common_menu() and * hildon_pogram_set_common_toolbar() **/ void hildon_program_add_window (HildonProgram *self, HildonWindow *window) { HildonProgramPrivate *priv; g_return_if_fail (HILDON_IS_PROGRAM (self)); priv = HILDON_PROGRAM_GET_PRIVATE (self); g_assert (priv); if (g_slist_find_custom (priv->windows, window, hildon_program_window_list_compare) ) { /* We already have that window */ return; } if (!priv->window_count) { hildon_program_update_top_most (self); /* Now that we have a window we should start keeping track of * the root window */ gdk_window_set_events (gdk_get_default_root_window (), gdk_window_get_events (gdk_get_default_root_window ()) | GDK_PROPERTY_CHANGE_MASK); gdk_window_add_filter (gdk_get_default_root_window (), hildon_program_root_window_event_filter, self ); } hildon_window_set_can_hibernate_property (window, &priv->killable); hildon_window_set_program (window, G_OBJECT (self)); priv->windows = g_slist_append (priv->windows, window); priv->window_count ++; }
/* This takes ownership of the socket. * It creates and attaches a source to the component’s context. */ void component_attach_socket (Component *component, NiceSocket *nicesock) { GSList *l; SocketSource *socket_source; g_assert (component != NULL); g_assert (nicesock != NULL); g_assert (component->ctx != NULL); if (nicesock->fileno == NULL) return; /* Find an existing SocketSource in the component which contains @socket, or * create a new one. * * Whenever a source is added or remove to socket_sources, socket_sources_age * must be incremented. */ l = g_slist_find_custom (component->socket_sources, nicesock, _find_socket_source); if (l != NULL) { socket_source = l->data; } else { socket_source = g_slice_new0 (SocketSource); socket_source->socket = nicesock; socket_source->component = component; component->socket_sources = g_slist_prepend (component->socket_sources, socket_source); component->socket_sources_age++; } /* Create and attach a source */ nice_debug ("Component %p (agent %p): Attach source (stream %u).", component, component->agent, component->stream->id); socket_source_attach (socket_source, component->ctx); }
static GSList * panel_applets_manager_get_applets_dirs (void) { const gchar *dir = NULL; gchar **paths; guint i; GSList *retval = NULL; dir = g_getenv ("CONSORT_PANEL_APPLETS_DIR"); if (!dir || g_strcmp0 (dir, "") == 0) { return g_slist_prepend (NULL, g_strdup (PANEL_APPLETS_DIR)); } paths = g_strsplit (dir, ":", 0); for (i = 0; paths[i]; i++) { if (g_slist_find_custom (retval, paths[i], (GCompareFunc) g_strcmp0)) continue; retval = g_slist_prepend (retval, g_strdup (paths[i])); } g_strfreev (paths); return g_slist_reverse (retval); }
static PyObject *PyScript_signal_unregister(PyScript *self, PyObject *args, PyObject *kwds) { static char *kwlist[] = {"signal", NULL}; char *signal = ""; GSList *search; if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", kwlist, &signal)) return NULL; search = g_slist_find_custom(self->registered_signals, signal, (GCompareFunc)strcmp); if (!search) return PyErr_Format(PyExc_KeyError, "script has not registered that signal"); g_free(search->data); self->registered_signals = g_slist_delete_link(self->registered_signals, search); if (!pysignals_unregister(signal)) return PyErr_Format(PyExc_SystemError, "script registered signal, but signal does not exist"); Py_RETURN_NONE; }
/* Return non-zero and set *value if key is in hash table. On zero return, *value is undefined. */ int hash_find(guint32 key, guint32 *value) { guint16 hash_index; HashBucket this_bucket; GSList *list_item; HashEntry *entry; g_assert(value); hash_index = key & 0xffff; this_bucket = hash_table[hash_index]; if(!this_bucket) return 0; list_item = g_slist_find_custom(this_bucket, GINT_TO_POINTER((guint32)hash_index), hash_find_comparator); if(list_item) { entry = list_item->data; g_assert(entry); *value = entry->value; return 1; } return 0; }
/* This makes sure that only all the buddies are in the permit list. */ static void add_buddies_in_permit(PurpleAccount *account, gboolean local) { GSList *list; /* Remove anyone in the permit list who is not in the buddylist */ for (list = account->permit; list != NULL; ) { char *person = list->data; list = list->next; if (!purple_find_buddy(account, person)) purple_privacy_permit_remove(account, person, local); } /* Now make sure everyone in the buddylist is in the permit list */ list = purple_find_buddies(account, NULL); while (list != NULL) { PurpleBuddy *buddy = list->data; if (!g_slist_find_custom(account->permit, buddy->name, (GCompareFunc)g_utf8_collate)) purple_privacy_permit_add(account, buddy->name, local); list = g_slist_delete_link(list, list); } }
static void handle_request(GObex *obex, GObexPacket *req) { GSList *match; int op; op = parse_request(obex, req); if (op < 0) goto fail; match = g_slist_find_custom(obex->req_handlers, GUINT_TO_POINTER(op), req_handler_cmpop); if (match) { struct req_handler *handler = match->data; handler->func(obex, req, handler->user_data); return; } op = -G_OBEX_RSP_NOT_IMPLEMENTED; fail: g_obex_debug(G_OBEX_DEBUG_ERROR, "%s", g_obex_strerror(-op)); g_obex_send_rsp(obex, -op, NULL, G_OBEX_HDR_INVALID); }
GdkPixbuf *xa_get_pixbuf_icon_from_cache(gchar *filename,gint size) { pixbuf_cache *tie = NULL; const gchar *icon_name; GSList *found = NULL; GdkPixbuf *pixbuf = NULL; if (strcmp(filename,"folder") == 0) icon_name = filename; else if (strcmp(filename,"lock") == 0) icon_name = "dialog-password"; else icon_name = xa_get_stock_mime_icon(filename); tie = g_new0(pixbuf_cache,1); if (tie) { tie->icon_name = g_strdup(icon_name); found = g_slist_find_custom(icon_cache,tie,(GCompareFunc)xa_icon_name_compare_func); if (found) { g_free (tie->icon_name); g_free (tie); return ((pixbuf_cache *)found->data)->pixbuf; } else { pixbuf = gtk_icon_theme_load_icon(icon_theme, icon_name, size, (GtkIconLookupFlags) 0, NULL); if (pixbuf) { tie->pixbuf = pixbuf; icon_cache = g_slist_prepend(icon_cache,tie); } } } return pixbuf; }
/** * return the number of the sub-budget wich has the name in param * create it if necessary * * \param budget_number the number of the budget * \param name the name of the sub-budget * \param create TRUE if we want to create it if it doen't exist * * \return the number of the sub-budget or FALSE if problem * */ gint gsb_data_budget_get_sub_budget_number_by_name ( gint budget_number, const gchar *name, gboolean create ) { GSList *list_tmp; struct_budget *budget; gint sub_budget_number = 0; if (!name || !strlen (name)) return FALSE; budget = gsb_data_budget_get_structure ( budget_number ); if (!budget) return FALSE; list_tmp = g_slist_find_custom ( budget -> sub_budget_list, name, (GCompareFunc) gsb_data_budget_get_pointer_from_sub_name_in_glist ); if ( list_tmp ) { struct_sub_budget *sub_budget; sub_budget = list_tmp -> data; sub_budget_number = sub_budget -> sub_budget_number; } else { if ( create ) { sub_budget_number = gsb_data_budget_new_sub_budget ( budget_number, name ); gsb_budget_update_combofix ( FALSE ); } } return sub_budget_number; }
static void check_color_schemes_enabled (GtkSettings *settings, AppearanceData *data) { gchar *theme = NULL; gchar *filename; GSList *symbolic_colors = NULL; gboolean enable_colors = FALSE; gint i; g_object_get (settings, "gtk-theme-name", &theme, NULL); filename = gtkrc_find_named (theme); g_free (theme); gtkrc_get_details (filename, NULL, &symbolic_colors); g_free (filename); for (i = 0; i < NUM_SYMBOLIC_COLORS; ++i) { gboolean found; found = (g_slist_find_custom (symbolic_colors, symbolic_names[i], (GCompareFunc) strcmp) != NULL); gtk_widget_set_sensitive (appearance_capplet_get_widget (data, symbolic_names[i]), found); enable_colors |= found; } g_slist_foreach (symbolic_colors, (GFunc) g_free, NULL); g_slist_free (symbolic_colors); gtk_widget_set_sensitive (appearance_capplet_get_widget (data, "color_scheme_table"), enable_colors); gtk_widget_set_sensitive (appearance_capplet_get_widget (data, "color_scheme_defaults_button"), enable_colors); if (enable_colors) gtk_widget_hide (appearance_capplet_get_widget (data, "color_scheme_message_hbox")); else gtk_widget_show (appearance_capplet_get_widget (data, "color_scheme_message_hbox")); }
static int headset_probe(struct btd_device *device, GSList *uuids) { struct btd_adapter *adapter = device_get_adapter(device); const gchar *path = device_get_path(device); const sdp_record_t *record; sdp_list_t *protos; int ch; bdaddr_t src, dst; DBG("path %s", path); if (!g_slist_find_custom(uuids, HSP_HS_UUID, (GCompareFunc) strcasecmp)) return -EINVAL; record = btd_device_get_record(device, uuids->data); if (!record || sdp_get_access_protos(record, &protos) < 0) { error("Invalid record"); return -EINVAL; } ch = sdp_get_proto_port(protos, RFCOMM_UUID); sdp_list_foreach(protos, (sdp_list_func_t) sdp_list_free, NULL); sdp_list_free(protos, NULL); if (ch <= 0) { error("Invalid RFCOMM channel"); return -EINVAL; } adapter_get_address(adapter, &src); device_get_address(device, &dst); return fake_input_register(connection, device, path, &src, &dst, HSP_HS_UUID, ch); }
/** Remove a file */ static int fuse_unlink(const char *path) { #ifndef HIDE_COMPLETED tolog(path); tolog(" - unlink\n"); #endif path++; GSList *item = g_slist_find_custom(link_list, path, (GCompareFunc) linkpathcmp); if (item == NULL) { return -ENOENT; } struct link_pair *l = (struct link_pair *) item->data; g_free(l->path); g_free(l->dest); g_free(item->data); link_list = g_slist_delete_link(link_list, item); return 0;; }
static uint8_t link_loss_alert_lvl_read(struct attribute *a, gpointer user_data, struct btd_device *device) { struct link_loss_adapter *adapter = user_data; struct connected_device *condev; GSList *l = NULL; uint8_t alert_level = NO_ALERT; if (device) l = g_slist_find_custom(adapter->connected_devices, device, lldevice_cmp); if (l) { condev = l->data; alert_level = condev->alert_level; } DBG("return alert level %d for dev %p", alert_level, device); /* update the alert level according to the requesting device */ attrib_db_update(adapter->adapter, a->handle, NULL, &alert_level, sizeof(alert_level), NULL); return 0; }
static void connect_cb(GIOChannel *chan, GError *err, gpointer user_data) { struct a2dp_device *dev; bdaddr_t dst; char address[18]; GError *gerr = NULL; GSList *l; if (err) { error("%s", err->message); return; } bt_io_get(chan, &gerr, BT_IO_OPT_DEST_BDADDR, &dst, BT_IO_OPT_INVALID); if (gerr) { error("%s", gerr->message); g_error_free(gerr); g_io_channel_shutdown(chan, TRUE, NULL); return; } ba2str(&dst, address); DBG("Incoming connection from %s", address); l = g_slist_find_custom(devices, &dst, device_cmp); if (l) { transport_connect_cb(chan, err, l->data); return; } dev = a2dp_device_new(&dst); bt_a2dp_notify_state(dev, HAL_A2DP_STATE_CONNECTING); signaling_connect_cb(chan, err, dev); }
static void bt_a2dp_connect(const void *buf, uint16_t len) { const struct hal_cmd_a2dp_connect *cmd = buf; struct a2dp_device *dev; uint8_t status; char addr[18]; bdaddr_t dst; GSList *l; DBG(""); android2bdaddr(&cmd->bdaddr, &dst); l = g_slist_find_custom(devices, &dst, device_cmp); if (l) { status = HAL_STATUS_FAILED; goto failed; } dev = a2dp_device_new(&dst); if (!a2dp_device_connect(dev, signaling_connect_cb)) { a2dp_device_remove(dev); status = HAL_STATUS_FAILED; goto failed; } ba2str(&dev->dst, addr); DBG("connecting to %s", addr); bt_a2dp_notify_state(dev, HAL_A2DP_STATE_CONNECTING); status = HAL_STATUS_SUCCESS; failed: ipc_send_rsp(hal_ipc, HAL_SERVICE_ID_A2DP, HAL_OP_A2DP_CONNECT, status); }
/** * nice_component_detach_socket: * @component: a #NiceComponent * @socket: the socket to detach the source for * * Detach the #GSource for the single specified @socket. It also closes it * and frees it! * * If the @socket doesn’t exist in this @component, do nothing. */ static void nice_component_detach_socket (NiceComponent *component, NiceSocket *nicesock) { GSList *l; SocketSource *socket_source; nice_debug ("Detach socket %p.", nicesock); /* Remove the socket from various lists. */ for (l = component->incoming_checks; l != NULL;) { IncomingCheck *icheck = l->data; GSList *next = l->next; if (icheck->local_socket == nicesock) { component->incoming_checks = g_slist_delete_link (component->incoming_checks, l); incoming_check_free (icheck); } l = next; } /* Find the SocketSource for the socket. */ l = g_slist_find_custom (component->socket_sources, nicesock, _find_socket_source); if (l == NULL) return; /* Detach the source. */ socket_source = l->data; component->socket_sources = g_slist_delete_link (component->socket_sources, l); component->socket_sources_age++; socket_source_detach (socket_source); socket_source_free (socket_source); }
static uint8_t link_loss_alert_lvl_write(struct attribute *a, gpointer user_data, struct btd_device *device) { uint8_t value; struct link_loss_adapter *adapter = user_data; GSList *l = NULL; struct connected_device *condev = NULL; if (device) { l = g_slist_find_custom(adapter->connected_devices, device, lldevice_cmp); if (l) condev = l->data; } if (a->len == 0) { DBG("Illegal alert level len"); goto set_error; } value = a->data[0]; if (value != NO_ALERT && value != MILD_ALERT && value != HIGH_ALERT) { DBG("Illegal alert value"); goto set_error; } /* Register a disconnect cb if the alert level is non-zero */ if (value != NO_ALERT && device && !condev) { condev = g_new0(struct connected_device, 1); condev->device = btd_device_ref(device); condev->adapter = adapter; condev->callback_id = btd_device_add_attio_callback(device, NULL, link_loss_disc_cb, condev); adapter->connected_devices = g_slist_append( adapter->connected_devices, condev); } else if (value == NO_ALERT && condev) {
static void cache_by_id (ShellAppSystem *self, GSList *apps) { GSList *iter; for (iter = apps; iter; iter = iter->next) { ShellAppInfo *info = iter->data; const char *id = shell_app_info_get_id (info); char *prefix = shell_app_info_get_prefix (info); shell_app_info_ref (info); /* the name is owned by the info itself */ if (prefix && !g_slist_find_custom (self->priv->known_vendor_prefixes, prefix, (GCompareFunc)g_strcmp0)) self->priv->known_vendor_prefixes = g_slist_append (self->priv->known_vendor_prefixes, prefix); else g_free (prefix); g_hash_table_replace (self->priv->app_id_to_info, (char*)id, info); } }
static void on_clicked_fold (RosterViewGtk* self, GtkTreePath* path, const gchar* name) { gboolean row_expanded = TRUE; GSList* existing_group = NULL; row_expanded = gtk_tree_view_row_expanded (GTK_TREE_VIEW (self->priv->tree_view), path); existing_group = g_slist_find_custom (self->priv->folded_groups, name, (GCompareFunc) g_ascii_strcasecmp); if (!row_expanded) { if (existing_group == NULL) { self->priv->folded_groups = g_slist_append (self->priv->folded_groups, g_strdup (name)); } } else { if (existing_group != NULL) { self->priv->folded_groups = g_slist_remove_link (self->priv->folded_groups, existing_group); g_free ((gchar *) existing_group->data); g_slist_free_1 (existing_group); } } gm_conf_set_string_list (CONTACTS_KEY "roster_folded_groups", self->priv->folded_groups); }
static gboolean update_ignore_paths (GSList **ignore_paths, const gchar *mount_path, gboolean ignore) { GSList *found; gchar *path_to_remove; found = g_slist_find_custom (*ignore_paths, mount_path, (GCompareFunc) ignore_path_compare); if (ignore && (found == NULL)) { *ignore_paths = g_slist_prepend (*ignore_paths, g_strdup (mount_path)); return TRUE; } if (!ignore && (found != NULL)) { path_to_remove = found->data; *ignore_paths = g_slist_remove (*ignore_paths, path_to_remove); g_free (path_to_remove); return TRUE; } return FALSE; }
void add_contact_with_three_groups_update_removing_two(void **state) { roster_create(); GSList *groups1 = NULL; groups1 = g_slist_append(groups1, strdup("friends")); groups1 = g_slist_append(groups1, strdup("work")); groups1 = g_slist_append(groups1, strdup("stuff")); roster_add("*****@*****.**", NULL, groups1, NULL, FALSE); GSList *groups2 = NULL; groups2 = g_slist_append(groups2, strdup("stuff")); roster_update("*****@*****.**", NULL, groups2, NULL, FALSE); GSList *groups_res = roster_get_groups(); assert_int_equal(g_slist_length(groups_res), 1); GSList *found = g_slist_find_custom(groups_res, "stuff", g_strcmp0); assert_true(found != NULL); assert_string_equal(found->data, "stuff"); g_slist_free_full(groups_res, g_free); roster_destroy(); }
static void pnat_remove(struct btd_adapter *adapter) { struct dun_server *server; GSList *match; bdaddr_t src; adapter_get_address(adapter, &src); match = g_slist_find_custom(servers, &src, server_cmp); if (match == NULL) return; server = match->data; servers = g_slist_delete_link(servers, match); disconnect(server); remove_record_from_server(server->record_handle); close(server->rfcomm_ctl); g_io_channel_shutdown(server->server, TRUE, NULL); g_io_channel_unref(server->server); g_free(server); }
/** * @name fab_route_get * * @brief Get a fabric route */ GSList * fab_route_get(void *rt_service, int src_sw, int dst_sw, fab_route_t *froute) { GSList *route = NULL; if (!fab_ctx->use_ecmp || !froute) { if (!(route = mul_route_get(rt_service, src_sw, dst_sw))) { return NULL; } } else { if (!(route = mul_route_get_mp(rt_service, src_sw, dst_sw, froute, fab_mp_select))) { return NULL; } } if (!g_slist_find_custom(route, froute, (GCompareFunc)fab_route_elem_valid)) { mul_destroy_route(route); return NULL; } return route; }
void heartrate_device_unregister(struct btd_device *device) { struct btd_adapter *adapter; struct heartrate_adapter *hradapter; struct heartrate *hr; GSList *l; adapter = device_get_adapter(device); hradapter = find_heartrate_adapter(adapter); if (hradapter == NULL) return; l = g_slist_find_custom(hradapter->devices, device, cmp_device); if (l == NULL) return; hr = l->data; hradapter->devices = g_slist_remove(hradapter->devices, hr); g_dbus_unregister_interface(btd_get_dbus_connection(), device_get_path(device), HEART_RATE_INTERFACE); }
static inline void tree_selection_collect_data_record(GtkTreeModel *model, GtkTreeIter *iter, collect_data_struct_t *cdata, gboolean unselect) { gpointer data; g_assert(NULL != cdata); g_assert(NULL != iter); data = cdata->gdf(model, iter); if (unselect) { cdata->to_unselect = g_slist_prepend(cdata->to_unselect, w_tree_iter_copy(iter)); } if (NULL != cdata->cfn && NULL != g_slist_find_custom(cdata->results, data, cdata->cfn)) { if (GUI_PROPERTY(gui_debug) >= 3) g_warning("%s has duplicate data: %p", cdata->name, data); return; } cdata->results = g_slist_prepend(cdata->results, data); }
static gnc_commodity * xaccTransFindCommonCurrency (Transaction *trans, QofBook *book) { gnc_commodity *com_scratch; GList *node = NULL; GSList *comlist = NULL, *found = NULL; if (!trans) return NULL; if (trans->splits == NULL) return NULL; g_return_val_if_fail (book, NULL); /* Find the most commonly used currency among the splits. If a given split is in a non-currency commodity, then look for an ancestor account in a currency, but prefer currencies used directly in splits. Ignore trading account splits in this whole process, they don't add any value to this algorithm. */ for (node = trans->splits; node; node = node->next) { Split *s = node->data; unsigned int curr_weight; if (s == NULL || s->acc == NULL) continue; if (xaccAccountGetType(s->acc) == ACCT_TYPE_TRADING) continue; com_scratch = xaccAccountGetCommodity(s->acc); if (com_scratch && gnc_commodity_is_currency(com_scratch)) { curr_weight = 3; } else { com_scratch = gnc_account_get_currency_or_parent(s->acc); if (com_scratch == NULL) continue; curr_weight = 1; } if ( comlist ) { found = g_slist_find_custom(comlist, com_scratch, commodity_equal); } if (comlist == NULL || found == NULL) { CommodityCount *count = g_slice_new0(CommodityCount); count->commodity = com_scratch; count->count = curr_weight; comlist = g_slist_append(comlist, count); } else { CommodityCount *count = (CommodityCount*)(found->data); count->count += curr_weight; } } found = g_slist_sort( comlist, commodity_compare); if ( found && found->data && (((CommodityCount*)(found->data))->commodity != NULL)) { return ((CommodityCount*)(found->data))->commodity; } /* We didn't find a currency in the current account structure, so try * an old one. */ return xaccTransFindOldCommonCurrency( trans, book ); }