Changeset 690

Show
Ignore:
Timestamp:
03/28/07 14:51:16 (2 years ago)
Author:
alo
Message:

--

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • cherokee/trunk/ChangeLog

    r689 r690  
     12007-03-28  Alvaro Lopez Ortega  <alvaro@alobbs.com> 
     2 
     3        * cherokee/source.c, cherokee/source.h, cherokee/header.c, 
     4        cherokee/buffer.c, cherokee/config_entry.c, 
     5        cherokee/config_node.c: Clean up: all these classes now use the 
     6        new CHEROKEE_ADD_FUNC_NEW and CHEROKEE_ADD_FUNC_FREE macros. 
     7 
     8        * cherokee/macros.h (CHEROKEE_ADD_FUNC_NEW, 
     9        CHEROKEE_ADD_FUNC_FREE): Added two new macros to implement 
     10        _new/_free methods by using _init/_mrproper. It's a pretty 
     11        mechanic thing, so I think it worth adding a macro. 
     12 
     13        * cherokee/dirs_table.h, 
     14        cherokee/dirs_table.c (cherokee_dirs_table_free, 
     15        cherokee_dirs_table_new): Methods removed. They are not longer 
     16        needed. 
     17 
     18        * cherokee/socket.h, cherokee/socket.c (cherokee_socket_new, 
     19        cherokee_socket_free): These methods have been removed, they are 
     20        no longer needed. 
     21         
     22        * cherokee/main.c, cherokee/main_admin.c, 
     23        cherokee/server.c (cherokee_server_init): Reanamed to 
     24        cherokee_server_initialize. _init/_mrproper are method names that 
     25        already have a meaning it should respect. 
     26         
    1272007-03-23  Alvaro Lopez Ortega  <alvaro@alobbs.com> 
    228 

  • cherokee/trunk/cherokee/buffer.c

    r660 r690  
    4848 
    4949 
    50 ret_t 
    51 cherokee_buffer_new (cherokee_buffer_t **buf) 
    52 { 
    53         CHEROKEE_NEW_STRUCT(n, buffer); 
    54  
    55         n->buf  = NULL; 
    56         n->size = 0; 
    57         n->len  = 0; 
    58  
    59         *buf = n; 
    60         return ret_ok; 
    61 } 
    62  
    63  
    64 ret_t 
    65 cherokee_buffer_free (cherokee_buffer_t *buf) 
     50/* Implements _new() and _free()  
     51 */ 
     52CHEROKEE_ADD_FUNC_NEW  (buffer); 
     53CHEROKEE_ADD_FUNC_FREE (buffer); 
     54 
     55ret_t  
     56cherokee_buffer_init (cherokee_buffer_t *buf) 
     57{ 
     58        buf->buf  = NULL; 
     59        buf->len  = 0; 
     60        buf->size = 0; 
     61 
     62        return ret_ok; 
     63} 
     64 
     65ret_t  
     66cherokee_buffer_mrproper (cherokee_buffer_t *buf) 
    6667{ 
    6768        if (buf->buf) { 
    …… 
    7071        } 
    7172 
    72         free (buf);      
    73         return ret_ok; 
    74 } 
    75  
    76  
    77 ret_t  
    78 cherokee_buffer_init (cherokee_buffer_t *buf) 
    79 { 
    80         buf->buf  = NULL; 
    8173        buf->len  = 0; 
    8274        buf->size = 0; 
    8375 
    8476        return ret_ok; 
    85 } 
    86  
    87 ret_t  
    88 cherokee_buffer_mrproper (cherokee_buffer_t *buf) 
    89 { 
    90         if (buf->buf) { 
    91                 free (buf->buf); 
    92         } 
    93  
    94         return cherokee_buffer_init (buf); 
    9577} 
    9678 

  • cherokee/trunk/cherokee/buffer.h

    r639 r690  
    5656ret_t cherokee_buffer_new                (cherokee_buffer_t **buf); 
    5757ret_t cherokee_buffer_free               (cherokee_buffer_t  *buf); 
    58 ret_t cherokee_buffer_clean              (cherokee_buffer_t  *buf); 
    59 ret_t cherokee_buffer_dup                (cherokee_buffer_t  *buf, cherokee_buffer_t **dup); 
    60  
    6158ret_t cherokee_buffer_init               (cherokee_buffer_t  *buf); 
    6259ret_t cherokee_buffer_mrproper           (cherokee_buffer_t  *buf); 
     60 
     61ret_t cherokee_buffer_clean              (cherokee_buffer_t  *buf); 
     62 
     63ret_t cherokee_buffer_dup                (cherokee_buffer_t  *buf, cherokee_buffer_t **dup); 
    6364void  cherokee_buffer_swap_buffers       (cherokee_buffer_t  *buf, cherokee_buffer_t *second);        
    6465 

  • cherokee/trunk/cherokee/config_entry.c

    r597 r690  
    3535 
    3636 
    37 ret_t  
    38 cherokee_config_entry_new (cherokee_config_entry_t **entry) 
    39 { 
    40         CHEROKEE_NEW_STRUCT (n, config_entry); 
    41                  
    42         cherokee_config_entry_init (n); 
    43  
    44         *entry = n;      
    45         return ret_ok; 
    46 } 
     37/* Implements _new() and _free()  
     38 */ 
     39CHEROKEE_ADD_FUNC_NEW  (config_entry); 
     40CHEROKEE_ADD_FUNC_FREE (config_entry); 
    4741 
    4842 
    …… 
    10599        } 
    106100 
    107         return ret_ok; 
    108 } 
    109  
    110  
    111 ret_t  
    112 cherokee_config_entry_free (cherokee_config_entry_t *entry)  
    113 { 
    114         cherokee_config_entry_mrproper (entry); 
    115  
    116         free (entry); 
    117101        return ret_ok; 
    118102} 

  • cherokee/trunk/cherokee/config_node.c

    r625 r690  
    3232 
    3333 
     34/* Implements _new() and _free()  
     35 */ 
     36CHEROKEE_ADD_FUNC_NEW  (config_node); 
     37CHEROKEE_ADD_FUNC_FREE (config_node); 
     38 
     39 
    3440ret_t  
    3541cherokee_config_node_init (cherokee_config_node_t *conf) 
    …… 
    4450} 
    4551 
    46 ret_t  
    47 cherokee_config_node_new (cherokee_config_node_t **conf) 
    48 { 
    49         CHEROKEE_NEW_STRUCT(n,config_node); 
    50  
    51         cherokee_config_node_init (n); 
    52  
    53         *conf = n; 
    54         return ret_ok; 
    55 } 
    56  
    5752 
    5853ret_t  
    …… 
    6863        } 
    6964 
    70         return ret_ok; 
    71 } 
    72  
    73 ret_t  
    74 cherokee_config_node_free (cherokee_config_node_t *conf) 
    75 { 
    76         cherokee_config_node_mrproper (conf); 
    77  
    78         free (conf); 
    7965        return ret_ok; 
    8066} 

  • cherokee/trunk/cherokee/config_node.h

    r622 r690  
    5353 
    5454ret_t cherokee_config_node_new       (cherokee_config_node_t **conf); 
    55 ret_t cherokee_config_node_free      (cherokee_config_node_t *conf); 
    56  
    57 ret_t cherokee_config_node_init      (cherokee_config_node_t *conf); 
    58 ret_t cherokee_config_node_mrproper  (cherokee_config_node_t *conf); 
     55ret_t cherokee_config_node_free      (cherokee_config_node_t  *conf); 
     56ret_t cherokee_config_node_init      (cherokee_config_node_t  *conf); 
     57ret_t cherokee_config_node_mrproper  (cherokee_config_node_t  *conf); 
    5958 
    6059ret_t cherokee_config_node_add       (cherokee_config_node_t *conf, const char *key, cherokee_buffer_t *val); 

  • cherokee/trunk/cherokee/dirs_table.c

    r625 r690  
    3636 
    3737#define ENTRIES "dirs" 
    38  
    39  
    40 ret_t  
    41 cherokee_dirs_table_new (cherokee_dirs_table_t **pt) 
    42 { 
    43         return cherokee_table_new(pt); 
    44 } 
    45  
    46 ret_t  
    47 cherokee_dirs_table_free (cherokee_dirs_table_t *pt) 
    48 { 
    49         return cherokee_table_free2 ( 
    50                 TABLE(pt),  
    51                 (cherokee_table_free_item_t) cherokee_config_entry_free); 
    52 } 
    5338 
    5439 

  • cherokee/trunk/cherokee/dirs_table.h

    r597 r690  
    3535 
    3636 
    37 ret_t cherokee_dirs_table_new      (cherokee_dirs_table_t **pt); 
    38 ret_t cherokee_dirs_table_free     (cherokee_dirs_table_t  *pt); 
    39  
    4037ret_t cherokee_dirs_table_init     (cherokee_dirs_table_t *pt); 
    41 ret_t cherokee_dirs_table_clean    (cherokee_dirs_table_t *pt); 
    4238ret_t cherokee_dirs_table_mrproper (cherokee_dirs_table_t *pt); 
    4339 
     40ret_t cherokee_dirs_table_clean    (cherokee_dirs_table_t *pt); 
    4441ret_t cherokee_dirs_table_get      (cherokee_dirs_table_t *pt, cherokee_buffer_t *requested_url, cherokee_config_entry_t *plugin_entry, cherokee_buffer_t *web_directory); 
    4542ret_t cherokee_dirs_table_add      (cherokee_dirs_table_t *pt, char *dir, cherokee_config_entry_t  *plugin_entry); 

  • cherokee/trunk/cherokee/header.c

    r652 r690  
    8585 
    8686 
     87/* Implements _new() and _free()  
     88 */ 
     89CHEROKEE_ADD_FUNC_NEW  (header); 
     90CHEROKEE_ADD_FUNC_FREE (header); 
     91 
     92 
    8793ret_t  
    8894cherokee_header_init (cherokee_header_t *hdr) 
    …… 
    127133{ 
    128134        clean_unknown_headers (hdr); 
    129         return ret_ok; 
    130 } 
    131  
    132 ret_t  
    133 cherokee_header_new (cherokee_header_t **hdr) 
    134 { 
    135         CHEROKEE_NEW_STRUCT(n,header); 
    136  
    137         *hdr = n; 
    138         return cherokee_header_init (n); 
    139 } 
    140  
    141 ret_t  
    142 cherokee_header_free (cherokee_header_t *hdr) 
    143 { 
    144         cherokee_header_mrproper (hdr); 
    145  
    146         free (hdr); 
    147135        return ret_ok; 
    148136} 

  • cherokee/trunk/cherokee/header.h

    r597 r690  
    7979ret_t cherokee_header_new                 (cherokee_header_t **hdr); 
    8080ret_t cherokee_header_free                (cherokee_header_t  *hdr); 
    81  
    82 ret_t cherokee_header_init                (cherokee_header_t *hdr); 
    83 ret_t cherokee_header_mrproper            (cherokee_header_t *hdr); 
     81ret_t cherokee_header_init                (cherokee_header_t  *hdr); 
     82ret_t cherokee_header_mrproper            (cherokee_header_t  *hdr); 
    8483 
    8584ret_t cherokee_header_clean               (cherokee_header_t *hdr); 

  • cherokee/trunk/cherokee/macros.h

    r656 r690  
    185185#endif 
    186186 
     187/* Automatic functions: 
     188 * These macros implement _new/_free by using _init/_mrproper. 
     189 */ 
     190#define CHEROKEE_ADD_FUNC_NEW(klass)  \ 
     191        ret_t                                                         \ 
     192        cherokee_ ## klass ## _new (cherokee_ ## klass ## _t **obj) { \ 
     193                ret_t ret;                                            \ 
     194                CHEROKEE_NEW_STRUCT (n, klass);                       \ 
     195                                                                      \ 
     196                ret = cherokee_ ## klass ## _init (n);                \ 
     197                if (unlikely (ret != ret_ok)) return ret;             \ 
     198                                                                      \ 
     199                *obj = n;                                             \ 
     200                return ret_ok;                                        \ 
     201        } 
     202 
     203#define CHEROKEE_ADD_FUNC_FREE(klass)  \ 
     204        ret_t                                                         \ 
     205        cherokee_ ## klass ## _free (cherokee_ ## klass ## _t *obj) { \ 
     206                cherokee_ ## klass ## _mrproper (obj);                \ 
     207                                                                      \ 
     208                free (obj);                                           \ 
     209                return ret_ok;                                        \ 
     210        } 
     211 
     212 
    187213/* Printing macros 
    188214 */ 

  • cherokee/trunk/cherokee/main.c

    r636 r690  
    145145        cherokee_server_write_pidfile (srv); 
    146146 
    147         ret = cherokee_server_init (srv); 
     147        ret = cherokee_server_initialize (srv); 
    148148        if (ret != ret_ok) return ret_error; 
    149149 

  • cherokee/trunk/cherokee/main_admin.c

    r649 r690  
    123123        if (ret != ret_ok) return 2; 
    124124 
    125         ret = cherokee_server_init (srv); 
     125        ret = cherokee_server_initialize (srv); 
    126126        if (ret != ret_ok) return 3; 
    127127 

  • cherokee/trunk/cherokee/server.c

    r673 r690  
    896896 
    897897ret_t 
    898 cherokee_server_init (cherokee_server_t *srv)  
     898cherokee_server_initialize (cherokee_server_t *srv)  
    899899{    
    900900        int            re; 

  • cherokee/trunk/cherokee/server.h

    r597 r690  
    4343 
    4444ret_t cherokee_server_new                (cherokee_server_t **srv); 
    45 ret_t cherokee_server_init               (cherokee_server_t  *srv); 
     45ret_t cherokee_server_free               (cherokee_server_t  *srv); 
    4646ret_t cherokee_server_clean              (cherokee_server_t  *srv); 
    47 ret_t cherokee_server_free               (cherokee_server_t  *srv); 
    4847 
     48ret_t cherokee_server_initialize         (cherokee_server_t *srv); 
    4949ret_t cherokee_server_step               (cherokee_server_t *srv); 
    5050void  cherokee_server_set_min_latency    (cherokee_server_t *srv, int msecs); 

  • cherokee/trunk/cherokee/socket.c

    r679 r690  
    156156} 
    157157 
    158 ret_t 
    159 cherokee_socket_new (cherokee_socket_t **socket) 
    160 { 
    161         CHEROKEE_NEW_STRUCT (n, socket); 
    162  
    163         /* Init  
    164          */ 
    165         cherokee_socket_init (n); 
    166          
    167         /* Return it 
    168          */ 
    169         *socket = n; 
    170         return ret_ok; 
    171 } 
    172  
    173158 
    174159ret_t  
    …… 
    440425 
    441426#endif  /* HAVE_TLS */ 
    442         return ret_ok; 
    443 } 
    444  
    445  
    446 ret_t 
    447 cherokee_socket_free (cherokee_socket_t *socket) 
    448 { 
    449         cherokee_socket_mrproper (socket); 
    450  
    451         free (socket); 
    452427        return ret_ok; 
    453428} 

  • cherokee/trunk/cherokee/socket.h

    r656 r690  
    175175                                          (SOCKET_STATUS(c) != socket_closed)) 
    176176 
    177 ret_t cherokee_socket_new               (cherokee_socket_t **socket); 
    178 ret_t cherokee_socket_free              (cherokee_socket_t  *socket); 
    179177 
    180178ret_t cherokee_socket_init              (cherokee_socket_t *socket); 

  • cherokee/trunk/cherokee/source.c

    r597 r690  
    3232 
    3333 
    34 ret_t 
    35 cherokee_source_new (cherokee_source_t **src) 
    36 { 
    37         CHEROKEE_NEW_STRUCT (n, source); 
    38          
    39         *src = n; 
    40         return cherokee_source_init (n); 
    41 } 
     34/* Implements _new() and _free()  
     35 */ 
     36CHEROKEE_ADD_FUNC_NEW  (source); 
     37CHEROKEE_ADD_FUNC_FREE (source); 
    4238 
    4339 

  • cherokee/trunk/cherokee/source.h

    r597 r690  
    5050 
    5151ret_t cherokee_source_new       (cherokee_source_t **src); 
     52ret_t cherokee_source_free      (cherokee_source_t  *src); 
    5253ret_t cherokee_source_init      (cherokee_source_t  *src); 
    5354ret_t cherokee_source_mrproper  (cherokee_source_t  *src); 
     55 
    5456ret_t cherokee_source_configure (cherokee_source_t  *src, cherokee_config_node_t *conf); 
    55  
    5657ret_t cherokee_source_connect   (cherokee_source_t  *src, cherokee_socket_t *socket); 
    5758 

  • cherokee/trunk/cherokee/table.h

    r597 r690  
    4545 
    4646ret_t cherokee_table_new       (cherokee_table_t **tab); 
     47ret_t cherokee_table_free      (cherokee_table_t  *tab); 
     48 
    4749ret_t cherokee_table_init      (cherokee_table_t  *tab); 
    4850ret_t cherokee_table_init_case (cherokee_table_t  *tab); 
    4951 
    50 ret_t cherokee_table_free      (cherokee_table_t  *tab); 
    5152ret_t cherokee_table_free2     (cherokee_table_t  *tab, cherokee_table_free_item_t func); 
    5253ret_t cherokee_table_clean     (cherokee_table_t  *tab);