Merge lp:~flier-lu/libmemcached/win32-vs2008 into lp:~tangent-org/libmemcached/trunk

[flier]

Remove C99 syntax and add supports to Win32 with VS2008

[lp:~flier-lu/libmemcached/win32-vs2008]

905. By flier on 2011-01-07

use pointer instead of reference to pass allocator

906. By flier on 2011-01-07

port libhashkit to win32

907. By flier on 2011-01-07

-h

908. By flier on 2011-01-07

port poll to win32

909. By flier on 2011-01-07

update solution

910. By flier on 2011-01-07

define LIBMEMCACHED_STATIC to support static link

911. By flier on 2011-01-07

use DLL mode by default

912. By flier on 2011-01-12

replace %zu instead of %lu

913. By flier on 2011-01-13

porting client

Unmerged revisions

913. By flier on 2011-01-13

porting client

912. By flier on 2011-01-12

replace %zu instead of %lu

911. By flier on 2011-01-07

use DLL mode by default

910. By flier on 2011-01-07

define LIBMEMCACHED_STATIC to support static link

909. By flier on 2011-01-07

update solution

908. By flier on 2011-01-07

port poll to win32

907. By flier on 2011-01-07

-h

906. By flier on 2011-01-07

port libhashkit to win32

905. By flier on 2011-01-07

use pointer instead of reference to pass allocator

904. By flier on 2011-01-06

Add VS2008 project

=== modified file '.bzrignore'
--- .bzrignore	2010-09-14 07:55:39 +0000
+++ .bzrignore	2011-01-13 03:40:43 +0000
@@ -185,3 +185,16 @@
 tests/testplus
 tests/testudp
 unittests/unittests
+win32/Debug
+win32/Release
+win32/libmemcached.vcproj.WIN2003R2.flier.user
+win32/memcapable.vcproj.WIN2003R2.flier.user
+win32/memcat.vcproj.WIN2003R2.flier.user
+win32/memcp.vcproj.WIN2003R2.flier.user
+win32/memdump.vcproj.WIN2003R2.flier.user
+win32/memerror.vcproj.WIN2003R2.flier.user
+win32/memflush.vcproj.WIN2003R2.flier.user
+win32/memrm.vcproj.WIN2003R2.flier.user
+win32/memslap.vcproj.WIN2003R2.flier.user
+win32/memstat.vcproj.WIN2003R2.flier.user
+*.bak
 
=== modified file 'clients/memcapable.c'
--- clients/memcapable.c	2010-10-28 22:21:05 +0000
+++ clients/memcapable.c	2011-01-13 03:40:43 +0000
@@ -11,11 +11,18 @@
 
 /* -*- Mode: C; tab-width: 2; c-basic-offset: 2; indent-tabs-mode: nil -*- */
 #undef NDEBUG
+
 #include "config.h"
-#include <pthread.h>
-#include <sys/types.h>
-#include <fcntl.h>
-#include <signal.h>
+#ifdef WIN32
+# define ETIMEDOUT WSAETIMEDOUT
+#else
+# include <pthread.h>
+# include <sys/types.h>
+# include <fcntl.h>
+# include <signal.h>
+# include <unistd.h>
+#endif
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <errno.h>
@@ -23,7 +30,6 @@
 #include <string.h>
 #include <inttypes.h>
 #include <stdbool.h>
-#include <unistd.h>
 #include <ctype.h>
 
 #include <libmemcached/memcached.h>
