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();
}
