Changeset 5c9512f for set.c


Ignore:
Timestamp:
2006-06-30T09:17:18Z (14 years ago)
Author:
Wilmer van der Gaast <wilmer@…>
Branches:
master
Children:
0a3c243
Parents:
1719464
Message:

Made set.c API more generic so it's not specific to irc_t structures anymore,
but can be used for account_t structures too, for example.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • set.c

    r1719464 r5c9512f  
    2626#include "bitlbee.h"
    2727
    28 set_t *set_add( irc_t *irc, char *key, char *def, void *eval )
    29 {
    30         set_t *s = set_find( irc, key );
    31        
     28set_t *set_add( set_t **head, char *key, char *def, void *eval, void *data )
     29{
     30        set_t *s = set_find( head, key );
     31       
     32        /* Possibly the setting already exists. If it doesn't exist yet,
     33           we create it. If it does, we'll just change the default. */
    3234        if( !s )
    3335        {
    34                 if( ( s = irc->set ) )
     36                if( ( s = *head ) )
    3537                {
    3638                        while( s->next ) s = s->next;
    37                         s->next = g_new ( set_t, 1 );
     39                        s->next = g_new0( set_t, 1 );
    3840                        s = s->next;
    3941                }
    4042                else
    4143                {
    42                         s = irc->set = g_new( set_t, 1 );
     44                        s = *head = g_new0( set_t, 1 );
    4345                }
    44                 memset( s, 0, sizeof( set_t ) );
    4546                s->key = g_strdup( key );
    4647        }
     
    5354        if( def ) s->def = g_strdup( def );
    5455       
    55         if( s->eval )
    56         {
    57                 g_free( s->eval );
    58                 s->eval = NULL;
    59         }
    60         if( eval ) s->eval = eval;
    61        
    62         return( s );
    63 }
    64 
    65 set_t *set_find( irc_t *irc, char *key )
    66 {
    67         set_t *s = irc->set;
     56        s->eval = eval;
     57        s->data = data;
     58       
     59        return s;
     60}
     61
     62set_t *set_find( set_t **head, char *key )
     63{
     64        set_t *s = *head;
    6865       
    6966        while( s )
     
    7471        }
    7572       
    76         return( s );
    77 }
    78 
    79 char *set_getstr( irc_t *irc, char *key )
    80 {
    81         set_t *s = set_find( irc, key );
     73        return s;
     74}
     75
     76char *set_getstr( set_t **head, char *key )
     77{
     78        set_t *s = set_find( head, key );
    8279       
    8380        if( !s || ( !s->value && !s->def ) )
    84                 return( NULL );
    85        
    86         return( s->value?s->value:s->def );
    87 }
    88 
    89 int set_getint( irc_t *irc, char *key )
    90 {
    91         char *s = set_getstr( irc, key );
     81                return NULL;
     82       
     83        return s->value ? s->value : s->def;
     84}
     85
     86int set_getint( set_t **head, char *key )
     87{
     88        char *s = set_getstr( head, key );
    9289        int i = 0;
    9390       
    9491        if( !s )
    95                 return( 0 );
     92                return 0;
    9693       
    9794        if( ( g_strcasecmp( s, "true" ) == 0 ) || ( g_strcasecmp( s, "yes" ) == 0 ) || ( g_strcasecmp( s, "on" ) == 0 ) )
    98                 return( 1 );
     95                return 1;
    9996       
    10097        if( sscanf( s, "%d", &i ) != 1 )
    101                 return( 0 );
    102        
    103         return( i );
    104 }
    105 
    106 int set_setstr( irc_t *irc, char *key, char *value )
    107 {
    108         set_t *s = set_find( irc, key );
     98                return 0;
     99       
     100        return i;
     101}
     102
     103int set_setstr( set_t **head, char *key, char *value )
     104{
     105        set_t *s = set_find( head, key );
    109106        char *nv = value;
    110107       
    111108        if( !s )
    112                 s = set_add( irc, key, NULL, NULL );
    113        
    114         if( s->eval && !( nv = s->eval( irc, s, value ) ) )
    115                 return( 0 );
     109                s = set_add( head, key, NULL, NULL, NULL );
     110       
     111        if( s->eval && !( nv = s->eval( s, value ) ) )
     112                return 0;
    116113       
    117114        if( s->value )
     
    121118        }
    122119       
     120        /* If there's a default setting and it's equal to what we're trying to
     121           set, stick with s->value = NULL. Otherwise, remember the setting. */
    123122        if( !s->def || ( strcmp( nv, s->def ) != 0 ) )
    124123                s->value = g_strdup( nv );
     
    127126                g_free( nv );
    128127       
    129         return( 1 );
    130 }
    131 
    132 int set_setint( irc_t *irc, char *key, int value )
     128        return 1;
     129}
     130
     131int set_setint( set_t **head, char *key, int value )
    133132{
    134133        char s[24];     /* Not quite 128-bit clean eh? ;-) */
    135134       
    136         sprintf( s, "%d", value );
    137         return( set_setstr( irc, key, s ) );
    138 }
    139 
    140 void set_del( irc_t *irc, char *key )
    141 {
    142         set_t *s = irc->set, *t = NULL;
     135        g_snprintf( s, sizeof( s ), "%d", value );
     136        return set_setstr( head, key, s );
     137}
     138
     139void set_del( set_t **head, char *key )
     140{
     141        set_t *s = *head, *t = NULL;
    143142       
    144143        while( s )
     
    153152                        t->next = s->next;
    154153                else
    155                         irc->set = s->next;
     154                        *head = s->next;
    156155               
    157156                g_free( s->key );
     
    162161}
    163162
    164 char *set_eval_int( irc_t *irc, set_t *set, char *value )
    165 {
    166         char *s = value;
    167        
    168         for( ; *s; s ++ )
     163char *set_eval_int( set_t *set, char *value )
     164{
     165        char *s;
     166       
     167        for( s = value; *s; s ++ )
    169168                if( *s < '0' || *s > '9' )
    170                         return( NULL );
    171        
    172         return( value );
    173 }
    174 
    175 char *set_eval_bool( irc_t *irc, set_t *set, char *value )
     169                        return NULL;
     170       
     171        return value;
     172}
     173
     174char *set_eval_bool( set_t *set, char *value )
    176175{
    177176        if( ( g_strcasecmp( value, "true" ) == 0 ) || ( g_strcasecmp( value, "yes" ) == 0 ) || ( g_strcasecmp( value, "on" ) == 0 ) )
     
    179178        if( ( g_strcasecmp( value, "false" ) == 0 ) || ( g_strcasecmp( value, "no" ) == 0 ) || ( g_strcasecmp( value, "off" ) == 0 ) )
    180179                return( value );
    181         return( set_eval_int( irc, set, value ) );
    182 }
    183 
    184 char *set_eval_to_char( irc_t *irc, set_t *set, char *value )
     180        return( set_eval_int( set, value ) );
     181}
     182
     183char *set_eval_to_char( set_t *set, char *value )
    185184{
    186185        char *s = g_new( char, 3 );
     
    191190                sprintf( s, "%c ", *value );
    192191       
    193         return( s );
    194 }
    195 
    196 char *set_eval_ops( irc_t *irc, set_t *set, char *value )
    197 {
     192        return s;
     193}
     194
     195char *set_eval_ops( set_t *set, char *value )
     196{
     197        irc_t *irc = set->data;
     198       
    198199        if( g_strcasecmp( value, "user" ) == 0 )
    199         {
    200200                irc_write( irc, ":%s!%s@%s MODE %s %s %s %s", irc->mynick, irc->mynick, irc->myhost,
    201201                                                              irc->channel, "+o-o", irc->nick, irc->mynick );
    202                 return( value );
    203         }
    204202        else if( g_strcasecmp( value, "root" ) == 0 )
    205         {
    206203                irc_write( irc, ":%s!%s@%s MODE %s %s %s %s", irc->mynick, irc->mynick, irc->myhost,
    207204                                                              irc->channel, "-o+o", irc->nick, irc->mynick );
    208                 return( value );
    209         }
    210205        else if( g_strcasecmp( value, "both" ) == 0 )
    211         {
    212206                irc_write( irc, ":%s!%s@%s MODE %s %s %s %s", irc->mynick, irc->mynick, irc->myhost,
    213207                                                              irc->channel, "+oo", irc->nick, irc->mynick );
    214                 return( value );
    215         }
    216208        else if( g_strcasecmp( value, "none" ) == 0 )
    217         {
    218209                irc_write( irc, ":%s!%s@%s MODE %s %s %s %s", irc->mynick, irc->mynick, irc->myhost,
    219210                                                              irc->channel, "-oo", irc->nick, irc->mynick );
    220                 return( value );
    221         }
    222        
    223         return( NULL );
    224 }
    225 
    226 char *set_eval_charset( irc_t *irc, set_t *set, char *value )
     211        else
     212                return NULL;
     213       
     214        return value;
     215}
     216
     217char *set_eval_charset( set_t *set, char *value )
    227218{
    228219        GIConv cd;
    229220
    230221        if ( g_strncasecmp( value, "none", 4 ) == 0 )
    231                 return( value );
     222                return value;
    232223
    233224        cd = g_iconv_open( "UTF-8", value );
    234225        if( cd == (GIConv) -1 )
    235                 return( NULL );
     226                return NULL;
    236227
    237228        g_iconv_close( cd );
    238         return( value );
    239 }
     229        return value;
     230}
Note: See TracChangeset for help on using the changeset viewer.