Fix coding style violations

diff --git a/clients/memslap.c b/clients/memslap.c
index cd170eb172ddcb75519bbfdf786557a2942c82a6..d42c06aefffab36b64bd52f6a1754f50a2ae9557 100644 (file)
--- a/clients/memslap.c
+++ b/clients/memslap.c
@@ -145,9 +145,9 @@ void scheduler(memcached_server_st *servers, conclusions_st *conclusion)
   if (opt_udp_io)
   {
     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_USE_UDP, opt_udp_io);
-    unsigned int i= 0;
-    for(i= 0; i < servers[0].count; i++ )
-      servers[i].type= MEMCACHED_CONNECTION_UDP;
+    unsigned int x= 0;
+    for(x= 0; x < servers[0].count; x++ )
+      servers[x].type= MEMCACHED_CONNECTION_UDP;
   }
   memcached_server_push(memc, servers);
 

diff --git a/libmemcached/byteorder.c b/libmemcached/byteorder.c
index c020785bd2603963f68c31fb213299980d82350c..28889aaee457158fce825a881bc02c9bb1d527db 100644 (file)
--- a/libmemcached/byteorder.c
+++ b/libmemcached/byteorder.c
@@ -20,10 +20,12 @@ static inline uint64_t swap64(uint64_t in)
 #endif
 }
 
