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