@@ -88,11 +94,13 @@
 static struct addrinfo *lookuphost(const char *hostname, const char *port)
 {
   struct addrinfo *ai= 0;
-  struct addrinfo hints= {.ai_family=AF_UNSPEC,
-    .ai_protocol=IPPROTO_TCP,
-    .ai_socktype=SOCK_STREAM};
+  struct addrinfo hints;
   int error= getaddrinfo(hostname, port, &hints, &ai);
 
+  hints.ai_family=AF_UNSPEC;
+  hints.ai_protocol=IPPROTO_TCP;
+  hints.ai_socktype=SOCK_STREAM;
+
   if (error != 0)
   {
     if (error != EAI_SYSTEM)
@@ -187,13 +195,12 @@
      ret= recv(fd, buf, len, 0);
 
   if (ret == SOCKET_ERROR && get_socket_errno() == EWOULDBLOCK) {
-    struct pollfd fds= {
-      .events= direction,
-      .fd= fd
-    };
-
+    struct pollfd fds;
     int err= poll(&fds, 1, timeout * 1000);
 
+    fds.events= direction;
+    fds.fd= fd;
+
     if (err == 1)
     {
       if (direction == POLLOUT)
@@ -322,6 +329,8 @@
  */
 static enum test_return recv_packet(response *rsp)
 {
+  size_t bodysz;
+
   execute(retry_read(rsp, sizeof(protocol_binary_response_no_extras)));
 
   /* Fix the byte order in the packet header */
@@ -334,7 +343,7 @@
   rsp->plain.message.header.response.cas=
           ntohll(rsp->plain.message.header.response.cas);
 
-  size_t bodysz= rsp->plain.message.header.response.bodylen;
+  bodysz= rsp->plain.message.header.response.bodylen;
   if (bodysz > 0)
     execute(retry_read(rsp->bytes + sizeof (protocol_binary_response_no_extras), bodysz));
 
@@ -362,6 +371,8 @@
                             uint32_t flags,
                             uint32_t exptime)
 {
+  off_t key_offset;
+
   /* all of the storage commands use the same command layout */
   protocol_binary_request_set *request= &cmd->set;
 
@@ -375,7 +386,7 @@
   request->message.body.flags= flags;
   request->message.body.expiration= exptime;
 
-  off_t key_offset= sizeof (protocol_binary_request_no_extras) + 8;
+  key_offset= sizeof (protocol_binary_request_no_extras) + 8;
   memcpy(cmd->bytes + key_offset, key, keylen);
   if (dta != NULL)
     memcpy(cmd->bytes + key_offset + keylen, dta, dtalen);
@@ -397,6 +408,8 @@
                         const void* dta,
                         size_t dtalen)
 {
+  off_t key_offset;
+
   /* all of the storage commands use the same command layout */
   memset(cmd, 0, sizeof (*cmd));
   cmd->plain.message.header.request.magic= PROTOCOL_BINARY_REQ;
@@ -405,7 +418,7 @@
   cmd->plain.message.header.request.bodylen= (uint32_t)(keylen + dtalen);
   cmd->plain.message.header.request.opaque= 0xdeadbeef;
 
-  off_t key_offset= sizeof (protocol_binary_request_no_extras);
+  key_offset= sizeof (protocol_binary_request_no_extras);
 
   if (key != NULL)
     memcpy(cmd->bytes + key_offset, key, keylen);
@@ -454,6 +467,8 @@
                                uint64_t initial,
                                uint32_t exptime)
 {
+  off_t key_offset;
+
   memset(cmd, 0, sizeof (cmd->incr));
   cmd->incr.message.header.request.magic= PROTOCOL_BINARY_REQ;
   cmd->incr.message.header.request.opcode= cc;
@@ -465,7 +480,7 @@
   cmd->incr.message.body.initial= htonll(initial);
   cmd->incr.message.body.expiration= htonl(exptime);
 
-  off_t key_offset= sizeof (protocol_binary_request_no_extras) + 20;
+  key_offset= sizeof (protocol_binary_request_no_extras) + 20;
   memcpy(cmd->bytes + key_offset, key, keylen);
 }
 
@@ -643,12 +658,13 @@
 {
   command cmd;
   response rsp;
+  int ii;
 
   uint64_t value= 0xdeadbeefdeadcafe;
   storage_command(&cmd, cc, key, strlen(key), &value, sizeof (value), 0, 0);
 
   /* set should always work */
-  for (int ii= 0; ii < 10; ii++)
+  for (ii= 0; ii < 10; ii++)
   {
     if (ii == 0)
       execute(send_packet(&cmd));
@@ -716,12 +732,13 @@
 {
   command cmd;
   response rsp;
+  int ii;
   uint64_t value= 0xdeadbeefdeadcafe;
   storage_command(&cmd, cc, key, strlen(key), &value, sizeof (value), 0, 0);
 
   /* first add should work, rest of them should fail (even with cas
      as wildcard */
-  for (int ii=0; ii < 10; ii++)
+  for (ii=0; ii < 10; ii++)
   {
     if (ii == 0)
       execute(send_packet(&cmd));
@@ -775,12 +792,13 @@
 {
   command cmd;
   response rsp;
+  int ii;
   uint64_t value= 0xdeadbeefdeadcafe;
   storage_command(&cmd, cc, key, strlen(key), &value, sizeof (value), 0, 0);
 
   /* first replace should fail, successive should succeed (when the
      item is added! */
-  for (int ii= 0; ii < 10; ii++)
+  for (ii= 0; ii < 10; ii++)
   {
     if (ii == 0)
       execute(send_packet(&cmd));
@@ -931,9 +949,9 @@
 {
   command cmd;
   response rsp;
+  uint64_t ii;
   arithmetic_command(&cmd, cc, key, strlen(key), 1, 0, 0);
-
-  uint64_t ii;
+  
   for (ii= 0; ii < 10; ++ii)
   {
     if (ii == 0)
@@ -969,9 +987,9 @@
 {
   command cmd;
   response rsp;
+  int ii;
   arithmetic_command(&cmd, cc, key, strlen(key), 1, 9, 0);
-
-  int ii;
+  
   for (ii= 9; ii > -1; --ii)
   {
     if (ii == 9)
@@ -1038,8 +1056,9 @@
 {
   command cmd;
   response rsp;
+  int ii;
 
-  for (int ii= 0; ii < 2; ++ii)
+  for (ii= 0; ii < 2; ++ii)
   {
     execute(binary_set_item(key, key));
     flush_command(&cmd, cc, 0, ii == 0);
@@ -1200,6 +1219,8 @@
 
 static enum test_return test_ascii_quit(void)
 {
+  char buffer[80];
+
   /* Verify that quit handles unknown options */
   execute(send_string("quit foo bar\r\n"));
   execute(receive_error_response());
@@ -1212,7 +1233,6 @@
   execute(send_string("quit\r\n"));
 
   /* Socket should be closed now, read should return 0 */
-  char buffer[80];
   verify(timeout_io_op(sock, POLLIN, buffer, sizeof(buffer)) == 0);
   return TEST_PASS_RECONNECT;
 
@@ -1220,6 +1240,8 @@
 
 static enum test_return test_ascii_version(void)
 {
+  char buffer[256];
+
   /* Verify that version command handles unknown options */
   execute(send_string("version foo bar\r\n"));
   execute(receive_error_response());
@@ -1230,7 +1252,7 @@
 
   /* Verify that verify works */
   execute(send_string("version\r\n"));
-  char buffer[256];
+  
   execute(receive_line(buffer, sizeof(buffer)));
   verify(strncmp(buffer, "VERSION ", 8) == 0);
 
@@ -1318,18 +1340,20 @@
 
 static enum test_return ascii_get_unknown_value(char **key, char **value, ssize_t *ndata)
 {
+  char *end, *ptr;
+  unsigned long val;
   char buffer[1024];
 
   execute(receive_line(buffer, sizeof(buffer)));
   verify(strncmp(buffer, "VALUE ", 6) == 0);
-  char *end= strchr(buffer + 6, ' ');
+  end= strchr(buffer + 6, ' ');
   verify(end != NULL);
   *end= '\0';
   *key= strdup(buffer + 6);
   verify(*key != NULL);
-  char *ptr= end + 1;
+  ptr= end + 1;
 
-  unsigned long val= strtoul(ptr, &end, 10); /* flags */
+  val= strtoul(ptr, &end, 10); /* flags */
   verify(ptr != end);
   verify(val == 0);
   verify(end != NULL);
@@ -1353,6 +1377,8 @@
 
 static enum test_return ascii_get_value(const char *key, const char *value)
 {
+  char *ptr, *end;
+  unsigned long val;
 
   char buffer[1024];
   size_t datasize= strlen(value);
@@ -1361,10 +1387,9 @@
   execute(receive_line(buffer, sizeof(buffer)));
   verify(strncmp(buffer, "VALUE ", 6) == 0);
   verify(strncmp(buffer + 6, key, strlen(key)) == 0);
-  char *ptr= buffer + 6 + strlen(key) + 1;
-  char *end;
+  ptr= buffer + 6 + strlen(key) + 1;  
 
-  unsigned long val= strtoul(ptr, &end, 10); /* flags */
+  val= strtoul(ptr, &end, 10); /* flags */
   verify(ptr != end);
   verify(val == 0);
   verify(end != NULL);
@@ -1409,6 +1434,8 @@
 static enum test_return ascii_gets_value(const char *key, const char *value,
                                          unsigned long *cas)
 {
+  char *ptr, *end;
+  unsigned long val;
 
   char buffer[1024];
   size_t datasize= strlen(value);
@@ -1417,10 +1444,9 @@
   execute(receive_line(buffer, sizeof(buffer)));
   verify(strncmp(buffer, "VALUE ", 6) == 0);
   verify(strncmp(buffer + 6, key, strlen(key)) == 0);
-  char *ptr= buffer + 6 + strlen(key) + 1;
-  char *end;
-
-  unsigned long val= strtoul(ptr, &end, 10); /* flags */
+  ptr= buffer + 6 + strlen(key) + 1;
+  
+  val= strtoul(ptr, &end, 10); /* flags */
   verify(ptr != end);
   verify(val == 0);
   verify(end != NULL);
@@ -1555,6 +1581,8 @@
 
 static enum test_return test_ascii_delete_impl(const char *key, bool noreply)
 {
+  char buffer[1024];
+
   execute(ascii_set_item(key, "value"));
 
   execute(send_string("delete\r\n"));
@@ -1562,8 +1590,7 @@
   /* BUG: the server accepts delete a b */
   execute(send_string("delete a b c d e\r\n"));
   execute(receive_error_response());
-
-  char buffer[1024];
+  
   sprintf(buffer, "delete %s%s\r\n", key, noreply ? " noreply" : "");
   execute(send_string(buffer));
 
@@ -1606,11 +1633,13 @@
 
 static enum test_return test_ascii_gets(void)
 {
+  unsigned long cas;
+
   execute(ascii_set_item("test_ascii_gets", "value"));
 
   execute(send_string("gets\r\n"));
   execute(receive_error_response());
-  unsigned long cas;
+  
   execute(ascii_gets_item("test_ascii_gets", "value", true, &cas));
   execute(ascii_gets_item("test_ascii_gets_notfound", "value", false, &cas));
 
@@ -1619,7 +1648,11 @@
 
 static enum test_return test_ascii_mget(void)
 {
+  uint32_t x;
   const uint32_t nkeys= 5;
+  char *returned[5];
+  char buffer[5];
+
   const char * const keys[]= {
     "test_ascii_mget1",
     "test_ascii_mget2",
@@ -1629,7 +1662,7 @@
     "test_ascii_mget6"
   };
 
-  for (uint32_t x= 0; x < nkeys; ++x)
+  for (x= 0; x < nkeys; ++x)
     execute(ascii_set_item(keys[x], "value"));
 
   /* Ask for a key that doesn't exist as well */
@@ -1637,9 +1670,7 @@
                       "test_ascii_mget4 test_ascii_mget5 "
                       "test_ascii_mget6\r\n"));
 
-  char *returned[nkeys];
-
-  for (uint32_t x= 0; x < nkeys; ++x)
+  for (x= 0; x < nkeys; ++x)
   {
     ssize_t nbytes = 0;
     char *v= NULL;
@@ -1648,16 +1679,16 @@
     verify(memcmp(v, "value", 5) == 0);
     free(v);
   }
-
-  char buffer[5];
+  
   execute(retry_read(buffer, 5));
   verify(memcmp(buffer, "END\r\n", 5) == 0);
 
   /* verify that we got all the keys we expected */
-  for (uint32_t x= 0; x < nkeys; ++x)
+  for (x= 0; x < nkeys; ++x)
   {
+    uint32_t y;
     bool found= false;
-    for (uint32_t y= 0; y < nkeys; ++y)
+    for (y= 0; y < nkeys; ++y)
     {
       if (strcmp(keys[x], returned[y]) == 0)
       {
@@ -1668,7 +1699,7 @@
     verify(found);
   }
 
-  for (uint32_t x= 0; x < nkeys; ++x)
+  for (x= 0; x < nkeys; ++x)
     free(returned[x]);
 
   return TEST_PASS;
@@ -1676,11 +1707,12 @@
 
 static enum test_return test_ascii_incr_impl(const char* key, bool noreply)
 {
+  int x;
   char cmd[300];
   sprintf(cmd, "incr %s 1%s\r\n", key, noreply ? " noreply" : "");
 
   execute(ascii_set_item(key, "0"));
-  for (int x= 1; x < 11; ++x)
+  for (x= 1; x < 11; ++x)
   {
     execute(send_string(cmd));
 
@@ -1688,9 +1720,10 @@
       execute(test_ascii_version());
     else
     {
+      int val;
       char buffer[80];
       execute(receive_line(buffer, sizeof(buffer)));
-      int val= atoi(buffer);
+      val= atoi(buffer);
       verify(val == x);
     }
   }
@@ -1712,11 +1745,12 @@
 
 static enum test_return test_ascii_decr_impl(const char* key, bool noreply)
 {
+  int x;
   char cmd[300];
   sprintf(cmd, "decr %s 1%s\r\n", key, noreply ? " noreply" : "");
 
   execute(ascii_set_item(key, "9"));
-  for (int x= 8; x > -1; --x)
+  for (x= 8; x > -1; --x)
   {
     execute(send_string(cmd));
 
@@ -1724,9 +1758,10 @@
       execute(test_ascii_version());
     else
     {
+      int val;
       char buffer[80];
       execute(receive_line(buffer, sizeof(buffer)));
-      int val= atoi(buffer);
+      val= atoi(buffer);
       verify(val == x);
     }
   }
@@ -1801,6 +1836,7 @@
                                                bool noreply)
 {
   const char *value;
+  char cmd[400];
 
   if (append)
     value="hello";
@@ -1813,8 +1849,7 @@
     value=" world";
   else
     value="hello";
-
-  char cmd[400];
+  
   sprintf(cmd, "%s %s 0 0 %u%s\r\n%s\r\n",
           append ? "append" : "prepend",
           key, (unsigned int)strlen(value), noreply ? " noreply" : "",
@@ -1864,10 +1899,12 @@
 
 static enum test_return test_ascii_stat(void)
 {
+  char buffer[1024];
+
   execute(send_string("stats noreply\r\n"));
   execute(receive_error_response());
   execute(send_string("stats\r\n"));
-  char buffer[1024];
+  
   do {
     execute(receive_line(buffer, sizeof(buffer)));
   } while (strcmp(buffer, "END\r\n") != 0);
@@ -1948,7 +1985,7 @@
   int failed= 0;
   const char *hostname= "localhost";
   const char *port= "11211";
-  int cmd;
+  int cmd, ii;
   bool prompt= false;
   const char *testname= NULL;
 
@@ -2000,8 +2037,11 @@
     return 1;
   }
 
-  for (int ii= 0; testcases[ii].description != NULL; ++ii)
+  for (ii= 0; testcases[ii].description != NULL; ++ii)
   {
+    bool reconnect= false;
+    enum test_return ret;
+
     if (testname != NULL && strcmp(testcases[ii].description, testname) != 0)
        continue;
 
@@ -2011,8 +2051,10 @@
 
     if (prompt)
     {
+      char buffer[80] = {0};
+
       fprintf(stdout, "\nPress <return> when you are ready? ");
-      char buffer[80] = {0};
+      
       if (fgets(buffer, sizeof(buffer), stdin) != NULL) {
         if (strncmp(buffer, "skip", 4) == 0)
         {
@@ -2029,8 +2071,8 @@
       fflush(stdout);
     }
 
-    bool reconnect= false;
-    enum test_return ret= testcases[ii].function();
+    reconnect= false;
+    ret= testcases[ii].function();
     if (ret == TEST_FAIL)
     {
       reconnect= true;
 
=== modified file 'clients/memcat.c'
--- clients/memcat.c	2010-07-27 22:38:51 +0000
+++ clients/memcat.c	2011-01-13 03:40:43 +0000
@@ -11,10 +11,13 @@
 
 #include "config.h"
 
+#ifndef WIN32
+# include <unistd.h>
+#endif
+
 #include <stdio.h>
 #include <inttypes.h>
 #include <string.h>
-#include <unistd.h>
 #include <getopt.h>
 #include <libmemcached/memcached.h>
 
@@ -95,8 +98,8 @@
       {
         if (opt_verbose)
         {
-          printf("key: %s\nflags: %x\nlength: %zu\nvalue: ",
-                 argv[optind], flags, string_length);
+          printf("key: %s\nflags: %x\nlength: %lu\nvalue: ",
+                 argv[optind], flags, (unsigned long)string_length);
         }
 
         if (opt_file)
@@ -115,7 +118,7 @@
           written= fwrite(string, 1, string_length, fp);
           if (written != string_length) 
           {
-            fprintf(stderr, "error writing file (written %zu, should be %zu)\n", written, string_length);
+            fprintf(stderr, "error writing file (written %lu, should be %lu)\n", (unsigned long) written, (unsigned long) string_length);
             return_code= -1;
             break;
           }
 
=== modified file 'clients/memcp.c'
--- clients/memcp.c	2010-07-27 22:38:51 +0000
+++ clients/memcp.c	2011-01-13 03:40:43 +0000
@@ -11,19 +11,22 @@
 
 #include "config.h"
 
+#ifndef WIN32
+# include <unistd.h>
+# include <sys/types.h>
+# include <sys/types.h>
+# include <strings.h>
+#endif
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <inttypes.h>
-#include <unistd.h>
 #include <getopt.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <sys/types.h>
 #include <fcntl.h>
 #include <errno.h>
-#include <strings.h>
 #include <string.h>
 #include <sys/types.h>
+#include <sys/stat.h>
 #include <stdlib.h>
 #include <limits.h>
 
@@ -147,9 +150,9 @@
     if (opt_verbose)
     {
       static const char *opstr[] = { "set", "add", "replace" };
-      printf("op: %s\nsource file: %s\nlength: %zu\n"
+      printf("op: %s\nsource file: %s\nlength: %lu\n"
 	     "key: %s\nflags: %x\nexpires: %llu\n",
-	     opstr[opt_method - OPT_SET], argv[optind], (size_t)sbuf.st_size,
+	     opstr[opt_method - OPT_SET], argv[optind], (unsigned long)sbuf.st_size,
 	     ptr, opt_flags, (unsigned long long)opt_expires);
     }
 
 
=== modified file 'clients/memdump.c'
--- clients/memdump.c	2010-06-29 06:39:40 +0000
+++ clients/memdump.c	2011-01-13 03:40:43 +0000
@@ -11,17 +11,20 @@
 
 #include "config.h"
 
+#ifndef WIN32
+# include <unistd.h>
+# include <strings.h>
+#endif
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <inttypes.h>
-#include <unistd.h>
 #include <getopt.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <fcntl.h>
 #include <errno.h>
-#include <strings.h>
 #include <string.h>
 
 #include <libmemcached/memcached.h>
 
=== modified file 'clients/memerror.c'
--- clients/memerror.c	2010-06-29 06:39:40 +0000
+++ clients/memerror.c	2011-01-13 03:40:43 +0000
@@ -10,10 +10,13 @@
  */
 #include "config.h"
 
+#ifndef WIN32
+# include <unistd.h>
+#endif
+
 #include <stdio.h>
 #include <inttypes.h>
 #include <string.h>
-#include <unistd.h>
 #include <getopt.h>
 #include <stdlib.h>
 #include <libmemcached/memcached.h>
 
=== modified file 'clients/memflush.c'
--- clients/memflush.c	2010-06-29 06:39:40 +0000
+++ clients/memflush.c	2011-01-13 03:40:43 +0000
@@ -9,9 +9,12 @@
  *
  */
 #include "config.h"
+  
+#ifndef WIN32
+# include <unistd.h>
+#endif
 
 #include <stdio.h>
-#include <unistd.h>
 #include <string.h>
 #include <getopt.h>
 #include <libmemcached/memcached.h>
 
=== modified file 'clients/memrm.c'
--- clients/memrm.c	2010-07-27 22:38:51 +0000
+++ clients/memrm.c	2011-01-13 03:40:43 +0000
@@ -10,8 +10,11 @@
  */
 #include "config.h"
 
+#ifndef WIN32
+# include <unistd.h>
+#endif
+
 #include <stdio.h>
-#include <unistd.h>
 #include <getopt.h>
 #include <libmemcached/memcached.h>
 #include <string.h>
 
=== modified file 'clients/memstat.c'
--- clients/memstat.c	2010-07-28 20:59:36 +0000
+++ clients/memstat.c	2011-01-13 03:40:43 +0000
@@ -13,6 +13,10 @@
  */
 #include "config.h"
 
+#ifndef WIN32
+# include <sys/time.h>
+#endif
+
 #include <stdio.h>
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -20,7 +24,6 @@
 #include <fcntl.h>
 #include <string.h>
 #include <getopt.h>
-#include <sys/time.h>
 
 #include <libmemcached/memcached.h>
 
@@ -158,9 +161,12 @@
   else if (strcmp(analyze_mode, "latency") == 0)
   {
     memcached_st **servers;
-    uint32_t flags, server_count= memcached_server_count(memc);
+    uint32_t x, flags, server_count= memcached_server_count(memc);
     uint32_t num_of_tests= 32;
     const char *test_key= "libmemcached_test_key";
+    struct timeval start_time, end_time;
+    uint32_t slowest_server= 0;
+    long elapsed_time, slowest_time= 0;
 
     servers= malloc(sizeof(memcached_st*) * server_count);
     if (!servers)
@@ -169,7 +175,7 @@
       return;
     }
 
-    for (uint32_t x= 0; x < server_count; x++)
+    for (x= 0; x < server_count; x++)
     {
       memcached_server_instance_st instance=
         memcached_server_instance_by_position(memc, x);
@@ -192,17 +198,15 @@
     }
 
     printf("Network Latency Test:\n\n");
-    struct timeval start_time, end_time;
-    uint32_t slowest_server= 0;
-    long elapsed_time, slowest_time= 0;
 
-    for (uint32_t x= 0; x < server_count; x++)
+    for (x= 0; x < server_count; x++)
     {
+      uint32_t y;
       memcached_server_instance_st instance=
         memcached_server_instance_by_position(memc, x);
       gettimeofday(&start_time, NULL);
 
-      for (uint32_t y= 0; y < num_of_tests; y++)
+      for (y= 0; y < num_of_tests; y++)
       {
         size_t vlen;
         char *val= memcached_get(servers[x], test_key, strlen(test_key),
@@ -250,7 +254,7 @@
     }
     printf("\n");
 
-    for (uint32_t x= 0; x < server_count; x++)
+    for (x= 0; x < server_count; x++)
       memcached_free(servers[x]);
 
     free(servers);
 
=== modified file 'clients/utilities.c'
--- clients/utilities.c	2010-07-28 20:59:36 +0000
+++ clients/utilities.c	2011-01-13 03:40:43 +0000
@@ -1,231 +1,241 @@
-/* LibMemcached
- * Copyright (C) 2006-2009 Brian Aker
- * All rights reserved.
- *
- * Use and distribution licensed under the BSD license.  See
- * the COPYING file in the parent directory for full text.
- *
- * Summary:
- *
- */
-#include "config.h"
-
-#include <stdio.h>
-#include <ctype.h>
-#include <string.h>
-#include "utilities.h"
-
-
-long int timedif(struct timeval a, struct timeval b)
-{
-  long us, s;
-
-  us = (int)(a.tv_usec - b.tv_usec);
-  us /= 1000;
-  s = (int)(a.tv_sec - b.tv_sec);
-  s *= 1000;
-  return s + us;
-}
-
-void version_command(const char *command_name)
-{
-  printf("%s v%u.%u\n", command_name, 1U, 0U);
-  exit(0);
-}
-
-static const char *lookup_help(memcached_options option)
-{
-  switch (option)
-  {
-  case OPT_SERVERS: return("List which servers you wish to connect to.");
-  case OPT_VERSION: return("Display the version of the application and then exit.");
-  case OPT_HELP: return("Display this message and then exit.");
-  case OPT_VERBOSE: return("Give more details on the progression of the application.");
-  case OPT_DEBUG: return("Provide output only useful for debugging.");
-  case OPT_FLAG: return("Provide flag information for storage operation.");
-  case OPT_EXPIRE: return("Set the expire option for the object.");
-  case OPT_SET: return("Use set command with memcached when storing.");
-  case OPT_REPLACE: return("Use replace command with memcached when storing.");
-  case OPT_ADD: return("Use add command with memcached when storing.");
-  case OPT_SLAP_EXECUTE_NUMBER: return("Number of times to execute the given test.");
-  case OPT_SLAP_INITIAL_LOAD: return("Number of key pairs to load before executing tests.");
-  case OPT_SLAP_TEST: return("Test to run (currently \"get\" or \"set\").");
-  case OPT_SLAP_CONCURRENCY: return("Number of users to simulate with load.");
-  case OPT_SLAP_NON_BLOCK: return("Set TCP up to use non-blocking IO.");
-  case OPT_SLAP_TCP_NODELAY: return("Set TCP socket up to use nodelay.");
-  case OPT_FLUSH: return("Flush servers before running tests.");
-  case OPT_HASH: return("Select hash type.");
-  case OPT_BINARY: return("Switch to binary protocol.");
-  case OPT_ANALYZE: return("Analyze the provided servers.");
-  case OPT_UDP: return("Use UDP protocol when communicating with server.");
-  case OPT_USERNAME: return "Username to use for SASL authentication";
-  case OPT_PASSWD: return "Password to use for SASL authentication";
-  case OPT_FILE: return "Path to file in which to save result";
-  case OPT_STAT_ARGS: return "Argument for statistics";
-  default: WATCHPOINT_ASSERT(0);
-  };
-
-  WATCHPOINT_ASSERT(0);
-  return "forgot to document this function :)";
-}
-
-void help_command(const char *command_name, const char *description,
-                  const struct option *long_options,
-                  memcached_programs_help_st *options __attribute__((unused)))
-{
-  unsigned int x;
-
-  printf("%s v%u.%u\n\n", command_name, 1U, 0U);
-  printf("\t%s\n\n", description);
-  printf("Current options. A '=' means the option takes a value.\n\n");
-
-  for (x= 0; long_options[x].name; x++)
-  {
-    const char *help_message;
-
-    printf("\t --%s%c\n", long_options[x].name,
-           long_options[x].has_arg ? '=' : ' ');
-    if ((help_message= lookup_help(long_options[x].val)))
-      printf("\t\t%s\n", help_message);
-  }
-
-  printf("\n");
-  exit(0);
-}
-
-void process_hash_option(memcached_st *memc, char *opt_hash)
-{
-  uint64_t set;
-  memcached_return_t rc;
-
-  if (opt_hash == NULL)
-    return;
-
-  set= MEMCACHED_HASH_DEFAULT; /* Just here to solve warning */
-  if (!strcasecmp(opt_hash, "CRC"))
-    set= MEMCACHED_HASH_CRC;
-  else if (!strcasecmp(opt_hash, "FNV1_64"))
-    set= MEMCACHED_HASH_FNV1_64;
-  else if (!strcasecmp(opt_hash, "FNV1A_64"))
-    set= MEMCACHED_HASH_FNV1A_64;
-  else if (!strcasecmp(opt_hash, "FNV1_32"))
-    set= MEMCACHED_HASH_FNV1_32;
-  else if (!strcasecmp(opt_hash, "FNV1A_32"))
-    set= MEMCACHED_HASH_FNV1A_32;
-  else
-  {
-    fprintf(stderr, "hash: type not recognized %s\n", opt_hash);
-    exit(1);
-  }
-
-  rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set);
-  if (rc != MEMCACHED_SUCCESS)
-  {
-    fprintf(stderr, "hash: memcache error %s\n", memcached_strerror(memc, rc));
-    exit(1);
-  }
-}
-
-#ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
-static char *username;
-static char *passwd;
-
-static int get_username(void *context, int id, const char **result,
-                        unsigned int *len)
-{
-  (void)context;
-  if (!result || (id != SASL_CB_USER && id != SASL_CB_AUTHNAME))
-    return SASL_BADPARAM;
-
-  *result= username;
-  if (len)
-     *len= (username == NULL) ? 0 : (unsigned int)strlen(username);
-
-  return SASL_OK;
-}
-
-static int get_password(sasl_conn_t *conn, void *context, int id,
-                        sasl_secret_t **psecret)
-{
-  (void)context;
-  static sasl_secret_t* x;
-
-  if (!conn || ! psecret || id != SASL_CB_PASS)
-    return SASL_BADPARAM;
-
-  if (passwd == NULL)
-  {
-     *psecret= NULL;
-     return SASL_OK;
-  }
-
-  size_t len= strlen(passwd);
-  x = realloc(x, sizeof(sasl_secret_t) + len);
-  if (!x)
-    return SASL_NOMEM;
-
-  x->len = len;
-  strcpy((void *)x->data, passwd);
-
-  *psecret = x;
-  return SASL_OK;
-}
-
-/* callbacks we support */
-static sasl_callback_t sasl_callbacks[] = {
-  {
-    SASL_CB_USER, &get_username, NULL
-  }, {
-    SASL_CB_AUTHNAME, &get_username, NULL
-  }, {
-    SASL_CB_PASS, &get_password, NULL
-  }, {
-    SASL_CB_LIST_END, NULL, NULL
-  }
-};
-#endif
-
-bool initialize_sasl(memcached_st *memc, char *user, char *password)
-{
-#ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
-  if (user != NULL && password != NULL)
-  {
-    username= user;
-    passwd= password;
-
-    if (sasl_client_init(NULL) != SASL_OK)
-    {
-      fprintf(stderr, "Failed to initialize sasl library!\n");
-      return false;
-    }
-    memcached_set_sasl_callbacks(memc, sasl_callbacks);
-  }
-#else
-  (void)memc;
-  (void)user;
-  (void)password;
-#endif
-
-  return true;
-}
-
-void shutdown_sasl(void)
-{
-#ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
-  if (username != NULL || passwd != NULL)
-    sasl_done();
-#endif
-}
-
-void initialize_sockets(void)
-{
-  /* Define the function for all platforms to avoid #ifdefs in each program */
-#ifdef WIN32
-  WSADATA wsaData;
-  if (WSAStartup(MAKEWORD(2,0), &wsaData) != 0)
-  {
-    fprintf(stderr, "Socket Initialization Error. Program aborted\n");
-    exit(EXIT_FAILURE);
-  }
-#endif
-}
+/* LibMemcached
+ * Copyright (C) 2006-2009 Brian Aker
+ * All rights reserved.
+ *
+ * Use and distribution licensed under the BSD license.  See
+ * the COPYING file in the parent directory for full text.
+ *
+ * Summary:
+ *
+ */
+#include "config.h"
+
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+#include "utilities.h"
+
+#ifdef WIN32
+#include <assert.h>
+
+long long strtoll(char const* s, char** sN, int base)
+{
+  assert(sN == 0);
+  assert(base == 10);
+  return _atoi64(s);
+}
+#endif
+
+long int timedif(struct timeval a, struct timeval b)
+{
+  long us, s;
+
+  us = (int)(a.tv_usec - b.tv_usec);
+  us /= 1000;
+  s = (int)(a.tv_sec - b.tv_sec);
+  s *= 1000;
+  return s + us;
+}
+
+void version_command(const char *command_name)
+{
+  printf("%s v%u.%u\n", command_name, 1U, 0U);
+  exit(0);
+}
+
+static const char *lookup_help(memcached_options option)
+{
+  switch (option)
+  {
+  case OPT_SERVERS: return("List which servers you wish to connect to.");
+  case OPT_VERSION: return("Display the version of the application and then exit.");
+  case OPT_HELP: return("Display this message and then exit.");
+  case OPT_VERBOSE: return("Give more details on the progression of the application.");
+  case OPT_DEBUG: return("Provide output only useful for debugging.");
+  case OPT_FLAG: return("Provide flag information for storage operation.");
+  case OPT_EXPIRE: return("Set the expire option for the object.");
+  case OPT_SET: return("Use set command with memcached when storing.");
+  case OPT_REPLACE: return("Use replace command with memcached when storing.");
+  case OPT_ADD: return("Use add command with memcached when storing.");
+  case OPT_SLAP_EXECUTE_NUMBER: return("Number of times to execute the given test.");
+  case OPT_SLAP_INITIAL_LOAD: return("Number of key pairs to load before executing tests.");
+  case OPT_SLAP_TEST: return("Test to run (currently \"get\" or \"set\").");
+  case OPT_SLAP_CONCURRENCY: return("Number of users to simulate with load.");
+  case OPT_SLAP_NON_BLOCK: return("Set TCP up to use non-blocking IO.");
+  case OPT_SLAP_TCP_NODELAY: return("Set TCP socket up to use nodelay.");
+  case OPT_FLUSH: return("Flush servers before running tests.");
+  case OPT_HASH: return("Select hash type.");
+  case OPT_BINARY: return("Switch to binary protocol.");
+  case OPT_ANALYZE: return("Analyze the provided servers.");
+  case OPT_UDP: return("Use UDP protocol when communicating with server.");
+  case OPT_USERNAME: return "Username to use for SASL authentication";
+  case OPT_PASSWD: return "Password to use for SASL authentication";
+  case OPT_FILE: return "Path to file in which to save result";
+  case OPT_STAT_ARGS: return "Argument for statistics";
+  default: WATCHPOINT_ASSERT(0);
+  };
+
+  WATCHPOINT_ASSERT(0);
+  return "forgot to document this function :)";
+}
+
+void help_command(const char *command_name, const char *description,
+                  const struct option *long_options,
+                  memcached_programs_help_st *options __attribute__((unused)))
+{
+  unsigned int x;
+
+  printf("%s v%u.%u\n\n", command_name, 1U, 0U);
+  printf("\t%s\n\n", description);
+  printf("Current options. A '=' means the option takes a value.\n\n");
+
+  for (x= 0; long_options[x].name; x++)
+  {
+    const char *help_message;
+
+    printf("\t --%s%c\n", long_options[x].name,
+           long_options[x].has_arg ? '=' : ' ');
+    if ((help_message= lookup_help(long_options[x].val)))
+      printf("\t\t%s\n", help_message);
+  }
+
+  printf("\n");
+  exit(0);
+}
+
+void process_hash_option(memcached_st *memc, char *opt_hash)
+{
+  uint64_t set;
+  memcached_return_t rc;
+
+  if (opt_hash == NULL)
+    return;
+
+  set= MEMCACHED_HASH_DEFAULT; /* Just here to solve warning */
+  if (!strcasecmp(opt_hash, "CRC"))
+    set= MEMCACHED_HASH_CRC;
+  else if (!strcasecmp(opt_hash, "FNV1_64"))
+    set= MEMCACHED_HASH_FNV1_64;
+  else if (!strcasecmp(opt_hash, "FNV1A_64"))
+    set= MEMCACHED_HASH_FNV1A_64;
+  else if (!strcasecmp(opt_hash, "FNV1_32"))
+    set= MEMCACHED_HASH_FNV1_32;
+  else if (!strcasecmp(opt_hash, "FNV1A_32"))
+    set= MEMCACHED_HASH_FNV1A_32;
+  else
+  {
+    fprintf(stderr, "hash: type not recognized %s\n", opt_hash);
+    exit(1);
+  }
+
+  rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set);
+  if (rc != MEMCACHED_SUCCESS)
+  {
+    fprintf(stderr, "hash: memcache error %s\n", memcached_strerror(memc, rc));
+    exit(1);
+  }
+}
+
+#ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
+static char *username;
+static char *passwd;
+
+static int get_username(void *context, int id, const char **result,
+                        unsigned int *len)
+{
+  (void)context;
+  if (!result || (id != SASL_CB_USER && id != SASL_CB_AUTHNAME))
+    return SASL_BADPARAM;
+
+  *result= username;
+  if (len)
+     *len= (username == NULL) ? 0 : (unsigned int)strlen(username);
+
+  return SASL_OK;
+}
+
+static int get_password(sasl_conn_t *conn, void *context, int id,
+                        sasl_secret_t **psecret)
+{
+  (void)context;
+  static sasl_secret_t* x;
+
+  if (!conn || ! psecret || id != SASL_CB_PASS)
+    return SASL_BADPARAM;
+
+  if (passwd == NULL)
+  {
+     *psecret= NULL;
+     return SASL_OK;
+  }
+
+  size_t len= strlen(passwd);
+  x = realloc(x, sizeof(sasl_secret_t) + len);
+  if (!x)
+    return SASL_NOMEM;
+
+  x->len = len;
+  strcpy((void *)x->data, passwd);
+
+  *psecret = x;
+  return SASL_OK;
+}
+
+/* callbacks we support */
+static sasl_callback_t sasl_callbacks[] = {
+  {
+    SASL_CB_USER, &get_username, NULL
+  }, {
+    SASL_CB_AUTHNAME, &get_username, NULL
+  }, {
+    SASL_CB_PASS, &get_password, NULL
+  }, {
+    SASL_CB_LIST_END, NULL, NULL
+  }
+};
+#endif
+
+bool initialize_sasl(memcached_st *memc, char *user, char *password)
+{
+#ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
+  if (user != NULL && password != NULL)
+  {
+    username= user;
+    passwd= password;
+
+    if (sasl_client_init(NULL) != SASL_OK)
+    {
+      fprintf(stderr, "Failed to initialize sasl library!\n");
+      return false;
+    }
+    memcached_set_sasl_callbacks(memc, sasl_callbacks);
+  }
+#else
+  (void)memc;
+  (void)user;
+  (void)password;
+#endif
+
+  return true;
+}
+
+void shutdown_sasl(void)
+{
+#ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
+  if (username != NULL || passwd != NULL)
+    sasl_done();
+#endif
+}
+
+void initialize_sockets(void)
+{
+  /* Define the function for all platforms to avoid #ifdefs in each program */
+#ifdef WIN32
+  WSADATA wsaData;
+  if (WSAStartup(MAKEWORD(2,0), &wsaData) != 0)
+  {
+    fprintf(stderr, "Socket Initialization Error. Program aborted\n");
+    exit(EXIT_FAILURE);
+  }
+#endif
+}
 
=== modified file 'clients/utilities.h'
--- clients/utilities.h	2010-07-27 22:38:51 +0000
+++ clients/utilities.h	2011-01-13 03:40:43 +0000
@@ -34,6 +34,11 @@
 #define OPTIONSTRING const char*
 #endif
 
+#ifdef WIN32
+# define strcasecmp strcmp
+long long strtoll(char const* s, char** sN, int base);
+#endif
+
 typedef struct memcached_programs_help_st memcached_programs_help_st;
 
 struct memcached_programs_help_st
 
=== modified file 'libhashkit/common.h'
--- libhashkit/common.h	2010-09-13 12:27:18 +0000
+++ libhashkit/common.h	2011-01-13 03:40:43 +0000
@@ -17,6 +17,26 @@
 #include <stdlib.h>
 #include <math.h>
 
+#ifdef WIN32
+
+#include <limits.h>
+#define UINT32_MAX UINT_MAX
+
+#define __CONCAT(x, y) (x##y)
+
+#define INT8_C(value) ((int8_t) value)
+#define UINT8_C(value) ((uint8_t) __CONCAT(value, U))
+#define INT16_C(value) value
+#define UINT16_C(value) __CONCAT(value, U)
+#define INT32_C(value) __CONCAT(value, L)
+#define UINT32_C(value) __CONCAT(value, UL)
+#define INT64_C(value) __CONCAT(value, LL)
+#define UINT64_C(value) __CONCAT(value, ULL)
+#define INTMAX_C(value) __CONCAT(value, LL)
+#define UINTMAX_C(value) __CONCAT(value, ULL)
+
+#endif
+
 #include "hashkit.h"
 
 #ifdef __cplusplus
 
=== modified file 'libhashkit/fnv.c'
--- libhashkit/fnv.c	2010-01-19 23:39:13 +0000
+++ libhashkit/fnv.c	2011-01-13 03:40:43 +0000
@@ -18,8 +18,9 @@
 {
   /* Thanks to [e-mail] for the pointer */
   uint64_t hash= FNV_64_INIT;
+  size_t x;
 
-  for (size_t x= 0; x < key_length; x++)
+  for (x= 0; x < key_length; x++)
   {
     hash *= FNV_64_PRIME;
     hash ^= (uint64_t)key[x];
@@ -31,8 +32,9 @@
 uint32_t hashkit_fnv1a_64(const char *key, size_t key_length, void *context __attribute__((unused)))
 {
   uint32_t hash= (uint32_t) FNV_64_INIT;
+  size_t x;
 
-  for (size_t x= 0; x < key_length; x++)
+  for (x= 0; x < key_length; x++)
   {
     uint32_t val= (uint32_t)key[x];
     hash ^= val;
@@ -45,8 +47,9 @@
 uint32_t hashkit_fnv1_32(const char *key, size_t key_length, void *context __attribute__((unused)))
 {
   uint32_t hash= FNV_32_INIT;
+  size_t x;
 
-  for (size_t x= 0; x < key_length; x++)
+  for (x= 0; x < key_length; x++)
   {
     uint32_t val= (uint32_t)key[x];
     hash *= FNV_32_PRIME;
@@ -59,8 +62,9 @@
 uint32_t hashkit_fnv1a_32(const char *key, size_t key_length, void *context __attribute__((unused)))
 {
   uint32_t hash= FNV_32_INIT;
+  size_t x;
 
-  for (size_t x= 0; x < key_length; x++)
+  for (x= 0; x < key_length; x++)
   {
     uint32_t val= (uint32_t)key[x];
     hash ^= val;
 
=== modified file 'libhashkit/hashkit.c'
--- libhashkit/hashkit.c	2010-01-22 19:04:16 +0000
+++ libhashkit/hashkit.c	2011-01-13 03:40:43 +0000
@@ -8,18 +8,16 @@
 
 #include "common.h"
 
-static const hashkit_st global_default_hash= {
-  .base_hash= {
-    .function= hashkit_one_at_a_time,
-    .context= NULL
-  },
-  .flags= {
-    .is_base_same_distributed= false,
-  }
-};
+static hashkit_st global_default_hash;
 
 static inline bool _hashkit_init(hashkit_st *self)
 {
+  memset(&global_default_hash, 0, sizeof(global_default_hash));
+
+  global_default_hash.base_hash.function = hashkit_one_at_a_time;
+  global_default_hash.base_hash.context = NULL;
+  global_default_hash.flags.is_base_same_distributed = false;
+
   self->base_hash= global_default_hash.base_hash;
   self->distribution_hash= global_default_hash.base_hash;
   self->flags= global_default_hash.flags;
 
=== modified file 'libhashkit/visibility.h'
--- libhashkit/visibility.h	2009-12-17 17:28:30 +0000
+++ libhashkit/visibility.h	2011-01-13 03:40:43 +0000
@@ -32,16 +32,26 @@
 #  define HASHKIT_API __global
 #  define HASHKIT_LOCAL __hidden
 # elif defined(_MSC_VER)
-#  define HASHKIT_API extern __declspec(dllexport) 
-#  define HASHKIT_LOCAL
+#  if defined(LIBMEMCACHED_STATIC)
+#   define HASHKIT_API
+#   define HASHKIT_LOCAL
+#  else
+#   define HASHKIT_API extern __declspec(dllexport) 
+#   define HASHKIT_LOCAL
+#  endif 
 # else
 #  define HASHKIT_API
 #  define HASHKIT_LOCAL
 # endif /* defined(HAVE_VISIBILITY) */
 #else  /* defined(BUILDING_HASHKIT) */
 # if defined(_MSC_VER)
-#  define HASHKIT_API extern __declspec(dllimport) 
-#  define HASHKIT_LOCAL
+#  if defined(LIBMEMCACHED_STATIC)
+#   define HASHKIT_API
+#   define HASHKIT_LOCAL
+#  else
+#   define HASHKIT_API extern __declspec(dllimport) 
+#   define HASHKIT_LOCAL
+#  endif 
 # else
 #  define HASHKIT_API
 #  define HASHKIT_LOCAL
 
=== modified file 'libmemcached/allocators.c'
--- libmemcached/allocators.c	2010-01-18 22:58:20 +0000
+++ libmemcached/allocators.c	2011-01-13 03:40:43 +0000
@@ -23,7 +23,7 @@
 
 void *_libmemcached_calloc(const memcached_st *ptr, size_t nelem, size_t size, void *context)
 {
-  if (ptr->allocators.malloc != _libmemcached_malloc)
+  if (ptr->allocators->malloc != _libmemcached_malloc)
   {
      void *ret = _libmemcached_malloc(ptr, nelem * size, context);
      if (ret != NULL) 
@@ -35,16 +35,26 @@
   return calloc(nelem, size);
 }
 
-static const struct _allocators_st global_default_allocator= {
-  .calloc= _libmemcached_calloc,
-  .context= NULL,
-  .free= _libmemcached_free,
-  .malloc= _libmemcached_malloc,
-  .realloc= _libmemcached_realloc
-};
-
-struct _allocators_st memcached_allocators_return_default(void)
+struct _allocators_st *create_global_default_allocator()
 {
+  struct _allocators_st *allocator = (struct _allocators_st *) malloc(sizeof(struct _allocators_st));
+
+  allocator->calloc= _libmemcached_calloc;
+  allocator->context= NULL;
+  allocator->free= _libmemcached_free;
+  allocator->malloc= _libmemcached_malloc;
+  allocator->realloc= _libmemcached_realloc;
+
+  return allocator;
+}
+
+static struct _allocators_st *global_default_allocator = NULL;
+
+struct _allocators_st *memcached_allocators_return_default(void)
+{  
+  if (global_default_allocator == NULL)
+    global_default_allocator = create_global_default_allocator();
+
   return global_default_allocator;
 }
 
@@ -66,11 +76,11 @@
   }
   else
   {
-    ptr->allocators.malloc= mem_malloc;
-    ptr->allocators.free= mem_free;
-    ptr->allocators.realloc= mem_realloc;
-    ptr->allocators.calloc= mem_calloc;
-    ptr->allocators.context= context;
+    ptr->allocators->malloc= mem_malloc;
+    ptr->allocators->free= mem_free;
+    ptr->allocators->realloc= mem_realloc;
+    ptr->allocators->calloc= mem_calloc;
+    ptr->allocators->context= context;
   }
 
   return MEMCACHED_SUCCESS;
@@ -78,7 +88,7 @@
 
 void *memcached_get_memory_allocators_context(const memcached_st *ptr)
 {
-  return ptr->allocators.context;
+  return ptr->allocators->context;
 }
 
 void memcached_get_memory_allocators(const memcached_st *ptr,
@@ -87,8 +97,8 @@
                                      memcached_realloc_fn *mem_realloc,
                                      memcached_calloc_fn *mem_calloc)
 {
-   *mem_malloc= ptr->allocators.malloc;
-   *mem_free= ptr->allocators.free;
-   *mem_realloc= ptr->allocators.realloc;
-   *mem_calloc= ptr->allocators.calloc;
+   *mem_malloc= ptr->allocators->malloc;
+   *mem_free= ptr->allocators->free;
+   *mem_realloc= ptr->allocators->realloc;
+   *mem_calloc= ptr->allocators->calloc;
 }
 
=== modified file 'libmemcached/allocators.h'
--- libmemcached/allocators.h	2010-01-21 23:45:12 +0000
+++ libmemcached/allocators.h	2011-01-13 03:40:43 +0000
@@ -47,7 +47,7 @@
 void *_libmemcached_calloc(const memcached_st *ptr, size_t nelem, size_t size, void *context);
 
 LIBMEMCACHED_LOCAL
-struct _allocators_st memcached_allocators_return_default(void);
+struct _allocators_st *memcached_allocators_return_default(void);
 
 #ifdef __cplusplus
 }
 
=== modified file 'libmemcached/analyze.c'
--- libmemcached/analyze.c	2010-01-10 00:49:55 +0000
+++ libmemcached/analyze.c	2011-01-13 03:40:43 +0000
@@ -49,13 +49,15 @@
                            const uint64_t total_get_hits,
                            const uint64_t total_get_cmds)
 {
+  double temp;
+
   if (total_get_hits == 0 || total_get_cmds == 0)
   {
     result->pool_hit_ratio= 0;
     return;
   }
 
-  double temp= (double) (total_get_hits/total_get_cmds);
+  temp = (double) (total_get_hits/total_get_cmds);
   result->pool_hit_ratio= temp * 100;
 }
 
 
=== modified file 'libmemcached/auto.c'
--- libmemcached/auto.c	2010-09-13 12:26:17 +0000
+++ libmemcached/auto.c	2011-01-13 03:40:43 +0000
@@ -89,6 +89,11 @@
 {
   uint32_t server_key;
   memcached_server_write_instance_st instance;
+  protocol_binary_request_incr request;
+  memcached_return_t rc;
+
+  struct libmemcached_io_vector_st vector[3];
+
   bool no_reply= ptr->flags.no_reply;
 
   unlikely (memcached_server_count(ptr) == 0)
@@ -103,8 +108,9 @@
       cmd= PROTOCOL_BINARY_CMD_DECREMENTQ;
     if(cmd == PROTOCOL_BINARY_CMD_INCREMENT)
       cmd= PROTOCOL_BINARY_CMD_INCREMENTQ;
-  }
-  protocol_binary_request_incr request= {.bytes= {0}};
+  }  
+
+  memset(&request, 0, sizeof(request));
 
   request.message.header.request.magic= PROTOCOL_BINARY_REQ;
   request.message.header.request.opcode= cmd;
@@ -116,14 +122,13 @@
   request.message.body.initial= htonll(initial);
   request.message.body.expiration= htonl((uint32_t) expiration);
 
-  struct libmemcached_io_vector_st vector[]=
-  {
-    { .length= sizeof(request.bytes), .buffer= request.bytes },
-    { .length= ptr->prefix_key_length, .buffer= ptr->prefix_key },
-    { .length= key_length, .buffer= key }
-  };
+  vector[0].length= sizeof(request.bytes); 
+  vector[0].buffer= request.bytes;
+  vector[1].length= ptr->prefix_key_length;
+  vector[1].buffer= ptr->prefix_key;
+  vector[2].length= key_length;
+  vector[2].buffer= key;
 
-  memcached_return_t rc;
   if ((rc= memcached_vdo(instance, vector, 3, true)) != MEMCACHED_SUCCESS)
   {
     memcached_io_reset(instance);
 
=== modified file 'libmemcached/behavior.c'
--- libmemcached/behavior.c	2010-07-27 22:38:51 +0000
+++ libmemcached/behavior.c	2011-01-13 03:40:43 +0000
@@ -178,6 +178,9 @@
   case MEMCACHED_BEHAVIOR_CORK:
       {
         memcached_server_write_instance_st instance;
+        memcached_return_t rc;
+        memcached_ternary_t enabled;
+
         bool action= set_flag(data);
 
         if (action == false)
@@ -191,16 +194,14 @@
           return MEMCACHED_NO_SERVERS;
 
 
-        /* We just try the first host, and if it is down we return zero */
-        memcached_return_t rc;
+        /* We just try the first host, and if it is down we return zero */        
         rc= memcached_connect(instance);
         if (rc != MEMCACHED_SUCCESS)
         {
           return rc;
         }
 
-        /* Now we test! */
-        memcached_ternary_t enabled;
+        /* Now we test! */        
         enabled= test_cork(instance, true);
 
         switch (enabled)
 
=== modified file 'libmemcached/byteorder.c'
--- libmemcached/byteorder.c	2010-09-02 08:23:44 +0000
+++ libmemcached/byteorder.c	2011-01-13 03:40:43 +0000
@@ -19,7 +19,9 @@
   /* Little endian, flip the bytes around until someone makes a faster/better
    * way to do this. */
   uint64_t rv= 0;
-  for (uint8_t x= 0; x < 8; x++)
+  uint8_t x;
+
+  for (x= 0; x < 8; x++)
   {
     rv= (rv << 8) | (in & 0xff);
     in >>= 8;
 
=== modified file 'libmemcached/common.h'
--- libmemcached/common.h	2010-07-27 22:38:51 +0000
+++ libmemcached/common.h	2011-01-13 03:40:43 +0000
@@ -21,10 +21,18 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <strings.h>
+
+#ifdef WIN32
+# define snprintf _snprintf
+# define strtoull strtoul
+#else
+# include <strings.h>
+# include <unistd.h>
+#endif
+
 #include <ctype.h>
 #include <sys/types.h>
-#include <unistd.h>
+
 #include <limits.h>
 #include <errno.h>
 #include <fcntl.h>
@@ -204,22 +212,22 @@
 
 static inline void libmemcached_free(const memcached_st *ptr, void *mem)
 {
-  ptr->allocators.free(ptr, mem, ptr->allocators.context);
+  ptr->allocators->free(ptr, mem, ptr->allocators->context);
 }
 
 static inline void *libmemcached_malloc(const memcached_st *ptr, const size_t size)
 {
-  return ptr->allocators.malloc(ptr, size, ptr->allocators.context);
+  return ptr->allocators->malloc(ptr, size, ptr->allocators->context);
 }
 
 static inline void *libmemcached_realloc(const memcached_st *ptr, void *mem, const size_t size)
 {
-  return ptr->allocators.realloc(ptr, mem, size, ptr->allocators.context);
+  return ptr->allocators->realloc(ptr, mem, size, ptr->allocators->context);
 }
 
 static inline void *libmemcached_calloc(const memcached_st *ptr, size_t nelem, size_t size)
 {
-  return ptr->allocators.calloc(ptr, nelem, size, ptr->allocators.context);
+  return ptr->allocators->calloc(ptr, nelem, size, ptr->allocators->context);
 }
 
 #ifdef __cplusplus
 
=== modified file 'libmemcached/connect.c'
--- libmemcached/connect.c	2010-09-13 06:05:34 +0000
+++ libmemcached/connect.c	2011-01-13 03:40:43 +0000
@@ -10,22 +10,26 @@
  */
 
 #include "common.h"
-#include <sys/time.h>
+#ifndef WIN32
+# include <sys/time.h>
+#endif
 #include <time.h>
 
 static memcached_return_t connect_poll(memcached_server_st *ptr)
 {
+  int timeout;
+
+  int error;
+  size_t loop_max= 5;
+
   struct pollfd fds[1];
   fds[0].fd = ptr->fd;
   fds[0].events = POLLOUT;
 
-  int timeout= ptr->root->connect_timeout;
+  timeout= ptr->root->connect_timeout;
   if (ptr->root->flags.no_block == true)
     timeout= -1;
 
-  int error;
-  size_t loop_max= 5;
-
   while (--loop_max) // Should only loop on cases of ERESTART or EINTR
   {
     error= poll(fds, 1, timeout);
@@ -371,7 +375,7 @@
 static memcached_return_t network_connect(memcached_server_st *ptr)
 {
   bool timeout_error_occured= false;
-
+  struct addrinfo *use;
 
   WATCHPOINT_ASSERT(ptr->fd == INVALID_SOCKET);
   WATCHPOINT_ASSERT(ptr->cursor_active == 0);
@@ -386,7 +390,7 @@
     ptr->options.sockaddr_inited= true;
   }
 
-  struct addrinfo *use= ptr->address_info;
+  use= ptr->address_info;
   /* Create the socket */
   while (use != NULL)
   {
 
=== modified file 'libmemcached/delete.c'
--- libmemcached/delete.c	2010-09-13 12:26:17 +0000
+++ libmemcached/delete.c	2011-01-13 03:40:43 +0000
@@ -25,6 +25,7 @@
   char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
   uint32_t server_key;
   memcached_server_write_instance_st instance;
+  bool no_reply;
 
   LIBMEMCACHED_MEMCACHED_DELETE_START();
 
@@ -41,7 +42,7 @@
 
   to_write= (ptr->flags.buffer_requests) ? false : true;
 
-  bool no_reply= (ptr->flags.no_reply);
+  no_reply= (ptr->flags.no_reply);
 
   if (ptr->flags.binary_protocol)
   {
@@ -153,7 +154,12 @@
                                                bool flush)
 {
   memcached_server_write_instance_st instance;
-  protocol_binary_request_delete request= {.bytes= {0}};
+  protocol_binary_request_delete request;
+  struct libmemcached_io_vector_st vector[3];
+  memcached_return_t rc;
+  uint32_t x;
+
+  memset(&request, 0, sizeof(request));
 
   instance= memcached_server_instance_fetch(ptr, server_key);
 
@@ -175,14 +181,14 @@
       memcached_io_write(instance, NULL, 0, true);
   }
 
-  struct libmemcached_io_vector_st vector[]=
-  {
-    { .length= sizeof(request.bytes), .buffer= request.bytes},
-    { .length= ptr->prefix_key_length, .buffer= ptr->prefix_key },
-    { .length= key_length, .buffer= key },
-  };
+  vector[0].length= sizeof(request.bytes);
+  vector[0].buffer= request.bytes;
+  vector[1].length= ptr->prefix_key_length;
+  vector[1].buffer= ptr->prefix_key;
+  vector[2].length= key_length;
+  vector[2].buffer= key;
 
-  memcached_return_t rc= MEMCACHED_SUCCESS;
+  rc= MEMCACHED_SUCCESS;
 
   if ((rc= memcached_vdo(instance, vector,  3, flush)) != MEMCACHED_SUCCESS)
   {
@@ -194,7 +200,7 @@
   {
     request.message.header.request.opcode= PROTOCOL_BINARY_CMD_DELETEQ;
 
-    for (uint32_t x= 0; x < ptr->number_of_replicas; ++x)
+    for (x= 0; x < ptr->number_of_replicas; ++x)
     {
       memcached_server_write_instance_st replica;
 
 
=== modified file 'libmemcached/do.c'
--- libmemcached/do.c	2010-09-13 12:26:17 +0000
+++ libmemcached/do.c	2011-01-13 03:40:43 +0000
@@ -56,6 +56,8 @@
 {
   memcached_return_t rc;
   ssize_t sent_length;
+  size_t command_length;
+  uint32_t x;
 
   WATCHPOINT_ASSERT(count);
   WATCHPOINT_ASSERT(vector);
@@ -78,8 +80,8 @@
 
   sent_length= memcached_io_writev(ptr, vector, count, with_flush);
 
-  size_t command_length= 0;
-  for (uint32_t x= 0; x < count; ++x, vector++)
+  command_length= 0;
+  for (x= 0; x < count; ++x, vector++)
   {
     command_length+= vector->length;
   }
 
=== modified file 'libmemcached/fetch.c'
--- libmemcached/fetch.c	2010-04-01 21:30:52 +0000
+++ libmemcached/fetch.c	2011-01-13 03:40:43 +0000
@@ -91,12 +91,13 @@
 {
   memcached_result_st *result= &ptr->result;
   memcached_return_t rc= MEMCACHED_FAILURE;
+  uint32_t x;
 
   while ((result= memcached_fetch_result(ptr, result, &rc)) != NULL) 
   {
     if (rc == MEMCACHED_SUCCESS)
     {
-      for (uint32_t x= 0; x < number_of_callbacks; x++)
+      for (x= 0; x < number_of_callbacks; x++)
       {
         rc= (*callback[x])(ptr, result, context);
         if (rc != MEMCACHED_SUCCESS)
 
=== modified file 'libmemcached/flush.c'
--- libmemcached/flush.c	2010-04-02 19:55:21 +0000
+++ libmemcached/flush.c	2011-01-13 03:40:43 +0000
@@ -55,7 +55,10 @@
 static memcached_return_t memcached_flush_binary(memcached_st *ptr, 
                                                  time_t expiration)
 {
-  protocol_binary_request_flush request= {.bytes= {0}};
+  protocol_binary_request_flush request;
+  uint32_t x;
+
+  memset(&request, 0, sizeof(request));
 
   unlikely (memcached_server_count(ptr) == 0)
     return MEMCACHED_NO_SERVERS;
@@ -67,7 +70,7 @@
   request.message.header.request.bodylen= htonl(request.message.header.request.extlen);
   request.message.body.expiration= htonl((uint32_t) expiration);
 
-  for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
+  for (x= 0; x < memcached_server_count(ptr); x++)
   {
     memcached_server_write_instance_st instance=
       memcached_server_instance_fetch(ptr, x);
@@ -88,7 +91,7 @@
     } 
   }
 
-  for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
+  for (x= 0; x < memcached_server_count(ptr); x++)
   {
     memcached_server_write_instance_st instance=
       memcached_server_instance_fetch(ptr, x);
 
=== modified file 'libmemcached/flush_buffers.c'
--- libmemcached/flush_buffers.c	2010-02-13 02:23:49 +0000
+++ libmemcached/flush_buffers.c	2011-01-13 03:40:43 +0000
@@ -3,8 +3,9 @@
 memcached_return_t memcached_flush_buffers(memcached_st *memc)
 {
   memcached_return_t ret= MEMCACHED_SUCCESS;
+  uint32_t x;
 
-  for (uint32_t x= 0; x < memcached_server_count(memc); ++x)
+  for (x= 0; x < memcached_server_count(memc); ++x)
   {
     memcached_server_write_instance_st instance=
       memcached_server_instance_fetch(memc, x);
 
=== modified file 'libmemcached/get.c'
--- libmemcached/get.c	2010-09-13 12:26:17 +0000
+++ libmemcached/get.c	2011-01-13 03:40:43 +0000
@@ -149,6 +149,8 @@
   uint8_t get_command_length= 4;
   unsigned int master_server_key= (unsigned int)-1; /* 0 is a valid server id! */
   bool is_master_key_set= false;
+  uint32_t x;
+  struct libmemcached_io_vector_st vector[4];
 
   unlikely (ptr->flags.use_udp)
     return MEMCACHED_NOT_SUPPORTED;
@@ -178,7 +180,7 @@
 
     It might be optimum to bounce the connection if count > some number.
   */
-  for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
+  for (x= 0; x < memcached_server_count(ptr); x++)
   {
     memcached_server_write_instance_st instance=
       memcached_server_instance_fetch(ptr, x);
@@ -211,7 +213,7 @@
     If a server fails we warn about errors and start all over with sending keys
     to the server.
   */
-  for (uint32_t x= 0; x < number_of_keys; x++)
+  for (x= 0; x < number_of_keys; x++)
   {
     memcached_server_write_instance_st instance;
     uint32_t server_key;
@@ -227,14 +229,14 @@
 
     instance= memcached_server_instance_fetch(ptr, server_key);
 
-    struct libmemcached_io_vector_st vector[]=
-    {
-      { .length= get_command_length, .buffer= get_command },
-      { .length= ptr->prefix_key_length, .buffer= ptr->prefix_key },
-      { .length= key_length[x], .buffer= keys[x] },
-      { .length= 1, .buffer= " " }
-    };
-
+    vector[0].length= get_command_length;
+    vector[0].buffer= get_command;
+    vector[1].length= ptr->prefix_key_length;
+    vector[1].buffer= ptr->prefix_key;
+    vector[2].length= key_length[x];
+    vector[2].buffer= keys[x];
+    vector[3].length= 1;
+    vector[3].buffer= " ";
 
     if (memcached_server_response_count(instance) == 0)
     {
@@ -266,7 +268,7 @@
   /*
     Should we muddle on if some servers are dead?
   */
-  for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
+  for (x= 0; x < memcached_server_count(ptr); x++)
   {
     memcached_server_write_instance_st instance=
       memcached_server_instance_fetch(ptr, x);
@@ -319,16 +321,16 @@
                                                  void *context,
                                                  unsigned int number_of_callbacks)
 {
+  memcached_return_t rc;
+  memcached_callback_st *original_callbacks= ptr->callbacks;
+  memcached_callback_st cb;
+
   if ((ptr->flags.binary_protocol) == 0)
     return MEMCACHED_NOT_SUPPORTED;
 
-  memcached_return_t rc;
-  memcached_callback_st *original_callbacks= ptr->callbacks;
-  memcached_callback_st cb= {
-    .callback= callback,
-    .context= context,
-    .number_of_callback= number_of_callbacks
-  };
+  cb.callback= callback;
+  cb.context= context;
+  cb.number_of_callback= number_of_callbacks;
 
   ptr->callbacks= &cb;
   rc= memcached_mget_by_key(ptr, master_key, master_key_length, keys,
@@ -345,6 +347,7 @@
                                              size_t number_of_keys, bool mget_mode)
 {
   memcached_return_t rc= MEMCACHED_NOTFOUND;
+  uint32_t x;
 
   int flush= number_of_keys == 1;
 
@@ -352,10 +355,15 @@
     If a server fails we warn about errors and start all over with sending keys
     to the server.
   */
-  for (uint32_t x= 0; x < number_of_keys; ++x)
+  for (x= 0; x < number_of_keys; ++x)
   {
     uint32_t server_key;
     memcached_server_write_instance_st instance;
+    protocol_binary_request_getk request;
+    memcached_return_t vk;
+    struct libmemcached_io_vector_st vector[3];
+
+    memset(&request, 0, sizeof(request));
 
     if (is_master_key_set)
     {
@@ -375,14 +383,12 @@
         continue;
     }
 
-    protocol_binary_request_getk request= {.bytes= {0}};
     request.message.header.request.magic= PROTOCOL_BINARY_REQ;
     if (mget_mode)
       request.message.header.request.opcode= PROTOCOL_BINARY_CMD_GETKQ;
     else
       request.message.header.request.opcode= PROTOCOL_BINARY_CMD_GETK;
-
-    memcached_return_t vk;
+    
     vk= memcached_validate_key_length(key_length[x],
                                       ptr->flags.binary_protocol);
     unlikely (vk != MEMCACHED_SUCCESS)
@@ -399,12 +405,12 @@
     request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES;
     request.message.header.request.bodylen= htonl((uint32_t)( key_length[x] + ptr->prefix_key_length));
 
-    struct libmemcached_io_vector_st vector[]=
-    {
-      { .length= sizeof(request.bytes), .buffer= request.bytes },
-      { .length= ptr->prefix_key_length, .buffer= ptr->prefix_key },
-      { .length= key_length[x], .buffer= keys[x] }
-    };
+    vector[0].length= sizeof(request.bytes);
+    vector[0].buffer= request.bytes;
+    vector[1].length= ptr->prefix_key_length;
+    vector[1].buffer= ptr->prefix_key;
+    vector[2].length= key_length[x];
+    vector[2].buffer= keys[x];
 
     if (memcached_io_writev(instance, vector, 3, flush) == -1)
     {
@@ -427,12 +433,16 @@
     /*
      * Send a noop command to flush the buffers
    */
-    protocol_binary_request_noop request= {.bytes= {0}};
+    uint32_t x;
+    protocol_binary_request_noop request;
+    
+    memset(&request, 0, sizeof(request));
+    
     request.message.header.request.magic= PROTOCOL_BINARY_REQ;
     request.message.header.request.opcode= PROTOCOL_BINARY_CMD_NOOP;
     request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES;
 
-    for (uint32_t x= 0; x < memcached_server_count(ptr); ++x)
+    for (x= 0; x < memcached_server_count(ptr); ++x)
     {
       memcached_server_write_instance_st instance=
         memcached_server_instance_fetch(ptr, x);
@@ -471,23 +481,30 @@
   memcached_return_t rc= MEMCACHED_NOTFOUND;
   uint32_t start= 0;
   uint64_t randomize_read= memcached_behavior_get(ptr, MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ);
+  uint32_t replica;
 
   if (randomize_read)
     start= (uint32_t)random() % (uint32_t)(ptr->number_of_replicas + 1);
 
   /* Loop for each replica */
-  for (uint32_t replica= 0; replica <= ptr->number_of_replicas; ++replica)
+  for (replica= 0; replica <= ptr->number_of_replicas; ++replica)
   {
     bool success= true;
-
-    for (uint32_t x= 0; x < number_of_keys; ++x)
+    uint32_t x;
+    protocol_binary_request_getk request;
+    struct libmemcached_io_vector_st vector[3];
+
+    memset(&request, 0, sizeof(request));
+
+    for (x= 0; x < number_of_keys; ++x)
     {
       memcached_server_write_instance_st instance;
+      uint32_t server;
 
       if (hash[x] == memcached_server_count(ptr))
         continue; /* Already successfully sent */
 
-      uint32_t server= hash[x] + replica;
+      server= hash[x] + replica;
 
       /* In case of randomized reads */
       if (randomize_read && ((server + start) <= (hash[x] + ptr->number_of_replicas)))
@@ -512,16 +529,12 @@
           continue;
         }
       }
-
-      protocol_binary_request_getk request= {
-        .message.header.request= {
-          .magic= PROTOCOL_BINARY_REQ,
-          .opcode= PROTOCOL_BINARY_CMD_GETK,
-          .keylen= htons((uint16_t)(key_length[x] + ptr->prefix_key_length)),
-          .datatype= PROTOCOL_BINARY_RAW_BYTES,
-          .bodylen= htonl((uint32_t)(key_length[x] + ptr->prefix_key_length))
-        }
-      };
+     
+      request.message.header.request.magic= PROTOCOL_BINARY_REQ;
+      request.message.header.request.opcode= PROTOCOL_BINARY_CMD_GETK;
+      request.message.header.request.keylen= htons((uint16_t)(key_length[x] + ptr->prefix_key_length));
+      request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES;
+      request.message.header.request.bodylen= htonl((uint32_t)(key_length[x] + ptr->prefix_key_length));
 
       /*
        * We need to disable buffering to actually know that the request was
@@ -533,12 +546,12 @@
        * that we might have processed some of the responses etc. For now,
        * just make sure we work _correctly_
      */
-      struct libmemcached_io_vector_st vector[]=
-      {
-        { .length= sizeof(request.bytes), .buffer= request.bytes },
-        { .length= ptr->prefix_key_length, .buffer= ptr->prefix_key },
-        { .length= key_length[x], .buffer= keys[x] }
-      };
+      vector[0].length= sizeof(request.bytes);
+      vector[0].buffer= request.bytes;
+      vector[1].length= ptr->prefix_key_length;
+      vector[1].buffer= ptr->prefix_key;
+      vector[2].length= key_length[x];
+      vector[2].buffer= keys[x];
 
       if (memcached_io_writev(instance, vector, 3, true) == -1)
       {
@@ -578,6 +591,7 @@
   {
     uint32_t* hash;
     bool* dead_servers;
+    size_t x;
 
     hash= libmemcached_malloc(ptr, sizeof(uint32_t) * number_of_keys);
     dead_servers= libmemcached_calloc(ptr, memcached_server_count(ptr), sizeof(bool));
@@ -591,14 +605,14 @@
 
     if (is_master_key_set)
     {
-      for (size_t x= 0; x < number_of_keys; x++)
+      for (x= 0; x < number_of_keys; x++)
       {
         hash[x]= master_server_key;
       }
     }
     else
     {
-      for (size_t x= 0; x < number_of_keys; x++)
+      for (x= 0; x < number_of_keys; x++)
       {
         hash[x]= memcached_generate_hash_with_redistribution(ptr, keys[x], key_length[x]);
       }
 
=== modified file 'libmemcached/hash.c'
--- libmemcached/hash.c	2010-03-02 22:16:10 +0000
+++ libmemcached/hash.c	2011-01-13 03:40:43 +0000
@@ -30,11 +30,12 @@
   case MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA:
   case MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY:
     {
+      memcached_continuum_item_st *begin, *end, *left, *right, *middle;
       uint32_t num= ptr->continuum_points_counter;
       WATCHPOINT_ASSERT(ptr->continuum);
 
       hash= hash;
-      memcached_continuum_item_st *begin, *end, *left, *right, *middle;
+      
       begin= left= ptr->continuum;
       end= right= ptr->continuum + num;
 
@@ -75,7 +76,8 @@
   if (ptr->flags.hash_with_prefix_key)
   {
     size_t temp_length= ptr->prefix_key_length + key_length;
-    char temp[temp_length];
+    char *temp = (char *) malloc(temp_length);
+    uint32_t hash;
 
     if (temp_length > MEMCACHED_MAX_KEY -1)
       return 0;
@@ -83,7 +85,11 @@
     strncpy(temp, ptr->prefix_key, ptr->prefix_key_length);
     strncpy(temp + ptr->prefix_key_length, key, key_length);
 
-    return generate_hash(ptr, temp, temp_length);
+    hash = generate_hash(ptr, temp, temp_length);
+
+    free(temp);
+
+    return hash;
   }
   else
   {
 
=== modified file 'libmemcached/hosts.c'
--- libmemcached/hosts.c	2010-04-05 22:27:54 +0000
+++ libmemcached/hosts.c	2011-01-13 03:40:43 +0000
@@ -207,6 +207,7 @@
       {
         char sort_host[MEMCACHED_MAX_HOST_SORT_LENGTH]= "";
         size_t sort_host_length;
+        uint32_t x;
 
         // Spymemcached ketema key format is: hostname/ip:port-index
         // If hostname is not available then: /ip:port-index
@@ -223,7 +224,7 @@
 
         if (is_ketama_weighted)
         {
-          for (uint32_t x= 0; x < pointer_per_hash; x++)
+          for (x= 0; x < pointer_per_hash; x++)
           {
              value= ketama_server_hash(sort_host, sort_host_length, x);
              ptr->continuum[continuum_index].index= host_index;
@@ -246,6 +247,7 @@
       {
         char sort_host[MEMCACHED_MAX_HOST_SORT_LENGTH]= "";
         size_t sort_host_length;
+        uint32_t x;
 
         if (list[host_index].port == MEMCACHED_DEFAULT_PORT)
         {
@@ -267,7 +269,7 @@
 
         if (is_ketama_weighted)
         {
-          for (uint32_t x = 0; x < pointer_per_hash; x++)
+          for (x = 0; x < pointer_per_hash; x++)
           {
              value= ketama_server_hash(sort_host, sort_host_length, x);
              ptr->continuum[continuum_index].index= host_index;
@@ -305,7 +307,7 @@
 
 memcached_return_t memcached_server_push(memcached_st *ptr, const memcached_server_list_st list)
 {
-  uint32_t count;
+  uint32_t count, x;
   memcached_server_st *new_host_list;
 
   if (! list)
@@ -320,7 +322,7 @@
 
   memcached_server_list_set(ptr, new_host_list);
 
-  for (uint32_t x= 0; x < count; x++)
+  for (x= 0; x < count; x++)
   {
     memcached_server_write_instance_st instance;
 
 
=== modified file 'libmemcached/io.c'
--- libmemcached/io.c	2010-09-15 00:44:32 +0000
+++ libmemcached/io.c	2011-01-13 03:40:43 +0000
@@ -24,12 +24,13 @@
 static memcached_return_t io_wait(memcached_server_write_instance_st ptr,
                                   memc_read_or_write read_or_write)
 {
-  struct pollfd fds= {
-    .fd= ptr->fd,
-    .events = POLLIN
-  };
-  int error;
+  struct pollfd fds;
+  int error, timeout;
+  size_t loop_max;
 
+  fds.fd= ptr->fd;
+  fds.events = POLLIN;
+  
   if (read_or_write == MEM_WRITE) /* write */
   {
     fds.events= POLLOUT;
@@ -55,11 +56,11 @@
       return MEMCACHED_FAILURE;
   }
 
-  int timeout= ptr->root->poll_timeout;
+  timeout= ptr->root->poll_timeout;
   if (ptr->root->flags.no_block == false)
     timeout= -1;
 
-  size_t loop_max= 5;
+  loop_max= 5;
   while (--loop_max) // While loop is for ERESTART or EINTR
   {
     error= poll(&fds, 1, timeout);
@@ -164,6 +165,11 @@
  */
   if (ptr->root->callbacks != NULL && ptr->root->flags.use_udp == false)
   {
+    uint32_t x;
+    char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
+    memcached_return_t error;
+    memcached_st *root;
+
     /*
      * We might have responses... try to read them out and fire
      * callbacks
@@ -171,10 +177,8 @@
     memcached_callback_st cb= *ptr->root->callbacks;
 
     memcached_set_processing_input((memcached_st *)ptr->root, true);
-
-    char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
-    memcached_return_t error;
-    memcached_st *root= (memcached_st *)ptr->root;
+        
+    root= (memcached_st *) ptr->root;
     error= memcached_response(ptr, buffer, sizeof(buffer),
                               &root->result);
 
@@ -182,7 +186,7 @@
 
     if (error == MEMCACHED_SUCCESS)
     {
-      for (unsigned int x= 0; x < cb.number_of_callback; x++)
+      for (x= 0; x < cb.number_of_callback; x++)
       {
         error= (*cb.callback[x])(ptr->root, &root->result, cb.context);
         if (error != MEMCACHED_SUCCESS)
@@ -281,8 +285,10 @@
         }
         else if (data_read == SOCKET_ERROR)
         {
-          ptr->cached_errno= get_socket_errno();
           memcached_return_t rc= MEMCACHED_ERRNO;
+
+          ptr->cached_errno= get_socket_errno();
+          
           switch (get_socket_errno())
           {
           case EWOULDBLOCK:
@@ -443,9 +449,10 @@
                             const struct libmemcached_io_vector_st *vector,
                             size_t number_of, bool with_flush)
 {
+  size_t x;
   ssize_t total= 0;
 
-  for (size_t x= 0; x < number_of; x++, vector++)
+  for (x= 0; x < number_of; x++, vector++)
   {
     ssize_t returnable;
 
@@ -496,8 +503,10 @@
 #define MAX_SERVERS_TO_POLL 100
   struct pollfd fds[MAX_SERVERS_TO_POLL];
   unsigned int host_index= 0;
+  uint32_t x, y;
+  int err;
 
-  for (uint32_t x= 0;
+  for (x= 0;
        x< memcached_server_count(memc) && host_index < MAX_SERVERS_TO_POLL;
        ++x)
   {
@@ -519,7 +528,7 @@
   if (host_index < 2)
   {
     /* We have 0 or 1 server with pending events.. */
-    for (uint32_t x= 0; x< memcached_server_count(memc); ++x)
+    for (x= 0; x< memcached_server_count(memc); ++x)
     {
       memcached_server_write_instance_st instance=
         memcached_server_instance_fetch(memc, x);
@@ -533,7 +542,7 @@
     return NULL;
   }
 
-  int err= poll(fds, host_index, memc->poll_timeout);
+  err= poll(fds, host_index, memc->poll_timeout);
   switch (err) {
   case -1:
     memc->cached_errno = get_socket_errno();
@@ -541,11 +550,11 @@
   case 0:
     break;
   default:
-    for (size_t x= 0; x < host_index; ++x)
+    for (x= 0; x < host_index; ++x)
     {
       if (fds[x].revents & POLLIN)
       {
-        for (uint32_t y= 0; y < memcached_server_count(memc); ++y)
+        for (y= 0; y < memcached_server_count(memc); ++y)
         {
           memcached_server_write_instance_st instance=
             memcached_server_instance_fetch(memc, y);
@@ -563,6 +572,11 @@
 static ssize_t io_flush(memcached_server_write_instance_st ptr,
                         memcached_return_t *error)
 {
+  ssize_t sent_length;
+  size_t return_length;
+  char *local_write_ptr;
+  size_t write_length;
+
   /*
    ** We might want to purge the input buffer if we haven't consumed
    ** any output yet... The test for the limits is the purge is inline
@@ -576,10 +590,9 @@
     if (rc != MEMCACHED_SUCCESS && rc != MEMCACHED_STORED)
       return -1;
   }
-  ssize_t sent_length;
-  size_t return_length;
-  char *local_write_ptr= ptr->write_buffer;
-  size_t write_length= ptr->write_buffer_offset;
+
+  local_write_ptr= ptr->write_buffer;
+  write_length= ptr->write_buffer_offset;
 
   *error= MEMCACHED_SUCCESS;
 
@@ -626,6 +639,8 @@
       case EAGAIN:
 #endif
         {
+          memcached_return_t rc;
+
           /*
            * We may be blocked on write because the input buffer
            * is full. Let's check if we have room in our input
@@ -635,8 +650,7 @@
           if (repack_input_buffer(ptr) ||
               process_input_buffer(ptr))
             continue;
-
-          memcached_return_t rc;
+          
           rc= io_wait(ptr, MEM_WRITE);
 
           if (rc == MEMCACHED_SUCCESS || rc == MEMCACHED_TIMEOUT)
@@ -786,10 +800,12 @@
 
 memcached_return_t memcached_io_init_udp_header(memcached_server_write_instance_st ptr, uint16_t thread_id)
 {
+  struct udp_datagram_header_st *header;
+
   if (thread_id > UDP_REQUEST_ID_MAX_THREAD_ID)
     return MEMCACHED_FAILURE;
 
-  struct udp_datagram_header_st *header= (struct udp_datagram_header_st *)ptr->write_buffer;
+  header= (struct udp_datagram_header_st *)ptr->write_buffer;
   header->request_id= htons((uint16_t) (generate_udp_request_thread_id(thread_id)));
   header->num_datagrams= htons(1);
   header->sequence_number= htons(0);
 
=== modified file 'libmemcached/memcached.c'
--- libmemcached/memcached.c	2010-09-13 06:05:34 +0000
+++ libmemcached/memcached.c	2011-01-13 03:40:43 +0000
@@ -11,41 +11,29 @@
 
 #include "common.h"
 
-static const memcached_st global_copy= {
-  .state= {
-    .is_purging= false,
-    .is_processing_input= false,
-    .is_time_for_rebuild= false,
-  },
-  .flags= {
-    .auto_eject_hosts= false,
-    .binary_protocol= false,
-    .buffer_requests= false,
-    .cork= false,
-    .hash_with_prefix_key= false,
-    .ketama_weighted= false,
-    .no_block= false,
-    .no_reply= false,
-    .randomize_replica_read= false,
-    .reuse_memory= false,
-    .support_cas= false,
-    .tcp_nodelay= false,
-    .use_cache_lookups= false,
-    .use_sort_hosts= false,
-    .use_udp= false,
-    .verify_key= false,
-    .tcp_keepalive= false
-  }
-};
+const memcached_st *create_global_copy()
+{
+  memcached_st *global = (memcached_st *) malloc(sizeof(memcached_st));
+
+  memset(global, 0, sizeof(memcached_st));
+
+  return global;
+}
+
+static const memcached_st *global_copy = NULL;
 
 static inline bool _memcached_init(memcached_st *self)
 {
-  self->state= global_copy.state;
-  self->flags= global_copy.flags;
+  hashkit_st *hash_ptr;
+
+  if (global_copy == NULL)
+    global_copy = create_global_copy();
+
+  self->state= global_copy->state;
+  self->flags= global_copy->flags;
 
   self->distribution= MEMCACHED_DISTRIBUTION_MODULA;
-
-  hashkit_st *hash_ptr;
+  
   hash_ptr= hashkit_create(&self->hashkit);
   if (! hash_ptr)
     return false;
@@ -199,6 +187,7 @@
 {
   memcached_return_t rc= MEMCACHED_SUCCESS;
   memcached_st *new_clone;
+  hashkit_st *hash_ptr;
 
   if (source == NULL)
     return memcached_create(clone);
@@ -221,8 +210,6 @@
   new_clone->retry_timeout= source->retry_timeout;
   new_clone->distribution= source->distribution;
 
-  hashkit_st *hash_ptr;
-
   hash_ptr= hashkit_clone(&new_clone->hashkit, &source->hashkit);
   if (! hash_ptr)
   {
 
=== modified file 'libmemcached/memcached.h'
--- libmemcached/memcached.h	2010-09-13 06:05:34 +0000
+++ libmemcached/memcached.h	2011-01-13 03:40:43 +0000
@@ -111,13 +111,7 @@
   memcached_result_st result;
   memcached_continuum_item_st *continuum; // Ketama
 
-  struct _allocators_st {
-    memcached_calloc_fn calloc;
-    memcached_free_fn free;
-    memcached_malloc_fn malloc;
-    memcached_realloc_fn realloc;
-    void *context;
-  } allocators;
+  allocators_st *allocators;
 
   memcached_clone_fn on_clone;
   memcached_cleanup_fn on_cleanup;
 
=== modified file 'libmemcached/purge.c'
--- libmemcached/purge.c	2010-02-13 02:23:49 +0000
+++ libmemcached/purge.c	2011-01-13 03:40:43 +0000
@@ -2,7 +2,7 @@
 
 memcached_return_t memcached_purge(memcached_server_write_instance_st ptr)
 {
-  uint32_t x;
+  uint32_t x, no_msg;
   memcached_return_t ret= MEMCACHED_SUCCESS;
   memcached_st *root= (memcached_st *)ptr->root;
 
@@ -30,7 +30,7 @@
   }
   WATCHPOINT_ASSERT(ptr->fd != -1);
 
-  uint32_t no_msg= memcached_server_response_count(ptr) - 1;
+  no_msg= memcached_server_response_count(ptr) - 1;
   if (no_msg > 0)
   {
     memcached_result_st result;
@@ -50,10 +50,10 @@
 
     for (x= 0; x < no_msg; x++)
     {
+      memcached_return_t rc;
+
       memcached_result_reset(result_ptr);
-      memcached_return_t rc= memcached_read_one_response(ptr, buffer,
-                                                         sizeof (buffer),
-                                                         result_ptr);
+      rc= memcached_read_one_response(ptr, buffer, sizeof (buffer), result_ptr);
       /*
        * Purge doesn't care for what kind of command results that is received.
        * The only kind of errors I care about if is I'm out of sync with the
@@ -69,9 +69,11 @@
       if (ptr->root->callbacks != NULL)
       {
         memcached_callback_st cb = *ptr->root->callbacks;
+        uint32_t y;
+
         if (rc == MEMCACHED_SUCCESS)
         {
-          for (uint32_t y= 0; y < cb.number_of_callback; y++)
+          for (y= 0; y < cb.number_of_callback; y++)
           {
             rc = (*cb.callback[y])(ptr->root, result_ptr, cb.context);
             if (rc != MEMCACHED_SUCCESS)
 
=== modified file 'libmemcached/quit.c'
--- libmemcached/quit.c	2010-04-22 00:49:09 +0000
+++ libmemcached/quit.c	2011-01-13 03:40:43 +0000
@@ -22,7 +22,10 @@
 
       if (ptr->root->flags.binary_protocol)
       {
-        protocol_binary_request_quit request = {.bytes= {0}};
+        protocol_binary_request_quit request;
+
+        memset(&request, 0, sizeof(request));
+
         request.message.header.request.magic = PROTOCOL_BINARY_REQ;
         request.message.header.request.opcode = PROTOCOL_BINARY_CMD_QUIT;
         request.message.header.request.datatype = PROTOCOL_BINARY_RAW_BYTES;
 
=== modified file 'libmemcached/response.c'
--- libmemcached/response.c	2010-07-16 03:54:57 +0000
+++ libmemcached/response.c	2011-01-13 03:40:43 +0000
@@ -22,6 +22,8 @@
                                                char *buffer, size_t buffer_length,
                                                memcached_result_st *result)
 {
+  memcached_return_t rc;
+
   memcached_server_response_decrement(ptr);
 
   if (result == NULL)
@@ -29,8 +31,7 @@
     memcached_st *root= (memcached_st *)ptr->root;
     result = &root->result;
   }
-
-  memcached_return_t rc;
+  
   if (ptr->root->flags.binary_protocol)
     rc= binary_read_one_response(ptr, buffer, buffer_length, result);
   else
@@ -341,6 +342,7 @@
 {
   memcached_return_t rc;
   protocol_binary_response_header header;
+  uint32_t bodylen;
 
   if ((rc= memcached_safe_read(ptr, &header.bytes, sizeof(header.bytes))) != MEMCACHED_SUCCESS)
   {
@@ -360,7 +362,7 @@
   header.response.status= ntohs(header.response.status);
   header.response.bodylen= ntohl(header.response.bodylen);
   header.response.cas= ntohll(header.response.cas);
-  uint32_t bodylen= header.response.bodylen;
+  bodylen= header.response.bodylen;
 
   if (header.response.status == PROTOCOL_BINARY_RESPONSE_SUCCESS ||
       header.response.status == PROTOCOL_BINARY_RESPONSE_AUTH_CONTINUE)
@@ -376,6 +378,7 @@
       /* FALLTHROUGH */
     case PROTOCOL_BINARY_CMD_GETK:
       {
+        char *vptr;
         uint16_t keylen= header.response.keylen;
         memcached_result_reset(result);
         result->item_cas= header.response.cas;
@@ -401,7 +404,7 @@
                                    bodylen) != MEMCACHED_SUCCESS)
           return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
 
-        char *vptr= memcached_string_value_mutable(&result->value);
+        vptr= memcached_string_value_mutable(&result->value);
         if ((rc= memcached_safe_read(ptr, vptr, bodylen)) != MEMCACHED_SUCCESS)
         {
           WATCHPOINT_ERROR(rc);
@@ -414,11 +417,13 @@
     case PROTOCOL_BINARY_CMD_INCREMENT:
     case PROTOCOL_BINARY_CMD_DECREMENT:
       {
+        uint64_t val;
+
         if (bodylen != sizeof(uint64_t) || buffer_length != sizeof(uint64_t))
           return MEMCACHED_PROTOCOL_ERROR;
 
         WATCHPOINT_ASSERT(bodylen == buffer_length);
-        uint64_t val;
+        
         if ((rc= memcached_safe_read(ptr, &val, sizeof(val))) != MEMCACHED_SUCCESS)
         {
           WATCHPOINT_ERROR(rc);
@@ -490,6 +495,8 @@
     case PROTOCOL_BINARY_CMD_SASL_AUTH:
     case PROTOCOL_BINARY_CMD_SASL_STEP:
       {
+        char * vptr;
+
         memcached_result_reset(result);
         result->item_cas= header.response.cas;
 
@@ -497,7 +504,7 @@
                                    bodylen) != MEMCACHED_SUCCESS)
           return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
 
-        char *vptr= memcached_string_value_mutable(&result->value);
+        vptr= memcached_string_value_mutable(&result->value);
         if ((rc= memcached_safe_read(ptr, vptr, bodylen)) != MEMCACHED_SUCCESS)
         {
           WATCHPOINT_ERROR(rc);
 
=== modified file 'libmemcached/sasl.c'
--- libmemcached/sasl.c	2010-09-13 12:26:17 +0000
+++ libmemcached/sasl.c	2011-01-13 03:40:43 +0000
@@ -11,6 +11,8 @@
  */
 #include "common.h"
 
+#ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
+
 void memcached_set_sasl_callbacks(memcached_st *ptr,
                                   const sasl_callback_t *callbacks)
 {
@@ -373,3 +375,5 @@
 
   return MEMCACHED_SUCCESS;
 }
+
+#endif
 
=== modified file 'libmemcached/server.c'
--- libmemcached/server.c	2010-07-16 02:33:19 +0000
+++ libmemcached/server.c	2011-01-13 03:40:43 +0000
@@ -153,12 +153,14 @@
                                            void *context,
                                            uint32_t number_of_callbacks)
 {
-  for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
+  uint32_t x, y;
+
+  for (x= 0; x < memcached_server_count(ptr); x++)
   {
     memcached_server_instance_st instance=
       memcached_server_instance_by_position(ptr, x);
 
-    for (uint32_t y= 0; y < number_of_callbacks; y++)
+    for (y= 0; y < number_of_callbacks; y++)
     {
       unsigned int iferror;
 
@@ -176,7 +178,9 @@
                                             memcached_server_execute_fn callback,
                                             void *context)
 {
-  for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
+  uint32_t x;
+
+  for (x= 0; x < memcached_server_count(ptr); x++)
   {
     memcached_server_write_instance_st instance=
       memcached_server_instance_fetch(ptr, x);
@@ -236,12 +240,15 @@
 
 void memcached_server_list_free(memcached_server_list_st self)
 {
+  const memcached_st *root;
+  uint32_t x;
+
   if (self == NULL)
     return;
 
-  const memcached_st *root= self->root;
+  root= self->root;
 
-  for (uint32_t x= 0; x < memcached_server_list_count(self); x++)
+  for (x= 0; x < memcached_server_list_count(self); x++)
   {
     if (self[x].address_info)
     {
 
=== modified file 'libmemcached/stats.c'
--- libmemcached/stats.c	2010-09-13 12:26:17 +0000
+++ libmemcached/stats.c	2011-01-13 03:40:43 +0000
@@ -242,13 +242,18 @@
   memcached_return_t rc;
 
   char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
-  protocol_binary_request_stats request= {.bytes= {0}};
+  protocol_binary_request_stats request;
+
+  memset(&request, 0, sizeof(request));
+
   request.message.header.request.magic= PROTOCOL_BINARY_REQ;
   request.message.header.request.opcode= PROTOCOL_BINARY_CMD_STAT;
   request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES;
 
   if (args != NULL)
   {
+    struct libmemcached_io_vector_st vector[2];
+
     size_t len= strlen(args);
 
     rc= memcached_validate_key_length(len, true);
@@ -258,11 +263,10 @@
     request.message.header.request.keylen= htons((uint16_t)len);
     request.message.header.request.bodylen= htonl((uint32_t) len);
 
-    struct libmemcached_io_vector_st vector[]=
-    {
-      { .length= sizeof(request.bytes), .buffer= request.bytes },
-      { .length= len, .buffer= args }
-    };
+    vector[0].length= sizeof(request.bytes);
+    vector[0].buffer= request.bytes;
+    vector[1].length= len;
+    vector[1].buffer= args;
 
     if (memcached_vdo(instance, vector, 2, true) != MEMCACHED_SUCCESS)
     {
@@ -397,6 +401,7 @@
 {
   memcached_return_t rc;
   memcached_stat_st *stats;
+  uint32_t x;
 
   unlikely (ptr->flags.use_udp)
   {
@@ -413,7 +418,7 @@
   }
 
   rc= MEMCACHED_SUCCESS;
-  for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
+  for (x= 0; x < memcached_server_count(ptr); x++)
   {
     memcached_return_t temp_return;
     memcached_server_write_instance_st instance;
@@ -544,9 +549,13 @@
 
 memcached_return_t memcached_stat_execute(memcached_st *memc, const char *args,  memcached_stat_fn func, void *context)
 {
+  struct local_context check;
+
   memcached_version(memc);
 
- struct local_context check= { .func= func, .context= context, .args= args };
+  check.func= func;
+  check.context= context;
+  check.args= args;
 
  return memcached_server_execute(memc, call_stat_fn, (void *)&check);
 }
 
=== modified file 'libmemcached/storage.c'
--- libmemcached/storage.c	2010-09-13 12:26:17 +0000
+++ libmemcached/storage.c	2011-01-13 03:40:43 +0000
@@ -105,12 +105,13 @@
     if (cas)
     {
       write_length= (size_t) snprintf(buffer, MEMCACHED_DEFAULT_COMMAND_SIZE,
-                                      "%s %.*s%.*s %u %llu %zu %llu%s\r\n",
+                                      "%s %.*s%.*s %u %llu %lu %llu%s\r\n",
                                       storage_op_string(verb),
                                       (int)ptr->prefix_key_length,
                                       ptr->prefix_key,
                                       (int)key_length, key, flags,
-                                      (unsigned long long)expiration, value_length,
+                                      (unsigned long long)expiration, 
+                                      (unsigned long)value_length,
                                       (unsigned long long)cas,
                                       (ptr->flags.no_reply) ? " noreply" : "");
     }
@@ -134,9 +135,10 @@
 
       write_length= (size_t)(buffer_ptr - buffer);
       write_length+= (size_t) snprintf(buffer_ptr, MEMCACHED_DEFAULT_COMMAND_SIZE,
-                                       "%u %llu %zu%s\r\n",
+                                       "%u %llu %lu%s\r\n",
                                        flags,
-                                       (unsigned long long)expiration, value_length,
+                                       (unsigned long long)expiration, 
+                                       (unsigned long)value_length,
                                        ptr->flags.no_reply ? " noreply" : "");
     }
 
@@ -155,12 +157,14 @@
     }
     else
     {
-      struct libmemcached_io_vector_st vector[]=
-      {
-        { .length= write_length, .buffer= buffer },
-        { .length= value_length, .buffer= value },
-        { .length= 2, .buffer= "\r\n" }
-      };
+      struct libmemcached_io_vector_st vector[3];
+      
+      vector[0].length= write_length;
+      vector[0].buffer= buffer;
+      vector[1].length= value_length;
+      vector[1].buffer= value;
+      vector[2].length= 2;
+      vector[2].buffer= "\r\n";
 
       if (ptr->flags.buffer_requests && verb == SET_OP)
       {
@@ -452,11 +456,15 @@
                                                 memcached_storage_action_t verb)
 {
   bool flush;
-  protocol_binary_request_set request= {.bytes= {0}};
+  protocol_binary_request_set request;
   size_t send_length= sizeof(request.bytes);
-
+  memcached_return_t rc;
+  struct libmemcached_io_vector_st vector[4];
+  
   bool noreply= server->root->flags.no_reply;
 
+  memset(&request, 0, sizeof(request));
+
   request.message.header.request.magic= PROTOCOL_BINARY_REQ;
   request.message.header.request.opcode= get_com_code(verb, noreply);
   request.message.header.request.keylen= htons((uint16_t)(key_length + ptr->prefix_key_length));
@@ -492,16 +500,17 @@
     }
   }
 
-  struct libmemcached_io_vector_st vector[]=
-  {
-    { .length= send_length, .buffer= request.bytes },
-    { .length= ptr->prefix_key_length, .buffer= ptr->prefix_key },
-    { .length= key_length, .buffer= key },
-    { .length= value_length, .buffer= value }
-  };
+  
+  vector[0].length= send_length;
+  vector[0].buffer= request.bytes;
+  vector[1].length= ptr->prefix_key_length;
+  vector[1].buffer= ptr->prefix_key;
+  vector[2].length= key_length;
+  vector[2].buffer= key;
+  vector[3].length= value_length;
+  vector[3].buffer= value;
 
-  /* write the header */
-  memcached_return_t rc;
+  /* write the header */  
   if ((rc= memcached_vdo(server, vector, 4, flush)) != MEMCACHED_SUCCESS)
   {
     memcached_io_reset(server);
@@ -510,10 +519,12 @@
 
   if (verb == SET_OP && ptr->number_of_replicas > 0)
   {
+    uint32_t x;
+
     request.message.header.request.opcode= PROTOCOL_BINARY_CMD_SETQ;
     WATCHPOINT_STRING("replicating");
 
-    for (uint32_t x= 0; x < ptr->number_of_replicas; x++)
+    for (x= 0; x < ptr->number_of_replicas; x++)
     {
       memcached_server_write_instance_st instance;
 
 
=== modified file 'libmemcached/types.h'
--- libmemcached/types.h	2010-07-16 02:33:19 +0000
+++ libmemcached/types.h	2011-01-13 03:40:43 +0000
@@ -44,6 +44,13 @@
 typedef void *(*memcached_realloc_fn)(const memcached_st *ptr, void *mem, const size_t size, void *context);
 typedef void *(*memcached_calloc_fn)(const memcached_st *ptr, size_t nelem, const size_t elsize, void *context);
 
+typedef struct _allocators_st {
+  memcached_calloc_fn calloc;
+  memcached_free_fn free;
+  memcached_malloc_fn malloc;
+  memcached_realloc_fn realloc;
+  void *context;
+} allocators_st;
 
 typedef memcached_return_t (*memcached_execute_fn)(const memcached_st *ptr, memcached_result_st *result, void *context);
 typedef memcached_return_t (*memcached_server_fn)(const memcached_st *ptr, memcached_server_instance_st server, void *context);
 
=== modified file 'libmemcached/verbosity.c'
--- libmemcached/verbosity.c	2010-04-04 21:53:03 +0000
+++ libmemcached/verbosity.c	2011-01-13 03:40:43 +0000
@@ -43,6 +43,7 @@
 {
   size_t send_length;
   memcached_server_fn callbacks[1];
+  struct context_st context;
 
   char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
 
@@ -51,7 +52,8 @@
   unlikely (send_length >= MEMCACHED_DEFAULT_COMMAND_SIZE)
     return MEMCACHED_WRITE_FAILURE;
 
-  struct context_st context = { .length= send_length, .buffer= buffer };
+  context.length= send_length;
+  context.buffer= buffer;
 
   callbacks[0]= _set_verbosity;
 
 
=== modified file 'libmemcached/version.c'
--- libmemcached/version.c	2010-07-16 03:54:57 +0000
+++ libmemcached/version.c	2011-01-13 03:40:43 +0000
@@ -10,11 +10,13 @@
 
 memcached_return_t memcached_version(memcached_st *ptr)
 {
+  bool was_blocking;
+  memcached_return_t rc;
+
   if (ptr->flags.use_udp)
     return MEMCACHED_NOT_SUPPORTED;
 
-  bool was_blocking= ptr->flags.no_block;
-  memcached_return_t rc;
+  was_blocking= ptr->flags.no_block;  
 
   ptr->flags.no_block= false;
 
@@ -35,11 +37,12 @@
   char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
   char *response_ptr;
   const char *command= "version\r\n";
+  uint32_t x;
 
   send_length= strlen(command);
 
   rc= MEMCACHED_SUCCESS;
-  for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
+  for (x= 0; x < memcached_server_count(ptr); x++)
   {
     memcached_return_t rrc;
     memcached_server_write_instance_st instance=
@@ -78,13 +81,17 @@
 static inline memcached_return_t memcached_version_binary(memcached_st *ptr)
 {
   memcached_return_t rc;
-  protocol_binary_request_version request= { .bytes= {0}};
+  uint32_t x;
+  protocol_binary_request_version request;
+
+  memset(&request, 0, sizeof(request));
+
   request.message.header.request.magic= PROTOCOL_BINARY_REQ;
   request.message.header.request.opcode= PROTOCOL_BINARY_CMD_VERSION;
   request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES;
 
   rc= MEMCACHED_SUCCESS;
-  for (uint32_t x= 0; x < memcached_server_count(ptr); x++) 
+  for (x= 0; x < memcached_server_count(ptr); x++) 
   {
     memcached_return_t rrc;
 
@@ -100,7 +107,7 @@
     }
   }
 
-  for (uint32_t x= 0; x < memcached_server_count(ptr); x++) 
+  for (x= 0; x < memcached_server_count(ptr); x++) 
   {
     memcached_server_write_instance_st instance=
       memcached_server_instance_fetch(ptr, x);
 
=== modified file 'libmemcached/visibility.h'
--- libmemcached/visibility.h	2010-01-21 23:45:12 +0000
+++ libmemcached/visibility.h	2011-01-13 03:40:43 +0000
@@ -35,16 +35,26 @@
 #  define LIBMEMCACHED_API __global
 #  define LIBMEMCACHED_LOCAL __hidden
 # elif defined(_MSC_VER)
-#  define LIBMEMCACHED_API extern __declspec(dllexport) 
-#  define LIBMEMCACHED_LOCAL
+#  if defined(LIBMEMCACHED_STATIC)
+#   define LIBMEMCACHED_API
+#   define LIBMEMCACHED_LOCAL
+#  else
+#   define LIBMEMCACHED_API extern __declspec(dllexport) 
+#   define LIBMEMCACHED_LOCAL
+#  endif
 # else
 #  define LIBMEMCACHED_API
 #  define LIBMEMCACHED_LOCAL
 # endif /* defined(HAVE_VISIBILITY) */
 #else  /* defined(BUILDING_LIBMEMCACHED) */
 # if defined(_MSC_VER)
-#  define LIBMEMCACHED_API extern __declspec(dllimport) 
-#  define LIBMEMCACHED_LOCAL
+#  if defined(LIBMEMCACHED_STATIC)
+#   define LIBMEMCACHED_API
+#   define LIBMEMCACHED_LOCAL
+#  else
+#   define LIBMEMCACHED_API extern __declspec(dllimport) 
+#   define LIBMEMCACHED_LOCAL
+#  endif
 # else
 #  define LIBMEMCACHED_API
 #  define LIBMEMCACHED_LOCAL
 
=== modified file 'libmemcached/watchpoint.h'
--- libmemcached/watchpoint.h	2010-09-13 12:31:19 +0000
+++ libmemcached/watchpoint.h	2011-01-13 03:40:43 +0000
@@ -58,9 +58,9 @@
 #define WATCHPOINT_IFERROR(A) do { if(A != MEMCACHED_SUCCESS)fprintf(stderr, "\nWATCHPOINT %s:%d %s\n", __FILE__, __LINE__, memcached_strerror(NULL, A));fflush(stdout); } while (0)
 #define WATCHPOINT_STRING(A) do { fprintf(stderr, "\nWATCHPOINT %s:%d (%s) %s\n", __FILE__, __LINE__,__func__,A);fflush(stdout); } while (0)
 #define WATCHPOINT_STRING_LENGTH(A,B) do { fprintf(stderr, "\nWATCHPOINT %s:%d (%s) %.*s\n", __FILE__, __LINE__,__func__,(int)B,A);fflush(stdout); } while (0)
-#define WATCHPOINT_NUMBER(A) do { fprintf(stderr, "\nWATCHPOINT %s:%d (%s) %zu\n", __FILE__, __LINE__,__func__,(size_t)(A));fflush(stdout); } while (0)
-#define WATCHPOINT_LABELED_NUMBER(A,B) do { fprintf(stderr, "\nWATCHPOINT %s:%d (%s) %s:%zu\n", __FILE__, __LINE__,__func__,(A),(size_t)(B));fflush(stdout); } while (0)
-#define WATCHPOINT_IF_LABELED_NUMBER(A,B,C) do { if(A) {fprintf(stderr, "\nWATCHPOINT %s:%d (%s) %s:%zu\n", __FILE__, __LINE__,__func__,(B),(size_t)(C));fflush(stdout);} } while (0)
+#define WATCHPOINT_NUMBER(A) do { fprintf(stderr, "\nWATCHPOINT %s:%d (%s) %lu\n", __FILE__, __LINE__,__func__,(long unsigned int)(A));fflush(stdout); } while (0)
+#define WATCHPOINT_LABELED_NUMBER(A,B) do { fprintf(stderr, "\nWATCHPOINT %s:%d (%s) %s:%lu\n", __FILE__, __LINE__,__func__,(A),(long unsigned int)(B));fflush(stdout); } while (0)
+#define WATCHPOINT_IF_LABELED_NUMBER(A,B,C) do { if(A) {fprintf(stderr, "\nWATCHPOINT %s:%d (%s) %s:%lu\n", __FILE__, __LINE__,__func__,(B),(long unsigned int)(C));fflush(stdout);} } while (0)
 #define WATCHPOINT_ERRNO(A) do { fprintf(stderr, "\nWATCHPOINT %s:%d (%s) %s\n", __FILE__, __LINE__,__func__, strerror(A));fflush(stdout); } while (0)
 #define WATCHPOINT_ASSERT_PRINT(A,B,C) do { if(!(A)){fprintf(stderr, "\nWATCHPOINT ASSERT %s:%d (%s) ", __FILE__, __LINE__,__func__);fprintf(stderr, (B),(C));fprintf(stderr,"\n");fflush(stdout); libmemcached_stack_dump(); } assert((A)); } while (0)
 #define WATCHPOINT_ASSERT(A) do { if (! (A)) {libmemcached_stack_dump();} assert((A)); } while (0)
 
=== modified file 'poll/poll.c'
--- poll/poll.c	2010-07-28 18:48:00 +0000
+++ poll/poll.c	2011-01-13 03:40:43 +0000
@@ -9,19 +9,27 @@
  *
  */
 #include "config.h"
-#include <sys/time.h>
-#include <strings.h>
+
+#ifdef WIN32
+# include <ws2tcpip.h>
+#else
+# include <sys/time.h>
+# include <strings.h>
+#endif
 
 int poll(struct pollfd fds[], nfds_t nfds, int tmo)
 {
+  int maxfd= 0, ret;
+  nfds_t x;
+  struct timeval timeout;
+  struct timeval *tp;
+
   fd_set readfds, writefds, errorfds;
   FD_ZERO(&readfds);
   FD_ZERO(&writefds);
-  FD_ZERO(&errorfds);
-
-  int maxfd= 0;
-
-  for (nfds_t x= 0; x < nfds; ++x)
+  FD_ZERO(&errorfds);  
+
+  for (x= 0; x < nfds; ++x)
   {
     if (fds[x].events & (POLLIN | POLLOUT))
     {
@@ -42,21 +50,22 @@
     }
   }
 
-  struct timeval timeout= { .tv_sec = tmo / 1000,
-                            .tv_usec= (tmo % 1000) * 1000 };
-  struct timeval *tp= &timeout;
+  timeout.tv_sec = tmo / 1000;
+  timeout.tv_usec= (tmo % 1000) * 1000;
+
+  tp= &timeout;
   if (tmo == -1)
   {
     tp= NULL;
   }
-  int ret= select(maxfd + 1, &readfds, &writefds, &errorfds, tp);
+  ret= select(maxfd + 1, &readfds, &writefds, &errorfds, tp);
   if (ret <= 0)
   {
     return ret;
   }
 
   /* Iterate through all of them because I need to clear the revent map */
-  for (nfds_t x= 0; x < nfds; ++x)
+  for (x= 0; x < nfds; ++x)
   {
     fds[x].revents= 0;
     if (FD_ISSET(fds[x].fd, &readfds))
 
=== added file 'win32/common.vsprops'
--- win32/common.vsprops	1970-01-01 00:00:00 +0000
+++ win32/common.vsprops	2011-01-13 03:40:43 +0000
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="gb2312"?>
+<VisualStudioPropertySheet
+	ProjectType="Visual C++"
+	Version="8.00"
+	Name="essential"
+	CharacterSet="2"
+	>
+	<Tool
+		Name="VCCLCompilerTool"
+		AdditionalIncludeDirectories="..;..\win32;"
+		PreprocessorDefinitions="WIN32;_WINDOWS;_USRDLL;LIBMEMCACHED_STATIC"
+		MinimalRebuild="true"
+		RuntimeLibrary="3"
+		WarningLevel="3"
+		DebugInformationFormat="4"
+	/>	
+	<Tool
+		Name="VCLinkerTool"
+		AdditionalDependencies="ws2_32.lib libmemcached-win32.lib"
+		AdditionalLibraryDirectories="&quot;$(OutDir)&quot;"
+		GenerateDebugInformation="true"
+		TargetMachine="1"
+	/>	
+</VisualStudioPropertySheet>
+	
 \ No newline at end of file
 
=== added file 'win32/debug.vsprops'
--- win32/debug.vsprops	1970-01-01 00:00:00 +0000
+++ win32/debug.vsprops	2011-01-13 03:40:43 +0000
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="gb2312"?>
+<VisualStudioPropertySheet
+	ProjectType="Visual C++"
+	Version="8.00"
+	Name="essential"
+	CharacterSet="2"
+	>
+	<Tool
+		Name="VCCLCompilerTool"
+		PreprocessorDefinitions="_DEBUG"
+	/>		
+</VisualStudioPropertySheet>
 \ No newline at end of file
 
=== added file 'win32/getopt.c'
--- win32/getopt.c	1970-01-01 00:00:00 +0000
+++ win32/getopt.c	2011-01-13 03:40:43 +0000
@@ -0,0 +1,1067 @@
+/* Getopt for GNU.
+   NOTE: getopt is now part of the C library, so if you don't know what
+   "Keep this file name-space clean" means, talk to [e-mail]
+   before changing it!
+
+   Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 2000
+   	Free Software Foundation, Inc.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public License as
+   published by the Free Software Foundation; either version 2 of the
+   License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public
+   License along with the GNU C Library; see the file COPYING.LIB.  If not,
+   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
 
+/* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>.
+   Ditto for AIX 3.2 and <stdlib.h>.  */
+#ifndef _NO_PROTO
+# define _NO_PROTO
+#endif
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#if !defined __STDC__ || !__STDC__
+/* This is a separate conditional since some stdc systems
+   reject `defined (const)'.  */
+# ifndef const
+#  define const
+# endif
+#endif
+
+#include <stdio.h>
+
+/* Comment out all this code if we are using the GNU C Library, and are not
+   actually compiling the library itself.  This code is part of the GNU C
+   Library, but also included in many other GNU distributions.  Compiling
+   and linking in this code is a waste when using the GNU C library
+   (especially if it is a shared library).  Rather than having every GNU
+   program understand `configure --with-gnu-libc' and omit the object files,
+   it is simpler to just do this in the source for each such file.  */
+
+#define GETOPT_INTERFACE_VERSION 2
+#if !defined _LIBC && defined __GLIBC__ && __GLIBC__ >= 2
+# include <gnu-versions.h>
+# if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION
+#  define ELIDE_CODE
+# endif
+#endif
+
+#ifndef ELIDE_CODE
+
+
+/* This needs to come after some library #include
+   to get __GNU_LIBRARY__ defined.  */
+#ifdef	__GNU_LIBRARY__
+/* Don't include stdlib.h for non-GNU C libraries because some of them
+   contain conflicting prototypes for getopt.  */
+# include <stdlib.h>
+# include <unistd.h>
+#endif	/* GNU C library.  */
+
+#ifdef VMS
+# include <unixlib.h>
+# if HAVE_STRING_H - 0
+#  include <string.h>
+# endif
+#endif
+
+#ifdef WIN32
+# define HAVE_STRING_H 1
+#endif
+
+#ifndef _
+/* This is for other GNU distributions with internationalized messages.
+   When compiling libc, the _ macro is predefined.  */
+# ifdef HAVE_LIBINTL_H
+#  include <libintl.h>
+#  define _(msgid)	gettext (msgid)
+# else
+#  define _(msgid)	(msgid)
+# endif
+#endif
+
+/* This version of `getopt' appears to the caller like standard Unix `getopt'
+   but it behaves differently for the user, since it allows the user
+   to intersperse the options with the other arguments.
+
+   As `getopt' works, it permutes the elements of ARGV so that,
+   when it is done, all the options precede everything else.  Thus
+   all application programs are extended to handle flexible argument order.
+
+   Setting the environment variable POSIXLY_CORRECT disables permutation.
+   Then the behavior is completely standard.
+
+   GNU application programs can use a third alternative mode in which
+   they can distinguish the relative order of options and other arguments.  */
+
+#include "getopt.h"
+
+/* For communication from `getopt' to the caller.
+   When `getopt' finds an option that takes an argument,
+   the argument value is returned here.
+   Also, when `ordering' is RETURN_IN_ORDER,
+   each non-option ARGV-element is returned here.  */
+
+char *optarg;
+
+/* Index in ARGV of the next element to be scanned.
+   This is used for communication to and from the caller
+   and for communication between successive calls to `getopt'.
+
+   On entry to `getopt', zero means this is the first call; initialize.
+
+   When `getopt' returns -1, this is the index of the first of the
+   non-option elements that the caller should itself scan.
+
+   Otherwise, `optind' communicates from one call to the next
+   how much of ARGV has been scanned so far.  */
+
+/* 1003.2 says this must be 1 before any call.  */
+int optind = 1;
+
+/* Formerly, initialization of getopt depended on optind==0, which
+   causes problems with re-calling getopt as programs generally don't
+   know that. */
+
+int __getopt_initialized;
+
+/* The next char to be scanned in the option-element
+   in which the last option character we returned was found.
+   This allows us to pick up the scan where we left off.
+
+   If this is zero, or a null string, it means resume the scan
+   by advancing to the next ARGV-element.  */
+
+static char *nextchar;
+
+/* Callers store zero here to inhibit the error message
+   for unrecognized options.  */
+
+int opterr = 1;
+
+/* Set to an option character which was unrecognized.
+   This must be initialized on some systems to avoid linking in the
+   system's own getopt implementation.  */
+
+int optopt = '?';
+
+/* Describe how to deal with options that follow non-option ARGV-elements.
+
+   If the caller did not specify anything,
+   the default is REQUIRE_ORDER if the environment variable
+   POSIXLY_CORRECT is defined, PERMUTE otherwise.
+
+   REQUIRE_ORDER means don't recognize them as options;
+   stop option processing when the first non-option is seen.
+   This is what Unix does.
+   This mode of operation is selected by either setting the environment
+   variable POSIXLY_CORRECT, or using `+' as the first character
+   of the list of option characters.
+
+   PERMUTE is the default.  We permute the contents of ARGV as we scan,
+   so that eventually all the non-options are at the end.  This allows options
+   to be given in any order, even with programs that were not written to
+   expect this.
+
+   RETURN_IN_ORDER is an option available to programs that were written
+   to expect options and other ARGV-elements in any order and that care about
+   the ordering of the two.  We describe each non-option ARGV-element
+   as if it were the argument of an option with character code 1.
+   Using `-' as the first character of the list of option characters
+   selects this mode of operation.
+
+   The special argument `--' forces an end of option-scanning regardless
+   of the value of `ordering'.  In the case of RETURN_IN_ORDER, only
+   `--' can cause `getopt' to return -1 with `optind' != ARGC.  */
+
+static enum
+{
+  REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
+} ordering;
+
+/* Value of POSIXLY_CORRECT environment variable.  */
+static char *posixly_correct;
+
 
+#ifdef	__GNU_LIBRARY__
+/* We want to avoid inclusion of string.h with non-GNU libraries
+   because there are many ways it can cause trouble.
+   On some systems, it contains special magic macros that don't work
+   in GCC.  */
+# include <string.h>
+# define my_index	strchr
+#else
+
+# if HAVE_STRING_H
+#  include <string.h>
+# else
+#  include <strings.h>
+# endif
+
+/* Avoid depending on library functions or files
+   whose names are inconsistent.  */
+
+#ifndef getenv
+extern char *getenv ();
+#endif
+
+static char *
+my_index (str, chr)
+     const char *str;
+     int chr;
+{
+  while (*str)
+    {
+      if (*str == chr)
+	return (char *) str;
+      str++;
+    }
+  return 0;
+}
+
+/* If using GCC, we can safely declare strlen this way.
+   If not using GCC, it is ok not to declare it.  */
+#ifdef __GNUC__
+/* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h.
+   That was relevant to code that was here before.  */
+# if (!defined __STDC__ || !__STDC__) && !defined strlen
+/* gcc with -traditional declares the built-in strlen to return int,
+   and has done so at least since version 2.4.5. -- rms.  */
+extern int strlen (const char *);
+# endif /* not __STDC__ */
+#endif /* __GNUC__ */
+
+#endif /* not __GNU_LIBRARY__ */
+
 
+/* Handle permutation of arguments.  */
+
+/* Describe the part of ARGV that contains non-options that have
+   been skipped.  `first_nonopt' is the index in ARGV of the first of them;
+   `last_nonopt' is the index after the last of them.  */
+
+static int first_nonopt;
+static int last_nonopt;
+
+#ifdef _LIBC
+/* Bash 2.0 gives us an environment variable containing flags
+   indicating ARGV elements that should not be considered arguments.  */
+
+/* Defined in getopt_init.c  */
+extern char *__getopt_nonoption_flags;
+
+static int nonoption_flags_max_len;
+static int nonoption_flags_len;
+
+static int original_argc;
+static char *const *original_argv;
+
+/* Make sure the environment variable bash 2.0 puts in the environment
+   is valid for the getopt call we must make sure that the ARGV passed
+   to getopt is that one passed to the process.  */
+static void
+__attribute__ ((unused))
+store_args_and_env (int argc, char *const *argv)
+{
+  /* XXX This is no good solution.  We should rather copy the args so
+     that we can compare them later.  But we must not use malloc(3).  */
+  original_argc = argc;
+  original_argv = argv;
+}
+# ifdef text_set_element
+text_set_element (__libc_subinit, store_args_and_env);
+# endif /* text_set_element */
+
+# define SWAP_FLAGS(ch1, ch2) \
+  if (nonoption_flags_len > 0)						      \
+    {									      \
+      char __tmp = __getopt_nonoption_flags[ch1];			      \
+      __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2];	      \
+      __getopt_nonoption_flags[ch2] = __tmp;				      \
+    }
+#else	/* !_LIBC */
+# define SWAP_FLAGS(ch1, ch2)
+#endif	/* _LIBC */
+
+/* Exchange two adjacent subsequences of ARGV.
+   One subsequence is elements [first_nonopt,last_nonopt)
+   which contains all the non-options that have been skipped so far.
+   The other is elements [last_nonopt,optind), which contains all
+   the options processed since those non-options were skipped.
+
+   `first_nonopt' and `last_nonopt' are relocated so that they describe
+   the new indices of the non-options in ARGV after they are moved.  */
+
+#if defined __STDC__ && __STDC__
+static void exchange (char **);
+#endif
+
+static void
+exchange (argv)
+     char **argv;
+{
+  int bottom = first_nonopt;
+  int middle = last_nonopt;
+  int top = optind;
+  char *tem;
+
+  /* Exchange the shorter segment with the far end of the longer segment.
+     That puts the shorter segment into the right place.
+     It leaves the longer segment in the right place overall,
+     but it consists of two parts that need to be swapped next.  */
+
+#ifdef _LIBC
+  /* First make sure the handling of the `__getopt_nonoption_flags'
+     string can work normally.  Our top argument must be in the range
+     of the string.  */
+  if (nonoption_flags_len > 0 && top >= nonoption_flags_max_len)
+    {
+      /* We must extend the array.  The user plays games with us and
+	 presents new arguments.  */
+      char *new_str = malloc (top + 1);
+      if (new_str == NULL)
+	nonoption_flags_len = nonoption_flags_max_len = 0;
+      else
+	{
+	  memset (__mempcpy (new_str, __getopt_nonoption_flags,
+			     nonoption_flags_max_len),
+		  '\0', top + 1 - nonoption_flags_max_len);
+	  nonoption_flags_max_len = top + 1;
+	  __getopt_nonoption_flags = new_str;
+	}
+    }
+#endif
+
+  while (top > middle && middle > bottom)
+    {
+      if (top - middle > middle - bottom)
+	{
+	  /* Bottom segment is the short one.  */
+	  int len = middle - bottom;
+	  register int i;
+
+	  /* Swap it with the top part of the top segment.  */
+	  for (i = 0; i < len; i++)
+	    {
+	      tem = argv[bottom + i];
+	      argv[bottom + i] = argv[top - (middle - bottom) + i];
+	      argv[top - (middle - bottom) + i] = tem;
+	      SWAP_FLAGS (bottom + i, top - (middle - bottom) + i);
+	    }
+	  /* Exclude the moved bottom segment from further swapping.  */
+	  top -= len;
+	}
+      else
+	{
+	  /* Top segment is the short one.  */
+	  int len = top - middle;
+	  register int i;
+
+	  /* Swap it with the bottom part of the bottom segment.  */
+	  for (i = 0; i < len; i++)
+	    {
+	      tem = argv[bottom + i];
+	      argv[bottom + i] = argv[middle + i];
+	      argv[middle + i] = tem;
+	      SWAP_FLAGS (bottom + i, middle + i);
+	    }
+	  /* Exclude the moved top segment from further swapping.  */
+	  bottom += len;
+	}
+    }
+
+  /* Update records for the slots the non-options now occupy.  */
+
+  first_nonopt += (optind - last_nonopt);
+  last_nonopt = optind;
+}
+
+/* Initialize the internal data when the first call is made.  */
+
+#if defined __STDC__ && __STDC__
+static const char *_getopt_initialize (int, char *const *, const char *);
+#endif
+static const char *
+_getopt_initialize (argc, argv, optstring)
+     int argc;
+     char *const *argv;
+     const char *optstring;
+{
+  /* Start processing options with ARGV-element 1 (since ARGV-element 0
+     is the program name); the sequence of previously skipped
+     non-option ARGV-elements is empty.  */
+
+  first_nonopt = last_nonopt = optind;
+
+  nextchar = NULL;
+
+  posixly_correct = getenv ("POSIXLY_CORRECT");
+
+  /* Determine how to handle the ordering of options and nonoptions.  */
+
+  if (optstring[0] == '-')
+    {
+      ordering = RETURN_IN_ORDER;
+      ++optstring;
+    }
+  else if (optstring[0] == '+')
+    {
+      ordering = REQUIRE_ORDER;
+      ++optstring;
+    }
+  else if (posixly_correct != NULL)
+    ordering = REQUIRE_ORDER;
+  else
+    ordering = PERMUTE;
+
+#ifdef _LIBC
+  if (posixly_correct == NULL
+      && argc == original_argc && argv == original_argv)
+    {
+      if (nonoption_flags_max_len == 0)
+	{
+	  if (__getopt_nonoption_flags == NULL
+	      || __getopt_nonoption_flags[0] == '\0')
+	    nonoption_flags_max_len = -1;
+	  else
+	    {
+	      const char *orig_str = __getopt_nonoption_flags;
+	      int len = nonoption_flags_max_len = strlen (orig_str);
+	      if (nonoption_flags_max_len < argc)
+		nonoption_flags_max_len = argc;
+	      __getopt_nonoption_flags =
+		(char *) malloc (nonoption_flags_max_len);
+	      if (__getopt_nonoption_flags == NULL)
+		nonoption_flags_max_len = -1;
+	      else
+		memset (__mempcpy (__getopt_nonoption_flags, orig_str, len),
+			'\0', nonoption_flags_max_len - len);
+	    }
+	}
+      nonoption_flags_len = nonoption_flags_max_len;
+    }
+  else
+    nonoption_flags_len = 0;
+#endif
+
+  return optstring;
+}
+
 
+/* Scan elements of ARGV (whose length is ARGC) for option characters
+   given in OPTSTRING.
+
+   If an element of ARGV starts with '-', and is not exactly "-" or "--",
+   then it is an option element.  The characters of this element
+   (aside from the initial '-') are option characters.  If `getopt'
+   is called repeatedly, it returns successively each of the option characters
+   from each of the option elements.
+
+   If `getopt' finds another option character, it returns that character,
+   updating `optind' and `nextchar' so that the next call to `getopt' can
+   resume the scan with the following option character or ARGV-element.
+
+   If there are no more option characters, `getopt' returns -1.
+   Then `optind' is the index in ARGV of the first ARGV-element
+   that is not an option.  (The ARGV-elements have been permuted
+   so that those that are not options now come last.)
+
+   OPTSTRING is a string containing the legitimate option characters.
+   If an option character is seen that is not listed in OPTSTRING,
+   return '?' after printing an error message.  If you set `opterr' to
+   zero, the error message is suppressed but we still return '?'.
+
+   If a char in OPTSTRING is followed by a colon, that means it wants an arg,
+   so the following text in the same ARGV-element, or the text of the following
+   ARGV-element, is returned in `optarg'.  Two colons mean an option that
+   wants an optional arg; if there is text in the current ARGV-element,
+   it is returned in `optarg', otherwise `optarg' is set to zero.
+
+   If OPTSTRING starts with `-' or `+', it requests different methods of
+   handling the non-option ARGV-elements.
+   See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
+
+   Long-named options begin with `--' instead of `-'.
+   Their names may be abbreviated as long as the abbreviation is unique
+   or is an exact match for some defined option.  If they have an
+   argument, it follows the option name in the same ARGV-element, separated
+   from the option name by a `=', or else the in next ARGV-element.
+   When `getopt' finds a long-named option, it returns 0 if that option's
+   `flag' field is nonzero, the value of the option's `val' field
+   if the `flag' field is zero.
+
+   The elements of ARGV aren't really const, because we permute them.
+   But we pretend they're const in the prototype to be compatible
+   with other systems.
+
+   LONGOPTS is a vector of `struct option' terminated by an
+   element containing a name which is zero.
+
+   LONGIND returns the index in LONGOPT of the long-named option found.
+   It is only valid when a long-named option has been found by the most
+   recent call.
+
+   If LONG_ONLY is nonzero, '-' as well as '--' can introduce
+   long-named options.  */
+
+int
+_getopt_internal (argc, argv, optstring, longopts, longind, long_only)
+     int argc;
+     char *const *argv;
+     const char *optstring;
+     const struct option *longopts;
+     int *longind;
+     int long_only;
+{
+  int print_errors = opterr;
+  if (optstring[0] == ':')
+    print_errors = 0;
+
+  optarg = NULL;
+
+  if (optind == 0 || !__getopt_initialized)
+    {
+      if (optind == 0)
+	optind = 1;	/* Don't scan ARGV[0], the program name.  */
+      optstring = _getopt_initialize (argc, argv, optstring);
+      __getopt_initialized = 1;
+    }
+
+  /* Test whether ARGV[optind] points to a non-option argument.
+     Either it does not have option syntax, or there is an environment flag
+     from the shell indicating it is not an option.  The later information
+     is only used when the used in the GNU libc.  */
+#ifdef _LIBC
+# define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0'	      \
+		      || (optind < nonoption_flags_len			      \
+			  && __getopt_nonoption_flags[optind] == '1'))
+#else
+# define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0')
+#endif
+
+  if (nextchar == NULL || *nextchar == '\0')
+    {
+      /* Advance to the next ARGV-element.  */
+
+      /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been
+	 moved back by the user (who may also have changed the arguments).  */
+      if (last_nonopt > optind)
+	last_nonopt = optind;
+      if (first_nonopt > optind)
+	first_nonopt = optind;
+
+      if (ordering == PERMUTE)
+	{
+	  /* If we have just processed some options following some non-options,
+	     exchange them so that the options come first.  */
+
+	  if (first_nonopt != last_nonopt && last_nonopt != optind)
+	    exchange ((char **) argv);
+	  else if (last_nonopt != optind)
+	    first_nonopt = optind;
+
+	  /* Skip any additional non-options
+	     and extend the range of non-options previously skipped.  */
+
+	  while (optind < argc && NONOPTION_P)
+	    optind++;
+	  last_nonopt = optind;
+	}
+
+      /* The special ARGV-element `--' means premature end of options.
+	 Skip it like a null option,
+	 then exchange with previous non-options as if it were an option,
+	 then skip everything else like a non-option.  */
+
+      if (optind != argc && !strcmp (argv[optind], "--"))
+	{
+	  optind++;
+
+	  if (first_nonopt != last_nonopt && last_nonopt != optind)
+	    exchange ((char **) argv);
+	  else if (first_nonopt == last_nonopt)
+	    first_nonopt = optind;
+	  last_nonopt = argc;
+
+	  optind = argc;
+	}
+
+      /* If we have done all the ARGV-elements, stop the scan
+	 and back over any non-options that we skipped and permuted.  */
+
+      if (optind == argc)
+	{
+	  /* Set the next-arg-index to point at the non-options
+	     that we previously skipped, so the caller will digest them.  */
+	  if (first_nonopt != last_nonopt)
+	    optind = first_nonopt;
+	  return -1;
+	}
+
+      /* If we have come to a non-option and did not permute it,
+	 either stop the scan or describe it to the caller and pass it by.  */
+
+      if (NONOPTION_P)
+	{
+	  if (ordering == REQUIRE_ORDER)
+	    return -1;
+	  optarg = argv[optind++];
+	  return 1;
+	}
+
+      /* We have found another option-ARGV-element.
+	 Skip the initial punctuation.  */
+
+      nextchar = (argv[optind] + 1
+		  + (longopts != NULL && argv[optind][1] == '-'));
+    }
+
+  /* Decode the current option-ARGV-element.  */
+
+  /* Check whether the ARGV-element is a long option.
+
+     If long_only and the ARGV-element has the form "-f", where f is
+     a valid short option, don't consider it an abbreviated form of
+     a long option that starts with f.  Otherwise there would be no
+     way to give the -f short option.
+
+     On the other hand, if there's a long option "fubar" and
+     the ARGV-element is "-fu", do consider that an abbreviation of
+     the long option, just like "--fu", and not "-f" with arg "u".
+
+     This distinction seems to be the most useful approach.  */
+
+  if (longopts != NULL
+      && (argv[optind][1] == '-'
+	  || (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1])))))
+    {
+      char *nameend;
+      const struct option *p;
+      const struct option *pfound = NULL;
+      int exact = 0;
+      int ambig = 0;
+      int indfound = -1;
+      int option_index;
+
+      for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
+	/* Do nothing.  */ ;
+
+      /* Test all long options for either exact match
+	 or abbreviated matches.  */
+      for (p = longopts, option_index = 0; p->name; p++, option_index++)
+	if (!strncmp (p->name, nextchar, nameend - nextchar))
+	  {
+	    if ((unsigned int) (nameend - nextchar)
+		== (unsigned int) strlen (p->name))
+	      {
+		/* Exact match found.  */
+		pfound = p;
+		indfound = option_index;
+		exact = 1;
+		break;
+	      }
+	    else if (pfound == NULL)
+	      {
+		/* First nonexact match found.  */
+		pfound = p;
+		indfound = option_index;
+	      }
+	    else
+	      /* Second or later nonexact match found.  */
+	      ambig = 1;
+	  }
+
+      if (ambig && !exact)
+	{
+	  if (print_errors)
+	    fprintf (stderr, _("%s: option `%s' is ambiguous\n"),
+		     argv[0], argv[optind]);
+	  nextchar += strlen (nextchar);
+	  optind++;
+	  optopt = 0;
+	  return '?';
+	}
+
+      if (pfound != NULL)
+	{
+	  option_index = indfound;
+	  optind++;
+	  if (*nameend)
+	    {
+	      /* Don't test has_arg with >, because some C compilers don't
+		 allow it to be used on enums.  */
+	      if (pfound->has_arg)
+		optarg = nameend + 1;
+	      else
+		{
+		  if (print_errors)
+		    {
+		      if (argv[optind - 1][1] == '-')
+			/* --option */
+			fprintf (stderr,
+				 _("%s: option `--%s' doesn't allow an argument\n"),
+				 argv[0], pfound->name);
+		      else
+			/* +option or -option */
+			fprintf (stderr,
+				 _("%s: option `%c%s' doesn't allow an argument\n"),
+				 argv[0], argv[optind - 1][0], pfound->name);
+		    }
+
+		  nextchar += strlen (nextchar);
+
+		  optopt = pfound->val;
+		  return '?';
+		}
+	    }
+	  else if (pfound->has_arg == 1)
+	    {
+	      if (optind < argc)
+		optarg = argv[optind++];
+	      else
+		{
+		  if (print_errors)
+		    fprintf (stderr,
+			   _("%s: option `%s' requires an argument\n"),
+			   argv[0], argv[optind - 1]);
+		  nextchar += strlen (nextchar);
+		  optopt = pfound->val;
+		  return optstring[0] == ':' ? ':' : '?';
+		}
+	    }
+	  nextchar += strlen (nextchar);
+	  if (longind != NULL)
+	    *longind = option_index;
+	  if (pfound->flag)
+	    {
+	      *(pfound->flag) = pfound->val;
+	      return 0;
+	    }
+	  return pfound->val;
+	}
+
+      /* Can't find it as a long option.  If this is not getopt_long_only,
+	 or the option starts with '--' or is not a valid short
+	 option, then it's an error.
+	 Otherwise interpret it as a short option.  */
+      if (!long_only || argv[optind][1] == '-'
+	  || my_index (optstring, *nextchar) == NULL)
+	{
+	  if (print_errors)
+	    {
+	      if (argv[optind][1] == '-')
+		/* --option */
+		fprintf (stderr, _("%s: unrecognized option `--%s'\n"),
+			 argv[0], nextchar);
+	      else
+		/* +option or -option */
+		fprintf (stderr, _("%s: unrecognized option `%c%s'\n"),
+			 argv[0], argv[optind][0], nextchar);
+	    }
+	  nextchar = (char *) "";
+	  optind++;
+	  optopt = 0;
+	  return '?';
+	}
+    }
+
+  /* Look at and handle the next short option-character.  */
+
+  {
+    char c = *nextchar++;
+    char *temp = my_index (optstring, c);
+
+    /* Increment `optind' when we start to process its last character.  */
+    if (*nextchar == '\0')
+      ++optind;
+
+    if (temp == NULL || c == ':')
+      {
+	if (print_errors)
+	  {
+	    if (posixly_correct)
+	      /* 1003.2 specifies the format of this message.  */
+	      fprintf (stderr, _("%s: illegal option -- %c\n"),
+		       argv[0], c);
+	    else
+	      fprintf (stderr, _("%s: invalid option -- %c\n"),
+		       argv[0], c);
+	  }
+	optopt = c;
+	return '?';
+      }
+    /* Convenience. Treat POSIX -W foo same as long option --foo */
+    if (temp[0] == 'W' && temp[1] == ';')
+      {
+	char *nameend;
+	const struct option *p;
+	const struct option *pfound = NULL;
+	int exact = 0;
+	int ambig = 0;
+	int indfound = 0;
+	int option_index;
+
+	/* This is an option that requires an argument.  */
+	if (*nextchar != '\0')
+	  {
+	    optarg = nextchar;
+	    /* If we end this ARGV-element by taking the rest as an arg,
+	       we must advance to the next element now.  */
+	    optind++;
+	  }
+	else if (optind == argc)
+	  {
+	    if (print_errors)
+	      {
+		/* 1003.2 specifies the format of this message.  */
+		fprintf (stderr, _("%s: option requires an argument -- %c\n"),
+			 argv[0], c);
+	      }
+	    optopt = c;
+	    if (optstring[0] == ':')
+	      c = ':';
+	    else
+	      c = '?';
+	    return c;
+	  }
+	else
+	  /* We already incremented `optind' once;
+	     increment it again when taking next ARGV-elt as argument.  */
+	  optarg = argv[optind++];
+
+	/* optarg is now the argument, see if it's in the
+	   table of longopts.  */
+
+	for (nextchar = nameend = optarg; *nameend && *nameend != '='; nameend++)
+	  /* Do nothing.  */ ;
+
+	/* Test all long options for either exact match
+	   or abbreviated matches.  */
+	for (p = longopts, option_index = 0; p->name; p++, option_index++)
+	  if (!strncmp (p->name, nextchar, nameend - nextchar))
+	    {
+	      if ((unsigned int) (nameend - nextchar) == strlen (p->name))
+		{
+		  /* Exact match found.  */
+		  pfound = p;
+		  indfound = option_index;
+		  exact = 1;
+		  break;
+		}
+	      else if (pfound == NULL)
+		{
+		  /* First nonexact match found.  */
+		  pfound = p;
+		  indfound = option_index;
+		}
+	      else
+		/* Second or later nonexact match found.  */
+		ambig = 1;
+	    }
+	if (ambig && !exact)
+	  {
+	    if (print_errors)
+	      fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"),
+		       argv[0], argv[optind]);
+	    nextchar += strlen (nextchar);
+	    optind++;
+	    return '?';
+	  }
+	if (pfound != NULL)
+	  {
+	    option_index = indfound;
+	    if (*nameend)
+	      {
+		/* Don't test has_arg with >, because some C compilers don't
+		   allow it to be used on enums.  */
+		if (pfound->has_arg)
+		  optarg = nameend + 1;
+		else
+		  {
+		    if (print_errors)
+		      fprintf (stderr, _("\
+%s: option `-W %s' doesn't allow an argument\n"),
+			       argv[0], pfound->name);
+
+		    nextchar += strlen (nextchar);
+		    return '?';
+		  }
+	      }
+	    else if (pfound->has_arg == 1)
+	      {
+		if (optind < argc)
+		  optarg = argv[optind++];
+		else
+		  {
+		    if (print_errors)
+		      fprintf (stderr,
+			       _("%s: option `%s' requires an argument\n"),
+			       argv[0], argv[optind - 1]);
+		    nextchar += strlen (nextchar);
+		    return optstring[0] == ':' ? ':' : '?';
+		  }
+	      }
+	    nextchar += strlen (nextchar);
+	    if (longind != NULL)
+	      *longind = option_index;
+	    if (pfound->flag)
+	      {
+		*(pfound->flag) = pfound->val;
+		return 0;
+	      }
+	    return pfound->val;
+	  }
+	  nextchar = NULL;
+	  return 'W';	/* Let the application handle it.   */
+      }
+    if (temp[1] == ':')
+      {
+	if (temp[2] == ':')
+	  {
+	    /* This is an option that accepts an argument optionally.  */
+	    if (*nextchar != '\0')
+	      {
+		optarg = nextchar;
+		optind++;
+	      }
+	    else
+	      optarg = NULL;
+	    nextchar = NULL;
+	  }
+	else
+	  {
+	    /* This is an option that requires an argument.  */
+	    if (*nextchar != '\0')
+	      {
+		optarg = nextchar;
+		/* If we end this ARGV-element by taking the rest as an arg,
+		   we must advance to the next element now.  */
+		optind++;
+	      }
+	    else if (optind == argc)
+	      {
+		if (print_errors)
+		  {
+		    /* 1003.2 specifies the format of this message.  */
+		    fprintf (stderr,
+			     _("%s: option requires an argument -- %c\n"),
+			     argv[0], c);
+		  }
+		optopt = c;
+		if (optstring[0] == ':')
+		  c = ':';
+		else
+		  c = '?';
+	      }
+	    else
+	      /* We already incremented `optind' once;
+		 increment it again when taking next ARGV-elt as argument.  */
+	      optarg = argv[optind++];
+	    nextchar = NULL;
+	  }
+      }
+    return c;
+  }
+}
+
+int
+getopt ( int argc, char *const *argv, const char *optstring)
+{
+  return _getopt_internal (argc, argv, optstring,