-uint64_t ntohll(uint64_t value) {
+uint64_t ntohll(uint64_t value)
+{
   return swap64(value);
 }
 
-uint64_t htonll(uint64_t value) {
+uint64_t htonll(uint64_t value)
+{
   return swap64(value);
 }

diff --git a/libmemcached/hsieh_hash.c b/libmemcached/hsieh_hash.c
index e6c23cd97a64ba6783ff253b735b6ab24b404286..91d515f216e767cccc97a1b5cecf6266ded601ba 100644 (file)
--- a/libmemcached/hsieh_hash.c
+++ b/libmemcached/hsieh_hash.c
@@ -22,13 +22,15 @@ uint32_t hsieh_hash(const char *key, size_t key_length)
   uint32_t hash = 0, tmp;
   int rem;
 
-  if (key_length <= 0 || key == NULL) return 0;
+  if (key_length <= 0 || key == NULL)
+    return 0;
 
   rem = key_length & 3;
   key_length >>= 2;
 
   /* Main loop */
-  for (;key_length > 0; key_length--) {
+  for (;key_length > 0; key_length--)
+  {
     hash  += get16bits (key);
     tmp    = (get16bits (key+2) << 11) ^ hash;
     hash   = (hash << 16) ^ tmp;
@@ -37,7 +39,8 @@ uint32_t hsieh_hash(const char *key, size_t key_length)
   }
 
   /* Handle end cases */
-  switch (rem) {
+  switch (rem)
+  {
   case 3: hash += get16bits (key);
           hash ^= hash << 16;
           hash ^= key[sizeof (uint16_t)] << 18;

diff --git a/libmemcached/jenkins_hash.c b/libmemcached/jenkins_hash.c
index 940e4718c0810ae976a85e822383269ddbc4e6be..409a405400e46e875a4d3ef4e3cb893a57f7fad8 100644 (file)
--- a/libmemcached/jenkins_hash.c
+++ b/libmemcached/jenkins_hash.c
@@ -63,7 +63,8 @@ uint32_t jenkins_hash(const void *key, size_t length, uint32_t initval)
   a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
 
   u.ptr = key;
-  if ((u.i & 0x3) == 0) {
+  if ((u.i & 0x3) == 0)
+  {
     const uint32_t *k = (const uint32_t *)key;         /* read 32-bit chunks */
 
     /*------ all but last block: aligned reads and affect 32 bits of (a,b,c) */
@@ -104,7 +105,9 @@ uint32_t jenkins_hash(const void *key, size_t length, uint32_t initval)
     case 0 : return c;              /* zero length strings require no mixing */
     }
 
-  } else if ((u.i & 0x1) == 0) {
+  } 
+  else if ((u.i & 0x1) == 0)
+  {
     const uint16_t *k = (const uint16_t *)key;         /* read 16-bit chunks */
     const uint8_t  *k8;
 
@@ -151,7 +154,9 @@ uint32_t jenkins_hash(const void *key, size_t length, uint32_t initval)
     case 0 : return c;                     /* zero length requires no mixing */
     }
 
-  } else {                        /* need to read the key one byte at a time */
+  } 
+  else
+  {                        /* need to read the key one byte at a time */
     const uint8_t *k = (const uint8_t *)key;
 
     /*--------------- all but the last block: affect some 32 bits of (a,b,c) */

diff --git a/libmemcached/memcached_connect.c b/libmemcached/memcached_connect.c
index f066c52661d25a585585d60fa5496aad08cc2cf9..aca8ffd0a00088964d6110fa2d55663441b451e1 100644 (file)
--- a/libmemcached/memcached_connect.c
+++ b/libmemcached/memcached_connect.c
@@ -159,7 +159,8 @@ test_connect:
                 (struct sockaddr *)&servAddr,
                 sizeof(servAddr)) < 0)
     {
-      switch (errno) {
+      switch (errno)
+      {
       case EINPROGRESS:
       case EALREADY:
       case EINTR:
@@ -209,7 +210,8 @@ static memcached_return network_connect(memcached_server_st *ptr)
     while (use != NULL)
     {
       /* Memcache server does not support IPV6 in udp mode, so skip if not ipv4 */
-      if (ptr->type == MEMCACHED_CONNECTION_UDP && use->ai_family != AF_INET) {
+      if (ptr->type == MEMCACHED_CONNECTION_UDP && use->ai_family != AF_INET)
+      {
         use= use->ai_next;
         continue;
       }

diff --git a/libmemcached/memcached_get.c b/libmemcached/memcached_get.c
index 3305a772a01a3ad7825299bb8723d4c2d8a57ffe..2de7acbdbc7bde3eac8cd2399031c81cab7057c3 100644 (file)
--- a/libmemcached/memcached_get.c
+++ b/libmemcached/memcached_get.c
@@ -293,7 +293,8 @@ static memcached_return binary_mget_by_key(memcached_st *ptr,
     memcached_return vk;
     vk= memcached_validate_key_length(key_length[x],
                                       ptr->flags & MEM_BINARY_PROTOCOL);
-    unlikely (vk != MEMCACHED_SUCCESS) {
+    unlikely (vk != MEMCACHED_SUCCESS)
+    {
       if (x > 0)
         memcached_io_reset(&ptr->hosts[server_key]);
       return vk;

diff --git a/libmemcached/memcached_quit.c b/libmemcached/memcached_quit.c
index 592bde9f90f04a363a79119ed613c90279587f69..80b9314ac593a2350c28ae925579d42b13566fac 100644 (file)
--- a/libmemcached/memcached_quit.c
+++ b/libmemcached/memcached_quit.c
@@ -26,7 +26,8 @@ void memcached_quit_server(memcached_server_st *ptr, uint8_t io_death)
         request.message.header.request.opcode = PROTOCOL_BINARY_CMD_QUIT;
         request.message.header.request.datatype = PROTOCOL_BINARY_RAW_BYTES;
         rc= memcached_do(ptr, request.bytes, sizeof(request.bytes), 1);
-      } else 
+      }
+      else
         rc= memcached_do(ptr, "quit\r\n", 6, 1);
 
       WATCHPOINT_ASSERT(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_FETCH_NOTFINISHED);

diff --git a/libmemcached/memcached_response.c b/libmemcached/memcached_response.c
index 940c9f8844e26632181e09b404a9b8c277a75585..e9f82b0af3653064e9cec4fa4a8906d1b6128b31 100644 (file)
--- a/libmemcached/memcached_response.c
+++ b/libmemcached/memcached_response.c
@@ -50,7 +50,8 @@ memcached_return memcached_response(memcached_server_st *ptr,
    * compatibility. 
    */
   if ((ptr->root->flags & MEM_BINARY_PROTOCOL) == 0)
-    while (memcached_server_response_count(ptr) > 1) {
+    while (memcached_server_response_count(ptr) > 1)
+    {
       memcached_return rc= memcached_read_one_response(ptr, buffer, buffer_length, result);
       
       unlikely (rc != MEMCACHED_END &&

diff --git a/libmemcached/memcached_storage.c b/libmemcached/memcached_storage.c
index 9acc7c3bcaef41f91acf357ced485de3b5218cac..0243de5055d6d8f2a10f65b64df40bd1e5b16ec3 100644 (file)
--- a/libmemcached/memcached_storage.c
+++ b/libmemcached/memcached_storage.c
@@ -105,7 +105,8 @@ static inline memcached_return memcached_send(memcached_st *ptr,
                            (unsigned long long)expiration, value_length,
                            (ptr->flags & MEM_NOREPLY) ? " noreply" : "");
 
-  if (ptr->flags & MEM_USE_UDP && ptr->flags & MEM_BUFFER_REQUESTS) {
+  if (ptr->flags & MEM_USE_UDP && ptr->flags & MEM_BUFFER_REQUESTS)
+  {
     size_t cmd_size= write_length + value_length + 2;
     if (cmd_size > MAX_UDP_DATAGRAM_LENGTH - UDP_DATAGRAM_HEADER_LENGTH)
       return MEMCACHED_WRITE_FAILURE;
@@ -338,7 +339,8 @@ memcached_return memcached_cas_by_key(memcached_st *ptr,
   return rc;
 }
 
-static inline uint8_t get_com_code(memcached_storage_action verb, bool noreply) {
+static inline uint8_t get_com_code(memcached_storage_action verb, bool noreply)
+{
    uint8_t ret;
 
   if (noreply)

diff --git a/tests/atomsmasher.c b/tests/atomsmasher.c
index 7c4c8ae396f7f0ceeed6befc3312916b1f3d754f..08aa86f7f7cb3d72f30cb15ba4efb12ca97a8240 100644 (file)
--- a/tests/atomsmasher.c
+++ b/tests/atomsmasher.c
@@ -186,7 +186,8 @@ static test_return add_test(memcached_st *memc)
 static test_return many_adds(memcached_st *memc)
 {
   unsigned int i;
-  for (i = 0; i < TEST_COUNTER; i++){
+  for (i = 0; i < TEST_COUNTER; i++)
+  {
     add_test(memc);
   }
   return 0;

diff --git a/tests/function.c b/tests/function.c
index 09d2673e6bda967cb4d85da96c1e08a2d004ce2b..8cd48eadffaba64cd3d84df630d79d593457a22e 100644 (file)
--- a/tests/function.c
+++ b/tests/function.c
@@ -2228,7 +2228,7 @@ test_return user_supplied_bug18(memcached_st *trash)
 {
   memcached_return rc;
   int value;
-  int i;
+  int x;
   memcached_server_st *server_pool;
   memcached_st *memc;
 
@@ -2270,11 +2270,11 @@ test_return user_supplied_bug18(memcached_st *trash)
   assert(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->continuum[0].index);
 
   /* verify the standard ketama set. */
-  for (i= 0; i < 99; i++)
+  for (x= 0; x < 99; x++)
   {
-    uint32_t server_idx = memcached_generate_hash(memc, test_cases[i].key, strlen(test_cases[i].key));
+    uint32_t server_idx = memcached_generate_hash(memc, test_cases[x].key, strlen(test_cases[x].key));
     char *hostname = memc->hosts[server_idx].hostname;
-    assert(strcmp(hostname, test_cases[i].server) == 0);
+    assert(strcmp(hostname, test_cases[x].server) == 0);
   }
 
   memcached_server_list_free(server_pool);
@@ -3173,7 +3173,8 @@ static test_return analyzer_test(memcached_st *memc)
   return TEST_SUCCESS;
 }
 
-static void increment_request_id(uint16_t *id) {
+static void increment_request_id(uint16_t *id)
+{
   (*id)++;
   if ((*id & UDP_REQUEST_ID_THREAD_MASK) != 0)
     *id= 0;
@@ -3183,21 +3184,22 @@ static uint16_t *get_udp_request_ids(memcached_st *memc)
 {
   uint16_t *ids= malloc(sizeof(uint16_t) * memc->number_of_hosts);
   assert(ids != NULL);
-  unsigned int i;
-  for (i= 0; i < memc->number_of_hosts; i++)
-    ids[i]= get_udp_datagram_request_id((struct udp_datagram_header_st *) memc->hosts[i].write_buffer);
+  unsigned int x;
+  for (x= 0; x < memc->number_of_hosts; x++)
+    ids[x]= get_udp_datagram_request_id((struct udp_datagram_header_st *) memc->hosts[x].write_buffer);
 
   return ids;
 }
 
-static test_return post_udp_op_check(memcached_st *memc, uint16_t *expected_req_ids) {
-  unsigned int i;
+static test_return post_udp_op_check(memcached_st *memc, uint16_t *expected_req_ids)
+{
+  unsigned int x;
   memcached_server_st *cur_server = memc->hosts;
   uint16_t *cur_req_ids = get_udp_request_ids(memc);
-  for (i= 0; i < memc->number_of_hosts; i++)
+  for (x= 0; x < memc->number_of_hosts; x++)
   {
-    assert(cur_server[i].cursor_active == 0);
-    assert(cur_req_ids[i] == expected_req_ids[i]);
+    assert(cur_server[x].cursor_active == 0);
+    assert(cur_req_ids[x] == expected_req_ids[x]);
   }
   free(expected_req_ids);
   free(cur_req_ids);
@@ -3215,15 +3217,15 @@ static memcached_return init_udp(memcached_st *memc)
     return MEMCACHED_FAILURE;
 
   uint32_t num_hosts= memc->number_of_hosts;
-  unsigned int i= 0;
+  unsigned int x= 0;
   memcached_server_st servers[num_hosts];
   memcpy(servers, memc->hosts, sizeof(memcached_server_st) * num_hosts);
   memc->number_of_hosts= 0;
   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_USE_UDP, 1);
-  for (i= 0; i < num_hosts; i++)
+  for (x= 0; x < num_hosts; x++)
   {
-    assert(memcached_server_add_udp(memc, servers[i].hostname, servers[i].port) == MEMCACHED_SUCCESS);
-    assert(memc->hosts[i].write_buffer_offset == UDP_DATAGRAM_HEADER_LENGTH);
+    assert(memcached_server_add_udp(memc, servers[x].hostname, servers[x].port) == MEMCACHED_SUCCESS);
+    assert(memc->hosts[x].write_buffer_offset == UDP_DATAGRAM_HEADER_LENGTH);
   }
   return MEMCACHED_SUCCESS;
 }
@@ -3278,9 +3280,9 @@ static test_return set_udp_behavior_test(memcached_st *memc)
 
 static test_return udp_set_test(memcached_st *memc)
 {
-  unsigned int i= 0;
+  unsigned int x= 0;
   unsigned int num_iters= 1025; //request id rolls over at 1024
-  for (i= 0; i < num_iters;i++)
+  for (x= 0; x < num_iters;x++)
   {
     memcached_return rc;
     char *key= "foo";
@@ -3300,9 +3302,12 @@ static test_return udp_set_test(memcached_st *memc)
             memc->hosts[server_key].write_buffer_offset < init_offset)
       increment_request_id(&expected_ids[server_key]);
     
-    if (rc == MEMCACHED_SUCCESS) {
+    if (rc == MEMCACHED_SUCCESS)
+    {
       assert(memc->hosts[server_key].write_buffer_offset == UDP_DATAGRAM_HEADER_LENGTH);
-    } else {
+    } 
+    else
+    {
       assert(memc->hosts[server_key].write_buffer_offset != UDP_DATAGRAM_HEADER_LENGTH);
       assert(memc->hosts[server_key].write_buffer_offset <= MAX_UDP_DATAGRAM_LENGTH);
     }
@@ -3332,9 +3337,9 @@ static test_return udp_set_too_big_test(memcached_st *memc)
 
 test_return udp_delete_test(memcached_st *memc)
 {
-  unsigned int i= 0;
+  unsigned int x= 0;
   unsigned int num_iters= 1025; //request id rolls over at 1024
-  for (i= 0; i < num_iters;i++)
+  for (x= 0; x < num_iters;x++)
   {
     memcached_return rc;
     char *key= "foo";
@@ -3482,8 +3487,8 @@ test_return udp_mixed_io_test(memcached_st *memc)
     {"udp_decr_test", 0, udp_decr_test},
     {"udp_version_test", 0, udp_version_test}
   };
-  unsigned int i= 0;
-  for (i= 0; i < 500; i++)
+  unsigned int x= 0;
+  for (x= 0; x < 500; x++)
   {
     current_op= mixed_io_ops[random() % 9];
     assert(current_op.function(memc) == TEST_SUCCESS);

diff --git a/tests/server.c b/tests/server.c
index 8a7970a0d48809032413aa9da5c95b6b9ed4acc7..d0942edf4005e71b306c1d5e67036f0d59cbfd5e 100644 (file)
--- a/tests/server.c
+++ b/tests/server.c
@@ -38,10 +38,13 @@ void server_startup(server_startup_st *construct)
         int count;
         int status;
 
-        if(x == 0) {
+        if (x == 0)
+        {
           sprintf(buffer, "%s -d -P /tmp/%umemc.pid -t 1 -p %u -U %u -m 128",
                     MEMCACHED_BINARY, x, x + TEST_PORT_BASE, x + TEST_PORT_BASE);
-        } else {
+        } 
+        else
+        {
           sprintf(buffer, "%s -d -P /tmp/%umemc.pid -t 1 -p %u -U %u",
                     MEMCACHED_BINARY, x, x + TEST_PORT_BASE, x + TEST_PORT_BASE);
         }