Changeset 5ebff60 for lib/xmltree.c


Ignore:
Timestamp:
2015-02-20T22:50:54Z (9 years ago)
Author:
dequis <dx@…>
Branches:
master
Children:
0b9daac, 3d45471, 7733b8c
Parents:
af359b4
git-author:
Indent <please@…> (19-02-15 05:47:20)
git-committer:
dequis <dx@…> (20-02-15 22:50:54)
Message:

Reindent everything to K&R style with tabs

Used uncrustify, with the configuration file in ./doc/uncrustify.cfg

Commit author set to "Indent <please@…>" so that it's easier to
skip while doing git blame.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lib/xmltree.c

    raf359b4 r5ebff60  
    3333#define g_strncasecmp g_ascii_strncasecmp
    3434
    35 static void xt_start_element( GMarkupParseContext *ctx, const gchar *element_name, const gchar **attr_names, const gchar **attr_values, gpointer data, GError **error )
     35static void xt_start_element(GMarkupParseContext *ctx, const gchar *element_name, const gchar **attr_names,
     36                             const gchar **attr_values, gpointer data, GError **error)
    3637{
    3738        struct xt_parser *xt = data;
    38         struct xt_node *node = g_new0( struct xt_node, 1 ), *nt;
     39        struct xt_node *node = g_new0(struct xt_node, 1), *nt;
    3940        int i;
    40        
     41
    4142        node->parent = xt->cur;
    42         node->name = g_strdup( element_name );
    43        
     43        node->name = g_strdup(element_name);
     44
    4445        /* First count the number of attributes */
    45         for( i = 0; attr_names[i]; i ++ );
    46        
     46        for (i = 0; attr_names[i]; i++) {
     47                ;
     48        }
     49
    4750        /* Then allocate a NULL-terminated array. */
    48         node->attr = g_new0( struct xt_attr, i + 1 );
    49        
     51        node->attr = g_new0(struct xt_attr, i + 1);
     52
    5053        /* And fill it, saving one variable by starting at the end. */
    51         for( i --; i >= 0; i -- )
    52         {
    53                 node->attr[i].key = g_strdup( attr_names[i] );
    54                 node->attr[i].value = g_strdup( attr_values[i] );
    55         }
    56        
     54        for (i--; i >= 0; i--) {
     55                node->attr[i].key = g_strdup(attr_names[i]);
     56                node->attr[i].value = g_strdup(attr_values[i]);
     57        }
     58
    5759        /* Add it to the linked list of children nodes, if we have a current
    5860           node yet. */
    59         if( xt->cur )
    60         {
    61                 if( xt->cur->children )
    62                 {
    63                         for( nt = xt->cur->children; nt->next; nt = nt->next );
     61        if (xt->cur) {
     62                if (xt->cur->children) {
     63                        for (nt = xt->cur->children; nt->next; nt = nt->next) {
     64                                ;
     65                        }
    6466                        nt->next = node;
    65                 }
    66                 else
    67                 {
     67                } else {
    6868                        xt->cur->children = node;
    6969                }
    70         }
    71         else if( xt->root )
    72         {
     70        } else if (xt->root) {
    7371                /* ERROR situation: A second root-element??? */
    7472        }
    75        
     73
    7674        /* Now this node will be the new current node. */
    7775        xt->cur = node;
    7876        /* And maybe this is the root? */
    79         if( xt->root == NULL )
     77        if (xt->root == NULL) {
    8078                xt->root = node;
    81 }
    82 
    83 static void xt_text( GMarkupParseContext *ctx, const gchar *text, gsize text_len, gpointer data, GError **error )
     79        }
     80}
     81
     82static void xt_text(GMarkupParseContext *ctx, const gchar *text, gsize text_len, gpointer data, GError **error)
    8483{
    8584        struct xt_parser *xt = data;
    8685        struct xt_node *node = xt->cur;
    87        
    88         if( node == NULL )
     86
     87        if (node == NULL) {
    8988                return;
    90        
     89        }
     90
    9191        /* FIXME: Does g_renew also OFFICIALLY accept NULL arguments? */
    92         node->text = g_renew( char, node->text, node->text_len + text_len + 1 );
    93         memcpy( node->text + node->text_len, text, text_len );
     92        node->text = g_renew(char, node->text, node->text_len + text_len + 1);
     93        memcpy(node->text + node->text_len, text, text_len);
    9494        node->text_len += text_len;
    9595        /* Zero termination is always nice to have. */
     
    9797}
    9898
    99 static void xt_end_element( GMarkupParseContext *ctx, const gchar *element_name, gpointer data, GError **error )
     99static void xt_end_element(GMarkupParseContext *ctx, const gchar *element_name, gpointer data, GError **error)
    100100{
    101101        struct xt_parser *xt = data;
    102        
     102
    103103        xt->cur->flags |= XT_COMPLETE;
    104104        xt->cur = xt->cur->parent;
     
    114114};
    115115
    116 struct xt_parser *xt_new( const struct xt_handler_entry *handlers, gpointer data )
    117 {
    118         struct xt_parser *xt = g_new0( struct xt_parser, 1 );
    119        
     116struct xt_parser *xt_new(const struct xt_handler_entry *handlers, gpointer data)
     117{
     118        struct xt_parser *xt = g_new0(struct xt_parser, 1);
     119
    120120        xt->data = data;
    121121        xt->handlers = handlers;
    122         xt_reset( xt );
    123        
     122        xt_reset(xt);
     123
    124124        return xt;
    125125}
     
    127127/* Reset the parser, flush everything we have so far. For example, we need
    128128   this for XMPP when doing TLS/SASL to restart the stream. */
    129 void xt_reset( struct xt_parser *xt )
    130 {
    131         if( xt->parser )
    132                 g_markup_parse_context_free( xt->parser );
    133        
    134         xt->parser = g_markup_parse_context_new( &xt_parser_funcs, 0, xt, NULL );
    135        
    136         if( xt->root )
    137         {
    138                 xt_free_node( xt->root );
     129void xt_reset(struct xt_parser *xt)
     130{
     131        if (xt->parser) {
     132                g_markup_parse_context_free(xt->parser);
     133        }
     134
     135        xt->parser = g_markup_parse_context_new(&xt_parser_funcs, 0, xt, NULL);
     136
     137        if (xt->root) {
     138                xt_free_node(xt->root);
    139139                xt->root = NULL;
    140140                xt->cur = NULL;
     
    144144/* Feed the parser, don't execute any handler. Returns -1 on errors, 0 on
    145145   end-of-stream and 1 otherwise. */
    146 int xt_feed( struct xt_parser *xt, const char *text, int text_len )
    147 {
    148         if( !g_markup_parse_context_parse( xt->parser, text, text_len, &xt->gerr ) )
    149         {
     146int xt_feed(struct xt_parser *xt, const char *text, int text_len)
     147{
     148        if (!g_markup_parse_context_parse(xt->parser, text, text_len, &xt->gerr)) {
    150149                return -1;
    151150        }
    152        
    153         return !( xt->root && xt->root->flags & XT_COMPLETE );
     151
     152        return !(xt->root && xt->root->flags & XT_COMPLETE);
    154153}
    155154
     
    157156   a node isn't necessary if you want to start at the root, just pass
    158157   NULL. This second argument is needed for recursive calls. */
    159 int xt_handle( struct xt_parser *xt, struct xt_node *node, int depth )
     158int xt_handle(struct xt_parser *xt, struct xt_node *node, int depth)
    160159{
    161160        struct xt_node *c;
    162161        xt_status st;
    163162        int i;
    164        
    165         if( xt->root == NULL )
     163
     164        if (xt->root == NULL) {
    166165                return 1;
    167        
    168         if( node == NULL )
    169                 return xt_handle( xt, xt->root, depth );
    170        
    171         if( depth != 0 )
    172                 for( c = node->children; c; c = c->next )
    173                         if( !xt_handle( xt, c, depth > 0 ? depth - 1 : depth ) )
     166        }
     167
     168        if (node == NULL) {
     169                return xt_handle(xt, xt->root, depth);
     170        }
     171
     172        if (depth != 0) {
     173                for (c = node->children; c; c = c->next) {
     174                        if (!xt_handle(xt, c, depth > 0 ? depth - 1 : depth)) {
    174175                                return 0;
    175        
    176         if( node->flags & XT_COMPLETE && !( node->flags & XT_SEEN ) )
    177         {
    178                 if( xt->handlers ) for( i = 0; xt->handlers[i].func; i ++ )
    179                 {
    180                         /* This one is fun! \o/ */
    181                        
    182                             /* If handler.name == NULL it means it should always match. */
    183                         if( ( xt->handlers[i].name == NULL ||
    184                               /* If it's not, compare. There should always be a name. */
    185                               g_strcasecmp( xt->handlers[i].name, node->name ) == 0 ) &&
    186                             /* If handler.parent == NULL, it's a match. */
    187                             ( xt->handlers[i].parent == NULL ||
    188                               /* If there's a parent node, see if the name matches. */
    189                               ( node->parent ? g_strcasecmp( xt->handlers[i].parent, node->parent->name ) == 0 :
    190                               /* If there's no parent, the handler should mention <root> as a parent. */
    191                                                strcmp( xt->handlers[i].parent, "<root>" ) == 0 ) ) )
    192                         {
    193                                 st = xt->handlers[i].func( node, xt->data );
    194                                
    195                                 if( st == XT_ABORT )
    196                                         return 0;
    197                                 else if( st != XT_NEXT )
    198                                         break;
    199176                        }
    200177                }
    201                
     178        }
     179
     180        if (node->flags & XT_COMPLETE && !(node->flags & XT_SEEN)) {
     181                if (xt->handlers) {
     182                        for (i = 0; xt->handlers[i].func; i++) {
     183                                /* This one is fun! \o/ */
     184
     185                                /* If handler.name == NULL it means it should always match. */
     186                                if ((xt->handlers[i].name == NULL ||
     187                                     /* If it's not, compare. There should always be a name. */
     188                                     g_strcasecmp(xt->handlers[i].name, node->name) == 0) &&
     189                                    /* If handler.parent == NULL, it's a match. */
     190                                    (xt->handlers[i].parent == NULL ||
     191                                     /* If there's a parent node, see if the name matches. */
     192                                     (node->parent ? g_strcasecmp(xt->handlers[i].parent, node->parent->name) == 0 :
     193                                      /* If there's no parent, the handler should mention <root> as a parent. */
     194                                      strcmp(xt->handlers[i].parent, "<root>") == 0))) {
     195                                        st = xt->handlers[i].func(node, xt->data);
     196
     197                                        if (st == XT_ABORT) {
     198                                                return 0;
     199                                        } else if (st != XT_NEXT) {
     200                                                break;
     201                                        }
     202                                }
     203                        }
     204                }
     205
    202206                node->flags |= XT_SEEN;
    203207        }
    204        
     208
    205209        return 1;
    206210}
     
    209213   streams because there's no reason to keep a complete packet history
    210214   in memory. */
    211 void xt_cleanup( struct xt_parser *xt, struct xt_node *node, int depth )
     215void xt_cleanup(struct xt_parser *xt, struct xt_node *node, int depth)
    212216{
    213217        struct xt_node *c, *prev;
    214        
    215         if( !xt || !xt->root )
     218
     219        if (!xt || !xt->root) {
    216220                return;
    217        
    218         if( node == NULL )
    219         {
    220                 xt_cleanup( xt, xt->root, depth );
     221        }
     222
     223        if (node == NULL) {
     224                xt_cleanup(xt, xt->root, depth);
    221225                return;
    222226        }
    223        
    224         if( node->flags & XT_SEEN && node == xt->root )
    225         {
    226                 xt_free_node( xt->root );
     227
     228        if (node->flags & XT_SEEN && node == xt->root) {
     229                xt_free_node(xt->root);
    227230                xt->root = xt->cur = NULL;
    228231                /* xt->cur should be NULL already, BTW... */
    229                
     232
    230233                return;
    231234        }
    232        
     235
    233236        /* c contains the current node, prev the previous node (or NULL).
    234237           I admit, this one's pretty horrible. */
    235         for( c = node->children, prev = NULL; c; prev = c, c = c ? c->next : node->children )
    236         {
    237                 if( c->flags & XT_SEEN )
    238                 {
     238        for (c = node->children, prev = NULL; c; prev = c, c = c ? c->next : node->children) {
     239                if (c->flags & XT_SEEN) {
    239240                        /* Remove the node from the linked list. */
    240                         if( prev )
     241                        if (prev) {
    241242                                prev->next = c->next;
    242                         else
     243                        } else {
    243244                                node->children = c->next;
    244                        
    245                         xt_free_node( c );
    246                        
     245                        }
     246
     247                        xt_free_node(c);
     248
    247249                        /* Since the for loop wants to get c->next, make sure
    248250                           c points at something that exists (and that c->next
     
    251253                           That explains the ? thing in for(). */
    252254                        c = prev;
    253                 }
    254                 else
    255                 {
     255                } else {
    256256                        /* This node can't be cleaned up yet, but maybe a
    257257                           subnode can. */
    258                         if( depth != 0 )
    259                                 xt_cleanup( xt, c, depth > 0 ? depth - 1 : depth );
    260                 }
    261         }
    262 }
    263 
    264 struct xt_node *xt_from_string( const char *in, int len )
     258                        if (depth != 0) {
     259                                xt_cleanup(xt, c, depth > 0 ? depth - 1 : depth);
     260                        }
     261                }
     262        }
     263}
     264
     265struct xt_node *xt_from_string(const char *in, int len)
    265266{
    266267        struct xt_parser *parser;
    267268        struct xt_node *ret = NULL;
    268        
    269         if( len == 0 )
    270                 len = strlen( in );
    271        
    272         parser = xt_new( NULL, NULL );
    273         xt_feed( parser, in, len );
    274         if( parser->cur == NULL )
    275         {
     269
     270        if (len == 0) {
     271                len = strlen(in);
     272        }
     273
     274        parser = xt_new(NULL, NULL);
     275        xt_feed(parser, in, len);
     276        if (parser->cur == NULL) {
    276277                ret = parser->root;
    277278                parser->root = NULL;
    278279        }
    279         xt_free( parser );
    280        
     280        xt_free(parser);
     281
    281282        return ret;
    282283}
    283284
    284 static void xt_to_string_real( struct xt_node *node, GString *str, int indent )
     285static void xt_to_string_real(struct xt_node *node, GString *str, int indent)
    285286{
    286287        char *buf;
    287288        struct xt_node *c;
    288289        int i;
    289        
    290         if( indent > 1 )
    291                 g_string_append_len( str, "\n\t\t\t\t\t\t\t\t",
    292                                      indent < 8 ? indent : 8 );
    293        
    294         g_string_append_printf( str, "<%s", node->name );
    295        
    296         for( i = 0; node->attr[i].key; i ++ )
    297         {
    298                 buf = g_markup_printf_escaped( " %s=\"%s\"", node->attr[i].key, node->attr[i].value );
    299                 g_string_append( str, buf );
    300                 g_free( buf );
    301         }
    302        
    303         if( node->text == NULL && node->children == NULL )
    304         {
    305                 g_string_append( str, "/>" );
     290
     291        if (indent > 1) {
     292                g_string_append_len(str, "\n\t\t\t\t\t\t\t\t",
     293                                    indent < 8 ? indent : 8);
     294        }
     295
     296        g_string_append_printf(str, "<%s", node->name);
     297
     298        for (i = 0; node->attr[i].key; i++) {
     299                buf = g_markup_printf_escaped(" %s=\"%s\"", node->attr[i].key, node->attr[i].value);
     300                g_string_append(str, buf);
     301                g_free(buf);
     302        }
     303
     304        if (node->text == NULL && node->children == NULL) {
     305                g_string_append(str, "/>");
    306306                return;
    307307        }
    308        
    309         g_string_append( str, ">" );
    310         if( node->text_len > 0 )
    311         {
    312                 buf = g_markup_escape_text( node->text, node->text_len );
    313                 g_string_append( str, buf );
    314                 g_free( buf );
    315         }
    316        
    317         for( c = node->children; c; c = c->next )
    318                 xt_to_string_real( c, str, indent ? indent + 1 : 0 );
    319        
    320         if( indent > 0 && node->children )
    321                 g_string_append_len( str, "\n\t\t\t\t\t\t\t\t",
    322                                      indent < 8 ? indent : 8 );
    323        
    324         g_string_append_printf( str, "</%s>", node->name );
    325 }
    326 
    327 char *xt_to_string( struct xt_node *node )
     308
     309        g_string_append(str, ">");
     310        if (node->text_len > 0) {
     311                buf = g_markup_escape_text(node->text, node->text_len);
     312                g_string_append(str, buf);
     313                g_free(buf);
     314        }
     315
     316        for (c = node->children; c; c = c->next) {
     317                xt_to_string_real(c, str, indent ? indent + 1 : 0);
     318        }
     319
     320        if (indent > 0 && node->children) {
     321                g_string_append_len(str, "\n\t\t\t\t\t\t\t\t",
     322                                    indent < 8 ? indent : 8);
     323        }
     324
     325        g_string_append_printf(str, "</%s>", node->name);
     326}
     327
     328char *xt_to_string(struct xt_node *node)
    328329{
    329330        GString *ret;
    330        
    331         ret = g_string_new( "" );
    332         xt_to_string_real( node, ret, 0 );
    333         return g_string_free( ret, FALSE );
     331
     332        ret = g_string_new("");
     333        xt_to_string_real(node, ret, 0);
     334        return g_string_free(ret, FALSE);
    334335}
    335336
    336337/* WITH indentation! */
    337 char *xt_to_string_i( struct xt_node *node )
     338char *xt_to_string_i(struct xt_node *node)
    338339{
    339340        GString *ret;
    340        
    341         ret = g_string_new( "" );
    342         xt_to_string_real( node, ret, 1 );
    343         return g_string_free( ret, FALSE );
    344 }
    345 
    346 void xt_print( struct xt_node *node )
    347 {
    348         char *str = xt_to_string_i( node );
    349         fprintf( stderr, "%s", str );
    350         g_free( str );
    351 }
    352 
    353 struct xt_node *xt_dup( struct xt_node *node )
    354 {
    355         struct xt_node *dup = g_new0( struct xt_node, 1 );
     341
     342        ret = g_string_new("");
     343        xt_to_string_real(node, ret, 1);
     344        return g_string_free(ret, FALSE);
     345}
     346
     347void xt_print(struct xt_node *node)
     348{
     349        char *str = xt_to_string_i(node);
     350
     351        fprintf(stderr, "%s", str);
     352        g_free(str);
     353}
     354
     355struct xt_node *xt_dup(struct xt_node *node)
     356{
     357        struct xt_node *dup = g_new0(struct xt_node, 1);
    356358        struct xt_node *c, *dc = NULL;
    357359        int i;
    358        
     360
    359361        /* Let's NOT copy the parent element here BTW! Only do it for children. */
    360        
    361         dup->name = g_strdup( node->name );
     362
     363        dup->name = g_strdup(node->name);
    362364        dup->flags = node->flags;
    363         if( node->text )
    364         {
    365                 dup->text = g_memdup( node->text, node->text_len + 1 );
     365        if (node->text) {
     366                dup->text = g_memdup(node->text, node->text_len + 1);
    366367                dup->text_len = node->text_len;
    367368        }
    368        
     369
    369370        /* Count the number of attributes and allocate the new array. */
    370         for( i = 0; node->attr[i].key; i ++ );
    371         dup->attr = g_new0( struct xt_attr, i + 1 );
    372        
     371        for (i = 0; node->attr[i].key; i++) {
     372                ;
     373        }
     374        dup->attr = g_new0(struct xt_attr, i + 1);
     375
    373376        /* Copy them all! */
    374         for( i --; i >= 0; i -- )
    375         {
    376                 dup->attr[i].key = g_strdup( node->attr[i].key );
    377                 dup->attr[i].value = g_strdup( node->attr[i].value );
    378         }
    379        
     377        for (i--; i >= 0; i--) {
     378                dup->attr[i].key = g_strdup(node->attr[i].key);
     379                dup->attr[i].value = g_strdup(node->attr[i].value);
     380        }
     381
    380382        /* This nice mysterious loop takes care of the children. */
    381         for( c = node->children; c; c = c->next )
    382         {
    383                 if( dc == NULL )
    384                         dc = dup->children = xt_dup( c );
    385                 else
    386                         dc = ( dc->next = xt_dup( c ) );
    387                
     383        for (c = node->children; c; c = c->next) {
     384                if (dc == NULL) {
     385                        dc = dup->children = xt_dup(c);
     386                } else {
     387                        dc = (dc->next = xt_dup(c));
     388                }
     389
    388390                dc->parent = dup;
    389391        }
    390        
     392
    391393        return dup;
    392394}
    393395
    394396/* Frees a node. This doesn't clean up references to itself from parents! */
    395 void xt_free_node( struct xt_node *node )
     397void xt_free_node(struct xt_node *node)
    396398{
    397399        int i;
    398        
    399         if( !node )
     400
     401        if (!node) {
    400402                return;
    401        
    402         g_free( node->name );
    403         g_free( node->text );
    404        
    405         for( i = 0; node->attr[i].key; i ++ )
    406         {
    407                 g_free( node->attr[i].key );
    408                 g_free( node->attr[i].value );
    409         }
    410         g_free( node->attr );
    411        
    412         while( node->children )
    413         {
     403        }
     404
     405        g_free(node->name);
     406        g_free(node->text);
     407
     408        for (i = 0; node->attr[i].key; i++) {
     409                g_free(node->attr[i].key);
     410                g_free(node->attr[i].value);
     411        }
     412        g_free(node->attr);
     413
     414        while (node->children) {
    414415                struct xt_node *next = node->children->next;
    415                
    416                 xt_free_node( node->children );
     416
     417                xt_free_node(node->children);
    417418                node->children = next;
    418419        }
    419        
    420         g_free( node );
    421 }
    422 
    423 void xt_free( struct xt_parser *xt )
    424 {
    425         if( !xt )
     420
     421        g_free(node);
     422}
     423
     424void xt_free(struct xt_parser *xt)
     425{
     426        if (!xt) {
    426427                return;
    427        
    428         if( xt->root )
    429                 xt_free_node( xt->root );
    430        
    431         g_markup_parse_context_free( xt->parser );
    432        
    433         g_free( xt );
     428        }
     429
     430        if (xt->root) {
     431                xt_free_node(xt->root);
     432        }
     433
     434        g_markup_parse_context_free(xt->parser);
     435
     436        g_free(xt);
    434437}
    435438
     
    437440   list, not the node itself! The reason you have to do this by hand: So
    438441   that you can also use this function as a find-next. */
    439 struct xt_node *xt_find_node( struct xt_node *node, const char *name )
    440 {
    441         while( node )
    442         {
     442struct xt_node *xt_find_node(struct xt_node *node, const char *name)
     443{
     444        while (node) {
    443445                char *colon;
    444                
    445                 if( g_strcasecmp( node->name, name ) == 0 ||
    446                     ( ( colon = strchr( node->name, ':' ) ) &&
    447                       g_strcasecmp( colon + 1, name ) == 0 ) )
     446
     447                if (g_strcasecmp(node->name, name) == 0 ||
     448                    ((colon = strchr(node->name, ':')) &&
     449                     g_strcasecmp(colon + 1, name) == 0)) {
    448450                        break;
    449                
     451                }
     452
    450453                node = node->next;
    451454        }
    452        
     455
    453456        return node;
    454457}
     
    457460   ../foo/bar to find a subnode bar of a node foo which is a child
    458461   of node's parent. Pass the node directly, not its list of children. */
    459 struct xt_node *xt_find_path( struct xt_node *node, const char *name )
    460 {
    461         while( name && *name && node )
    462         {
     462struct xt_node *xt_find_path(struct xt_node *node, const char *name)
     463{
     464        while (name && *name && node) {
    463465                char *colon, *slash;
    464466                int n;
    465                
    466                 if( ( slash = strchr( name, '/' ) ) )
     467
     468                if ((slash = strchr(name, '/'))) {
    467469                        n = slash - name;
    468                 else
    469                         n = strlen( name );
    470                
    471                 if( strncmp( name, "..", n ) == 0 )
    472                 {
     470                } else {
     471                        n = strlen(name);
     472                }
     473
     474                if (strncmp(name, "..", n) == 0) {
    473475                        node = node->parent;
    474                 }
    475                 else
    476                 {
     476                } else {
    477477                        node = node->children;
    478                        
    479                         while( node )
    480                         {
    481                                 if( g_strncasecmp( node->name, name, n ) == 0 ||
    482                                     ( ( colon = strchr( node->name, ':' ) ) &&
    483                                       g_strncasecmp( colon + 1, name, n ) == 0 ) )
     478
     479                        while (node) {
     480                                if (g_strncasecmp(node->name, name, n) == 0 ||
     481                                    ((colon = strchr(node->name, ':')) &&
     482                                     g_strncasecmp(colon + 1, name, n) == 0)) {
    484483                                        break;
    485                                
     484                                }
     485
    486486                                node = node->next;
    487487                        }
    488488                }
    489                
     489
    490490                name = slash ? slash + 1 : NULL;
    491491        }
    492        
     492
    493493        return node;
    494494}
    495495
    496 char *xt_find_attr( struct xt_node *node, const char *key )
     496char *xt_find_attr(struct xt_node *node, const char *key)
    497497{
    498498        int i;
    499499        char *colon;
    500        
    501         if( !node )
     500
     501        if (!node) {
    502502                return NULL;
    503        
    504         for( i = 0; node->attr[i].key; i ++ )
    505                 if( g_strcasecmp( node->attr[i].key, key ) == 0 )
     503        }
     504
     505        for (i = 0; node->attr[i].key; i++) {
     506                if (g_strcasecmp(node->attr[i].key, key) == 0) {
    506507                        break;
    507        
     508                }
     509        }
     510
    508511        /* This is an awful hack that only takes care of namespace prefixes
    509512           inside a tag. Since IMHO excessive namespace usage in XMPP is
    510513           massive overkill anyway (this code exists for almost four years
    511514           now and never really missed it): Meh. */
    512         if( !node->attr[i].key && strcmp( key, "xmlns" ) == 0 &&
    513             ( colon = strchr( node->name, ':' ) ) )
    514         {
     515        if (!node->attr[i].key && strcmp(key, "xmlns") == 0 &&
     516            (colon = strchr(node->name, ':'))) {
    515517                *colon = '\0';
    516                 for( i = 0; node->attr[i].key; i ++ )
    517                         if( strncmp( node->attr[i].key, "xmlns:", 6 ) == 0 &&
    518                             strcmp( node->attr[i].key + 6, node->name ) == 0 )
     518                for (i = 0; node->attr[i].key; i++) {
     519                        if (strncmp(node->attr[i].key, "xmlns:", 6) == 0 &&
     520                            strcmp(node->attr[i].key + 6, node->name) == 0) {
    519521                                break;
     522                        }
     523                }
    520524                *colon = ':';
    521525        }
    522        
     526
    523527        return node->attr[i].value;
    524528}
    525529
    526 struct xt_node *xt_find_node_by_attr( struct xt_node *xt, const char *tag, const char *key, const char *value )
     530struct xt_node *xt_find_node_by_attr(struct xt_node *xt, const char *tag, const char *key, const char *value)
    527531{
    528532        struct xt_node *c;
    529533        char *s;
    530534
    531         for( c = xt; ( c = xt_find_node( c, tag ) ); c = c->next )
    532         {
    533                 if( ( s = xt_find_attr( c, key ) ) && strcmp( s, value ) == 0 )
    534                 {
     535        for (c = xt; (c = xt_find_node(c, tag)); c = c->next) {
     536                if ((s = xt_find_attr(c, key)) && strcmp(s, value) == 0) {
    535537                        return c;
    536538                }
     
    542544/* Strip a few non-printable characters that aren't allowed in XML streams
    543545   (and upset some XMPP servers for example). */
    544 void xt_strip_text( char *in )
     546void xt_strip_text(char *in)
    545547{
    546548        char *out = in;
     
    549551                0, 1, 1, 0, 0, 1, 0, 0, /* 9 (tab), 10 (\n), 13 (\r) */
    550552        };
    551        
    552         if( !in )
     553
     554        if (!in) {
    553555                return;
    554 
    555         while( *in )
    556         {
    557                 if( (unsigned int) *in >= ' ' || nonprint[(unsigned int) *in] )
    558                         *out ++ = *in;
    559                 in ++;
     556        }
     557
     558        while (*in) {
     559                if ((unsigned int) *in >= ' ' || nonprint[(unsigned int) *in]) {
     560                        *out++ = *in;
     561                }
     562                in++;
    560563        }
    561564        *out = *in;
    562565}
    563566
    564 struct xt_node *xt_new_node( char *name, const char *text, struct xt_node *children )
     567struct xt_node *xt_new_node(char *name, const char *text, struct xt_node *children)
    565568{
    566569        struct xt_node *node, *c;
    567        
    568         node = g_new0( struct xt_node, 1 );
    569         node->name = g_strdup( name );
     570
     571        node = g_new0(struct xt_node, 1);
     572        node->name = g_strdup(name);
    570573        node->children = children;
    571         node->attr = g_new0( struct xt_attr, 1 );
    572        
    573         if( text )
    574         {
    575                 node->text = g_strdup( text );
    576                 xt_strip_text( node->text );
    577                 node->text_len = strlen( node->text );
    578         }
    579        
    580         for( c = children; c; c = c->next )
    581         {
    582                 if( c->parent != NULL )
    583                 {
     574        node->attr = g_new0(struct xt_attr, 1);
     575
     576        if (text) {
     577                node->text = g_strdup(text);
     578                xt_strip_text(node->text);
     579                node->text_len = strlen(node->text);
     580        }
     581
     582        for (c = children; c; c = c->next) {
     583                if (c->parent != NULL) {
    584584                        /* ERROR CONDITION: They seem to have a parent already??? */
    585585                }
    586                
     586
    587587                c->parent = node;
    588588        }
    589        
     589
    590590        return node;
    591591}
    592592
    593 void xt_add_child( struct xt_node *parent, struct xt_node *child )
     593void xt_add_child(struct xt_node *parent, struct xt_node *child)
    594594{
    595595        struct xt_node *node;
    596        
     596
    597597        /* This function can actually be used to add more than one child, so
    598598           do handle this properly. */
    599         for( node = child; node; node = node->next )
    600         {
    601                 if( node->parent != NULL )
    602                 {
     599        for (node = child; node; node = node->next) {
     600                if (node->parent != NULL) {
    603601                        /* ERROR CONDITION: They seem to have a parent already??? */
    604602                }
    605                
     603
    606604                node->parent = parent;
    607605        }
    608        
    609         if( parent->children == NULL )
    610         {
     606
     607        if (parent->children == NULL) {
    611608                parent->children = child;
    612         }
    613         else
    614         {
    615                 for( node = parent->children; node->next; node = node->next );
     609        } else {
     610                for (node = parent->children; node->next; node = node->next) {
     611                        ;
     612                }
    616613                node->next = child;
    617614        }
     
    619616
    620617/* Same, but at the beginning. */
    621 void xt_insert_child( struct xt_node *parent, struct xt_node *child )
     618void xt_insert_child(struct xt_node *parent, struct xt_node *child)
    622619{
    623620        struct xt_node *node, *last = NULL;
    624        
    625         if( child == NULL )
     621
     622        if (child == NULL) {
    626623                return; /* BUG */
    627        
    628         for( node = child; node; node = node->next )
    629         {
    630                 if( node->parent != NULL )
    631                 {
     624
     625        }
     626        for (node = child; node; node = node->next) {
     627                if (node->parent != NULL) {
    632628                        /* ERROR CONDITION: They seem to have a parent already??? */
    633629                }
    634                
     630
    635631                node->parent = parent;
    636632                last = node;
    637633        }
    638        
     634
    639635        last->next = parent->children;
    640636        parent->children = child;
    641637}
    642638
    643 void xt_add_attr( struct xt_node *node, const char *key, const char *value )
     639void xt_add_attr(struct xt_node *node, const char *key, const char *value)
    644640{
    645641        int i;
    646        
     642
    647643        /* Now actually it'd be nice if we can also change existing attributes
    648644           (which actually means this function doesn't have the right name).
    649645           So let's find out if we have this attribute already... */
    650         for( i = 0; node->attr[i].key; i ++ )
    651                 if( strcmp( node->attr[i].key, key ) == 0 )
     646        for (i = 0; node->attr[i].key; i++) {
     647                if (strcmp(node->attr[i].key, key) == 0) {
    652648                        break;
    653        
    654         if( node->attr[i].key == NULL )
    655         {
     649                }
     650        }
     651
     652        if (node->attr[i].key == NULL) {
    656653                /* If not, allocate space for a new attribute. */
    657                 node->attr = g_renew( struct xt_attr, node->attr, i + 2 );
    658                 node->attr[i].key = g_strdup( key );
    659                 node->attr[i+1].key = NULL;
    660         }
    661         else
    662         {
     654                node->attr = g_renew(struct xt_attr, node->attr, i + 2);
     655                node->attr[i].key = g_strdup(key);
     656                node->attr[i + 1].key = NULL;
     657        } else {
    663658                /* Otherwise, free the old value before setting the new one. */
    664                 g_free( node->attr[i].value );
    665         }
    666        
    667         node->attr[i].value = g_strdup( value );
    668 }
    669 
    670 int xt_remove_attr( struct xt_node *node, const char *key )
     659                g_free(node->attr[i].value);
     660        }
     661
     662        node->attr[i].value = g_strdup(value);
     663}
     664
     665int xt_remove_attr(struct xt_node *node, const char *key)
    671666{
    672667        int i, last;
    673        
    674         for( i = 0; node->attr[i].key; i ++ )
    675                 if( strcmp( node->attr[i].key, key ) == 0 )
     668
     669        for (i = 0; node->attr[i].key; i++) {
     670                if (strcmp(node->attr[i].key, key) == 0) {
    676671                        break;
    677        
     672                }
     673        }
     674
    678675        /* If we didn't find the attribute... */
    679         if( node->attr[i].key == NULL )
     676        if (node->attr[i].key == NULL) {
    680677                return 0;
    681        
    682         g_free( node->attr[i].key );
    683         g_free( node->attr[i].value );
    684        
     678        }
     679
     680        g_free(node->attr[i].key);
     681        g_free(node->attr[i].value);
     682
    685683        /* If it's the last, this is easy: */
    686         if( node->attr[i+1].key == NULL )
    687         {
     684        if (node->attr[i + 1].key == NULL) {
    688685                node->attr[i].key = node->attr[i].value = NULL;
    689         }
    690         else /* It's also pretty easy, actually. */
    691         {
     686        } else { /* It's also pretty easy, actually. */
    692687                /* Find the last item. */
    693                 for( last = i + 1; node->attr[last+1].key; last ++ );
    694                
     688                for (last = i + 1; node->attr[last + 1].key; last++) {
     689                        ;
     690                }
     691
    695692                node->attr[i] = node->attr[last];
    696693                node->attr[last].key = NULL;
    697694                node->attr[last].value = NULL;
    698695        }
    699        
     696
    700697        /* Let's not bother with reallocating memory here. It takes time and
    701698           most packets don't stay in memory for long anyway. */
    702        
     699
    703700        return 1;
    704701}
Note: See TracChangeset for help on using the changeset viewer.