Removed some not required void* casts

diff --git a/src/cexpr/cexpr.c b/src/cexpr/cexpr.c
index 54ce516d9b2571985027838f02f014c86252a534..0de7e2c11a46707d528c3054604bf56d8634355b 100644 (file)
--- a/src/cexpr/cexpr.c
+++ b/src/cexpr/cexpr.c
@@ -389,7 +389,7 @@ static cexpr_t * CEXPR_walk_node(
             /* in case of a string, set the value and return */
             if (node->cl_obj->gid == CLERI_GID_STRING)
             {
-                (*condition)->str = (char *) malloc(node->len -1);
+                (*condition)->str = malloc(node->len -1);
                 if ((*condition)->str == NULL)
                 {
                     return NULL;
@@ -554,7 +554,7 @@ static cexpr_t * CEXPR_walk_node(
  */
 static cexpr_t * CEXPR_new(void)
 {
-    cexpr_t * cexpr = (cexpr_t *) malloc(sizeof(cexpr_t));
+    cexpr_t * cexpr = malloc(sizeof(cexpr_t));
     if (cexpr != NULL)
     {
         cexpr->operator = CEXPR_AND;

diff --git a/src/cfgparser/cfgparser.c b/src/cfgparser/cfgparser.c
index 3ae8599a6d2e215a38de1fa9bcd80ee07348bd48..368bdf628261bdfe8db0828f98d874b651af1f33 100644 (file)
--- a/src/cfgparser/cfgparser.c
+++ b/src/cfgparser/cfgparser.c
@@ -141,7 +141,7 @@ cfgparser_t * cfgparser_new(void)
 {
     cfgparser_t * cfgparser;
 
-    cfgparser = (cfgparser_t *) malloc(sizeof(cfgparser_t));
+    cfgparser = malloc(sizeof(cfgparser_t));
     if (cfgparser != NULL)
     {
         cfgparser->sections = NULL;
@@ -172,8 +172,7 @@ cfgparser_section_t * cfgparser_section(
 
     if (current == NULL)
     {
-        cfgparser->sections =
-                (cfgparser_section_t *) malloc(sizeof(cfgparser_section_t));
+        cfgparser->sections = malloc(sizeof(cfgparser_section_t));
         if (cfgparser->sections == NULL)
         {
             ERR_ALLOC
@@ -201,8 +200,7 @@ cfgparser_section_t * cfgparser_section(
         }
         current = current->next;
     }
-    current->next =
-            (cfgparser_section_t *) malloc(sizeof(cfgparser_section_t));
+    current->next = malloc(sizeof(cfgparser_section_t));
     if (current->next == NULL)
     {
         ERR_ALLOC
@@ -234,8 +232,8 @@ cfgparser_option_t * cfgparser_string_option(
         const char * val,
         const char * def)
 {
-    cfgparser_via_t * val_u = (cfgparser_via_t *) malloc(sizeof(cfgparser_via_t));
-    cfgparser_via_t * def_u = (cfgparser_via_t *) malloc(sizeof(cfgparser_via_t));
+    cfgparser_via_t * val_u = malloc(sizeof(cfgparser_via_t));
+    cfgparser_via_t * def_u = malloc(sizeof(cfgparser_via_t));
 
     if (val_u == NULL || def_u == NULL)
     {
@@ -278,8 +276,8 @@ cfgparser_option_t * cfgparser_integer_option(
         int32_t val,
         int32_t def)
 {
-    cfgparser_via_t * val_u = (cfgparser_via_t *) malloc(sizeof(cfgparser_via_t));
-    cfgparser_via_t * def_u = (cfgparser_via_t *) malloc(sizeof(cfgparser_via_t));
+    cfgparser_via_t * val_u = malloc(sizeof(cfgparser_via_t));
+    cfgparser_via_t * def_u = malloc(sizeof(cfgparser_via_t));
     if (val_u == NULL || def_u == NULL)
     {
         ERR_ALLOC
@@ -309,8 +307,8 @@ cfgparser_option_t * cfgparser_real_option(
         double val,
         double def)
 {
-    cfgparser_via_t * val_u = (cfgparser_via_t *) malloc(sizeof(cfgparser_via_t));
-    cfgparser_via_t * def_u = (cfgparser_via_t *) malloc(sizeof(cfgparser_via_t));
+    cfgparser_via_t * val_u = malloc(sizeof(cfgparser_via_t));
+    cfgparser_via_t * def_u = malloc(sizeof(cfgparser_via_t));
     if (val_u == NULL || def_u == NULL)
     {
         ERR_ALLOC
@@ -427,8 +425,7 @@ static cfgparser_option_t * cfgparser_new_option(
 
     if (current == NULL)
     {
-        section->options =
-                (cfgparser_option_t *) malloc(sizeof(cfgparser_option_t));
+        section->options = malloc(sizeof(cfgparser_option_t));
         if (section->options == NULL)
         {
             ERR_ALLOC
@@ -467,7 +464,7 @@ static cfgparser_option_t * cfgparser_new_option(
         current = current->next;
     }
 
-    prev->next = (cfgparser_option_t *) malloc(sizeof(cfgparser_option_t));
+    prev->next = malloc(sizeof(cfgparser_option_t));
     if (prev->next == NULL)
     {
         ERR_ALLOC

diff --git a/src/ctree/ctree.c b/src/ctree/ctree.c
index 0693a6145e2793d370fc2f9e7ed7aeb2cf4b4fcc..e6fefe3c3162bcf03b5e01b26773f8d3b7187698 100644 (file)
--- a/src/ctree/ctree.c
+++ b/src/ctree/ctree.c
@@ -46,7 +46,7 @@ static void CT_free(ct_node_t * node, ct_free_cb cb);
  */
 ct_t * ct_new(void)
 {
-    ct_t * ct = (ct_t *) malloc(sizeof(ct_t));
+    ct_t * ct = malloc(sizeof(ct_t));
     if (ct == NULL)
     {
         return NULL;
@@ -273,7 +273,7 @@ int ct_items(ct_t * ct, ct_item_cb cb, void * args)
     size_t len = 1;
     ct_node_t * nd;
     int rc = 0;
-    char * buffer = (char *) malloc(buffer_sz);
+    char * buffer = malloc(buffer_sz);
     uint_fast16_t i, end;
 
     if (buffer == NULL)
@@ -763,7 +763,7 @@ static void * CT_pop(ct_node_t * parent, ct_node_t ** nd, const char * key)
  */
 static ct_node_t * CT_node_new(const char * key, size_t len, void * data)
 {
-    ct_node_t * node = (ct_node_t *) malloc(sizeof(ct_node_t));
+    ct_node_t * node = malloc(sizeof(ct_node_t));
     if (node == NULL)
     {
         return NULL;
@@ -776,7 +776,7 @@ static ct_node_t * CT_node_new(const char * key, size_t len, void * data)
     node->nodes = NULL;
     if (len)
     {
-        node->key = (char *) malloc(len);
+        node->key = malloc(len);
         if (node->key == NULL)
         {
             free(node);

diff --git a/src/llist/llist.c b/src/llist/llist.c
index 290877fea234360443130158e23930df9e7f86de..893ed3630d736abcf5819199fb10e14b91d8bdfc 100644 (file)
--- a/src/llist/llist.c
+++ b/src/llist/llist.c
@@ -12,7 +12,7 @@ static llist_node_t * LLIST_node_new(void * data);
  */
 llist_t * llist_new(void)
 {
-    llist_t * llist = (llist_t *) malloc(sizeof(llist_t));
+    llist_t * llist = malloc(sizeof(llist_t));
     if (llist == NULL)
     {
         return NULL;
@@ -266,8 +266,7 @@ vec_t * llist2vec(llist_t * llist)
  */
 static llist_node_t * LLIST_node_new(void * data)
 {
-    llist_node_t * llist_node;
-    llist_node = (llist_node_t *) malloc(sizeof(llist_node_t));
+    llist_node_t * llist_node = malloc(sizeof(llist_node_t));
     if (llist_node == NULL)
     {
         return NULL;

diff --git a/src/procinfo/procinfo.c b/src/procinfo/procinfo.c
index 0f177591bbb07cd58b1397ec3debc89b9947c2cc..e5a832db68fdd3aef7070e17804644fd910a12c1 100644 (file)
--- a/src/procinfo/procinfo.c
+++ b/src/procinfo/procinfo.c
@@ -114,7 +114,7 @@ long int procinfo_open_files(const char * path, int include_fd)
         return -1;
     }
 
-    struct proc_fdinfo * fd_info = (struct proc_fdinfo *) malloc(buffer_size);
+    struct proc_fdinfo * fd_info = malloc(buffer_size);
 
     if (fd_info == NULL)
     {

diff --git a/src/qpack/qpack.c b/src/qpack/qpack.c
index 032bbf258ebc979dea3a4fccea2be7fadd3732ed..3495c7415c416a0a86dffd0a60c2f926f3d959bb 100644 (file)
--- a/src/qpack/qpack.c
+++ b/src/qpack/qpack.c
@@ -214,14 +214,14 @@ qp_unpacker_t * qp_unpacker_ff(const char * fn)
  */
 qp_packer_t * qp_packer_new(size_t alloc_size)
 {
-    qp_packer_t * packer = (qp_packer_t *) malloc(sizeof(qp_packer_t));
+    qp_packer_t * packer = malloc(sizeof(qp_packer_t));
     if (packer != NULL)
     {
         packer->alloc_size = alloc_size;
         packer->buffer_size = packer->alloc_size;
         packer->len = 0;
 
-        packer->buffer = (unsigned char *) malloc(packer->buffer_size);
+        packer->buffer = malloc(packer->buffer_size);
         if (packer->buffer == NULL)
         {
             free(packer);

diff --git a/src/siri/db/aggregate.c b/src/siri/db/aggregate.c
index e19ba52912bd1accd34536a4ee8a3bd664412744..a3578e393daf17669ae47b4d6b2651eadd44db72 100644 (file)
--- a/src/siri/db/aggregate.c
+++ b/src/siri/db/aggregate.c
@@ -519,7 +519,7 @@ siridb_points_t * siridb_aggregate_run(
  */
 static siridb_aggr_t * AGGREGATE_new(uint32_t gid)
 {
-    siridb_aggr_t * aggr = (siridb_aggr_t *) malloc(sizeof(siridb_aggr_t));
+    siridb_aggr_t * aggr = malloc(sizeof(siridb_aggr_t));
     if (aggr == NULL)
     {
         return NULL;
@@ -588,7 +588,7 @@ static int AGGREGATE_init_filter(
 
     case CLERI_GID_STRING:
         aggr->filter_tp = TP_STRING;
-        aggr->filter_via.raw = (unsigned char *) malloc(node->len - 1);
+        aggr->filter_via.raw = malloc(node->len - 1);
         if (aggr->filter_via.raw == NULL)
         {
             sprintf(err_msg, "Memory allocation error.");

diff --git a/src/siri/db/db.c b/src/siri/db/db.c
index a1cd56de6d76fa84ab7083b87e279ae444922d18..2c35e7db82220866f222185c27a7a4c0759e4b69 100644 (file)
--- a/src/siri/db/db.c
+++ b/src/siri/db/db.c
@@ -720,7 +720,7 @@ void siridb__free(siridb_t * siridb)
  */
 static siridb_t * siridb__new(void)
 {
-    siridb_t * siridb = (siridb_t *) malloc(sizeof(siridb_t));
+    siridb_t * siridb = malloc(sizeof(siridb_t));
     if (siridb == NULL)
     {
         goto fail0;

diff --git a/src/siri/db/queries.c b/src/siri/db/queries.c
index 6d1a9c55688e39247bb5547a81730dc62f16a96c..7668b2c479f457f01dc3fac6abe771af6137e883 100644 (file)
--- a/src/siri/db/queries.c
+++ b/src/siri/db/queries.c
@@ -68,8 +68,7 @@ static void QUERIES_free_merge_result(vec_t * plist);
 
 query_select_t * query_select_new(void)
 {
-    query_select_t * q_select =
-            (query_select_t *) malloc(sizeof(query_select_t));
+    query_select_t * q_select = malloc(sizeof(query_select_t));
 
     if (q_select == NULL)
     {
@@ -100,8 +99,7 @@ query_select_t * query_select_new(void)
 
 query_alter_t * query_alter_new(void)
 {
-    query_alter_t * q_alter =
-            (query_alter_t *) malloc(sizeof(query_alter_t));
+    query_alter_t * q_alter = malloc(sizeof(query_alter_t));
 
     if (q_alter == NULL)
     {
@@ -120,8 +118,7 @@ query_alter_t * query_alter_new(void)
 
 query_count_t * query_count_new(void)
 {
-    query_count_t * q_count =
-            (query_count_t *) malloc(sizeof(query_count_t));
+    query_count_t * q_count = malloc(sizeof(query_count_t));
 
     if (q_count == NULL)
     {
@@ -138,8 +135,7 @@ query_count_t * query_count_new(void)
 
 query_drop_t * query_drop_new(void)
 {
-    query_drop_t * q_drop =
-            (query_drop_t *) malloc(sizeof(query_drop_t));
+    query_drop_t * q_drop = malloc(sizeof(query_drop_t));
 
     if (q_drop == NULL)
     {
@@ -158,8 +154,7 @@ query_drop_t * query_drop_new(void)
 
 query_list_t * query_list_new(void)
 {
-    query_list_t * q_list =
-            (query_list_t *) malloc(sizeof(query_list_t));
+    query_list_t * q_list = malloc(sizeof(query_list_t));
 
     if (q_list == NULL)
     {
@@ -177,8 +172,7 @@ query_list_t * query_list_new(void)
 
 void query_alter_free(uv_handle_t * handle)
 {
-    query_alter_t * q_alter =
-            (query_alter_t *) ((siridb_query_t *) handle->data)->data;
+    query_alter_t * q_alter = ((siridb_query_t *) handle->data)->data;
 
     switch (q_alter->alter_tp)
     {
@@ -204,23 +198,21 @@ void query_alter_free(uv_handle_t * handle)
 
 void query_count_free(uv_handle_t * handle)
 {
-    query_count_t * q_count =
-            (query_count_t *) ((siridb_query_t *) handle->data)->data;
+    query_count_t * q_count = ((siridb_query_t *) handle->data)->data;
 
     QUERIES_FREE(q_count, handle)
 }
 
 void query_drop_free(uv_handle_t * handle)
 {
-    query_drop_t * q_drop =
-            (query_drop_t *) ((siridb_query_t *) handle->data)->data;
+    query_drop_t * q_drop = ((siridb_query_t *) handle->data)->data;
 
     if (q_drop->shards_list != NULL)
     {
         siridb_shard_t * shard;
         while (q_drop->shards_list->len)
         {
-            shard = (siridb_shard_t *) vec_pop(q_drop->shards_list);
+            shard = vec_pop(q_drop->shards_list);
             siridb_shard_decref(shard);
         }
 
@@ -232,8 +224,7 @@ void query_drop_free(uv_handle_t * handle)
 
 void query_list_free(uv_handle_t * handle)
 {
-    query_list_t * q_list =
-            (query_list_t *) ((siridb_query_t *) handle->data)->data;
+    query_list_t * q_list = ((siridb_query_t *) handle->data)->data;
 
     if (q_list->props != NULL)
     {
@@ -245,8 +236,7 @@ void query_list_free(uv_handle_t * handle)
 
 void query_select_free(uv_handle_t * handle)
 {
-    query_select_t * q_select =
-            (query_select_t *) ((siridb_query_t *) handle->data)->data;
+    query_select_t * q_select = ((siridb_query_t *) handle->data)->data;
 
     siridb_presuf_free(q_select->presuf);
 

diff --git a/src/siri/db/query.c b/src/siri/db/query.c
index 6526b918d9b1a70a4cfb902221c9282c778ef8c3..f480a02c77cf44f1a22f36673292d23f97c26785 100644 (file)
--- a/src/siri/db/query.c
+++ b/src/siri/db/query.c
@@ -58,13 +58,13 @@ void siridb_query_run(
         float factor,
         int flags)
 {
-    uv_async_t * handle = (uv_async_t *) malloc(sizeof(uv_async_t));
+    uv_async_t * handle = malloc(sizeof(uv_async_t));
     if (handle == NULL)
     {
         ERR_ALLOC
         return;
     }
-    siridb_query_t * query = (siridb_query_t *) malloc(sizeof(siridb_query_t));
+    siridb_query_t * query = malloc(sizeof(siridb_query_t));
     if (query == NULL)
     {
         ERR_ALLOC
@@ -602,7 +602,7 @@ static void QUERY_parse(uv_async_t * handle)
         return;
     }
 
-    uv_async_t * forward = (uv_async_t *) malloc(sizeof(uv_async_t));
+    uv_async_t * forward = malloc(sizeof(uv_async_t));
     uv_async_init(siri.loop, forward, (uv_async_cb) query->nodes->cb);
     forward->data = handle->data;
     uv_async_send(forward);

diff --git a/src/siri/db/server.c b/src/siri/db/server.c
index 800f7434d9761aa6ec87bdd086cf8c1739977672..55f7ae3e368d6221e57db09ee2a6d482506c1273 100644 (file)
--- a/src/siri/db/server.c
+++ b/src/siri/db/server.c
@@ -58,8 +58,7 @@ siridb_server_t * siridb_server_new(
         uint16_t port,
         uint16_t pool)
 {
-    siridb_server_t * server =
-            (siridb_server_t *) malloc(sizeof(siridb_server_t));
+    siridb_server_t * server = malloc(sizeof(siridb_server_t));
     if (server == NULL)
     {
         ERR_ALLOC
@@ -133,15 +132,14 @@ int siridb_server_send_pkg(
     assert (cb != NULL);
     int rc;
     uint8_t n = 0;
-    sirinet_promise_t * promise =
-            (sirinet_promise_t *) malloc(sizeof(sirinet_promise_t));
+    sirinet_promise_t * promise = malloc(sizeof(sirinet_promise_t));
     if (promise == NULL)
     {
         ERR_ALLOC
         return -1;
     }
 
-    promise->timer = (uv_timer_t *) malloc(sizeof(uv_timer_t));
+    promise->timer = malloc(sizeof(uv_timer_t));
     if (promise->timer == NULL)
     {
         ERR_ALLOC
@@ -159,7 +157,7 @@ int siridb_server_send_pkg(
     promise->server = server;
     promise->data = data;
 
-    uv_write_t * req = (uv_write_t *) malloc(sizeof(uv_write_t));
+    uv_write_t * req = malloc(sizeof(uv_write_t));
     if (req == NULL)
     {
         ERR_ALLOC
@@ -408,7 +406,7 @@ void siridb_server_connect(siridb_t * siridb, siridb_server_t * server)
             /* IPv4 */
             struct sockaddr_in dest;
 
-            uv_connect_t * req = (uv_connect_t *) malloc(sizeof(uv_connect_t));
+            uv_connect_t * req = malloc(sizeof(uv_connect_t));
             if (req == NULL)
             {
                 ERR_ALLOC
@@ -430,7 +428,7 @@ void siridb_server_connect(siridb_t * siridb, siridb_server_t * server)
             /* IPv6 */
             struct sockaddr_in6 dest6;
 
-            uv_connect_t * req = (uv_connect_t *) malloc(sizeof(uv_connect_t));
+            uv_connect_t * req = malloc(sizeof(uv_connect_t));
             if (req == NULL)
             {
                 ERR_ALLOC
@@ -555,7 +553,7 @@ static void SERVER_on_resolved(
                     addr, server->name);
 
         }
-        uv_connect_t * req = (uv_connect_t *) malloc(sizeof(uv_connect_t));
+        uv_connect_t * req = malloc(sizeof(uv_connect_t));
         if (req == NULL)
         {
             ERR_ALLOC

diff --git a/src/siri/db/shard.c b/src/siri/db/shard.c
index 007d4b4e826da63ee904bf4c56d1e68bfddfa635..a88adcfa58e8215dc92cb50430aafe5c49b97b2e 100644 (file)
--- a/src/siri/db/shard.c
+++ b/src/siri/db/shard.c
@@ -140,7 +140,7 @@ int siridb_shard_load(siridb_t * siridb, uint64_t id)
     int is_ts64;
     FILE * fp;
     off_t shard_sz;
-    siridb_shard_t * shard = (siridb_shard_t *) malloc(sizeof(siridb_shard_t));
+    siridb_shard_t * shard = malloc(sizeof(siridb_shard_t));
 
     if (shard == NULL)
     {
@@ -296,7 +296,7 @@ siridb_shard_t *  siridb_shard_create(
         uint8_t tp,
         siridb_shard_t * replacing)
 {
-    siridb_shard_t * shard = (siridb_shard_t *) malloc(sizeof(siridb_shard_t));
+    siridb_shard_t * shard = malloc(sizeof(siridb_shard_t));
     if (shard == NULL)
     {
         ERR_ALLOC
@@ -572,7 +572,7 @@ size_t siridb_shard_write_points(
     {
         size_t p = 0;
         size_t ts_sz = siridb->time->ts_sz;
-        cdata = (unsigned char *) malloc(dsize);
+        cdata = malloc(dsize);
         if (cdata == NULL)
         {
             ERR_ALLOC
@@ -629,7 +629,7 @@ int siridb_shard_get_points_num32(
         }
     }
 
-    temp = (uint32_t *) malloc(sizeof(uint32_t) * idx->len * 3);
+    temp = malloc(sizeof(uint32_t) * idx->len * 3);
     if (temp == NULL)
     {
         log_critical("Memory allocation error");
@@ -726,7 +726,7 @@ int siridb_shard_get_points_num64(
         }
     }
 
-    temp = (uint64_t *) malloc(sizeof(uint64_t) * idx->len * 2);
+    temp = malloc(sizeof(uint64_t) * idx->len * 2);
     if (temp == NULL)
     {
         log_critical("Memory allocation error");
@@ -822,7 +822,7 @@ int siridb_shard_get_points_num_compressed(
         }
     }
 
-    bits = (unsigned char *) malloc(size);
+    bits = malloc(size);
     if (bits == NULL)
     {
         log_critical("Memory allocation error");
@@ -906,7 +906,7 @@ int siridb_shard_get_points_log_compressed(
             return -1;
         }
     }
-    bits = (uint8_t *) malloc(size);
+    bits = malloc(size);
     if (bits == NULL)
     {
         free(bits);
@@ -976,8 +976,8 @@ int siridb_shard_get_points_log32(
         }
     }
 
-    tdata = (uint32_t *) malloc(sizeof(uint32_t) * idx->len);
-    cdata = (char *) malloc(dsize);
+    tdata = malloc(sizeof(uint32_t) * idx->len);
+    cdata = malloc(dsize);
     if (cdata == NULL || tdata == NULL)
     {
         free(tdata);
@@ -1093,8 +1093,8 @@ int siridb_shard_get_points_log64(
         }
     }
 
-    tdata = (uint64_t *) malloc(sizeof(uint64_t) * idx->len);
-    cdata = (char *) malloc(dsize);
+    tdata = malloc(sizeof(uint64_t) * idx->len);
+    cdata = malloc(dsize);
     if (cdata == NULL || tdata == NULL)
     {
         free(tdata);
@@ -1725,7 +1725,7 @@ static int SHARD_get_idx(
     }
 
     n = SIRIDB_SHARD_MAX_CHUNK_SZ / idx_sz;
-    data = (char *) malloc(n * idx_sz);
+    data = malloc(n * idx_sz);
 
     if (data == NULL)
     {

diff --git a/src/siri/db/time.c b/src/siri/db/time.c
index f2547cf8a41860db6fc4473dd7a823716a18c348..1d9f6f3cf0e39d15df85ec922224795e623dbd73 100644 (file)
--- a/src/siri/db/time.c
+++ b/src/siri/db/time.c
@@ -17,7 +17,7 @@ const char * siridb_time_short_map[] = {"s", "ms", "us", "ns"};
  */
 siridb_time_t * siridb_time_new(siridb_timep_t precision)
 {
-    siridb_time_t * time = (siridb_time_t *) malloc(sizeof(siridb_time_t));
+    siridb_time_t * time = malloc(sizeof(siridb_time_t));
     if (time == NULL)
     {
         ERR_ALLOC

diff --git a/src/siri/db/user.c b/src/siri/db/user.c
index 8657b7cdd9c5fe0fe30d66792a0b3f16351be4c6..345303ac70cc5ea8ba73a8c468373b420fbfb832 100644 (file)
--- a/src/siri/db/user.c
+++ b/src/siri/db/user.c
@@ -29,7 +29,7 @@
  */
 siridb_user_t * siridb_user_new(void)
 {
-    siridb_user_t * user = (siridb_user_t *) malloc(sizeof(siridb_user_t));
+    siridb_user_t * user = malloc(sizeof(siridb_user_t));
     if (user == NULL)
     {
         ERR_ALLOC

diff --git a/src/siri/db/walker.c b/src/siri/db/walker.c
index 8754bb4f4fd45c375427336eaaa438ea5a53d48b..a0e3ac1ce5a00afcfe017e4cc72d65c3ceabe8b2 100644 (file)
--- a/src/siri/db/walker.c
+++ b/src/siri/db/walker.c
@@ -12,8 +12,7 @@ siridb_walker_t * siridb_walker_new(
         const uint64_t now,
         uint8_t * flags)
 {
-    siridb_walker_t * walker =
-            (siridb_walker_t *) malloc(sizeof(siridb_walker_t));
+    siridb_walker_t * walker = malloc(sizeof(siridb_walker_t));
     if (walker == NULL)
     {
         ERR_ALLOC
@@ -58,8 +57,7 @@ int siridb_walker_append(
         cleri_node_t * node,
         uv_async_cb cb)
 {
-    siridb_nodes_t * wnode =
-            (siridb_nodes_t *) malloc(sizeof(siridb_nodes_t));
+    siridb_nodes_t * wnode = malloc(sizeof(siridb_nodes_t));
     if (wnode == NULL)
     {
         ERR_ALLOC
@@ -94,8 +92,7 @@ int siridb_walker_insert(
 {
     siridb_nodes_t * current = walker->exit_nodes;
 
-    walker->exit_nodes =
-            (siridb_nodes_t *) malloc(sizeof(siridb_nodes_t));
+    walker->exit_nodes = malloc(sizeof(siridb_nodes_t));
     if (walker->exit_nodes == NULL)
     {
         ERR_ALLOC

diff --git a/src/siri/file/handler.c b/src/siri/file/handler.c
index b780f14e6fb0fc406aaed6fc9e02f93e638b9f01..9afaaeba1bb8f089a6d4c161208f5e731de5641f 100644 (file)
--- a/src/siri/file/handler.c
+++ b/src/siri/file/handler.c
@@ -8,7 +8,7 @@
 
 siri_fh_t * siri_fh_new(uint16_t size)
 {
-    siri_fh_t * fh = (siri_fh_t *) malloc(sizeof(siri_fh_t));
+    siri_fh_t * fh = malloc(sizeof(siri_fh_t));
     if (fh == NULL)
     {
         ERR_ALLOC
@@ -17,7 +17,7 @@ siri_fh_t * siri_fh_new(uint16_t size)
     {
         fh->size = size;
         fh->idx = 0;
-        fh->fpointers = (siri_fp_t **) calloc(size, sizeof(siri_fp_t *));
+        fh->fpointers = calloc(size, sizeof(siri_fp_t *));
         if (fh->fpointers == NULL)
         {
             ERR_ALLOC

diff --git a/src/siri/file/pointer.c b/src/siri/file/pointer.c
index 4513d976dd91783a9ddb5388c58a551df1d1c46a..60f7887a98493160af80b0ee9736efcb222a7627 100644 (file)
--- a/src/siri/file/pointer.c
+++ b/src/siri/file/pointer.c
@@ -11,7 +11,7 @@
  */
 siri_fp_t * siri_fp_new(void)
 {
-    siri_fp_t * fp = (siri_fp_t *) malloc(sizeof(siri_fp_t));
+    siri_fp_t * fp = malloc(sizeof(siri_fp_t));
     if (fp == NULL)
     {
         ERR_ALLOC

diff --git a/src/siri/service/client.c b/src/siri/service/client.c
index 941efb42ed5bde017f6dbe8c3e45ad50daa6c243..dc9608af24ac81eafa8863bbd7f6b66e6af953d5 100644 (file)
--- a/src/siri/service/client.c
+++ b/src/siri/service/client.c
@@ -114,7 +114,7 @@ int siri_service_client_request(
 
     uv_tcp_init(siri.loop, (uv_tcp_t *) siri.client->stream);
 
-    adm_client = (siri_service_client_t *) malloc(sizeof(siri_service_client_t));
+    adm_client = malloc(sizeof(siri_service_client_t));
     if (adm_client == NULL)
     {
         sirinet_stream_decref(siri.client);
@@ -159,7 +159,7 @@ int siri_service_client_request(
         /* IPv4 */
         struct sockaddr_in dest;
 
-        uv_connect_t * req = (uv_connect_t *) malloc(sizeof(uv_connect_t));
+        uv_connect_t * req = malloc(sizeof(uv_connect_t));
         if (req == NULL)
         {
             sirinet_stream_decref(siri.client);
@@ -183,7 +183,7 @@ int siri_service_client_request(
         /* IPv6 */
         struct sockaddr_in6 dest6;
 
-        uv_connect_t * req = (uv_connect_t *) malloc(sizeof(uv_connect_t));
+        uv_connect_t * req = malloc(sizeof(uv_connect_t));
         if (req == NULL)
         {
             sirinet_stream_decref(siri.client);
@@ -250,8 +250,7 @@ static int CLIENT_resolve_dns(
     hints.ai_protocol = IPPROTO_TCP;
     hints.ai_flags = AI_NUMERICSERV;
 
-    uv_getaddrinfo_t * resolver =
-            (uv_getaddrinfo_t *) malloc(sizeof(uv_getaddrinfo_t));
+    uv_getaddrinfo_t * resolver = malloc(sizeof(uv_getaddrinfo_t));
 
     if (resolver == NULL)
     {
@@ -306,7 +305,7 @@ static void CLIENT_on_resolved(
     }
     else
     {
-        uv_connect_t * req = (uv_connect_t *) malloc(sizeof(uv_connect_t));
+        uv_connect_t * req = malloc(sizeof(uv_connect_t));
         if (req == NULL)
         {
             CLIENT_err(adm_client, "memory allocation error");
@@ -376,7 +375,7 @@ static void CLIENT_send_pkg(
         siri_service_client_t * adm_client,
         sirinet_pkg_t * pkg)
 {
-    uv_write_t * req = (uv_write_t *) malloc(sizeof(uv_write_t));
+    uv_write_t * req = malloc(sizeof(uv_write_t));
     if (req == NULL)
     {
         free(pkg);

diff --git a/src/siri/siri.c b/src/siri/siri.c
index 5d53a3f4fe556defabdca28d7a757dc2583cd724..e72d9cde7f039ae55db291f2fcbf6c1d0f74d42a 100644 (file)
--- a/src/siri/siri.c
+++ b/src/siri/siri.c
@@ -157,7 +157,7 @@ int siri_start(void)
     siri.fh = siri_fh_new(siri.cfg->max_open_files);
 
     /* initialize the default event loop */
-    siri.loop = (uv_loop_t *) malloc(sizeof(uv_loop_t));
+    siri.loop = malloc(sizeof(uv_loop_t));
     if (siri.loop == NULL)
     {
         return -1;