void free_aml_allocator(void) { g_ptr_array_foreach(alloc_list, aml_free, NULL); g_ptr_array_free(alloc_list, true); alloc_list = 0; }
void remmina_string_array_free(RemminaStringArray *array) { g_ptr_array_foreach(array, (GFunc) g_free, NULL); g_ptr_array_free(array, TRUE); }
static void mc_search__conditions_free (GPtrArray * array) { g_ptr_array_foreach (array, (GFunc) mc_search__cond_struct_free, NULL); g_ptr_array_free (array, TRUE); }
static void retrieve_messagebook_callback2(struct MessageListViewData *data) { g_ptr_array_foreach(data->messages, process_message, data); }
void call_remove_all_errors (callable_obj_t * call) { g_ptr_array_foreach (call->_error_dialogs, (GFunc) gtk_widget_destroy, NULL); }
static void collect_strings_free (GPtrArray *data) { g_ptr_array_foreach (data, (GFunc)g_free, NULL); g_ptr_array_free (data, TRUE); }
static gboolean ui_to_setting (CEPageIP4 *self) { CEPageIP4Private *priv = CE_PAGE_IP4_GET_PRIVATE (self); GtkTreeModel *model; GtkTreeIter tree_iter; int int_method = IP4_METHOD_AUTO; const char *method; GArray *dns_servers = NULL; GSList *search_domains = NULL; GPtrArray *addresses = NULL; gboolean valid = FALSE, iter_valid; const char *text; gboolean ignore_auto_dns = FALSE; const char *dhcp_client_id = NULL; char **items = NULL, **iter; /* Method */ if (gtk_combo_box_get_active_iter (priv->method, &tree_iter)) { gtk_tree_model_get (GTK_TREE_MODEL (priv->method_store), &tree_iter, METHOD_COL_NUM, &int_method, -1); } switch (int_method) { case IP4_METHOD_LINK_LOCAL: method = NM_SETTING_IP4_CONFIG_METHOD_LINK_LOCAL; break; case IP4_METHOD_MANUAL: method = NM_SETTING_IP4_CONFIG_METHOD_MANUAL; break; case IP4_METHOD_SHARED: method = NM_SETTING_IP4_CONFIG_METHOD_SHARED; break; case IP4_METHOD_AUTO_ADDRESSES: ignore_auto_dns = TRUE; /* fall through */ default: method = NM_SETTING_IP4_CONFIG_METHOD_AUTO; break; } /* IP addresses */ model = gtk_tree_view_get_model (priv->addr_list); iter_valid = gtk_tree_model_get_iter_first (model, &tree_iter); addresses = g_ptr_array_sized_new (1); while (iter_valid) { char *item = NULL; struct in_addr tmp_addr, tmp_gateway = { 0 }; GArray *addr; guint32 empty_val = 0, prefix; gtk_tree_model_get (model, &tree_iter, COL_ADDRESS, &item, -1); if (!item || !inet_aton (item, &tmp_addr)) { g_warning ("%s: IPv4 address '%s' missing or invalid!", __func__, item ? item : "<none>"); g_free (item); goto out; } g_free (item); gtk_tree_model_get (model, &tree_iter, COL_PREFIX, &item, -1); if (!item) { g_warning ("%s: IPv4 prefix '%s' missing!", __func__, item ? item : "<none>"); goto out; } if (!parse_netmask (item, &prefix)) { g_warning ("%s: IPv4 prefix '%s' invalid!", __func__, item ? item : "<none>"); g_free (item); goto out; } g_free (item); /* Gateway is optional... */ gtk_tree_model_get (model, &tree_iter, COL_GATEWAY, &item, -1); if (item && !inet_aton (item, &tmp_gateway)) { g_warning ("%s: IPv4 gateway '%s' invalid!", __func__, item ? item : "<none>"); g_free (item); goto out; } g_free (item); addr = g_array_sized_new (FALSE, TRUE, sizeof (guint32), 3); g_array_append_val (addr, tmp_addr.s_addr); g_array_append_val (addr, prefix); if (tmp_gateway.s_addr) g_array_append_val (addr, tmp_gateway.s_addr); else g_array_append_val (addr, empty_val); g_ptr_array_add (addresses, addr); iter_valid = gtk_tree_model_iter_next (model, &tree_iter); } /* Don't pass empty array to the setting */ if (!addresses->len) { g_ptr_array_free (addresses, TRUE); addresses = NULL; } /* DNS servers */ dns_servers = g_array_new (FALSE, FALSE, sizeof (guint)); text = gtk_entry_get_text (GTK_ENTRY (priv->dns_servers)); if (text && strlen (text)) { items = g_strsplit_set (text, ", ;:", 0); for (iter = items; *iter; iter++) { struct in_addr tmp_addr; char *stripped = g_strstrip (*iter); if (!strlen (stripped)) continue; if (inet_pton (AF_INET, stripped, &tmp_addr)) g_array_append_val (dns_servers, tmp_addr.s_addr); else { g_strfreev (items); goto out; } } g_strfreev (items); } /* Search domains */ text = gtk_entry_get_text (GTK_ENTRY (priv->dns_searches)); if (text && strlen (text)) { items = g_strsplit_set (text, ", ;:", 0); for (iter = items; *iter; iter++) { char *stripped = g_strstrip (*iter); if (strlen (stripped)) search_domains = g_slist_prepend (search_domains, g_strdup (stripped)); } if (items) g_strfreev (items); } search_domains = g_slist_reverse (search_domains); /* DHCP client ID */ if (!strcmp (method, NM_SETTING_IP4_CONFIG_METHOD_AUTO)) { dhcp_client_id = gtk_entry_get_text (priv->dhcp_client_id); if (dhcp_client_id && !strlen (dhcp_client_id)) dhcp_client_id = NULL; } /* Update setting */ g_object_set (priv->setting, NM_SETTING_IP4_CONFIG_METHOD, method, NM_SETTING_IP4_CONFIG_ADDRESSES, addresses, NM_SETTING_IP4_CONFIG_DNS, dns_servers, NM_SETTING_IP4_CONFIG_DNS_SEARCH, search_domains, NM_SETTING_IP4_CONFIG_IGNORE_AUTO_DNS, ignore_auto_dns, NM_SETTING_IP4_CONFIG_DHCP_CLIENT_ID, dhcp_client_id, NULL); valid = TRUE; out: if (addresses) { g_ptr_array_foreach (addresses, (GFunc) free_one_addr, NULL); g_ptr_array_free (addresses, TRUE); } if (dns_servers) g_array_free (dns_servers, TRUE); g_slist_foreach (search_domains, (GFunc) g_free, NULL); g_slist_free (search_domains); return valid; }
/** * @brief Execute a function for each of the clients * * @param func The function to execute * @param user_data The value to pass as second parameter to each * call. * * This is a simple wrapper around g_ptr_array_foreach. * * @note This function will lock the @ref clients_list_lock mutex. */ void clients_each(GFunc func, gpointer user_data) { g_mutex_lock(clients_list_lock); g_ptr_array_foreach(clients_list, func, user_data); g_mutex_unlock(clients_list_lock); }
static void free_column_names_array (GPtrArray *column_names) { g_ptr_array_foreach (column_names, (GFunc) g_free, NULL); g_ptr_array_free (column_names, TRUE); }
vol_err_t vol_getfilenames(vol_t handle) { struct volume* vhnd = handle; struct vfile *curfile; log_info("Fetching filenames from array."); guint64 os; os = vhnd->footer.filenames.offset; gint i, j = 0, l = 0; vol_err_t err; gchar* datadir; guint8 bite; log_debug("Scraping array header."); for (i=0; i <=4; i++) { err = vol_getheader(handle, &vhnd->footer.filenames.header, vhnd->footer.filenames.offset + i); if (err) return err; /* Header verification * There might be a memory leak here */ if (memcmp("vols", vhnd->footer.filenames.header.ident, 4)) { log_debug("Retrieved IDstring does not matched needed IDstring."); err = VOL_ERR_BADHEADER; } else { vhnd->footer.filenames.offset += i; err = VOL_ERR_OK; break; } } if (err == VOL_ERR_BADHEADER) { log_critical("Array identity string not recognized."); return VOL_ERR_BROKEN; } if (vhnd->footer.filenames.header.val != 0) { os+=sizeof(struct header); vhnd->footer.filenames.data = g_ptr_array_new_with_free_func(g_free); vhnd->files = g_ptr_array_new_with_free_func(vol_filesarray_free); log_debug("Fetching array data."); for (i = 0; i < vhnd->footer.filenames.header.val; i++) { if (j == 0) log_debug("Seeking to end of string."); j++; readbyte(&vhnd->volio, (guint64)(os+j), &bite); if (bite == 0x00) { j++; log_debug("String at offset 0x%lx indexed. Size is %d. Pulling now.", os, j); gchar *data, *sanitary, *pathcopy1, *pathcopy2; curfile = (struct vfile*)g_malloc(sizeof(struct vfile)); curfile->vol = vhnd; curfile->data.data = NULL; data = readpart(&vhnd->volio, (guint64)os, sizeof(gchar)*j); sanitary = sanitizepath(data); log_debug("Pulled string: %s.", data); i++; os+=j; j=0; log_debug("Adding string to arrays."); pathcopy1 = g_strdup(sanitary); pathcopy2 = g_strdup(sanitary); g_ptr_array_add(vhnd->footer.filenames.data, (gpointer)data); curfile->path = g_strdup(data); curfile->path_canonical = sanitary; curfile->name = g_strdup(basename(pathcopy1)); curfile->dir = g_strdup(dirname(pathcopy2)); g_free(pathcopy1); g_free(pathcopy2); g_ptr_array_add(vhnd->files, (gpointer)curfile); l++; } else if (bite == 0x5C) { log_todo("Warn windows users about invalid characters and forward slashes"); log_warning("An internal path string may contain backslashes."); } } struct counter* k; k = g_malloc0(sizeof(struct counter)); k->count = 0; log_info("File arrays created."); g_ptr_array_foreach(vhnd->files, printfiles, (gpointer)k); g_free(k); } else { log_message("Array is empty. (No files in volume?)"); vhnd->footer.filenames.data = NULL; } vhnd->footer.fileprops.offset = vhnd->footer.filenames.header.val +vhnd->footer.filenames.offset+sizeof(struct header); return err; }
gint main (gint argc, gchar ** argv) { gint ret = 0; VsgPRTree2d *tree; VsgVector2d lb; VsgVector2d ub; GTimer *timer = NULL; MPI_Init (&argc, &argv); MPI_Comm_size (MPI_COMM_WORLD, &sz); MPI_Comm_rank (MPI_COMM_WORLD, &rk); vsg_init_gdouble (); parse_args (argc, argv); if (nc_padding > 0) { if (_verbose && rk == 0) g_printerr ("%d: NodeCounter padding: %d\n", rk, nc_padding); _nc_padding_buffer = g_malloc (nc_padding * sizeof (char)); } points = g_ptr_array_new (); lb.x = -1.; lb.y = -1.; ub.x = 1.; ub.y = 1.; /* create the tree */ tree = vsg_prtree2d_new_full (&lb, &ub, (VsgPoint2dLocFunc) vsg_vector2d_vector2d_locfunc, (VsgPoint2dDistFunc) vsg_vector2d_dist, NULL, _maxbox); if (_hilbert) { /* configure for hilbert curve order traversal */ vsg_prtree2d_set_children_order_hilbert (tree); } if (_verbose) { MPI_Barrier (MPI_COMM_WORLD); g_printerr ("%d: set_parallel begin\n", rk); } vsg_prtree2d_set_parallel (tree, &pconfig); if (_verbose) { MPI_Barrier (MPI_COMM_WORLD); g_printerr ("%d: set_parallel ok\n", rk); } if (_verbose) { MPI_Barrier (MPI_COMM_WORLD); g_printerr ("%d: fill begin\n", rk); } _fill (tree, _np); /* /\* try one exterior point *\/ */ /* if (sz > 1) */ /* { */ /* if (rk == 1) */ /* { */ /* Pt *pt; */ /* _ref_count += _np+1; */ /* pt = pt_alloc (TRUE, NULL); */ /* pt->vector.x = ub.x+1.; */ /* pt->vector.y = ub.y+1.; */ /* pt->weight = _np+1; */ /* vsg_prtree2d_insert_point (tree, pt); */ /* } */ /* else */ /* { */ /* _ref_count += _np+1; */ /* } */ /* vsg_prtree2d_migrate_flush (tree); */ /* _distribute (tree); */ /* } */ if (_verbose) { MPI_Barrier (MPI_COMM_WORLD); g_printerr ("%d: fill ok\n", rk); } if (_do_write) { gchar fn[1024]; FILE *f; sprintf (fn, "comm-%03d.svg", rk); f = fopen (fn, "w"); fprintf (f, "\n<g style=\"stroke-width:0.01; stroke:black; " \ "fill:none\">\n"); fclose (f); } if (_verbose) { g_printerr ("%d: near/far traversal begin\n", rk); MPI_Barrier (MPI_COMM_WORLD); timer = g_timer_new (); } /* accumulate the point counts across the tree */ _do_upward_pass (tree); /* do some near/far traversal */ vsg_prtree2d_near_far_traversal (tree, (VsgPRTree2dFarInteractionFunc) _far, (VsgPRTree2dInteractionFunc) _near, &ret); /* accumulate from top to leaves */ vsg_prtree2d_traverse (tree, G_PRE_ORDER, (VsgPRTree2dFunc) _down, NULL); if (_verbose) { MPI_Barrier (MPI_COMM_WORLD); g_printerr ("%d: near/far traversal ok elapsed=%f seconds\n", rk, g_timer_elapsed (timer, NULL)); g_timer_destroy (timer); } if (_do_write) { gchar fn[1024]; FILE *f; MPI_Barrier (MPI_COMM_WORLD); g_sprintf (fn, "prtree2parallel-%03d.txt", rk); f = fopen (fn, "w"); vsg_prtree2d_write (tree, f); fclose (f); _tree_write (tree, "prtree2parallel-"); } if (_do_write) { gchar fn[1024]; FILE *f; sprintf (fn, "comm-%03d.svg", rk); f = fopen (fn, "a"); fprintf (f, "</g>\n"); fclose (f); } if (_verbose) { gint near_count_sum, far_count_sum; MPI_Barrier (MPI_COMM_WORLD); g_printerr ("%d: processor msg stats fw=%d bw=%d\n", rk, _fw_count, _bw_count); g_printerr ("%d: processor call stats near=%d far=%d\n", rk, _near_count, _far_count); MPI_Reduce (&_near_count, &near_count_sum, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD); MPI_Reduce (&_far_count, &far_count_sum, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD); if (rk == 0) { g_printerr ("%d: mean call stats near=%f far=%f\n", rk, (1.*near_count_sum)/sz, (1.*far_count_sum)/sz); } } /* check correctness of results */ g_ptr_array_foreach (points, (GFunc) _check_pt_count, &_ref_count); /* destroy the points */ g_ptr_array_foreach (points, empty_array, NULL); g_ptr_array_free (points, TRUE); /* destroy the tree */ vsg_prtree2d_free (tree); if (nc_padding > 0) g_free (_nc_padding_buffer); MPI_Finalize (); return ret; }
static GVariant * parse_json_dictionary (JsonNode *node, const GVariantType *entry_type, GError **error) { const GVariantType *key_type; const GVariantType *value_type; GVariant *result = NULL; GPtrArray *children; JsonObject *object; JsonNode *key_node; GList *members = NULL; gboolean is_string; GVariant *value; GVariant *key; GVariant *child; GList *l; children = g_ptr_array_new (); if (!check_type (node, JSON_NODE_OBJECT, 0, error)) goto out; object = json_node_get_object (node); key_type = g_variant_type_key (entry_type); value_type = g_variant_type_value (entry_type); is_string = (g_variant_type_equal (key_type, G_VARIANT_TYPE_STRING) || g_variant_type_equal (key_type, G_VARIANT_TYPE_OBJECT_PATH) || g_variant_type_equal (key_type, G_VARIANT_TYPE_SIGNATURE)); members = json_object_get_members (object); for (l = members; l != NULL; l = g_list_next (l)) { if (is_string) { key_node = json_node_init_string (json_node_alloc (), l->data); } else { key_node = cockpit_json_parse (l->data, -1, NULL); if (key_node == NULL) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA, "Unexpected key '%s' in JSON object", (gchar *)l->data); goto out; } } key = parse_json (key_node, key_type, error); json_node_free (key_node); if (!key) goto out; value = parse_json (json_object_get_member (object, l->data), value_type, error); if (!value) { g_variant_unref (key); goto out; } child = g_variant_new_dict_entry (key, value); g_ptr_array_add (children, child); } result = g_variant_new_array (entry_type, (GVariant *const *)children->pdata, children->len); children->len = 0; out: g_list_free (members); g_ptr_array_foreach (children, (GFunc)g_variant_unref, NULL); g_ptr_array_free (children, TRUE); return result; }
static GwyContainer* igor_load(const gchar *filename, G_GNUC_UNUSED GwyRunType mode, GError **error) { GwyContainer *meta = NULL, *container = NULL; GwyDataField *dfield = NULL, *maskfield = NULL; GwyTextHeaderParser parser; IgorFile igorfile; IgorWaveHeader5 *wave5; GError *err = NULL; guchar *p, *buffer = NULL; gint xres, yres; gsize expected_size, size = 0; gchar *note = NULL; const gchar *value; gchar key[64]; guint i, chid; GQuark quark; guint nlabels; if (!gwy_file_get_contents(filename, &buffer, &size, &err)) { err_GET_FILE_CONTENTS(error, &err); return NULL; } gwy_clear(&igorfile, 1); if (!igor_read_headers(&igorfile, buffer, size, FALSE, error)) goto fail; /* Only accept v5 files because older do not support 2D data */ if (igorfile.header.version != 5) { g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA, _("Format version is %d. Only version 5 is supported."), igorfile.header.version); goto fail; } /* Detect Asylum research files, leave it at generic if not detected. */ if (memcmp(buffer + size-5, "MFP3D", 5) == 0) igorfile.variant = IGOR_ASYLUM_MPF3D; else if (memcmp(buffer + size-5, "Force", 5) == 0) igorfile.variant = IGOR_ASYLUM_FORCE; gwy_debug("producer variant %u", igorfile.variant); /* Must have exactly 3 dims: xres, yres, nchannels */ wave5 = &igorfile.wave5; xres = wave5->n_dim[0]; yres = wave5->n_dim[1]; igorfile.nchannels = wave5->n_dim[2]; if (igorfile.nchannels==0) igorfile.nchannels=1; if (!xres || !yres || !igorfile.nchannels || wave5->n_dim[3]) { g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA, _("Only two-dimensional data are supported.")); goto fail; } igorfile.type_size = igor_data_type_size(wave5->type); if (!igorfile.type_size) { err_DATA_TYPE(error, wave5->type); goto fail; } if (wave5->npts != xres*yres*igorfile.nchannels) { g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA, _("Number of data points %u does not match resolutions " "%u×%u×%u."), wave5->npts, xres, yres, igorfile.nchannels); goto fail; } if (igorfile.header.wfm_size <= igorfile.wave_header_size) { err_INVALID(error, "wfmSize"); goto fail; } expected_size = igorfile.header.wfm_size - igorfile.wave_header_size; if (expected_size != wave5->npts*igorfile.type_size) { g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA, _("Data size %u does not match " "the number of data points %u×%u."), (guint)expected_size, wave5->npts, igorfile.type_size); } if (err_SIZE_MISMATCH(error, expected_size + igorfile.headers_size, size, FALSE)) goto fail; p = buffer + igorfile.headers_size + expected_size; gwy_debug("remaning data size: %lu", (gulong)(size - (p - buffer))); p += igorfile.header.formula_size; if ((igorfile.variant == IGOR_ASYLUM_FORCE || igorfile.variant == IGOR_ASYLUM_MPF3D) && igorfile.header.note_size && (p - buffer) + igorfile.header.note_size <= size) { note = g_strndup((const gchar*)p, size); gwy_clear(&parser, 1); parser.key_value_separator = ":"; igorfile.meta = gwy_text_header_parse(note, &parser, NULL, NULL); } p += igorfile.header.note_size; /* FIXME: Support extended units for non-Asylum files! */ p += igorfile.header.data_e_units_size; for (i = 0; i < MAXDIMS; i++) p += igorfile.header.dim_e_units_size[i]; /* Skip labels of x and y dimension, we don't know what to do with them. */ for (i = 0; i < 2; i++) p += igorfile.header.dim_labels_size[i]; /* FIXME: The labels are mandatory only in Asylum Research files. */ nlabels = igorfile.header.dim_labels_size[2]/(MAX_WAVE_NAME5+1); expected_size = (MAX_WAVE_NAME5 + 1)*(nlabels); if ((p - buffer) + expected_size > size ) { g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA, _("Cannot read channel labels.")); goto fail; } igorfile.titles = read_channel_labels(p, igorfile.nchannels+1, nlabels); p += igorfile.header.dim_labels_size[2]; if (igorfile.meta) { igorfile.channel_info = g_new0(AsylumChannelInfo, igorfile.nchannels); for (i = 0; i < igorfile.nchannels; i++) { AsylumChannelInfo *chinfo = igorfile.channel_info + i; const gchar *title = g_ptr_array_index(igorfile.titles, i+1); if (title) { chinfo->name = canonicalize_title(title); g_snprintf(key, sizeof(key), "%sUnit", chinfo->name); value = g_hash_table_lookup(igorfile.meta, key); if (value) chinfo->units = value; else chinfo->units = channel_title_to_units(chinfo->name); } } } container = gwy_container_new(); for (i = chid = 0; i < igorfile.nchannels; i++, chid++) { const gchar *title = g_ptr_array_index(igorfile.titles, i+1); const gchar *zunits = NULL; if (igorfile.channel_info) { AsylumChannelInfo *chinfo = igorfile.channel_info + i; zunits = chinfo->units; meta = igor_get_metadata(&igorfile, i + 1); } dfield = igor_read_data_field(&igorfile, buffer, i, zunits, FALSE); maskfield = gwy_app_channel_mask_of_nans(dfield, TRUE); quark = gwy_app_get_data_key_for_id(chid); gwy_container_set_object(container, quark, dfield); g_object_unref(dfield); if (maskfield) { g_snprintf(key, sizeof(key), "/%d/mask", chid); gwy_container_set_object_by_name(container, key, maskfield); } if (meta) { g_snprintf(key, sizeof(key), "/%d/meta", chid); gwy_container_set_object_by_name(container, key, meta); } if (title) { g_snprintf(key, sizeof(key), "/%d/data/title", chid); gwy_container_set_string_by_name(container, key, g_strdup(title)); } gwy_app_channel_title_fall_back(container,chid); if (wave5->type & IGOR_COMPLEX) { chid++; dfield = igor_read_data_field(&igorfile, buffer, i, zunits, TRUE); quark = gwy_app_get_data_key_for_id(chid); gwy_container_set_object(container, quark, dfield); g_object_unref(dfield); if (meta) { g_snprintf(key, sizeof(key), "/%d/meta", chid); /* container still holds a reference */ g_object_unref(meta); meta = gwy_container_duplicate(meta); gwy_container_set_object_by_name(container, key, meta); } if (maskfield) { g_snprintf(key, sizeof(key), "/%d/mask", chid); /* container still holds a reference */ g_object_unref(maskfield); maskfield = gwy_data_field_duplicate(maskfield); gwy_container_set_object_by_name(container, key, maskfield); } if (title) { g_snprintf(key, sizeof(key), "/%d/data/title", chid); gwy_container_set_string_by_name(container, key, g_strdup(title)); }; gwy_app_channel_title_fall_back(container,chid); } gwy_object_unref(meta); gwy_object_unref(maskfield); gwy_file_channel_import_log_add(container, chid, NULL, filename); } fail: gwy_file_abandon_contents(buffer, size, NULL); g_free(note); if (igorfile.channel_info) { for (i = 0; i < igorfile.nchannels; i++) g_free(igorfile.channel_info[i].name); g_free(igorfile.channel_info); } if (igorfile.meta) g_hash_table_destroy(igorfile.meta); if (igorfile.titles) { g_ptr_array_foreach(igorfile.titles, (GFunc)g_free, NULL); g_ptr_array_free(igorfile.titles, TRUE); } return container; }
static GwyContainer* ezdfile_load(const gchar *filename, G_GNUC_UNUSED GwyRunType mode, GError **error) { GwyContainer *meta, *container = NULL; guchar *buffer = NULL; gsize size = 0; GError *err = NULL; EZDSection *section = NULL; GwyDataField *dfield = NULL; GPtrArray *ezdfile; guint header_size, n; gint i; gchar *p; if (!gwy_file_get_contents(filename, &buffer, &size, &err)) { err_GET_FILE_CONTENTS(error, &err); return NULL; } if (strncmp(buffer, MAGIC, MAGIC_SIZE) || !(header_size = find_data_start(buffer, size))) { err_FILE_TYPE(error, "EZD/NID"); gwy_file_abandon_contents(buffer, size, NULL); return NULL; } ezdfile = g_ptr_array_new(); p = g_strndup(buffer, header_size - DATA_MAGIC_SIZE); if (!file_read_header(ezdfile, p, error)) { gwy_file_abandon_contents(buffer, size, NULL); g_free(p); return NULL; } g_free(p); n = find_data_offsets(buffer + header_size, size - header_size, ezdfile, error); if (!n) { gwy_file_abandon_contents(buffer, size, NULL); return NULL; } /* fix for ranges equal to zero */ g_ptr_array_foreach(ezdfile, &check_section_ranges, NULL); container = gwy_container_new(); i = 0; for (n = 0; n < ezdfile->len; n++) { gchar key[24]; section = (EZDSection*)g_ptr_array_index(ezdfile, n); if (!section->data) continue; if (err_DIMENSION(NULL, section->xres) || err_DIMENSION(NULL, section->yres)) continue; dfield = gwy_data_field_new(section->xres, section->yres, 1.0, 1.0, FALSE); read_data_field(dfield, section); g_snprintf(key, sizeof(key), "/%d/data", i); gwy_container_set_object_by_name(container, key, dfield); g_object_unref(dfield); fix_scales(section, i, container); meta = ezdfile_get_metadata(ezdfile, n); if (meta) { g_snprintf(key, sizeof(key), "/%d/meta", i); gwy_container_set_object_by_name(container, key, meta); g_object_unref(meta); } i++; } gwy_file_abandon_contents(buffer, size, NULL); ezdfile_free(ezdfile); return container; }
static void detail_device (gpointer data, gpointer user_data) { NMDevice *device = NM_DEVICE (data); struct cb_info *info = user_data; char *tmp; NMDeviceState state; guint32 caps; guint32 speed; const GArray *array; int j; gboolean is_default = FALSE; const char *id = NULL; state = nm_device_get_state (device); for (j = 0; info->active && (j < info->active->len); j++) { NMActiveConnection *candidate = g_ptr_array_index (info->active, j); const GPtrArray *devices = nm_active_connection_get_devices (candidate); NMDevice *candidate_dev; NMConnection *connection; NMSettingConnection *s_con; if (!devices || !devices->len) continue; candidate_dev = g_ptr_array_index (devices, 0); if (candidate_dev == device) { if (nm_active_connection_get_default (candidate)) is_default = TRUE; connection = get_connection_for_active (candidate); if (!connection) break; s_con = (NMSettingConnection *) nm_connection_get_setting (connection, NM_TYPE_SETTING_CONNECTION); if (s_con) id = nm_setting_connection_get_id (s_con); break; } } print_header ("Device", nm_device_get_iface (device), id); /* General information */ if (NM_IS_DEVICE_ETHERNET (device)) print_string ("Type", "Wired"); else if (NM_IS_DEVICE_WIFI (device)) print_string ("Type", "802.11 WiFi"); else if (NM_IS_GSM_DEVICE (device)) print_string ("Type", "Mobile Broadband (GSM)"); else if (NM_IS_CDMA_DEVICE (device)) print_string ("Type", "Mobile Broadband (CDMA)"); else if (NM_IS_DEVICE_BT (device)) print_string ("Type", "Bluetooth"); print_string ("Driver", nm_device_get_driver (device) ? nm_device_get_driver (device) : "(unknown)"); print_string ("State", get_dev_state_string (state)); if (is_default) print_string ("Default", "yes"); else print_string ("Default", "no"); tmp = NULL; if (NM_IS_DEVICE_ETHERNET (device)) tmp = g_strdup (nm_device_ethernet_get_hw_address (NM_DEVICE_ETHERNET (device))); else if (NM_IS_DEVICE_WIFI (device)) tmp = g_strdup (nm_device_wifi_get_hw_address (NM_DEVICE_WIFI (device))); if (tmp) { print_string ("HW Address", tmp); g_free (tmp); } /* Capabilities */ caps = nm_device_get_capabilities (device); printf ("\n Capabilities:\n"); if (caps & NM_DEVICE_CAP_CARRIER_DETECT) print_string (" Carrier Detect", "yes"); speed = 0; if (NM_IS_DEVICE_ETHERNET (device)) { /* Speed in Mb/s */ speed = nm_device_ethernet_get_speed (NM_DEVICE_ETHERNET (device)); } else if (NM_IS_DEVICE_WIFI (device)) { /* Speed in b/s */ speed = nm_device_wifi_get_bitrate (NM_DEVICE_WIFI (device)); speed /= 1000; } if (speed) { char *speed_string; speed_string = g_strdup_printf ("%u Mb/s", speed); print_string (" Speed", speed_string); g_free (speed_string); } /* Wireless specific information */ if ((NM_IS_DEVICE_WIFI (device))) { guint32 wcaps; NMAccessPoint *active_ap = NULL; const char *active_bssid = NULL; const GPtrArray *aps; printf ("\n Wireless Properties\n"); wcaps = nm_device_wifi_get_capabilities (NM_DEVICE_WIFI (device)); if (wcaps & (NM_WIFI_DEVICE_CAP_CIPHER_WEP40 | NM_WIFI_DEVICE_CAP_CIPHER_WEP104)) print_string (" WEP Encryption", "yes"); if (wcaps & NM_WIFI_DEVICE_CAP_WPA) print_string (" WPA Encryption", "yes"); if (wcaps & NM_WIFI_DEVICE_CAP_RSN) print_string (" WPA2 Encryption", "yes"); if (nm_device_get_state (device) == NM_DEVICE_STATE_ACTIVATED) { active_ap = nm_device_wifi_get_active_access_point (NM_DEVICE_WIFI (device)); active_bssid = active_ap ? nm_access_point_get_hw_address (active_ap) : NULL; } printf ("\n Wireless Access Points %s\n", active_ap ? "(* = current AP)" : ""); aps = nm_device_wifi_get_access_points (NM_DEVICE_WIFI (device)); if (aps && aps->len) g_ptr_array_foreach ((GPtrArray *) aps, detail_access_point, (gpointer) active_bssid); } else if (NM_IS_DEVICE_ETHERNET (device)) { printf ("\n Wired Properties\n"); if (nm_device_ethernet_get_carrier (NM_DEVICE_ETHERNET (device))) print_string (" Carrier", "on"); else print_string (" Carrier", "off"); } /* IP Setup info */ if (state == NM_DEVICE_STATE_ACTIVATED) { NMIP4Config *cfg = nm_device_get_ip4_config (device); GSList *iter; printf ("\n IPv4 Settings:\n"); for (iter = (GSList *) nm_ip4_config_get_addresses (cfg); iter; iter = g_slist_next (iter)) { NMIP4Address *addr = (NMIP4Address *) iter->data; guint32 prefix = nm_ip4_address_get_prefix (addr); char *tmp2; tmp = ip4_address_as_string (nm_ip4_address_get_address (addr)); print_string (" Address", tmp); g_free (tmp); tmp2 = ip4_address_as_string (nm_utils_ip4_prefix_to_netmask (prefix)); tmp = g_strdup_printf ("%d (%s)", prefix, tmp2); g_free (tmp2); print_string (" Prefix", tmp); g_free (tmp); tmp = ip4_address_as_string (nm_ip4_address_get_gateway (addr)); print_string (" Gateway", tmp); g_free (tmp); printf ("\n"); } array = nm_ip4_config_get_nameservers (cfg); if (array) { int i; for (i = 0; i < array->len; i++) { tmp = ip4_address_as_string (g_array_index (array, guint32, i)); print_string (" DNS", tmp); g_free (tmp); } } } printf ("\n\n"); }
void wtap_close(wtap *wth) { guint i, j; wtapng_if_descr_t *wtapng_if_descr; wtapng_if_stats_t *if_stats; wtap_sequential_close(wth); if (wth->subtype_close != NULL) (*wth->subtype_close)(wth); if (wth->random_fh != NULL) file_close(wth->random_fh); if (wth->priv != NULL) g_free(wth->priv); if (wth->fast_seek != NULL) { g_ptr_array_foreach(wth->fast_seek, g_fast_seek_item_free, NULL); g_ptr_array_free(wth->fast_seek, TRUE); } g_free(wth->shb_hdr.opt_comment); g_free(wth->shb_hdr.shb_hardware); g_free(wth->shb_hdr.shb_os); g_free(wth->shb_hdr.shb_user_appl); for(i = 0; i < wth->interface_data->len; i++) { wtapng_if_descr = &g_array_index(wth->interface_data, wtapng_if_descr_t, i); if(wtapng_if_descr->opt_comment != NULL){ g_free(wtapng_if_descr->opt_comment); } if(wtapng_if_descr->if_name != NULL){ g_free(wtapng_if_descr->if_name); } if(wtapng_if_descr->if_description != NULL){ g_free(wtapng_if_descr->if_description); } if(wtapng_if_descr->if_filter_str != NULL){ g_free(wtapng_if_descr->if_filter_str); } if(wtapng_if_descr->if_filter_bpf_bytes != NULL){ g_free(wtapng_if_descr->if_filter_bpf_bytes); } if(wtapng_if_descr->if_os != NULL){ g_free(wtapng_if_descr->if_os); } for(j = 0; j < wtapng_if_descr->num_stat_entries; j++) { if_stats = &g_array_index(wtapng_if_descr->interface_statistics, wtapng_if_stats_t, j); if(if_stats->opt_comment != NULL){ g_free(if_stats->opt_comment); } } if(wtapng_if_descr->num_stat_entries != 0){ g_array_free(wtapng_if_descr->interface_statistics, TRUE); } } g_array_free(wth->interface_data, TRUE); g_free(wth); }
int main (int argc, char **argv) { #ifdef VSG_HAVE_MPI VsgPRTreeParallelConfig pconfig = {{NULL,}}; #endif VsgVector2d lbound = {-1., -1.}; VsgVector2d ubound = {1., 1.}; VsgPRTree2d *prtree; AranSolver2d *solver; int ret = 0; guint i; GTimer *timer = NULL; #ifdef VSG_HAVE_MPI MPI_Init (&argc, &argv); MPI_Comm_size (MPI_COMM_WORLD, &sz); MPI_Comm_rank (MPI_COMM_WORLD, &rk); #endif aran_init(); parse_args (argc, argv); #ifdef VSG_HAVE_MPI pconfig.communicator = MPI_COMM_WORLD; pconfig.point = point_accum_vtable; aran_development2d_vtable_init (&pconfig.node_data, 0, order); #endif points = g_ptr_array_new (); if (check) check_points = g_malloc0 (np * sizeof (PointAccum)); prtree = vsg_prtree2d_new_full (&lbound, &ubound, (VsgPoint2dLocFunc) vsg_vector2d_vector2d_locfunc, (VsgPoint2dDistFunc) vsg_vector2d_dist, (VsgRegion2dLocFunc) NULL, maxbox); aran_binomial_require (2*order); solver = aran_solver2d_new (prtree, ARAN_TYPE_DEVELOPMENT2D, aran_development2d_new (0, order), (AranZeroFunc) aran_development2d_set_zero); #ifdef VSG_HAVE_MPI aran_solver2d_set_parallel (solver, &pconfig); #endif if (virtual_maxbox != 0) aran_solver2d_set_nf_isleaf (solver, _nf_isleaf_virtual_maxbox, &virtual_maxbox); aran_solver2d_set_functions (solver, (AranParticle2ParticleFunc2d) p2p, (AranParticle2MultipoleFunc2d) p2m, (AranMultipole2MultipoleFunc2d) aran_development2d_m2m, (AranMultipole2LocalFunc2d) aran_development2d_m2l, (AranLocal2LocalFunc2d) aran_development2d_l2l, (AranLocal2ParticleFunc2d)l2p); if (semifar_threshold < G_MAXUINT) { aran_solver2d_set_functions_full (solver, (AranParticle2ParticleFunc2d) p2p, (AranParticle2MultipoleFunc2d) p2m, (AranMultipole2MultipoleFunc2d) aran_development2d_m2m, (AranMultipole2LocalFunc2d) aran_development2d_m2l, (AranLocal2LocalFunc2d) aran_development2d_l2l, (AranLocal2ParticleFunc2d) l2p, (AranParticle2LocalFunc2d) p2l, (AranMultipole2ParticleFunc2d) m2p, semifar_threshold); if (semifar_threshold == 0) { PointAccum p1 = {{0.1, 0.1}, 0.1, 0., 0}; PointAccum p2 = {{-0.1, -0.1}, 0.1, 0., 1}; /* compute operators timings to be able to compute optimal solver parameters */ aran_solver2d_profile_operators (solver, (AranParticleInitFunc2d) point_accum_clear_accum, &p1, &p2); /* alternatively, we could get timings from profile databases */ /* aran_profile_db_read_file ("./profiledb-newtonfield3.ini", NULL); */ /* aran_solver2d_db_profile_operators (solver, (gdouble) order); */ } } if (_hilbert) { /* configure for hilbert curve order traversal */ aran_solver2d_set_children_order_hilbert (solver); } _distribution (points, solver); if (_verbose) { g_printerr ("%d : solve begin\n", rk); #ifdef VSG_HAVE_MPI MPI_Barrier (MPI_COMM_WORLD); #endif timer = g_timer_new (); } aran_solver2d_solve (solver); if (_verbose) { #ifdef VSG_HAVE_MPI MPI_Barrier (MPI_COMM_WORLD); #endif g_printerr ("%d : solve ok elapsed=%f seconds\n", rk, g_timer_elapsed (timer, NULL)); g_timer_destroy (timer); } if (check) { if (sz == 1) { for (i=0; i<np; i++) { PointAccum *pi = &check_points[i]; guint j; for (j=0; j<np; j++) { if (i != j) { PointAccum *pj = &check_points[j]; gcomplex128 zd_m_zs = (pi->vector.x + I*pi->vector.y) - (pj->vector.x + I*pj->vector.y); pi->accum += 1./zd_m_zs * pj->density; } } } } else check_parallel_points (solver); aran_solver2d_foreach_point (solver, (GFunc) check_point_accum, &ret); if (_verbose) g_printerr ("%d : max err = %e\n", rk, maxerr); g_free (check_points); } aran_solver2d_free (solver); #ifdef VSG_HAVE_MPI aran_development2d_vtable_clear (&pconfig.node_data); #endif /* destroy the points */ g_ptr_array_foreach (points, empty_array, NULL); g_ptr_array_free (points, TRUE); #ifdef VSG_HAVE_MPI MPI_Finalize (); #endif return ret; }
void free_codepages_list (void) { g_ptr_array_foreach (codepages, free_codepage_desc, NULL); g_ptr_array_free (codepages, TRUE); }
static void free_names(GPtrArray *names) { g_ptr_array_foreach(names, (GFunc)g_free, NULL); g_ptr_array_free(names, TRUE); }
static void _init_recipient_page(struct MessageNewViewData *view) { Evas_Object *win, *btn; win = ui_utils_view_window_get(VIEW_PTR(*view)); view->layout_recipients = elm_layout_add(view->pager); elm_win_resize_object_add(win, view->layout_recipients); elm_layout_file_set(view->layout_recipients, phoneui_theme, "phoneui/messages/new/recipients"); evas_object_show(view->layout_recipients); edje_object_part_text_set(elm_layout_edje_get(view->layout_recipients), "recipients_title", D_("Define Recipients")); view->list_recipients = elm_genlist_add(win); elm_genlist_mode_set(view->list_recipients, ELM_LIST_LIMIT); evas_object_size_hint_align_set(view->list_recipients, 0.0, 0.0); evas_object_size_hint_weight_set(view->list_recipients, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); elm_object_scale_set(view->list_recipients, 1.0); elm_object_part_content_set(view->layout_recipients, "recipients_list", view->list_recipients); itc.item_style = "contact"; itc.func.text_get = gl_text_get; itc.func.content_get = gl_content_get; itc.func.state_get = NULL; itc.func.del = gl_del; evas_object_show(view->list_recipients); g_ptr_array_foreach(view->recipients, _process_recipient, view); btn = elm_button_add(win); elm_object_text_set(btn, D_("Back")); evas_object_smart_callback_add(btn, "clicked", _recipients_button_back_clicked, view); elm_object_part_content_set(view->layout_recipients, "recipients_button_back", btn); evas_object_show(btn); btn = elm_button_add(win); elm_object_text_set(btn, D_("Contact")); evas_object_smart_callback_add(btn, "clicked", _recipients_button_add_contact_clicked, view); elm_object_part_content_set(view->layout_recipients, "recipients_button_add_contact", btn); evas_object_show(btn); btn = elm_button_add(win); elm_object_text_set(btn, D_("Number")); evas_object_smart_callback_add(btn, "clicked", _recipients_button_add_number_clicked, view); elm_object_part_content_set(view->layout_recipients, "recipients_button_add_number", btn); evas_object_show(btn); btn = elm_button_add(win); elm_object_text_set(btn, D_("Send")); evas_object_smart_callback_add(btn, "clicked", _recipients_button_send_clicked, view); elm_object_part_content_set(view->layout_recipients, "recipients_button_send", btn); evas_object_show(btn); elm_naviframe_item_simple_push(view->pager, view->layout_recipients); }
void ipc_recv_scroll(ipc_endpoint_t *UNUSED(ipc), ipc_scroll_t *msg, guint UNUSED(length)) { g_ptr_array_foreach(globalconf.webviews, (GFunc)webview_scroll_recv, msg); }
static void PrintElements(GPtrArray* array) { g_ptr_array_foreach(array, &PrintElement, NULL); }
gint main (gint argc, gchar ** argv) { gint ret = 0; VsgPRTree3d *tree; VsgVector3d lb; VsgVector3d ub; MPI_Init (&argc, &argv); MPI_Comm_size (MPI_COMM_WORLD, &sz); MPI_Comm_rank (MPI_COMM_WORLD, &rk); vsg_init_gdouble (); parse_args (argc, argv); points = g_ptr_array_new (); regions = g_ptr_array_new (); lb.x = -1.; lb.y = -1.; lb.z = -1.; ub.x = 1.; ub.y = 1.; ub.z = 1.; /* create the tree */ tree = vsg_prtree3d_new_full (&lb, &ub, (VsgPoint3dLocFunc) vsg_vector3d_vector3d_locfunc, (VsgPoint3dDistFunc) vsg_vector3d_dist, (VsgRegion3dLocFunc) _sphere_loc3, 2); if (_hilbert) { /* configure for hilbert curve order traversal */ vsg_prtree3d_set_children_order_hilbert (tree); } if (_verbose) { MPI_Barrier (MPI_COMM_WORLD); g_printerr ("%d: set_parallel begin\n", rk); } vsg_prtree3d_set_parallel (tree, &pconfig); if (_verbose) { MPI_Barrier (MPI_COMM_WORLD); g_printerr ("%d: set_parallel ok\n", rk); } if (_verbose) { MPI_Barrier (MPI_COMM_WORLD); g_printerr ("%d: fill begin\n", rk); } _fill (tree, _np); _check_local_counts (tree); if (_verbose) { MPI_Barrier (MPI_COMM_WORLD); g_printerr ("%d: fill ok\n", rk); } /* update total points and regions count */ init_total_points_count (); init_total_regions_count (); if (_scatter_before) { if (_verbose) { MPI_Barrier (MPI_COMM_WORLD); g_printerr ("%d: scatter nodes begin\n", rk); } vsg_prtree3d_distribute_scatter_leaves (tree); _check_local_counts (tree); ret += check_points_number (tree); ret += check_regions_number (tree); if (_verbose) { MPI_Barrier (MPI_COMM_WORLD); g_printerr ("%d: scatter nodes ok\n", rk); } _write_regions (tree, "rg-scatter"); _tree_write (tree, "scatter-"); } if (_do_contiguous) { if (_verbose) { MPI_Barrier (MPI_COMM_WORLD); g_printerr ("%d: contiguous distribute begin\n", rk); } vsg_prtree3d_distribute_contiguous_leaves (tree); _check_local_counts (tree); ret += check_points_number (tree); ret += check_regions_number (tree); if (_verbose) { MPI_Barrier (MPI_COMM_WORLD); g_printerr ("%d: contiguous distribute ok\n", rk); } _write_regions (tree, "rg-contiguous"); } _exterior_points (tree); vsg_prtree3d_distribute_contiguous_leaves (tree); _check_local_counts (tree); if (_do_write) { MPI_Barrier (MPI_COMM_WORLD); _tree_write (tree, "prtree3parallel-"); } if (_do_write) { gchar fn[1024]; FILE *f; g_sprintf (fn, "prtree3parallel-%03d.txt", rk); f = fopen (fn, "w"); vsg_prtree3d_write (tree, f); fclose (f); } /* destroy the points */ g_ptr_array_foreach (points, empty_array, NULL); g_ptr_array_free (points, TRUE); /* destroy the spheres */ g_ptr_array_foreach (regions, empty_array, NULL); g_ptr_array_free (regions, TRUE); /* destroy the tree */ vsg_prtree3d_free (tree); MPI_Finalize (); return ret; }
// Frees all elements, but does not modify the pointer array. static void FreeElements(GPtrArray* array) { g_ptr_array_foreach(array, &FreeElement, NULL); }
static gboolean egg_desktop_file_launchv (EggDesktopFile *desktop_file, GSList *documents, va_list args, GError **error) { EggDesktopFileLaunchOption option; GSList *translated_documents = NULL, *docs = NULL; char *command, **argv; int argc, i, screen_num; gboolean success, current_success; GdkDisplay *display; char *startup_id; GPtrArray *env = NULL; char **variables = NULL; GdkScreen *screen = NULL; int workspace = -1; const char *directory = NULL; guint32 launch_time = (guint32)-1; GSpawnFlags flags = G_SPAWN_SEARCH_PATH; GSpawnChildSetupFunc setup_func = NULL; gpointer setup_data = NULL; GPid *ret_pid = NULL; int *ret_stdin = NULL, *ret_stdout = NULL, *ret_stderr = NULL; char **ret_startup_id = NULL; if (documents && desktop_file->document_code == 0) { g_set_error (error, EGG_DESKTOP_FILE_ERROR, EGG_DESKTOP_FILE_ERROR_NOT_LAUNCHABLE, _("Application does not accept documents on command line")); return FALSE; } /* Read the options: technically it's incorrect for the caller to * NULL-terminate the list of options (rather than 0-terminating * it), but NULL-terminating lets us use G_GNUC_NULL_TERMINATED, * it's more consistent with other glib/gtk methods, and it will * work as long as sizeof (int) <= sizeof (NULL), and NULL is * represented as 0. (Which is true everywhere we care about.) */ while ((option = va_arg (args, EggDesktopFileLaunchOption))) { switch (option) { case EGG_DESKTOP_FILE_LAUNCH_CLEARENV: if (env) g_ptr_array_free (env, TRUE); env = g_ptr_array_new (); break; case EGG_DESKTOP_FILE_LAUNCH_PUTENV: variables = va_arg (args, char **); for (i = 0; variables[i]; i++) env = array_putenv (env, variables[i]); break; case EGG_DESKTOP_FILE_LAUNCH_SCREEN: screen = va_arg (args, GdkScreen *); break; case EGG_DESKTOP_FILE_LAUNCH_WORKSPACE: workspace = va_arg (args, int); break; case EGG_DESKTOP_FILE_LAUNCH_DIRECTORY: directory = va_arg (args, const char *); break; case EGG_DESKTOP_FILE_LAUNCH_TIME: launch_time = va_arg (args, guint32); break; case EGG_DESKTOP_FILE_LAUNCH_FLAGS: flags |= va_arg (args, GSpawnFlags); /* Make sure they didn't set any flags that don't make sense. */ flags &= ~G_SPAWN_FILE_AND_ARGV_ZERO; break; case EGG_DESKTOP_FILE_LAUNCH_SETUP_FUNC: setup_func = va_arg (args, GSpawnChildSetupFunc); setup_data = va_arg (args, gpointer); break; case EGG_DESKTOP_FILE_LAUNCH_RETURN_PID: ret_pid = va_arg (args, GPid *); break; case EGG_DESKTOP_FILE_LAUNCH_RETURN_STDIN_PIPE: ret_stdin = va_arg (args, int *); break; case EGG_DESKTOP_FILE_LAUNCH_RETURN_STDOUT_PIPE: ret_stdout = va_arg (args, int *); break; case EGG_DESKTOP_FILE_LAUNCH_RETURN_STDERR_PIPE: ret_stderr = va_arg (args, int *); break; case EGG_DESKTOP_FILE_LAUNCH_RETURN_STARTUP_ID: ret_startup_id = va_arg (args, char **); break; default: g_set_error (error, EGG_DESKTOP_FILE_ERROR, EGG_DESKTOP_FILE_ERROR_UNRECOGNIZED_OPTION, _("Unrecognized launch option: %d"), GPOINTER_TO_INT (option)); success = FALSE; goto out; } } if (screen) { char *display_name = gdk_screen_make_display_name (screen); char *display_env = g_strdup_printf ("DISPLAY=%s", display_name); env = array_putenv (env, display_env); g_free (display_name); g_free (display_env); display = gdk_screen_get_display (screen); } else { display = gdk_display_get_default (); screen = gdk_display_get_default_screen (display); } screen_num = gdk_screen_get_number (screen); translated_documents = translate_document_list (desktop_file, documents); docs = translated_documents; success = FALSE; do { command = parse_exec (desktop_file, &docs, error); if (!command) goto out; if (!g_shell_parse_argv (command, &argc, &argv, error)) { g_free (command); goto out; } g_free (command); #if GTK_CHECK_VERSION (2, 12, 0) startup_id = start_startup_notification (display, desktop_file, argv[0], screen_num, workspace, launch_time); if (startup_id) { char *startup_id_env = g_strdup_printf ("DESKTOP_STARTUP_ID=%s", startup_id); env = array_putenv (env, startup_id_env); g_free (startup_id_env); } #else startup_id = NULL; #endif /* GTK 2.12 */ if (env != NULL) g_ptr_array_add (env, NULL); current_success = g_spawn_async_with_pipes (directory, argv, env ? (char **)(env->pdata) : NULL, flags, setup_func, setup_data, ret_pid, ret_stdin, ret_stdout, ret_stderr, error); g_strfreev (argv); if (startup_id) { #if GTK_CHECK_VERSION (2, 12, 0) if (current_success) { set_startup_notification_timeout (display, startup_id); if (ret_startup_id) *ret_startup_id = startup_id; else g_free (startup_id); } else #endif /* GTK 2.12 */ g_free (startup_id); } else if (ret_startup_id) *ret_startup_id = NULL; if (current_success) { /* If we successfully launch any instances of the app, make * sure we return TRUE and don't set @error. */ success = TRUE; error = NULL; /* Also, only set the output params on the first one */ ret_pid = NULL; ret_stdin = ret_stdout = ret_stderr = NULL; ret_startup_id = NULL; } } while (docs && current_success); out: if (env) { g_ptr_array_foreach (env, (GFunc)g_free, NULL); g_ptr_array_free (env, TRUE); } free_document_list (translated_documents); return success; }
CLFEXP void claro_list_foreach(claro_list_t * list, list_foreach_func * foreach_func, void * data) { GPtrArray * array = (GPtrArray *)list; g_ptr_array_foreach(array, (GFunc)foreach_func, data); }
gint main (gint argc, gchar ** argv) { gint ret = 0; VsgPRTree3d *tree; gint i; VsgVector3d lb; VsgVector3d ub; MPI_Init (&argc, &argv); MPI_Comm_size (MPI_COMM_WORLD, &sz); MPI_Comm_rank (MPI_COMM_WORLD, &rk); if (argc > 1 && g_strncasecmp (argv[1], "--version", 9) == 0) { if (rk == 0) g_print ("%s\n", PACKAGE_VERSION); return 0; } if (argc > 1 && g_strncasecmp (argv[1], "--write", 7) == 0) { _do_write = TRUE; } vsg_init_gdouble (); points = g_ptr_array_new (); regions = g_ptr_array_new (); if (rk == 0) { VsgVector3d *pt; Sphere *c; lb.x = -1.; lb.y = -1.; lb.z = -1.; ub.x = 0.; ub.y = 0.; ub.z = 0.; pt = pt_alloc (TRUE, NULL); pt->x = -0.5; pt->y = -0.5; pt->z = -0.5; c = rg_alloc (TRUE, NULL); c->center.x = -0.6; c->center.y = -0.6; c->center.z = -0.6; c->radius = 0.1; } else { VsgVector3d *pt; Sphere *c; lb.x = 0.; lb.y = 0.; lb.z = 0.; ub.x = 1.*rk; ub.y = 1.*rk; ub.z = 1.*rk; pt = pt_alloc (TRUE, NULL); pt->x = 0.5*rk; pt->y = 0.5*rk; pt->z = 0.5*rk; pt = pt_alloc (TRUE, NULL); pt->x = 0.60*rk; pt->y = 0.65*rk; pt->z = 0.70*rk; pt = pt_alloc (TRUE, NULL); pt->x = 0.15*rk; pt->y = 0.75*rk; pt->z = 0.80*rk; c = rg_alloc (TRUE, NULL); c->center.x = 0.6*rk; c->center.y = 0.6*rk; c->center.z = 0.6*rk; c->radius = 0.11; } /* create the tree */ tree = vsg_prtree3d_new_full (&lb, &ub, (VsgPoint3dLocFunc) vsg_vector3d_vector3d_locfunc, (VsgPoint3dDistFunc) vsg_vector3d_dist, (VsgRegion3dLocFunc) _sphere_loc3, 2); /* insert the points */ for (i=0; i<points->len; i++) { vsg_prtree3d_insert_point (tree, g_ptr_array_index (points, i)); } /* insert the regions */ for (i=0; i<regions->len; i++) { vsg_prtree3d_insert_region (tree, g_ptr_array_index (regions, i)); } /* count total created points and regions */ init_total_points_count (); init_total_regions_count (); /* MPI_Barrier (MPI_COMM_WORLD); */ /* g_printerr ("%d: set_parallel begin\n", rk); */ vsg_prtree3d_set_parallel (tree, &pconfig); /* MPI_Barrier (MPI_COMM_WORLD); */ /* g_printerr ("%d: set_parallel ok\n", rk); */ ret += check_points_number (tree); ret += check_regions_number (tree); /* MPI_Barrier (MPI_COMM_WORLD); */ /* g_printerr ("%d: before migrate_flush ok\n", rk); */ { VsgVector3d *pt; Sphere *c; pt = pt_alloc (TRUE, NULL); pt->x = 0.5*rk; pt->y = 0.75*rk; pt->z = 0.75*rk; vsg_prtree3d_insert_point (tree, pt); c = rg_alloc (TRUE, NULL); c->center.x = 1.; c->center.y = 0.6*rk; c->center.z = 0.6*rk; c->radius = 0.1; vsg_prtree3d_insert_region (tree, c); } /* update total points and regions count */ init_total_points_count (); init_total_regions_count (); /* MPI_Barrier (MPI_COMM_WORLD); */ /* g_printerr ("%d: migrate_flush begin\n", rk); */ vsg_prtree3d_migrate_flush (tree); /* MPI_Barrier (MPI_COMM_WORLD); */ /* g_printerr ("%d: migrate_flush ok\n", rk); */ ret += check_points_number (tree); ret += check_regions_number (tree); /* MPI_Barrier (MPI_COMM_WORLD); */ /* g_printerr ("%d: distribute_nodes begin\n", rk); */ for (i=0; i<sz; i++) { gint dst = (i+1) % sz; /* MPI_Barrier (MPI_COMM_WORLD); */ /* g_printerr ("%d: move to %d\n", rk, dst); */ vsg_prtree3d_distribute_concentrate (tree, dst); ret += check_points_number (tree); ret += check_regions_number (tree); } /* MPI_Barrier (MPI_COMM_WORLD); */ /* g_printerr ("%d: split between nodes\n", rk); */ vsg_prtree3d_distribute_scatter_leaves (tree); ret += check_points_number (tree); ret += check_regions_number (tree); /* /\* MPI_Barrier (MPI_COMM_WORLD); *\/ */ /* /\* g_printerr ("%d: distribute_nodes ok\n", rk); *\/ */ if (_do_write) { MPI_Barrier (MPI_COMM_WORLD); _tree_write (tree); } if (_do_write) { gchar fn[1024]; FILE *f; g_sprintf (fn, "prtree3parallel-%03d.txt", rk); f = fopen (fn, "w"); vsg_prtree3d_write (tree, f); fclose (f); } /* destroy the points */ g_ptr_array_foreach (points, empty_array, NULL); g_ptr_array_free (points, TRUE); /* destroy the spheres */ g_ptr_array_foreach (regions, empty_array, NULL); g_ptr_array_free (regions, TRUE); /* destroy the tree */ vsg_prtree3d_free (tree); MPI_Finalize (); return ret; }
static void set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { NMSettingWiredPrivate *priv = NM_SETTING_WIRED_GET_PRIVATE (object); GHashTable *new_hash; switch (prop_id) { case PROP_PORT: g_free (priv->port); priv->port = g_value_dup_string (value); break; case PROP_SPEED: priv->speed = g_value_get_uint (value); break; case PROP_DUPLEX: g_free (priv->duplex); priv->duplex = g_value_dup_string (value); break; case PROP_AUTO_NEGOTIATE: priv->auto_negotiate = g_value_get_boolean (value); break; case PROP_MAC_ADDRESS: if (priv->device_mac_address) g_byte_array_free (priv->device_mac_address, TRUE); priv->device_mac_address = g_value_dup_boxed (value); break; case PROP_CLONED_MAC_ADDRESS: if (priv->cloned_mac_address) g_byte_array_free (priv->cloned_mac_address, TRUE); priv->cloned_mac_address = g_value_dup_boxed (value); break; case PROP_MAC_ADDRESS_BLACKLIST: nm_utils_slist_free (priv->mac_address_blacklist, g_free); priv->mac_address_blacklist = g_value_dup_boxed (value); break; case PROP_MTU: priv->mtu = g_value_get_uint (value); break; case PROP_S390_SUBCHANNELS: if (priv->s390_subchannels) { g_ptr_array_foreach (priv->s390_subchannels, (GFunc) g_free, NULL); g_ptr_array_free (priv->s390_subchannels, TRUE); } priv->s390_subchannels = g_value_dup_boxed (value); break; case PROP_S390_NETTYPE: g_free (priv->s390_nettype); priv->s390_nettype = g_value_dup_string (value); break; case PROP_S390_OPTIONS: /* Must make a deep copy of the hash table here... */ g_hash_table_remove_all (priv->s390_options); new_hash = g_value_get_boxed (value); if (new_hash) g_hash_table_foreach (new_hash, copy_hash, priv->s390_options); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }