static void build_func_tree(GHashTable *methods) { struct lua_cmd_entry *entry; GNode *parent; GNode *node; gchar **pp; GList *list; if (lua_cmd_queue.length == 0) return; main_tree = g_node_new(NULL); for (list = lua_cmd_queue.head; list != NULL; list = list->next) { entry = (struct lua_cmd_entry *) list->data; parent = main_tree; pp = entry->cmdv; if (entry->method != NULL) { if (g_hash_table_lookup(methods, entry->method) == NULL) continue; } while (*pp != NULL) { node = g_node_first_child(parent); if (node == NULL || strcmp(*pp, node->data)) node = g_node_prepend(parent, g_node_new(*pp)); parent = node; pp++; } g_node_prepend(node, g_node_new(entry)); } }
// tested: OK. static int parse_vat_92(GNode *node_top) { uint32_t fa, va, pa; uint16_t fs, vs, ps; int nfolders, nvars; int i, j; VatSymEntry *vse; GNode *node_fol, *node_var; if(tihw.calc_type != TI92) return -1; // handle 000B: names and handles of all folders (including "main") heap_get_block_addr_and_size(0xb, &fa, &fs); // skip maximum number of folders before handle #$B needs to be resized // and actual number of folders nfolders = mem_rd_word(fa+2); fa += 4; // now, we read a list of SYM_ENTRY structs (list of folders) for(i=0; i<nfolders; i++) { TI92_SYM_ENTRY se; // read struct memcpy(&se, ti68k_get_real_address(fa + i * sizeof(TI92_SYM_ENTRY)), sizeof(TI92_SYM_ENTRY)); se.handle = GUINT16_FROM_BE(se.handle); // add node vse = g_malloc0(sizeof(VatSymEntry)); strcpy(vse->name, se.name); vse->handle = se.handle; g_node_append(node_top, node_fol = g_node_new(vse)); // handle xxxx: names and handles of all variables heap_get_block_addr_and_size(se.handle, &va, &vs); // skip max num and actual num of vars nvars = mem_rd_word(va+2); va += 4; for(j=0; j<nvars; j++) { // read struct memcpy(&se, ti68k_get_real_address(va + j * sizeof(TI92_SYM_ENTRY)), sizeof(TI92_SYM_ENTRY)); se.handle = GUINT16_FROM_BE(se.handle); // add node vse = g_malloc0(sizeof(VatSymEntry)); strcpy(vse->name, se.name); vse->handle = se.handle; g_node_append(node_fol, node_var = g_node_new(vse)); // handle: variable content heap_get_block_addr_and_size(se.handle, &pa, &ps); } } return 0; }
/*! * Recursive function that handles converging \c JsonNode's to \c * GNode's. * * \param root \c Root JsonNode to convert. * \param node \c GNode. * \param parsing_array \c true if handling an array, else \c false. */ static void clr_oci_json_parse_aux(JsonNode* root, GNode* node, bool parsing_array) { guint i; g_assert (root); g_assert (node); if (JSON_NODE_TYPE(root) == JSON_NODE_OBJECT) { JsonObject *object = json_node_get_object(root); if (object) { guint j; guint size; GList* keys, *key = NULL; GList* values, *value = NULL; size = json_object_get_size(object); keys = json_object_get_members(object); values = json_object_get_values(object); node = g_node_append(node, g_node_new(NULL)); for (j = 0, key = keys, value = values; j < size; j++) { if (key) { node = g_node_append(node->parent, g_node_new(g_strdup(key->data))); } if (value) { clr_oci_json_parse_aux(value->data, node, false); } key = g_list_next(key); value = g_list_next(value); } if (keys) { g_list_free(keys); } if (values) { g_list_free(values); } } } else if (JSON_NODE_TYPE(root) == JSON_NODE_ARRAY) { JsonArray* array = json_node_get_array(root); guint array_size = json_array_get_length (array); JsonNode *array_element; for (i = 0; i < array_size; i++) { array_element = json_array_get_element(array, i); clr_oci_json_parse_aux(array_element, node, true); } } else if (JSON_NODE_TYPE(root) == JSON_NODE_VALUE) { node = g_node_append(node, g_node_new(clr_oci_json_string(root))); if (parsing_array) { node = g_node_append(node, g_node_new(NULL)); } } }
static void _reconstruct_bookmark_tree (GNode *parent_node, GtkTreeIter *iter) { GNode *node; GNode *origNode; GtkTreeIter childIter; gftp2_bookmark *bm; gtk_tree_model_get (GTK_TREE_MODEL(editor->store), iter, COLUMN_ENTRY, &origNode, -1); g_assert (origNode); node = g_node_new (origNode->data); g_node_append (parent_node, node); bm = (gftp2_bookmark *) node->data; gtk_tree_store_set (editor->store, iter, COLUMN_NAME, bm->name, COLUMN_ENTRY, node, -1); if (editor->selected_node == origNode) editor->selected_node = node; /* bm = (gftp2_bookmark *) childNode->data; */ /* fprintf (stderr, "Reconstruct %s\n", bm->name); */ if (!gtk_tree_model_iter_children (GTK_TREE_MODEL(editor->store), &childIter, iter)) return; /* for node's child */ do { _reconstruct_bookmark_tree (node, &childIter); } while (gtk_tree_model_iter_next(GTK_TREE_MODEL(editor->store), &childIter)); }
xmlDoc *xml_doc_new() { GNode *root; xmlDoc *doc; NODE_DATA *node_data; #ifdef XML_TRACE LOG(LOG_DEBUG, "IN : xml_doc_new()"); #endif doc = (xmlDoc *)calloc(sizeof(xmlDoc), 1); g_assert(doc != NULL); doc->version = NULL; doc->encoding = NULL; node_data = (NODE_DATA *)calloc(sizeof(NODE_DATA), 1); g_assert(node_data != NULL); node_data->name = NULL; node_data->content = NULL; node_data->attr = NULL; node_data->depth = 0; node_data->doc = doc; root = g_node_new((gpointer)node_data); doc->root = root; #ifdef XML_TRACE LOG(LOG_DEBUG, "OUT : xml_doc_new()"); #endif return(doc); }
void dump_to_parent (GNode* parent, TreeElement table [], int length) { int i = 0; for (i = 0; i < length ; i++) { GNode* temp = g_node_new (&table [i]); g_node_insert (parent, -1, temp); } }
static void test_addNodeInTree_NullIn() { before(); GNode *tree = NULL; add_node_in_tree(tree, NULL); assert_tree_is_null("Add node in tree ─ Tree is null", tree); // THIS IS THE STRUCTURE: // // test-dir (3 children) //├─ bepa.png //├─ cepa.jpg //└─ epa.png GNode *expected = get_tree(SINGLE_FILE, FALSE, FALSE); add_node_in_tree(tree, expected); assert_tree_is_null("Add node in tree ─ Tree is null", tree); tree = get_tree(SINGLE_FILE, FALSE, FALSE); add_node_in_tree(tree, NULL); assert_trees_equal("Add node in tree ─ Node is null", tree, expected); GNode *node_without_data = g_node_new(NULL); add_node_in_tree(tree, node_without_data); assert_trees_equal("Add node in tree ─ Node is null", tree, expected); free_whole_tree(tree); free_whole_tree(expected); free_whole_tree(node_without_data); after(); }
/** * g_node_copy_deep: * @node: a #GNode * @copy_func: the function which is called to copy the data inside each node, * or %NULL to use the original data. * @data: data to pass to @copy_func * * Recursively copies a #GNode and its data. * * Return value: a new #GNode containing copies of the data in @node. * * Since: 2.4 **/ GNode* g_node_copy_deep (GNode *node, GCopyFunc copy_func, gpointer data) { GNode *new_node = NULL; if (copy_func == NULL) return g_node_copy (node); if (node) { GNode *child, *new_child; new_node = g_node_new (copy_func (node->data, data)); for (child = g_node_last_child (node); child; child = child->prev) { new_child = g_node_copy_deep (child, copy_func, data); g_node_prepend (new_node, new_child); } } return new_node; }
static GNode* find_stat_node(GNode *parent_stat_node, header_field_info *needle_hfinfo) { GNode *needle_stat_node; header_field_info *hfinfo; ph_stats_node_t *stats; needle_stat_node = g_node_first_child(parent_stat_node); while (needle_stat_node) { hfinfo = STAT_NODE_HFINFO(needle_stat_node); if (hfinfo && hfinfo->id == needle_hfinfo->id) { return needle_stat_node; } needle_stat_node = g_node_next_sibling(needle_stat_node); } /* None found. Create one. */ stats = g_new(ph_stats_node_t, 1); /* Intialize counters */ stats->hfinfo = needle_hfinfo; stats->num_pkts_total = 0; stats->num_pkts_last = 0; stats->num_bytes_total = 0; stats->num_bytes_last = 0; needle_stat_node = g_node_new(stats); g_node_append(parent_stat_node, needle_stat_node); return needle_stat_node; }
GNode* remmina_file_manager_get_group_tree(void) { gchar dirname[MAX_PATH_LEN]; gchar filename[MAX_PATH_LEN]; GDir* dir; const gchar* name; RemminaFile* remminafile; const gchar* group; GNode* root; root = g_node_new(NULL); g_snprintf(dirname, MAX_PATH_LEN, "%s/.remmina", g_get_home_dir()); dir = g_dir_open(dirname, 0, NULL); if (dir == NULL) return root; while ((name = g_dir_read_name(dir)) != NULL) { if (!g_str_has_suffix(name, ".remmina")) continue; g_snprintf(filename, MAX_PATH_LEN, "%s/%s", dirname, name); remminafile = remmina_file_load(filename); group = remmina_file_get_string(remminafile, "group"); remmina_file_manager_add_group(root, group); remmina_file_free(remminafile); } g_dir_close(dir); return root; }
GLADE_CB void on_mkdir_clicked (GtkToolButton *toolbutton, gpointer user_data) { gchar *ret; GNode *node; VarEntry *ve; if(GFMFile.trees.vars == NULL) return; if(tifiles_calc_is_ti8x(GFMFile.model)) return; ret = msgbox_input(_("New Folder"), _("folder"), _("Name of folder to create:")); if(ret == NULL) return; ret[8] = '\0'; ve = tifiles_ve_create(); strcpy(ve->name, ret); ve->type = tifiles_folder_type(GFMFile.model); node = g_node_new(ve); g_node_append(GFMFile.trees.vars, node); ctree_refresh(); labels_refresh(); }
gboolean xmms_magic_add (const gchar *desc, const gchar *mime, ...) { GNode *tree, *node = NULL; va_list ap; gchar *s; gpointer *root_props; gboolean ret = TRUE; g_return_val_if_fail (desc, FALSE); g_return_val_if_fail (mime, FALSE); /* now process the magic specs in the argument list */ va_start (ap, mime); s = va_arg (ap, gchar *); if (!s) { /* no magic specs passed -> failure */ va_end (ap); return FALSE; } /* root node stores the description and the mimetype */ root_props = g_new0 (gpointer, 2); root_props[0] = g_strdup (desc); root_props[1] = g_strdup (mime); tree = g_node_new (root_props); do { if (!*s) { ret = FALSE; xmms_log_error ("invalid magic spec: '%s'", s); break; } s = g_strdup (s); /* we need our own copy */ node = xmms_magic_add_node (tree, s, node); if (!node) { xmms_log_error ("invalid magic spec: '%s'", s); ret = FALSE; g_free (s); break; } g_free (s); } while ((s = va_arg (ap, gchar *))); va_end (ap); /* only add this tree to the list if all spec chunks are valid */ if (ret) { magic_list = g_list_insert_sorted (magic_list, tree, (GCompareFunc) cb_sort_magic_list); } else { xmms_magic_tree_free (tree); } return ret; }
static GNode *xml_build_tree(XMLFile *file, GNode *parent, guint level) { GNode *node = NULL; XMLNode *xmlnode; XMLTag *tag; while (xml_parse_next_tag(file) == 0) { if (file->level < level) break; if (file->level == level) { g_warning("xml_build_tree(): Parse error in %s", file->path); break; } tag = xml_get_current_tag(file); if (!tag) break; xmlnode = xml_node_new(xml_copy_tag(tag), NULL); xmlnode->element = xml_get_element(file); if (!parent) node = g_node_new(xmlnode); else node = g_node_append_data(parent, xmlnode); xml_build_tree(file, node, file->level); if (file->level == 0) break; } return node; }
/*! * Convert a JSON file into a tree of nodes. * * \param[out] node Tree representation of \p filename. * \param filename Absolute path to JSON file to parse. * * \return \c true on success, else \c false. */ bool clr_oci_json_parse (GNode** node, const gchar* filename) { bool result = false; GError* error = NULL; JsonParser* parser = NULL; JsonNode *root = NULL; if ((!node) || (!filename) || (!(*filename))) { return false; } parser = json_parser_new(); if (! json_parser_load_from_file(parser, filename, &error)) { g_debug("unable to parse '%s'", filename); if (error) { g_debug("Error parsing '%s': %s", filename, error->message); g_error_free(error); } goto exit; } root = json_parser_get_root (parser); if (! root) { goto exit; } *node = g_node_new(g_strdup(filename)); clr_oci_json_parse_aux(root, *node, false); result = true; exit: g_object_unref(parser); return result; }
static plist_t parse_unicode_node(char *bnode, uint64_t size) { plist_data_t data = plist_new_plist_data(); uint64_t i = 0; gunichar2 *unicodestr = NULL; gchar *tmpstr = NULL; glong items_read = 0; glong items_written = 0; GError *error = NULL; data->type = PLIST_STRING; unicodestr = (gunichar2 *) malloc(sizeof(gunichar2) * size); memcpy(unicodestr, bnode, sizeof(gunichar2) * size); for (i = 0; i < size; i++) byte_convert((uint8_t *) (unicodestr + i), sizeof(gunichar2)); tmpstr = g_utf16_to_utf8(unicodestr, size, &items_read, &items_written, &error); free(unicodestr); data->type = PLIST_STRING; data->strval = (char *) malloc(sizeof(char) * (items_written + 1)); memcpy(data->strval, tmpstr, items_written); data->strval[items_written] = '\0'; data->length = strlen(data->strval); g_free(tmpstr); return g_node_new(data); }
static gint mh_scan_tree(Folder *folder) { FolderItem *item; gchar *rootpath; cm_return_val_if_fail(folder != NULL, -1); if (!folder->node) { item = folder_item_new(folder, folder->name, NULL); item->folder = folder; folder->node = item->node = g_node_new(item); } else item = FOLDER_ITEM(folder->node->data); rootpath = folder_item_get_path(item); if (change_dir(rootpath) < 0) { g_free(rootpath); return -1; } g_free(rootpath); mh_create_tree(folder); mh_remove_missing_folder_items(folder); mh_scan_tree_recursive(item); return 0; }
static plist_t parse_real_node(char *bnode, uint8_t size) { plist_data_t data = plist_new_plist_data(); float floatval = 0.0; uint8_t* buf; size = 1 << size; // make length less misleading buf = malloc (size); memcpy (buf, bnode, size); switch (size) { case sizeof(float): float_byte_convert(buf, size); floatval = *(float *) buf; data->realval = floatval; break; case sizeof(double): float_byte_convert(buf, size); data->realval = *(double *) buf; break; default: free(data); return NULL; } free (buf); data->type = PLIST_REAL; data->length = sizeof(double); return g_node_new(data); }
static plist_t parse_uint_node(char *bnode, uint8_t size, char **next_object) { plist_data_t data = plist_new_plist_data(); size = 1 << size; // make length less misleading switch (size) { case sizeof(uint8_t): case sizeof(uint16_t): case sizeof(uint32_t): case sizeof(uint64_t): memcpy(&data->intval, bnode, size); data->intval = UINT_TO_HOST(&data->intval, size); break; default: free(data); return NULL; }; *next_object = bnode + size; data->type = PLIST_UINT; data->length = sizeof(uint64_t); return g_node_new(data); }
static void glade_eprop_model_data_add_row (GladeEditorProperty * eprop) { GladeEPropModelData *eprop_data = GLADE_EPROP_MODEL_DATA (eprop); GValue value = { 0, }; GNode *node = NULL; GList *columns = NULL; GladeProperty *property = glade_editor_property_get_property (eprop); glade_property_get (property, &node); glade_widget_property_get (glade_property_get_widget (property), "columns", &columns); if (!columns) return; clear_view (eprop); if (!node) node = g_node_new (NULL); else node = glade_model_data_tree_copy (node); append_row (node, columns); eprop_data->adding_row = TRUE; g_value_init (&value, GLADE_TYPE_MODEL_DATA_TREE); g_value_take_boxed (&value, node); glade_editor_property_commit (eprop, &value); g_value_unset (&value); eprop_data->adding_row = FALSE; }
static void tracker_storage_init (TrackerStorage *storage) { TrackerStoragePrivate *priv; g_message ("Initializing Storage..."); priv = TRACKER_STORAGE_GET_PRIVATE (storage); priv->mounts = g_node_new (NULL); priv->mounts_by_uuid = g_hash_table_new_full (g_str_hash, g_str_equal, (GDestroyNotify) g_free, NULL); priv->unmount_watchdogs = g_hash_table_new_full (NULL, NULL, NULL, (GDestroyNotify) g_source_remove); priv->volume_monitor = g_volume_monitor_get (); /* Volume and property notification callbacks */ g_signal_connect_object (priv->volume_monitor, "mount-removed", G_CALLBACK (mount_removed_cb), storage, 0); g_signal_connect_object (priv->volume_monitor, "mount-pre-unmount", G_CALLBACK (mount_pre_removed_cb), storage, 0); g_signal_connect_object (priv->volume_monitor, "mount-added", G_CALLBACK (mount_added_cb), storage, 0); g_message ("Mount monitors set up for to watch for added, removed and pre-unmounts..."); /* Get all mounts and set them up */ if (!mounts_setup (storage)) { return; } }
/** * as_node_new: (skip) * * Creates a new empty tree whicah can have nodes appended to it. * * Returns: (transfer full): a new empty tree * * Since: 0.1.0 **/ AsNode * as_node_new (void) { AsNodeData *data; data = g_slice_new0 (AsNodeData); data->tag = AS_TAG_LAST; return g_node_new (data); }
UrlRouter * url_router_new (void) { UrlNodeData *data; data = url_node_data_new("", FALSE, NULL, NULL); return g_node_new(data); }
static void i7_node_init(I7Node *self) { I7_NODE_USE_PRIVATE; priv->id = g_strdup_printf("node-%p", self); self->gnode = g_node_new(self); self->tree_item = NULL; self->tree_points = goo_canvas_points_new(4); priv->blessed = FALSE; priv->match = I7_NODE_CANT_COMPARE; priv->transcript_diffs = NULL; priv->transcript_pango_string = NULL; priv->expected_diffs = NULL; priv->expected_pango_string = NULL; /* Create the cairo gradients */ /* Label */ priv->label_pattern = cairo_pattern_create_linear(0.0, 0.0, 0.0, 1.0); cairo_pattern_add_color_stop_rgba(priv->label_pattern, 1.0, 0.0, 0.33, 0.0, 0.3); cairo_pattern_add_color_stop_rgba(priv->label_pattern, 0.67, 0.73, 0.84, 0.73, 0.1); cairo_pattern_add_color_stop_rgba(priv->label_pattern, 0.0, 0.5, 0.85, 0.5, 0.0); /* Node, unplayed, without blessed transcript text: Tango Chameleon 3 */ priv->node_pattern[NODE_UNPLAYED_UNBLESSED] = create_node_pattern(0.31, 0.60, 0.02); /* Node, unplayed, with blessed transcript text: Tango Chameleon 1 */ priv->node_pattern[NODE_UNPLAYED_BLESSED] = create_node_pattern(0.54, 0.87, 0.2); /* Node, played, without blessed transcript text: Tango Butter 3 */ priv->node_pattern[NODE_PLAYED_UNBLESSED] = create_node_pattern(0.77, 0.63, 0.0); /* Node, played, with blessed transcript text: Tango Butter 1 */ priv->node_pattern[NODE_PLAYED_BLESSED] = create_node_pattern(0.99, 0.91, 0.31); /* Create the canvas items, though some of them can't be drawn yet */ priv->command_shape_item = goo_canvas_path_model_new(GOO_CANVAS_ITEM_MODEL(self), "", "stroke-pattern", NULL, "fill-pattern", priv->node_pattern[NODE_UNPLAYED_UNBLESSED], NULL); priv->label_shape_item = goo_canvas_path_model_new(GOO_CANVAS_ITEM_MODEL(self), "", "stroke-pattern", NULL, "fill-pattern", priv->label_pattern, NULL); priv->command_item = goo_canvas_text_model_new(GOO_CANVAS_ITEM_MODEL(self), "", 0.0, 0.0, -1, GTK_ANCHOR_CENTER, NULL); priv->label_item = goo_canvas_text_model_new(GOO_CANVAS_ITEM_MODEL(self), "", 0.0, 0.0, -1, GTK_ANCHOR_CENTER, NULL); priv->badge_item = goo_canvas_path_model_new(GOO_CANVAS_ITEM_MODEL(self), "", "fill-color", "red", "line-width", 0, "visibility", GOO_CANVAS_ITEM_HIDDEN, NULL); g_object_set_data(G_OBJECT(priv->badge_item), "path-drawn", NULL); g_object_set_data(G_OBJECT(priv->badge_item), "node-part", GINT_TO_POINTER(I7_NODE_PART_DIFFERS_BADGE)); /* Avoid drawing the differs badges unless they're actually needed, otherwise it really slows down the story startup */ priv->x = 0.0; priv->command_width = -1.0; priv->command_height = -1.0; priv->label_width = -1.0; priv->label_height = -1.0; }
static void xml_start_element (GMarkupParseContext *context, const gchar *element_name, const gchar **attribute_names, const gchar **attribute_values, gpointer user_data, GError **error) { struct Settings* me = (struct Settings*)user_data; // printf("in xml_start_element %s\n", element_name); if (!g_strcmp0(element_name, "dl_settings")) { // printf("in xml_start_element %s\n", element_name); struct SettingsPage* new_page = malloc(sizeof(struct SettingsPage)); new_page->name = NULL; new_page->settings = NULL; GNode* new_node = g_node_new (new_page); if (!me->settings_tree) me->settings_tree = new_node; else g_node_append(me->settings_tree, new_node); int i=0; while (attribute_names[i]) { // printf(" %s -> %s\n", attribute_names[i], attribute_values[i]); if (!g_strcmp0(attribute_names[i], "name")) new_page->name = g_strdup(attribute_values[i]); i++; } me->cur_node = new_node; } else if (!g_strcmp0(element_name, "dl_setting")) { struct Setting* s = malloc(sizeof(struct Setting)); me->nb_settings++; me->settings = g_slist_append(me->settings, s); struct SettingsPage* p = (struct SettingsPage*)me->cur_node->data; p->settings = g_slist_append(p->settings, s); int i=0; while (attribute_names[i]) { // printf(" %s -> %s\n", attribute_names[i], attribute_values[i]); if (!g_strcmp0(attribute_names[i], "var")) s->var = g_strdup(attribute_values[i]); else if (!g_strcmp0(attribute_names[i], "value")) s->value = g_ascii_strtod (attribute_values[i], NULL); else if (!g_strcmp0(attribute_names[i], "min")) s->min = g_ascii_strtod (attribute_values[i], NULL); else if (!g_strcmp0(attribute_names[i], "max")) s->max = g_ascii_strtod (attribute_values[i], NULL); else if (!g_strcmp0(attribute_names[i], "step")) s->step = g_ascii_strtod (attribute_values[i], NULL); else if (!g_strcmp0(attribute_names[i], "shortname")) s->shortname = g_strdup(attribute_values[i]); else if (!g_strcmp0(attribute_names[i], "module")) s->module = g_strdup(attribute_values[i]); else if (!g_strcmp0(attribute_names[i], "handler")) s->handler = g_strdup(attribute_values[i]); i++; } } }
static GNode * xmms_magic_add_node (GNode *tree, const gchar *s, GNode *prev_node) { xmms_magic_entry_t *entry; gpointer *data = tree->data; guint indent = 0, prev_indent; g_assert (s); XMMS_DBG ("adding magic spec to tree '%s'", (gchar *) data[0]); /* indent level is number of leading '>' characters */ while (*s == '>') { indent++; s++; } entry = parse_entry (s); if (!entry) { XMMS_DBG ("cannot parse magic entry"); return NULL; } if (!indent) { return g_node_append_data (tree, entry); } if (!prev_node) { XMMS_DBG ("invalid indent level"); xmms_magic_entry_free (entry); return NULL; } prev_indent = g_node_depth (prev_node) - 2; if (indent > prev_indent) { /* larger jumps are invalid */ if (indent != prev_indent + 1) { XMMS_DBG ("invalid indent level"); xmms_magic_entry_free (entry); return NULL; } return g_node_append_data (prev_node, entry); } else { while (indent < prev_indent) { prev_indent--; prev_node = prev_node->parent; } return g_node_insert_after (prev_node->parent, prev_node, g_node_new (entry)); } }
/* --------- < Used by open_close_branch > ------------- */ GNode* new_tree_node (void* userdata, int state_info, GNode* parent) { TreeElement* temp = (TreeElement*) malloc (sizeof (TreeElement)); /* temp = {NULL, NULL, state_info, parent, NULL, userdata}; */ memset (temp -> base_format, 0x0, sizeof (temp -> base_format)); memset (temp -> format, 0x0, sizeof (temp -> format)); temp -> state_info = state_info; temp -> parent = parent; temp -> lastchild = NULL; temp -> userdata = userdata; return g_node_new (temp); }
static DirSource* dir_source_new (GFile *file) { DirSourceData *source = NULL; source = g_slice_new0(DirSourceData); source->base.node.type = ANJUTA_PROJECT_SOURCE; source->base.file = g_object_ref (file); return g_node_new (source); }
se_modemap* se_modemap_simple_create(const char* map_name ) { g_assert( map_name && map_name[0] ); se_modemap *map = g_malloc0( sizeof(se_modemap) ); strncpy( map->mapName, map_name, sizeof map->mapName - 1 ); se_modemap_data *root_data = g_malloc0( sizeof(se_modemap_data) ); root_data->key = se_key_null_init(); map->root = g_node_new( root_data ); return map; }
static plist_t parse_array_node(char *bnode, uint64_t size, uint32_t ref_size) { plist_data_t data = plist_new_plist_data(); data->type = PLIST_ARRAY; data->length = size; data->buff = (uint8_t *) malloc(sizeof(uint8_t) * size * ref_size); memcpy(data->buff, bnode, sizeof(uint8_t) * size * ref_size); return g_node_new(data); }
static void test_getNextInTree_RootWithoutElements() { before(); GNode *tree = g_node_new(NULL); assert_trees_equal("Get Next ─ Input is Root without elements", tree, get_next_in_tree(tree)); assert_trees_equal("Get First ─ Input is Root without elements", tree, get_first_in_tree(tree)); assert_trees_equal("Get Last ─ Input is Root without elements", tree, get_last_in_tree(tree)); free_whole_tree(tree); after(); }