// 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)); } } }
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(); }
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)); }
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; }
static void plist_copy_node(GNode * node, gpointer parent_node_ptr) { plist_t newnode = NULL; plist_data_t data = plist_get_data(node); plist_data_t newdata = plist_new_plist_data(); assert(data); // plist should always have data memcpy(newdata, data, sizeof(struct plist_data_s)); plist_type node_type = plist_get_node_type(node); if (node_type == PLIST_DATA || node_type == PLIST_STRING || node_type == PLIST_KEY) { switch (node_type) { case PLIST_DATA: newdata->buff = (uint8_t *) malloc(data->length); memcpy(newdata->buff, data->buff, data->length); case PLIST_KEY: case PLIST_STRING: newdata->strval = strdup((char *) data->strval); default: break; } } newnode = plist_new_node(newdata); if (*(plist_t*)parent_node_ptr) { g_node_append(*(plist_t*)parent_node_ptr, newnode); } else { *(plist_t*)parent_node_ptr = newnode; } g_node_children_foreach(node, G_TRAVERSE_ALL, plist_copy_node, &newnode); }
static gboolean cloud_config_simplify(GNode *node, __unused__ gpointer data) { if (node->data) { return false; } GNode *child = g_node_last_child(node); while (child) { if (child->data) { child = g_node_prev_sibling(child); continue; } GNode *remove = child; child = g_node_prev_sibling(child); g_node_append(node->parent, g_node_copy(remove)); g_node_unlink(remove); g_node_destroy(remove); } if (g_node_n_children(node) == 0) { g_node_unlink(node); g_node_destroy(node); } return false; }
void plist_add_sub_node(plist_t node, plist_t subnode) { if (node && subnode) { plist_type type = plist_get_node_type(node); if (type == PLIST_DICT || type == PLIST_ARRAY) g_node_append(node, subnode); } }
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 plist_t plist_add_sub_element(plist_t node, plist_type type, const void *value, uint64_t length) { //only structured types can have children plist_type node_type = plist_get_node_type(node); if (node_type == PLIST_DICT || node_type == PLIST_ARRAY) { //only structured types are allowed to have nulll value if (value || (!value && (type == PLIST_DICT || type == PLIST_ARRAY))) { plist_t subnode = NULL; //now handle value plist_data_t data = plist_new_plist_data(); data->type = type; data->length = length; switch (type) { case PLIST_BOOLEAN: data->boolval = *((char *) value); break; case PLIST_UINT: data->intval = *((uint64_t *) value); break; case PLIST_REAL: data->realval = *((double *) value); break; case PLIST_KEY: case PLIST_STRING: data->strval = strdup((char *) value); break; case PLIST_DATA: data->buff = (uint8_t *) malloc(length); memcpy(data->buff, value, length); break; case PLIST_DATE: data->timeval.tv_sec = ((GTimeVal *) value)->tv_sec; data->timeval.tv_usec = ((GTimeVal *) value)->tv_usec; break; case PLIST_ARRAY: case PLIST_DICT: default: break; } subnode = plist_new_node(data); if (node) g_node_append(node, subnode); return subnode; } else return NULL; } return NULL; }
bool processors_tree_create(GNode *tree, struct lcfgx_tree_node *node) { g_debug("%s tree %p node %p key %s", __PRETTY_FUNCTION__, tree, node, node->key); char *key = g_strdup(node->key); char *x; if( (x = strstr(key,"-")) != NULL) *x = '\0'; struct processor *p = g_hash_table_lookup(g_dionaea->processors->names, key); if( p == NULL ) { g_error("Could not find processor '%s' (%s)", node->key, key); } g_free(key); struct processor *pt = g_malloc0(sizeof(struct processor)); memcpy(pt, p, sizeof(struct processor)); struct lcfgx_tree_node *n; if( pt->cfg != NULL ) { if( lcfgx_get_map(node, &n, "config") == LCFGX_PATH_FOUND_TYPE_OK ) { if( (pt->config = pt->cfg(n)) == NULL ) { g_error("processor %s rejected config", node->key); } } else { g_error("processor %s expects config", node->key); } } GNode *me = g_node_new(pt); g_node_append(tree, me); if( lcfgx_get_map(node, &n, "next") == LCFGX_PATH_FOUND_TYPE_OK ) { struct lcfgx_tree_node *it; for( it = n->value.elements; it != NULL; it = it->next ) { if( processors_tree_create(me, it) != true ) return false; } } return true; }
static int get_dirlist (CalcHandle* handle, GNode** vars, GNode** apps) { GNode *root; int ret; ret = dirlist_init_trees(handle, vars, apps); if (ret) { return ret; } root = g_node_new(NULL); if (!root) { return ERR_MALLOC; } g_node_append(*apps, root); ret = nsp_session_open(handle, NSP_SID_FILE_MGMT); if (!ret) { ret = nsp_cmd_s_dir_attributes(handle, "/"); if (!ret) { ret = nsp_cmd_r_dir_attributes(handle, NULL, NULL, NULL); if (!ret) { ret = nsp_session_close(handle); if (!ret) { ret = nsp_session_open(handle, NSP_SID_FILE_MGMT); if (!ret) { ret = enumerate_folder(handle, vars, "/"); // Fall through for closing session. } } } } DO_CLOSE_SESSION(handle); } return ret; }
/** * g_node_insert: * @parent: the #GNode to place @node under * @position: the position to place @node at, with respect to its siblings * If position is -1, @node is inserted as the last child of @parent * @node: the #GNode to insert * * Inserts a #GNode beneath the parent at the given position. * * Returns: the inserted #GNode */ GNode* g_node_insert (GNode *parent, gint position, GNode *node) { g_return_val_if_fail (parent != NULL, node); g_return_val_if_fail (node != NULL, node); g_return_val_if_fail (G_NODE_IS_ROOT (node), node); if (position > 0) return g_node_insert_before (parent, g_node_nth_child (parent, position), node); else if (position == 0) return g_node_prepend (parent, node); else /* if (position < 0) */ return g_node_append (parent, node); }
static gboolean data_changed_idle (GladeEditorProperty * eprop) { GladeEPropModelData *eprop_data = GLADE_EPROP_MODEL_DATA (eprop); GladeProperty *property = glade_editor_property_get_property (eprop); GNode *data_tree = NULL, *new_tree, *row; GtkTreeIter iter; gint rownum; glade_property_get (property, &data_tree); g_assert (data_tree); new_tree = g_node_new (NULL); if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (eprop_data->store), &iter)) { do { gtk_tree_model_get (GTK_TREE_MODEL (eprop_data->store), &iter, COLUMN_ROW, &rownum, -1); if ((row = g_node_nth_child (data_tree, rownum)) != NULL) { /* Make a new tree by copying row by row... */ row = glade_model_data_tree_copy (row); g_node_append (new_tree, row); } } while (gtk_tree_model_iter_next (GTK_TREE_MODEL (eprop_data->store), &iter)); } /* Were already in an idle, no need to idle from here... */ if (eprop_data->pending_data_tree) glade_model_data_tree_free (eprop_data->pending_data_tree); eprop_data->pending_data_tree = new_tree; update_data_tree_idle (eprop); return FALSE; }
static void append_row (GNode * node, GList * columns) { GladeModelData *data; GladeColumnType *column; GNode *row; GList *list; g_assert (node && columns); row = g_node_new (NULL); g_node_append (node, row); for (list = columns; list; list = list->next) { column = list->data; data = glade_model_data_new (g_type_from_name (column->type_name), column->column_name); g_node_append_data (row, data); } }
xmlNode *xml_add_child(xmlNode *parent, gchar *name, gchar *content){ NODE_DATA *node_data; GNode *child; #ifdef XML_TRACE LOG(LOG_DEBUG, "IN : xml_add_child()"); #endif if(name == NULL) { #ifdef XML_TRACE LOG(LOG_DEBUG, "OUT : xml_add_child() = NULL"); #endif return(NULL); } node_data = (NODE_DATA *)calloc(sizeof(NODE_DATA), 1); if(!node_data){ #ifdef XML_TRACE LOG(LOG_DEBUG, "OUT : xml_add_child() = NULL"); #endif return(NULL); } node_data->name = g_strdup(name); node_data->attr = NULL; node_data->depth = ((NODE_DATA *)(parent->data))->depth + 1; node_data->doc = ((NODE_DATA *)(parent->data))->doc; if(content == NULL) node_data->content = NULL; else node_data->content = g_strdup(content); child = g_node_new((gpointer)node_data); g_node_append(parent, child); #ifdef XML_TRACE LOG(LOG_DEBUG, "OUT : xml_add_child()"); #endif return(child); }
/** Accepts a node type, the line number and column it came from, and a list of * of GNode*'s which should be its children. The list MUST be NULL-terminated, * even if it is empty. */ G_GNUC_WARN_UNUSED_RESULT G_GNUC_NULL_TERMINATED G_GNUC_MALLOC GNode* mk_ptree_node(enum PTType type, gsize line, gsize column, ...) { va_list ap; GenericParseTree *gt; GNode *head, *add; gt = (GenericParseTree *) ptree_alloc(type); gt->meta.type = type; gt->meta.line_no = line; gt->meta.col_no = column; head = g_node_new(gt); va_start(ap, column); while((add = va_arg(ap, GNode*)) != NULL) { g_node_append(head, add); } va_end(ap); return head; }
static void add_item (int is_folder) { GtkTreeIter iter; GtkTreeModel *model; gftp2_bookmark *new_item; GNode *new_node; new_item = gftp2_bookmark_new (); if (is_folder) new_item->name = g_strdup ("(New folder)"); else new_item->name = g_strdup ("(New bookmark)"); new_item->is_folder = is_folder; new_node = g_node_new (new_item); g_node_append (bookmark_root, new_node); gtk_tree_store_append (GTK_TREE_STORE (editor->store), &iter, NULL); gtk_tree_store_set (GTK_TREE_STORE (editor->store), &iter, COLUMN_NAME, new_item->name, COLUMN_ENTRY, new_node, -1); editor->changed = 1; gtk_widget_set_sensitive (GTK_WIDGET (editor->save_button), TRUE); }
/** * ticalcs_dirlist_ve_add: * @tree: source tree. * @entry: entry to add. * * Add an entry into the main tree (if it doesn't exist yet). * * Return value: none. **/ TIEXPORT3 void TICALL ticalcs_dirlist_ve_add(GNode* tree, VarEntry *entry) { TreeInfo *info; int i, j; int found = 0; GNode *parent = NULL; VarEntry *fe = NULL; GNode *child; VarEntry *ve; const char *folder; if (tree == NULL || entry == NULL) { ticalcs_critical("ticalcs_dirlist_ve_add: an argument is NULL"); return; } info = (TreeInfo *)(tree->data); if (info == NULL) { return; } if (strcmp(info->type, VAR_NODE_NAME) && strcmp(info->type, APP_NODE_NAME)) { return; } if (!strcmp(entry->folder, "") && tifiles_has_folder(info->model)) { folder = "main"; } else { folder = entry->folder; } // If TI8x tree is empty, create pseudo-folder (NULL) if (!g_node_n_children(tree) && !tifiles_has_folder(info->model)) { parent = g_node_new(NULL); g_node_append(tree, parent); } // Check for one folder at least... if (g_node_n_children(tree) > 0) { // Parse folders for (found = 0, i = 0; i < (int)g_node_n_children(tree); i++) { parent = g_node_nth_child(tree, i); fe = (VarEntry *) (parent->data); if (fe == NULL) { break; } if (!strcmp(fe->name, folder)) { found = !0; break; } } } // folder doesn't exist? => create! if ((!found && fe) || (!g_node_n_children(tree) && tifiles_has_folder(info->model))) { fe = tifiles_ve_create(); if (fe != NULL) { ticalcs_strlcpy(fe->name, entry->folder, sizeof(fe->name)); fe->type = TI89_DIR; parent = g_node_new(fe); g_node_append(tree, parent); } } if (!strcmp(entry->name, "")) { return; } // next, add variables beneath this folder for (found = 0, j = 0; j < (int)g_node_n_children(parent); j++) { child = g_node_nth_child(parent, j); ve = (VarEntry *) (child->data); if (!strcmp(ve->name, entry->name)) { found = !0; break; } } if (!found) { ve = tifiles_ve_dup(entry); if (ve != NULL) { child = g_node_new(ve); g_node_append(parent, child); } } if (fe && found) { fe->size++; } }
static int get_dirlist (CalcHandle* handle, GNode** vars, GNode** apps) { TreeInfo *ti; GNode *folder; uint16_t unused; uint8_t hl, ll, lh; uint8_t mem[8]; char *utf8; // get list of folders & FLASH apps (*vars) = g_node_new(NULL); ti = (TreeInfo *)g_malloc(sizeof(TreeInfo)); ti->model = handle->model; ti->type = VAR_NODE_NAME; (*vars)->data = ti; (*apps) = g_node_new(NULL); ti = (TreeInfo *)g_malloc(sizeof(TreeInfo)); ti->model = handle->model; ti->type = APP_NODE_NAME; (*apps)->data = ti; TRYF(ti85_send_REQ(0x0000, TI86_DIR, "")); TRYF(ti85_recv_ACK(&unused)); TRYF(ti85_recv_XDP(&unused, mem)); TRYF(ti85_send_ACK()); hl = mem[0]; ll = mem[1]; lh = mem[2]; ti->mem_free = (hl << 16) | (lh << 8) | ll; folder = g_node_new(NULL); g_node_append(*vars, folder); // Add permanent variables (Func, Pol, Param, DifEq, ZRCL as WIND, WIND, WIND, WIND, WIND) { GNode *node; VarEntry *ve; ve = tifiles_ve_create(); ve->type = TI86_FUNC; node = g_node_new(ve); g_node_append(folder, node); ve = tifiles_ve_create(); ve->type = TI86_POL; node = g_node_new(ve); g_node_append(folder, node); ve = tifiles_ve_create(); ve->type = TI86_PARAM; node = g_node_new(ve); g_node_append(folder, node); ve = tifiles_ve_create(); ve->type = TI86_DIFEQ; node = g_node_new(ve); g_node_append(folder, node); ve = tifiles_ve_create(); ve->type = TI86_ZRCL; node = g_node_new(ve); g_node_append(folder, node); } for (;;) { VarEntry *ve = tifiles_ve_create(); GNode *node; int err; uint16_t ve_size; err = ti85_recv_VAR(&ve_size, &ve->type, ve->name); ve->size = ve_size; TRYF(ti85_send_ACK()); if (err == ERR_EOT) break; else if (err != 0) return err; node = g_node_new(ve); g_node_append(folder, node); utf8 = ticonv_varname_to_utf8(handle->model, ve->name, ve->type); g_snprintf(update_->text, sizeof(update_->text), _("Parsing %s"), utf8); g_free(utf8); update_label(); } return 0; }
static bool cloud_config_parse(yaml_parser_t *parser, GNode *node, int state) { GNode *last_leaf = node; yaml_event_t event; bool finished = 0; while (!finished) { if (!yaml_parser_parse(parser, &event)) { LOG("An error occurred while the yaml file was parsed.\n"); return false; } switch (event.type) { case YAML_SCALAR_EVENT: if (state & SEQ) { last_leaf = g_node_append(node, g_node_new(g_strdup((gchar*) event.data.scalar.value))); } else if (state & VAL) { g_node_append_data(last_leaf, g_strdup((gchar*) event.data.scalar.value)); state &= MAP | SEQ; } else { last_leaf = g_node_append(node, g_node_new(g_strdup((gchar*) event.data.scalar.value))); state |= VAL; } break; case YAML_SEQUENCE_START_EVENT: /* remove VAL bit if it's set */ if (state & MAP) state = MAP; if (state & SEQ) { last_leaf = g_node_append(node, g_node_new(NULL)); } else { last_leaf = g_node_append(last_leaf, g_node_new(NULL)); } if (!cloud_config_parse(parser, last_leaf, SEQ)) { return false; } last_leaf = last_leaf->parent; break; case YAML_SEQUENCE_END_EVENT: finished = true; break; case YAML_MAPPING_START_EVENT: last_leaf = g_node_append(node, g_node_new(NULL)); if (!cloud_config_parse(parser, last_leaf, MAP)) { return false; } last_leaf = last_leaf->parent; break; case YAML_MAPPING_END_EVENT: last_leaf = last_leaf->parent; finished = true; break; case YAML_STREAM_END_EVENT: finished = true; break; case YAML_NO_TOKEN: LOG("Unexpectedly reached end of YAML input!"); finished = true; break; default: /* Ignore these for now */ break; } if (!finished) { yaml_event_delete(&event); } } return true; }
/* Save selections in a common xml-file. Called when unloading the plugin. * This is analog to folder.h::folder_write_list. */ void notification_foldercheck_write_array(void) { gchar *path; XMLTag *tag; XMLNode *xmlnode; GNode *rootnode; gint ii; PrefFile *pfile; /* Do nothing if foldercheck is not in use */ if(specific_folder_array_size == 0) return; path = foldercheck_get_array_path(); if((pfile = prefs_write_open(path)) == NULL) { debug_print("Notification Plugin Error: Cannot open " "file " FOLDERCHECK_ARRAY " for writing\n"); return; } /* XML declarations */ xml_file_put_xml_decl(pfile->fp); /* Build up XML tree */ /* root node */ tag = xml_tag_new("foldercheckarray"); xmlnode = xml_node_new(tag, NULL); rootnode = g_node_new(xmlnode); /* branch nodes */ for(ii = 0; ii < specific_folder_array_size; ii++) { GNode *branchnode; GSList *walk; SpecificFolderArrayEntry *entry; entry = foldercheck_get_entry_from_id(ii); tag = xml_tag_new("branch"); xml_tag_add_attr(tag, xml_attr_new("name",entry->name)); xmlnode = xml_node_new(tag, NULL); branchnode = g_node_new(xmlnode); g_node_append(rootnode, branchnode); /* Write out the list as leaf nodes */ for(walk = entry->list; walk != NULL; walk = g_slist_next(walk)) { gchar *identifier; GNode *node; FolderItem *item = (FolderItem*) walk->data; identifier = folder_item_get_identifier(item); tag = xml_tag_new("folderitem"); xml_tag_add_attr(tag, xml_attr_new("identifier", identifier)); g_free(identifier); xmlnode = xml_node_new(tag, NULL); node = g_node_new(xmlnode); g_node_append(branchnode, node); } /* for all list elements in branch node */ } /* for all branch nodes */ /* Actual writing and cleanup */ xml_write_tree(rootnode, pfile->fp); if(prefs_file_close(pfile) < 0) { debug_print("Notification Plugin Error: Failed to write " "file " FOLDERCHECK_ARRAY "\n"); } /* Free XML tree */ xml_free_tree(rootnode); }
/** * add_menu_node(GNode * cur_node, GNode * new_node) * @brief adds menu item node to the N-array tree * @param cur_node * @param new_node */ GNode *add_menu_node(GNode * cur_node, GNode * new_node) { return g_node_append(cur_node, new_node); }
static int get_dirlist (CalcHandle* handle, GNode** vars, GNode** apps) { TreeInfo *ti; VarEntry info; uint32_t unused; uint8_t buffer[65536]; int err; char folder_name[9] = ""; GNode *folder = NULL; char *utf8; // get list of folders & FLASH apps (*vars) = g_node_new(NULL); ti = (TreeInfo *)g_malloc(sizeof(TreeInfo)); ti->model = handle->model; ti->type = VAR_NODE_NAME; (*vars)->data = ti; (*apps) = g_node_new(NULL); ti = (TreeInfo *)g_malloc(sizeof(TreeInfo)); ti->model = handle->model; ti->type = APP_NODE_NAME; (*apps)->data = ti; TRYF(ti92_send_REQ(0, TI92_RDIR, "")); TRYF(ti92_recv_ACK(NULL)); TRYF(ti92_recv_VAR(&info.size, &info.type, info.name)); for (;;) { VarEntry *ve = tifiles_ve_create(); GNode *node; TRYF(ti92_send_ACK()); TRYF(ti92_send_CTS()); TRYF(ti92_recv_ACK(NULL)); TRYF(ti92_recv_XDP(&unused, buffer)); memcpy(ve->name, buffer + 4, 8); // skip 4 extra 00s ve->name[8] = '\0'; ve->type = buffer[12]; ve->attr = buffer[13]; ve->size = buffer[14] | (buffer[15] << 8) | (buffer[16] << 16) | (buffer[17] << 24); strcpy(ve->folder, ""); if (ve->type == TI92_DIR) { strcpy(folder_name, ve->name); node = g_node_new(ve); folder = g_node_append(*vars, node); } else { strcpy(ve->folder, folder_name); if(!strcmp(ve->folder, "main") && (!strcmp(ve->name, "regcoef") || !strcmp(ve->name, "regeq"))) { tifiles_ve_delete(ve); } else { node = g_node_new(ve); g_node_append(folder, node); } } ticalcs_info(_("Name: %8s | Type: %8s | Attr: %i | Size: %08X"), ve->name, tifiles_vartype2string(handle->model, ve->type), ve->attr, ve->size); TRYF(ti92_send_ACK()); err = ti92_recv_CNT(); if (err == ERR_EOT) break; TRYF(err); utf8 = ticonv_varname_to_utf8(handle->model, ve->name, ve->type); g_snprintf(update_->text, sizeof(update_->text), _("Parsing %s/%s"), ((VarEntry *) (folder->data))->name, utf8); g_free(utf8); update_->label(); } TRYF(ti92_send_ACK()); return 0; }
static void g_node_test (void) { GNode *root; GNode *node; GNode *node_B; GNode *node_D; GNode *node_F; GNode *node_G; GNode *node_J; guint i; gchar *tstring; failed = FALSE; root = g_node_new (C2P ('A')); TEST (NULL, g_node_depth (root) == 1 && g_node_max_height (root) == 1); node_B = g_node_new (C2P ('B')); g_node_append (root, node_B); TEST (NULL, root->children == node_B); g_node_append_data (node_B, C2P ('E')); g_node_prepend_data (node_B, C2P ('C')); node_D = g_node_new (C2P ('D')); g_node_insert (node_B, 1, node_D); node_F = g_node_new (C2P ('F')); g_node_append (root, node_F); TEST (NULL, root->children->next == node_F); node_G = g_node_new (C2P ('G')); g_node_append (node_F, node_G); node_J = g_node_new (C2P ('J')); g_node_prepend (node_G, node_J); g_node_insert (node_G, 42, g_node_new (C2P ('K'))); g_node_insert_data (node_G, 0, C2P ('H')); g_node_insert (node_G, 1, g_node_new (C2P ('I'))); TEST (NULL, g_node_depth (root) == 1); TEST (NULL, g_node_max_height (root) == 4); TEST (NULL, g_node_depth (node_G->children->next) == 4); TEST (NULL, g_node_n_nodes (root, G_TRAVERSE_LEAFS) == 7); TEST (NULL, g_node_n_nodes (root, G_TRAVERSE_NON_LEAFS) == 4); TEST (NULL, g_node_n_nodes (root, G_TRAVERSE_ALL) == 11); TEST (NULL, g_node_max_height (node_F) == 3); TEST (NULL, g_node_n_children (node_G) == 4); TEST (NULL, g_node_find_child (root, G_TRAVERSE_ALL, C2P ('F')) == node_F); TEST (NULL, g_node_find (root, G_LEVEL_ORDER, G_TRAVERSE_NON_LEAFS, C2P ('I')) == NULL); TEST (NULL, g_node_find (root, G_IN_ORDER, G_TRAVERSE_LEAFS, C2P ('J')) == node_J); for (i = 0; i < g_node_n_children (node_B); i++) { node = g_node_nth_child (node_B, i); TEST (NULL, P2C (node->data) == ('C' + i)); } for (i = 0; i < g_node_n_children (node_G); i++) TEST (NULL, g_node_child_position (node_G, g_node_nth_child (node_G, i)) == i); /* we have built: A * / \ * B F * / | \ \ * C D E G * / /\ \ * H I J K * * for in-order traversal, 'G' is considered to be the "left" * child of 'F', which will cause 'F' to be the last node visited. */ tstring = NULL; g_node_traverse (root, G_PRE_ORDER, G_TRAVERSE_ALL, -1, node_build_string, &tstring); TEST (tstring, strcmp (tstring, "ABCDEFGHIJK") == 0); g_free (tstring); tstring = NULL; g_node_traverse (root, G_POST_ORDER, G_TRAVERSE_ALL, -1, node_build_string, &tstring); TEST (tstring, strcmp (tstring, "CDEBHIJKGFA") == 0); g_free (tstring); tstring = NULL; g_node_traverse (root, G_IN_ORDER, G_TRAVERSE_ALL, -1, node_build_string, &tstring); TEST (tstring, strcmp (tstring, "CBDEAHGIJKF") == 0); g_free (tstring); tstring = NULL; g_node_traverse (root, G_LEVEL_ORDER, G_TRAVERSE_ALL, -1, node_build_string, &tstring); TEST (tstring, strcmp (tstring, "ABFCDEGHIJK") == 0); g_free (tstring); tstring = NULL; g_node_traverse (root, G_LEVEL_ORDER, G_TRAVERSE_LEAFS, -1, node_build_string, &tstring); TEST (tstring, strcmp (tstring, "CDEHIJK") == 0); g_free (tstring); tstring = NULL; g_node_traverse (root, G_PRE_ORDER, G_TRAVERSE_NON_LEAFS, -1, node_build_string, &tstring); TEST (tstring, strcmp (tstring, "ABFG") == 0); g_free (tstring); tstring = NULL; g_node_reverse_children (node_B); g_node_reverse_children (node_G); g_node_traverse (root, G_LEVEL_ORDER, G_TRAVERSE_ALL, -1, node_build_string, &tstring); TEST (tstring, strcmp (tstring, "ABFEDCGKJIH") == 0); g_free (tstring); tstring = NULL; g_node_append (node_D, g_node_new (C2P ('L'))); g_node_append (node_D, g_node_new (C2P ('M'))); g_node_traverse (root, G_LEVEL_ORDER, G_TRAVERSE_ALL, -1, node_build_string, &tstring); TEST (tstring, strcmp (tstring, "ABFEDCGLMKJIH") == 0); g_free (tstring); tstring = NULL; g_node_destroy (root); /* allocation tests */ root = g_node_new (NULL); node = root; for (i = 0; i < 2048; i++) { g_node_append (node, g_node_new (NULL)); if ((i%5) == 4) node = node->children->next; } TEST (NULL, g_node_max_height (root) > 100); TEST (NULL, g_node_n_nodes (root, G_TRAVERSE_ALL) == 1 + 2048); g_node_destroy (root); if (failed) exit(1); }
void plist_from_bin(const char *plist_bin, uint32_t length, plist_t * plist) { char *trailer = NULL; uint8_t offset_size = 0; uint8_t dict_param_size = 0; uint64_t num_objects = 0; uint64_t root_object = 0; uint64_t offset_table_index = 0; plist_t *nodeslist = NULL; uint64_t i = 0; uint64_t current_offset = 0; char *offset_table = NULL; uint32_t j = 0, str_i = 0, str_j = 0; uint32_t index1 = 0, index2 = 0; //first check we have enough data if (!(length >= BPLIST_MAGIC_SIZE + BPLIST_VERSION_SIZE + BPLIST_TRL_SIZE)) return; //check that plist_bin in actually a plist if (memcmp(plist_bin, BPLIST_MAGIC, BPLIST_MAGIC_SIZE) != 0) return; //check for known version if (memcmp(plist_bin + BPLIST_MAGIC_SIZE, BPLIST_VERSION, BPLIST_VERSION_SIZE) != 0) return; //now parse trailer trailer = (char *) (plist_bin + (length - BPLIST_TRL_SIZE)); offset_size = trailer[BPLIST_TRL_OFFSIZE_IDX]; dict_param_size = trailer[BPLIST_TRL_PARMSIZE_IDX]; num_objects = be64dec(trailer + BPLIST_TRL_NUMOBJ_IDX); root_object = be64dec(trailer + BPLIST_TRL_ROOTOBJ_IDX); offset_table_index = be64dec(trailer + BPLIST_TRL_OFFTAB_IDX); if (num_objects == 0) return; //allocate serialized array of nodes nodeslist = (plist_t *) malloc(sizeof(plist_t) * num_objects); if (!nodeslist) return; //parse serialized nodes offset_table = (char *) (plist_bin + offset_table_index); for (i = 0; i < num_objects; i++) { char *obj = NULL; current_offset = UINT_TO_HOST(offset_table + i * offset_size, offset_size); obj = (char *) (plist_bin + current_offset); nodeslist[i] = parse_bin_node(obj, dict_param_size, &obj); } //setup children for structured types for (i = 0; i < num_objects; i++) { plist_data_t data = plist_get_data(nodeslist[i]); switch (data->type) { case PLIST_DICT: for (j = 0; j < data->length; j++) { str_i = j * dict_param_size; str_j = (j + data->length) * dict_param_size; index1 = UINT_TO_HOST(data->buff + str_i, dict_param_size); index2 = UINT_TO_HOST(data->buff + str_j, dict_param_size); //first one is actually a key plist_get_data(nodeslist[index1])->type = PLIST_KEY; if (index1 < num_objects) { if (G_NODE_IS_ROOT(nodeslist[index1])) g_node_append(nodeslist[i], nodeslist[index1]); else g_node_append(nodeslist[i], g_node_copy_deep(nodeslist[index1], copy_plist_data, NULL)); } if (index2 < num_objects) { if (G_NODE_IS_ROOT(nodeslist[index2])) g_node_append(nodeslist[i], nodeslist[index2]); else g_node_append(nodeslist[i], g_node_copy_deep(nodeslist[index2], copy_plist_data, NULL)); } } free(data->buff); break; case PLIST_ARRAY: for (j = 0; j < data->length; j++) { str_j = j * dict_param_size; index1 = UINT_TO_HOST(data->buff + str_j, dict_param_size); if (index1 < num_objects) { if (G_NODE_IS_ROOT(nodeslist[index1])) g_node_append(nodeslist[i], nodeslist[index1]); else g_node_append(nodeslist[i], g_node_copy_deep(nodeslist[index1], copy_plist_data, NULL)); } } free(data->buff); break; default: break; } } *plist = nodeslist[root_object]; free(nodeslist); }
static gboolean tnef_parse (MimeParser *parser, MimeInfo *mimeinfo) { TNEFStruct *tnef; MimeInfo *sub_info = NULL; variableLength *tmp_var; Attachment *att; int parse_result = 0; gboolean cal_done = FALSE; if (!procmime_decode_content(mimeinfo)) { debug_print("error decoding\n"); return FALSE; } debug_print("Tnef parser parsing part (%d).\n", mimeinfo->length); if (mimeinfo->content == MIMECONTENT_FILE) debug_print("content: %s\n", mimeinfo->data.filename); else debug_print("contents in memory (len %zd)\n", strlen(mimeinfo->data.mem)); tnef = g_new0(TNEFStruct, 1); TNEFInitialize(tnef); tnef->Debug = debug_get_mode(); if (mimeinfo->content == MIMECONTENT_MEM) parse_result = TNEFParseMemory(mimeinfo->data.mem, mimeinfo->length, tnef); else parse_result = TNEFParseFile(mimeinfo->data.filename, tnef); mimeinfo->type = MIMETYPE_MULTIPART; mimeinfo->subtype = g_strdup("mixed"); g_hash_table_insert(mimeinfo->typeparameters, g_strdup("description"), g_strdup("Parsed from MS-TNEF")); if (parse_result != 0) { g_warning("Failed to parse TNEF data."); TNEFFree(tnef); return FALSE; } sub_info = NULL; if (tnef->messageClass[0] != '\0') { if (strcmp(tnef->messageClass, "IPM.Contact") == 0) sub_info = tnef_parse_vcard(tnef); else if (strcmp(tnef->messageClass, "IPM.Task") == 0) sub_info = tnef_parse_vtask(tnef); else if (strcmp(tnef->messageClass, "IPM.Appointment") == 0) { sub_info = tnef_parse_vcal(tnef); cal_done = TRUE; } } if (sub_info) g_node_append(mimeinfo->node, sub_info->node); sub_info = NULL; if (tnef->MapiProperties.count > 0) { tmp_var = MAPIFindProperty (&(tnef->MapiProperties), PROP_TAG(PT_BINARY,PR_RTF_COMPRESSED)); if (tmp_var != MAPI_UNDEFINED) { sub_info = tnef_parse_rtf(tnef, tmp_var); } } if (sub_info) g_node_append(mimeinfo->node, sub_info->node); sub_info = NULL; tmp_var = MAPIFindUserProp(&(tnef->MapiProperties), PROP_TAG(PT_STRING8,0x24)); if (tmp_var != MAPI_UNDEFINED) { if (!cal_done && strcmp(tmp_var->data, "IPM.Appointment") == 0) { sub_info = tnef_parse_vcal(tnef); } } if (sub_info) g_node_append(mimeinfo->node, sub_info->node); sub_info = NULL; att = tnef->starting_attach.next; while (att) { gchar *filename = NULL; gboolean is_object = TRUE; DWORD signature; tmp_var = MAPIFindProperty(&(att->MAPI), PROP_TAG(30,0x3707)); if (tmp_var == MAPI_UNDEFINED) tmp_var = MAPIFindProperty(&(att->MAPI), PROP_TAG(30,0x3001)); if (tmp_var == MAPI_UNDEFINED) tmp_var = &(att->Title); if (tmp_var->data) filename = g_strdup(tmp_var->data); tmp_var = MAPIFindProperty(&(att->MAPI), PROP_TAG(PT_OBJECT, PR_ATTACH_DATA_OBJ)); if (tmp_var == MAPI_UNDEFINED) tmp_var = MAPIFindProperty(&(att->MAPI), PROP_TAG(PT_BINARY, PR_ATTACH_DATA_OBJ)); if (tmp_var == MAPI_UNDEFINED) { tmp_var = &(att->FileData); is_object = FALSE; } sub_info = tnef_dump_file(filename, tmp_var->data + (is_object ? 16:0), tmp_var->size - (is_object ? 16:0)); if (sub_info) g_node_append(mimeinfo->node, sub_info->node); memcpy(&signature, tmp_var->data+(is_object ? 16:0), sizeof(DWORD)); if (TNEFCheckForSignature(signature) == 0) { debug_print("that's TNEF stuff, process it\n"); tnef_parse(parser, sub_info); } sub_info = NULL; att = att->next; g_free(filename); } TNEFFree(tnef); return TRUE; }
static int get_dirlist (CalcHandle* handle, GNode** vars, GNode** apps) { TreeInfo *ti; GNode *folder; uint16_t unused; uint32_t memory; char *utf8; // get list of folders & FLASH apps (*apps) = g_node_new(NULL); ti = (TreeInfo *)g_malloc(sizeof(TreeInfo)); ti->model = handle->model; ti->type = APP_NODE_NAME; (*apps)->data = ti; (*vars) = g_node_new(NULL); ti = (TreeInfo *)g_malloc(sizeof(TreeInfo)); ti->model = handle->model; ti->type = VAR_NODE_NAME; (*vars)->data = ti; TRYF(ti82_send_REQ(handle, 0x0000, TI83_DIR, "")); TRYF(ti82_recv_ACK(handle, &unused)); TRYF(ti82_recv_XDP(handle, &unused, (uint8_t *)&memory)); fixup(memory); TRYF(ti82_send_ACK(handle)); ti->mem_free = memory; folder = g_node_new(NULL); g_node_append(*vars, folder); // Add permanent variables (Window, RclWindow, TblSet aka WINDW, ZSTO, TABLE) { GNode *node; VarEntry *ve; ve = tifiles_ve_create(); ve->type = TI83_WINDW; node = g_node_new(ve); g_node_append(folder, node); ve = tifiles_ve_create(); ve->type = TI83_ZSTO; node = g_node_new(ve); g_node_append(folder, node); ve = tifiles_ve_create(); ve->type = TI83_TABLE; node = g_node_new(ve); g_node_append(folder, node); } for (;;) { VarEntry *ve = tifiles_ve_create(); GNode *node; int err; uint16_t ve_size; err = ti82_recv_VAR(handle, &ve_size, &ve->type, ve->name); ve->size = ve_size; TRYF(ti82_send_ACK(handle)); if (err == ERR_EOT) break; else if (err != 0) return err; node = g_node_new(ve); g_node_append(folder, node); utf8 = ticonv_varname_to_utf8(handle->model, ve->name, ve->type); g_snprintf(update_->text, sizeof(update_->text), _("Parsing %s"), utf8); g_free(utf8); update_label(); } return 0; }
/* return the reversed thread tree */ GNode *procmsg_get_thread_tree(GSList *mlist) { GNode *root, *parent, *node, *next; GHashTable *msgid_table; GRelation *subject_relation; MsgInfo *msginfo; const gchar *msgid; root = g_node_new(NULL); msgid_table = g_hash_table_new(g_str_hash, g_str_equal); subject_relation = g_relation_new(2); g_relation_index(subject_relation, 0, g_str_hash, g_str_equal); for (; mlist != NULL; mlist = mlist->next) { msginfo = (MsgInfo *)mlist->data; parent = root; if (msginfo->inreplyto) { parent = g_hash_table_lookup(msgid_table, msginfo->inreplyto); if (parent == NULL) { parent = root; } } node = g_node_insert_data_before (parent, parent == root ? parent->children : NULL, msginfo); if ((msgid = msginfo->msgid) && g_hash_table_lookup(msgid_table, msgid) == NULL) g_hash_table_insert(msgid_table, (gchar *)msgid, node); /* CLAWS: add subject to relation (without prefix) */ if (prefs_common.thread_by_subject) { subject_relation_insert(subject_relation, node); } } /* complete the unfinished threads */ for (node = root->children; node != NULL; ) { parent = NULL; next = node->next; msginfo = (MsgInfo *)node->data; if (msginfo->inreplyto) { parent = g_hash_table_lookup(msgid_table, msginfo->inreplyto); /* node should not be the parent, and node should not be an ancestor of parent (circular reference) */ if (parent && parent != node && !g_node_is_ancestor(node, parent)) { g_node_unlink(node); g_node_insert_before (parent, parent->children, node); } } node = next; } if (prefs_common.thread_by_subject) { for (node = root->children; node && node != NULL;) { next = node->next; msginfo = (MsgInfo *) node->data; parent = subject_relation_lookup(subject_relation, msginfo); /* the node may already be threaded by IN-REPLY-TO, so go up * in the tree to find the parent node */ if (parent != NULL) { if (g_node_is_ancestor(node, parent)) parent = NULL; if (parent == node) parent = NULL; } if (parent) { g_node_unlink(node); g_node_append(parent, node); } node = next; } } g_relation_destroy(subject_relation); g_hash_table_destroy(msgid_table); return root; }
void load_file(GtkFileSelection *selector, gpointer file_selector) { FILE *stream; gchar *pfad; gchar *filename; gchar txtBuffer[200]; gchar bouquetName[MAX_TXT_LEN+1]; bouquetEntry *bouquet; channelEntry *channel; GNode *node_root; GNode *node_bouquet; GNode *node_channel; gint sumBouquets = 0; gint diseqc, transportID, frequenz, symbolRate, fec, polarity, onid, serviceID, serviceType; gchar name[MAX_TXT_LEN+1]; //****************************** // load bouquets file & fill GNode. //****************************** filename = (gchar*) gtk_file_selection_get_filename(GTK_FILE_SELECTION(file_selector)); if (!(stream = fopen(filename, "rb"))){ GtkWidget* dialog; sprintf(txtBuffer,_("Could not read: '%s' \n"),filename); dialog = gtk_message_dialog_new (NULL,0, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK,txtIn(txtBuffer)); center_window(GTK_WINDOW(dialog)); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); return; } fgets(txtBuffer,BUFFER_SIZE,stream); // xml Version. fgets(txtBuffer,BUFFER_SIZE,stream); // ZAPIT - ID. if (!strFind(txtBuffer,"<ZAPIT>" )){ GtkWidget* dialog= gtk_message_dialog_new (NULL,0, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, txtIn(_("channel format unknown"))); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); fclose(stream); return; } GTK_LIST_STORE(MW_GET("LEFT_LIST_STORE"))->sort_column_id = -2; // switch off sorting. clear_left_listview(); fgets(txtBuffer,BUFFER_SIZE,stream); // Bouquet-Kennung. if (!strFind(txtBuffer,"<BOUQUET" )){ GtkWidget* dialog= gtk_message_dialog_new (NULL,0, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, txtIn(_("This is not a Bouquet File.\n" "Please select a bouquet-file like 'bouquets.xml'."))); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); fclose(stream); return; } // ***** OK, this seems to be a bouquets file. fseek(stream,0,0); fgets(txtBuffer,BUFFER_SIZE,stream); // xml Version. fgets(txtBuffer,BUFFER_SIZE,stream); // ZAPIT - ID. node_root = MW_GET("LEFT_NODE_ROOT"); while(1){ // read all Bouquets. fgets(txtBuffer,BUFFER_SIZE,stream); // Bouquet-Daten. if (strFind(txtBuffer,"</ZAPIT>" )) break; bouquet = malloc(sizeof(bouquetEntry)); sumBouquets++; node_bouquet = g_node_append(node_root, g_node_new(bouquet)); XMLtoAsc(bouquetName, extractData(txtBuffer,"name")); strcpy(bouquet->bouquetName,bouquetName); bouquet->hidden = atoi(extractData(txtBuffer,"hidden")); bouquet->locked = atoi(extractData(txtBuffer,"locked")); node_channel = g_node_last_child (node_bouquet); while(1){ // read all channels. fgets(txtBuffer,BUFFER_SIZE,stream); if (strFind(txtBuffer,"</BOUQUET>" )) break; channel = malloc(sizeof(channelEntry)); node_channel = g_node_append(node_bouquet, g_node_new(channel)); channel->serviceID= strtol(extractData(txtBuffer,"serviceID"),NULL,16); XMLtoAsc(channel->channelName, extractData(txtBuffer,"name")); channel->onid= strtol(extractData(txtBuffer,"onid"),NULL, 16); channel->frequency = 0; } } fclose(stream); // ****************************** // die services Datei einlesen und die Bouquets in verkette Liste mit diesen // Daten ergänzen. // ****************************** pfad=filename+strlen(filename); while(*pfad!='\\' && *pfad!='/') pfad--; *++pfad='\0'; strcpy(txtBuffer, filename); strcat(txtBuffer,ZAPIT_SERV_NAME); if (!(stream = fopen(txtBuffer, "rb"))){ GtkWidget* dialog; strcat(txtBuffer, _(" not found.")); dialog = gtk_message_dialog_new (NULL,0, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK,txtIn(txtBuffer)); center_window(GTK_WINDOW(dialog)); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); clear_left_listview(); return; } fgets(txtBuffer,BUFFER_SIZE,stream); // xml Version. fgets(txtBuffer,BUFFER_SIZE,stream); // ZAPIT-Kennung. while (1){ // alle Satelliten einlesen. fgets(txtBuffer,BUFFER_SIZE,stream); // Sat / Kabel Daten. if (!strFind(txtBuffer,"<sat" ) && !strFind(txtBuffer,"<cable" )) break; diseqc = atoi(extractData(txtBuffer,"diseqc")); while (1){ // alle Transponder einlesen. fgets(txtBuffer,BUFFER_SIZE,stream); // Transponder if (strFind(txtBuffer,"</" )) break; transportID= strtol(extractData(txtBuffer,"transponder id"),NULL, 16); onid = strtol(extractData(txtBuffer,"onid"),NULL,16); frequenz= atoi(extractData(txtBuffer,"frequency")); symbolRate= atoi(extractData(txtBuffer,"symbol_rate")); fec= atoi(extractData(txtBuffer,"fec_inner")); polarity= atoi(extractData(txtBuffer,"polarization")); while(1){ // Alle Channels einlesen. gint test=0; fgets(txtBuffer,BUFFER_SIZE,stream); // Kanaldaten. if (strFind(txtBuffer,"</" )) break; serviceID = strtol(extractData(txtBuffer,"service_id"),NULL,16); XMLtoAsc(name, extractData(txtBuffer,"name")); serviceType = strtol(extractData(txtBuffer,"service_type"),NULL,16); // ****************************** // jeden einzelnen Sender in der Liste mit den neuen Daten ergänzen. // ****************************** node_bouquet = g_node_first_child(node_root); while (node_bouquet){ node_channel = g_node_first_child(node_bouquet); while (node_channel){ channel = node_channel->data; if ((serviceID == channel->serviceID) && (onid == channel->onid)) { // dieser Sender ist in den Bouquets. Also fehlende Daten ergänzen. channel->serviceType=serviceType; channel->diseqc=diseqc; channel->transportID=transportID; channel->frequency=frequenz; channel->symbolRate=symbolRate; channel->fec=fec; channel->polarisation=polarity; test++; } node_channel = node_channel->next; } node_bouquet=node_bouquet->next; } // ****************************** // Wenn der Sender aus den Services nicht in den Bouquets vorhanden war und die Liste // das komplette Bouquet enthält-> im Bouquet "*NEW*" eintragen. // ****************************** if (!test && sumBouquets > 1){ node_bouquet = g_node_last_child(node_root); bouquet = node_bouquet->data; if (strcmp(bouquet->bouquetName, "*NEW*")){ bouquet = malloc(sizeof(bouquetEntry)); node_bouquet = g_node_append(node_root, g_node_new(bouquet)); strcpy(bouquet->bouquetName,"*NEW*"); bouquet->hidden = FALSE; bouquet->locked = FALSE; sumBouquets++; } channel = malloc(sizeof(channelEntry)); g_node_append(node_bouquet, g_node_new(channel)); channel->serviceType=serviceType; channel->diseqc=diseqc; channel->transportID=transportID; channel->frequency=frequenz; channel->symbolRate=symbolRate; channel->fec=fec; channel->polarisation=polarity; XMLtoAsc(channel->channelName,name); channel->onid= onid; channel->serviceID= serviceID; } } } } fclose(stream); //****************************** // Die Bouquets überprüfen. Wenn kein Eintrag bei (z.B.) Frequez vorhanden ist, // war der Sender nicht in der services enthalten -> Daten sind nicht komplett! // -> löschen. Ebenso wenn Datendienste nicht eingelsen werden sollten. //****************************** node_bouquet = g_node_first_child(node_root); while (node_bouquet){ node_channel = g_node_first_child (node_bouquet); while (node_channel){ channel = node_channel->data; if ( (!channel->frequency) || ((!GTK_TOGGLE_BUTTON(MW_GET("OPT_READ_DATA"))->active) && (getServicePic(channel->serviceType) == DATA)) ) { // Sender war in der Bouquets-datei, aber nicht in der Services -> Sender löschen. node_channel = remove_node(node_channel); continue; } node_channel = node_channel ->next; } if (!g_node_first_child (node_bouquet)){ // bouquet now empty ? -> delete it. node_bouquet = remove_node(node_bouquet); sumBouquets--; continue; } node_bouquet = node_bouquet->next; } gtk_widget_grab_focus(GTK_WIDGET(MW_GET("OPT_READ_SHORT"))); // unfocus search entry. fill_left_listview(); }