Changeset 62f53b50 for lib/xmltree.c

Timestamp:

2010-10-02T05:34:53Z (14 years ago)

Author:

Wilmer van der Gaast <wilmer@…>

Branches:

master

Children:

2af3e23

Parents:

05bf2a0 (diff), 04cd284 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merging msnp13 branch which, confusingly, upgrades the msn module to use
MSNP15. (The reason for this is that A) IMHO MSNP13 is what causes most of
the pain in this upgade and B) I initially intended to only implement MSNP13
but then discovered MS doesn't support it anymore.)

This fixes issues with display names being forgotten, adding contacts (and
them automatically getting blocked sometimes!!), and adds support for
away/status messages and some support for sending offline messages.

File:

• lib/xmltree.c (modified) (9 diffs)

lib/xmltree.c

@@ -141 +141 @@
 /* Feed the parser, don't execute any handler. Returns -1 on errors, 0 on
    end-of-stream and 1 otherwise. */
-int xt_feed( struct xt_parser *xt, char *text, int text_len )
+int xt_feed( struct xt_parser *xt, const char *text, int text_len )
 {
         if( !g_markup_parse_context_parse( xt->parser, text, text_len, &xt->gerr ) )
@@ -174 +174 @@
         if( node->flags & XT_COMPLETE && !( node->flags & XT_SEEN ) )
         {
-                for( i = 0; xt->handlers[i].func; i ++ )
+                if( xt->handlers ) for( i = 0; xt->handlers[i].func; i ++ )
                 {
                         /* This one is fun! \o/ */
                         
-                                                /* If handler.name == NULL it means it should always match. */
+                            /* If handler.name == NULL it means it should always match. */
                         if( ( xt->handlers[i].name == NULL || 
-                                                /* If it's not, compare. There should always be a name. */
+                              /* If it's not, compare. There should always be a name. */
                               g_strcasecmp( xt->handlers[i].name, node->name ) == 0 ) &&
-                                                /* If handler.parent == NULL, it's a match. */
+                            /* If handler.parent == NULL, it's a match. */
                             ( xt->handlers[i].parent == NULL ||
-                                                /* If there's a parent node, see if the name matches. */
+                              /* If there's a parent node, see if the name matches. */
                               ( node->parent ? g_strcasecmp( xt->handlers[i].parent, node->parent->name ) == 0 : 
-                                                /* If there's no parent, the handler should mention <root> as a parent. */
-                                               g_strcasecmp( xt->handlers[i].parent, "<root>" ) == 0 ) ) )
+                              /* If there's no parent, the handler should mention <root> as a parent. */
+                                               strcmp( xt->handlers[i].parent, "<root>" ) == 0 ) ) )
                         {
                                 st = xt->handlers[i].func( node, xt->data );
@@ -260 +260 @@
 }
 
+struct xt_node *xt_from_string( const char *in )
+{
+        struct xt_parser *parser;
+        struct xt_node *ret;
+        
+        parser = xt_new( NULL, NULL );
+        xt_feed( parser, in, strlen( in ) );
+        ret = parser->root;
+        parser->root = NULL;
+        xt_free( parser );
+        
+        return ret;
+}
+
 static void xt_to_string_real( struct xt_node *node, GString *str )
 {
@@ -317 +331 @@
         /* Indentation */
         for( c = node; c->parent; c = c->parent )
-                printf( "\t" );
+                printf( "    " );
         
         /* Start the tag */
@@ -324 +338 @@
         /* Print the attributes */
         for( i = 0; node->attr[i].key; i ++ )
-                printf( " %s=\"%s\"", node->attr[i].key, g_markup_escape_text( node->attr[i].value, -1 ) );
+        {
+                char *v = g_markup_escape_text( node->attr[i].value, -1 );
+                printf( " %s=\"%s\"", node->attr[i].key, v );
+                g_free( v );
+        }
         
         /* /> in case there's really *nothing* inside this tag, otherwise
@@ -344 +362 @@
                 for( i = 0; node->text[i] && isspace( node->text[i] ); i ++ );
                 if( node->text[i] )
-                        printf( "%s", g_markup_escape_text( node->text, -1 ) );
+                {
+                        char *v = g_markup_escape_text( node->text, -1 );
+                        printf( "%s", v );
+                        g_free( v );
+                }
         }
         
@@ -355 +377 @@
         if( node->children )
                 for( c = node; c->parent; c = c->parent )
-                        printf( "\t" );
+                        printf( "    " );
         
         /* Non-empty tag is now finished. */
@@ -460 +482 @@
                 
                 node = node->next;
+        }
+        
+        return node;
+}
+
+/* More advanced than the one above, understands something like
+   ../foo/bar to find a subnode bar of a node foo which is a child
+   of node's parent. Pass the node directly, not its list of children. */
+struct xt_node *xt_find_path( struct xt_node *node, const char *name )
+{
+        while( name && *name && node )
+        {
+                char *colon, *slash;
+                int n;
+                
+                if( ( slash = strchr( name, '/' ) ) )
+                        n = slash - name;
+                else
+                        n = strlen( name );
+                
+                if( strncmp( name, "..", n ) == 0 )
+                {
+                        node = node->parent;
+                }
+                else
+                {
+                        node = node->children;
+                        
+                        while( node )
+                        {
+                                if( g_strncasecmp( node->name, name, n ) == 0 ||
+                                    ( ( colon = strchr( node->name, ':' ) ) &&
+                                      g_strncasecmp( colon + 1, name, n ) == 0 ) )
+                                        break;
+                                
+                                node = node->next;
+                        }
+                }
+                
+                name = slash ? slash + 1 : NULL;
         }
         
@@ -550 +612 @@
 }
 
+/* Same, but at the beginning. */
+void xt_insert_child( struct xt_node *parent, struct xt_node *child )
+{
+        struct xt_node *node, *last;
+        
+        for( node = child; node; node = node->next )
+        {
+                if( node->parent != NULL )
+                {
+                        /* ERROR CONDITION: They seem to have a parent already??? */
+                }
+                
+                node->parent = parent;
+                last = node;
+        }
+        
+        last->next = parent->children;
+        parent->children = child;
+}
+
 void xt_add_attr( struct xt_node *node, const char *key, const char *value )
 {