Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • lib/xmltree.c

    r327af51 rdaae10f  
    141141/* Feed the parser, don't execute any handler. Returns -1 on errors, 0 on
    142142   end-of-stream and 1 otherwise. */
    143 int xt_feed( struct xt_parser *xt, const char *text, int text_len )
     143int xt_feed( struct xt_parser *xt, char *text, int text_len )
    144144{
    145145        if( !g_markup_parse_context_parse( xt->parser, text, text_len, &xt->gerr ) )
     
    174174        if( node->flags & XT_COMPLETE && !( node->flags & XT_SEEN ) )
    175175        {
    176                 if( xt->handlers ) for( i = 0; xt->handlers[i].func; i ++ )
     176                for( i = 0; xt->handlers[i].func; i ++ )
    177177                {
    178178                        /* This one is fun! \o/ */
    179179                       
    180                             /* If handler.name == NULL it means it should always match. */
     180                                                /* If handler.name == NULL it means it should always match. */
    181181                        if( ( xt->handlers[i].name == NULL ||
    182                               /* If it's not, compare. There should always be a name. */
     182                                                /* If it's not, compare. There should always be a name. */
    183183                              g_strcasecmp( xt->handlers[i].name, node->name ) == 0 ) &&
    184                             /* If handler.parent == NULL, it's a match. */
     184                                                /* If handler.parent == NULL, it's a match. */
    185185                            ( xt->handlers[i].parent == NULL ||
    186                               /* If there's a parent node, see if the name matches. */
     186                                                /* If there's a parent node, see if the name matches. */
    187187                              ( node->parent ? g_strcasecmp( xt->handlers[i].parent, node->parent->name ) == 0 :
    188                               /* If there's no parent, the handler should mention <root> as a parent. */
    189                                                strcmp( xt->handlers[i].parent, "<root>" ) == 0 ) ) )
     188                                                /* If there's no parent, the handler should mention <root> as a parent. */
     189                                               g_strcasecmp( xt->handlers[i].parent, "<root>" ) == 0 ) ) )
    190190                        {
    191191                                st = xt->handlers[i].func( node, xt->data );
     
    260260}
    261261
    262 struct xt_node *xt_from_string( const char *in )
    263 {
    264         struct xt_parser *parser;
    265         struct xt_node *ret;
    266        
    267         parser = xt_new( NULL, NULL );
    268         xt_feed( parser, in, strlen( in ) );
    269         ret = parser->root;
    270         parser->root = NULL;
    271         xt_free( parser );
    272        
    273         return ret;
    274 }
    275 
    276262static void xt_to_string_real( struct xt_node *node, GString *str )
    277263{
     
    331317        /* Indentation */
    332318        for( c = node; c->parent; c = c->parent )
    333                 printf( "    " );
     319                printf( "\t" );
    334320       
    335321        /* Start the tag */
     
    338324        /* Print the attributes */
    339325        for( i = 0; node->attr[i].key; i ++ )
    340         {
    341                 char *v = g_markup_escape_text( node->attr[i].value, -1 );
    342                 printf( " %s=\"%s\"", node->attr[i].key, v );
    343                 g_free( v );
    344         }
     326                printf( " %s=\"%s\"", node->attr[i].key, g_markup_escape_text( node->attr[i].value, -1 ) );
    345327       
    346328        /* /> in case there's really *nothing* inside this tag, otherwise
     
    362344                for( i = 0; node->text[i] && isspace( node->text[i] ); i ++ );
    363345                if( node->text[i] )
    364                 {
    365                         char *v = g_markup_escape_text( node->text, -1 );
    366                         printf( "%s", v );
    367                         g_free( v );
    368                 }
     346                        printf( "%s", g_markup_escape_text( node->text, -1 ) );
    369347        }
    370348       
     
    377355        if( node->children )
    378356                for( c = node; c->parent; c = c->parent )
    379                         printf( "    " );
     357                        printf( "\t" );
    380358       
    381359        /* Non-empty tag is now finished. */
     
    482460               
    483461                node = node->next;
    484         }
    485        
    486         return node;
    487 }
    488 
    489 /* More advanced than the one above, understands something like
    490    ../foo/bar to find a subnode bar of a node foo which is a child
    491    of node's parent. Pass the node directly, not its list of children. */
    492 struct xt_node *xt_find_path( struct xt_node *node, const char *name )
    493 {
    494         while( name && *name && node )
    495         {
    496                 char *colon, *slash;
    497                 int n;
    498                
    499                 if( ( slash = strchr( name, '/' ) ) )
    500                         n = slash - name;
    501                 else
    502                         n = strlen( name );
    503                
    504                 if( strncmp( name, "..", n ) == 0 )
    505                 {
    506                         node = node->parent;
    507                 }
    508                 else
    509                 {
    510                         node = node->children;
    511                        
    512                         while( node )
    513                         {
    514                                 if( g_strncasecmp( node->name, name, n ) == 0 ||
    515                                     ( ( colon = strchr( node->name, ':' ) ) &&
    516                                       g_strncasecmp( colon + 1, name, n ) == 0 ) )
    517                                         break;
    518                                
    519                                 node = node->next;
    520                         }
    521                 }
    522                
    523                 name = slash ? slash + 1 : NULL;
    524462        }
    525463       
     
    612550}
    613551
    614 /* Same, but at the beginning. */
    615 void xt_insert_child( struct xt_node *parent, struct xt_node *child )
    616 {
    617         struct xt_node *node, *last;
    618        
    619         for( node = child; node; node = node->next )
    620         {
    621                 if( node->parent != NULL )
    622                 {
    623                         /* ERROR CONDITION: They seem to have a parent already??? */
    624                 }
    625                
    626                 node->parent = parent;
    627                 last = node;
    628         }
    629        
    630         last->next = parent->children;
    631         parent->children = child;
    632 }
    633 
    634552void xt_add_attr( struct xt_node *node, const char *key, const char *value )
    635553{
Note: See TracChangeset for help on using the changeset viewer.