Merge in build trunk work.

diff --git a/clients/memaslap.c b/clients/memaslap.c
index 37e93ec3f9efa3eb15c42ff6b6c0be402982062c..8053775cb3bb6e4565636367c9290ac9a1504401 100644 (file)
--- a/clients/memaslap.c
+++ b/clients/memaslap.c
@@ -594,7 +594,7 @@ static void ms_options_parse(int argc, char *argv[])
       break;
 
     case OPT_BINARY_PROTOCOL:       /* --binary or -B */
-      ms_setting.binary_prot= true;
+      ms_setting.binary_prot_= true;
       break;
 
     case OPT_TPS:       /* --tps or -P */
@@ -800,7 +800,6 @@ static void ms_print_memslap_stats(struct timeval *start_time,
 /* the loop of the main thread, wait the work threads to complete */
 static void ms_monitor_slap_mode()
 {
-  int second= 0;
   struct timeval start_time, end_time;
 
   /* Wait all the threads complete initialization. */
@@ -828,6 +827,7 @@ static void ms_monitor_slap_mode()
   /* running in "run time" mode, user specify run time */
   if (ms_setting.run_time > 0)
   {
+    int second= 0;
     gettimeofday(&start_time, NULL);
     while (1)
     {

diff --git a/clients/memcp.cc b/clients/memcp.cc
index 59bd7478bb780a89d447d9c8949b1381c7342baa..c56a79cdb7eff4109cb0247424b065e8f9a7c577 100644 (file)
--- a/clients/memcp.cc
+++ b/clients/memcp.cc
@@ -207,6 +207,7 @@ int main(int argc, char *argv[])
     if ((file_buffer_ptr= (char *)malloc(sizeof(char) * (size_t)sbuf.st_size)) == NULL)
     {
       std::cerr << "Error allocating file buffer(" << strerror(errno) << ")" << std::endl;
+      close(fd);
       exit(EXIT_FAILURE);
     }
 
@@ -214,12 +215,14 @@ int main(int argc, char *argv[])
     if ((read_length= ::read(fd, file_buffer_ptr, (size_t)sbuf.st_size)) == -1)
     {
       std::cerr << "Error while reading file " << file_buffer_ptr << " (" << strerror(errno) << ")" << std::endl;
+      close(fd);
       exit(EXIT_FAILURE);
     }
 
     if (read_length != sbuf.st_size)
     {
       std::cerr << "Failure while reading file. Read length was not equal to stat() length" << std::endl;
+      close(fd);
       exit(EXIT_FAILURE);
     }
 

diff --git a/clients/ms_conn.c b/clients/ms_conn.c
index 3a6fd8e7da3b4ce269cac9c8e9d4fde4e4d80310..b4d5f673d11df8ce616ec7494f1c3a4dc49faf76 100644 (file)
--- a/clients/ms_conn.c
+++ b/clients/ms_conn.c
@@ -358,7 +358,7 @@ static int ms_conn_init(ms_conn_t *c,
   c->mlget_task.mlget_num= 0;
   c->mlget_task.value_index= -1;         /* default invalid value */
 
-  if (ms_setting.binary_prot)
+  if (ms_setting.binary_prot_)
   {
     c->protocol= binary_prot;
   }

diff --git a/clients/ms_setting.c b/clients/ms_setting.c
index c3444c9aa78b203714d1473560b79a3d59247f0d..3eb4d0e6e9d9a79668f91aef06512864a46de338 100644 (file)
--- a/clients/ms_setting.c
+++ b/clients/ms_setting.c
@@ -683,7 +683,7 @@ static void ms_build_distr()
         exit(1);
       }
 
-      if (! ms_setting.binary_prot
+      if (! ms_setting.binary_prot_
           && ((start_len > MAX_KEY_SIZE) || (end_len > MAX_KEY_SIZE)))
       {
         fprintf(stderr, "key length must be less than 250 bytes.\n");
@@ -880,7 +880,7 @@ static void ms_setting_slapmode_init_pre()
   ms_setting.reconnect= false;
   ms_setting.verbose= false;
   ms_setting.facebook_test= false;
-  ms_setting.binary_prot= false;
+  ms_setting.binary_prot_= false;
   ms_setting.stat_freq= 0;
   ms_setting.srv_str= NULL;
   ms_setting.cfg_file= NULL;

diff --git a/clients/ms_setting.h b/clients/ms_setting.h
index 964dc40077284295db661cbf8285fd604f2030ce..ec060c4103d9a83930e5881f1cef1d2f29b38516 100644 (file)
--- a/clients/ms_setting.h
+++ b/clients/ms_setting.h
@@ -153,7 +153,7 @@ typedef struct setting
   bool verbose;                         /* whether it outputs detailed information when verification */
   bool facebook_test;                   /* facebook test, TCP set and multi-get with UDP */
   uint32_t sock_per_conn;                    /* number of socks per connection structure */
-  bool binary_prot;                     /* whether it use binary protocol */
+  bool binary_prot_;                     /* whether it use binary protocol */
   int expected_tps;                     /* expected throughput */
   uint32_t rep_write_srv;                    /* which servers are used to do replication writing */
 } ms_setting_st;

diff --git a/clients/ms_stats.c b/clients/ms_stats.c
index 49a5ab6e85e1782d10f5dde2e2ea15a6c418a857..8d62a5aaa1ebf1649171fa8955c5d990c0d16592 100644 (file)
--- a/clients/ms_stats.c
+++ b/clients/ms_stats.c
@@ -219,10 +219,6 @@ void ms_dump_format_stats(ms_stat_t *stat,
   double global_std= 0;
   double global_log= 0;
 
-  uint64_t diff_time= 0;
-  uint64_t diff_events= 0;
-  double diff_squares= 0;
-  double diff_log_product= 0;
   double period_average= 0;
   uint64_t period_tps= 0;
   double period_rate= 0;
@@ -241,17 +237,17 @@ void ms_dump_format_stats(ms_stat_t *stat,
                     * global_average) / (double)(events - 1));
   global_log= exp(stat->log_product / (double)events);
 
-  diff_time= stat->total_time - stat->pre_total_time;
-  diff_events= events - stat->pre_events;
+  uint64_t diff_time= stat->total_time - stat->pre_total_time;
+  uint64_t diff_events= events - stat->pre_events;
   if (diff_events >= 1)
   {
     period_average= (double)(diff_time / diff_events);
     period_tps= diff_events / (uint64_t)freq;
     period_rate= (double)diff_events * obj_size / 1024 / 1024 / freq;
-    diff_squares= (double)stat->squares - (double)stat->pre_squares;
+    double diff_squares= (double)stat->squares - (double)stat->pre_squares;
     period_std= sqrt((diff_squares - (double)diff_events * period_average
                       * period_average) / (double)(diff_events - 1));
-    diff_log_product= stat->log_product - stat->pre_log_product;
+    double diff_log_product= stat->log_product - stat->pre_log_product;
     period_log= exp(diff_log_product / (double)diff_events);
   }
 

diff --git a/configure.ac b/configure.ac
index 13ecc5795615456e6991721395912f26d087c448..97934a57bdee60b9c3dac7f4bd1e0392a1f62be8 100644 (file)
--- a/configure.ac
+++ b/configure.ac
@@ -293,8 +293,6 @@ if test $ac_cv_c_endian = little; then
 fi
 ])
 
-AC_C_ENDIAN
-
 AX_CHECK_SOCK_CLOEXEC([AC_DEFINE([HAVE_SOCK_CLOEXEC], [1], [Check for SOCK_CLOEXEC.])],
                        [AC_DEFINE([HAVE_SOCK_CLOEXEC], [0], [Check for SOCK_CLOEXEC.])])
 

diff --git a/libmemcached-1.0/memcached.hpp b/libmemcached-1.0/memcached.hpp
index 4e1e17780c31faa6e93710137597ccd2a1f0a473..4f12e2ec833be1abd86a2deaf2bd3f2d6b94b221 100644 (file)
--- a/libmemcached-1.0/memcached.hpp
+++ b/libmemcached-1.0/memcached.hpp
@@ -75,39 +75,39 @@ public:
 
   Memcache()
   {
-    memc= memcached("", 0);
+    memc_= memcached(NULL, 0);
   }
 
   Memcache(const std::string &config)
   {
-    memc= memcached(config.c_str(), config.size());
+    memc_= memcached(config.c_str(), config.size());
   }
 
   Memcache(const std::string &hostname, in_port_t port)
   {
-    memc= memcached("", 0);
-    if (memc)
+    memc_= memcached(NULL, 0);
+    if (memc_)
     {
-      memcached_server_add(memc, hostname.c_str(), port);
+      memcached_server_add(memc_, hostname.c_str(), port);
     }
   }
 
   Memcache(memcached_st *clone)
   {
-    memc= memcached_clone(NULL, clone);
+    memc_= memcached_clone(NULL, clone);
   }
 
   Memcache(const Memcache &rhs)
   {
-    memc= memcached_clone(NULL, rhs.getImpl());
+    memc_= memcached_clone(NULL, rhs.getImpl());
   }
 
   Memcache &operator=(const Memcache &rhs)
   {
     if (this != &rhs)
     {
-      memcached_free(memc);
-      memc= memcached_clone(NULL, rhs.getImpl());
+      memcached_free(memc_);
+      memc_= memcached_clone(NULL, rhs.getImpl());
     }
 
     return *this;
@@ -115,7 +115,7 @@ public:
 
   ~Memcache()
   {
-    memcached_free(memc);
+    memcached_free(memc_);
   }
 
   /**
@@ -123,7 +123,7 @@ public:
    */
   const memcached_st *getImpl() const
   {
-    return memc;
+    return memc_;
   }
 
   /**
@@ -140,9 +140,9 @@ public:
 
   bool error(std::string& error_message) const
   {
-    if (memcached_failed(memcached_last_error(memc)))
+    if (memcached_failed(memcached_last_error(memc_)))
     {
-      error_message+= memcached_last_error_message(memc);
+      error_message+= memcached_last_error_message(memc_);
       return true;
     }
 
@@ -151,7 +151,7 @@ public:
 
   bool error() const
   {
-    if (memcached_failed(memcached_last_error(memc)))
+    if (memcached_failed(memcached_last_error(memc_)))
     {
       return true;
     }
@@ -161,18 +161,18 @@ public:
 
   bool error(memcached_return_t& arg) const
   {
-    arg= memcached_last_error(memc);
+    arg= memcached_last_error(memc_);
     return memcached_failed(arg);
   }
 
   bool setBehavior(memcached_behavior_t flag, uint64_t data)
   {
-    return (memcached_success(memcached_behavior_set(memc, flag, data)));
+    return (memcached_success(memcached_behavior_set(memc_, flag, data)));
   }
 
   uint64_t getBehavior(memcached_behavior_t flag)
   {
-    return memcached_behavior_get(memc, flag);
+    return memcached_behavior_get(memc_, flag);
   }
 
   /**
@@ -187,8 +187,8 @@ public:
 
     if (new_memc)
     {
-      memcached_free(memc);
-      memc= new_memc;
+      memcached_free(memc_);
+      memc_= new_memc;
 
       return true;
     }
@@ -205,7 +205,7 @@ public:
    */
   bool addServer(const std::string &server_name, in_port_t port)
   {
-    return memcached_success(memcached_server_add(memc, server_name.c_str(), port));
+    return memcached_success(memcached_server_add(memc_, server_name.c_str(), port));
   }
 
   /**
@@ -246,7 +246,7 @@ public:
     memcached_return_t rc;
 
     memcached_result_st *result;
-    if ((result= memcached_fetch_result(memc, NULL, &rc)))
+    if ((result= memcached_fetch_result(memc_, NULL, &rc)))
     {
       // Key
       key.assign(memcached_result_key_value(result), memcached_result_key_length(result));
@@ -254,7 +254,8 @@ public:
       // Actual value, null terminated
       ret_val.reserve(memcached_result_length(result) +1);
       ret_val.assign(memcached_result_value(result),
-                     memcached_result_value(result) +memcached_result_length(result));
+                     memcached_result_value(result) +memcached_result_length(result) +1);
+      ret_val.resize(memcached_result_length(result));
 
       // Misc
       flags= memcached_result_flags(result);
@@ -288,13 +289,15 @@ public:
     memcached_return_t rc;
     size_t value_length= 0;
 
-    char *value= memcached_get(memc, key.c_str(), key.length(),
+    char *value= memcached_get(memc_, key.c_str(), key.length(),
                                &value_length, &flags, &rc);
     if (value != NULL && ret_val.empty())
     {
-      ret_val.reserve(value_length);
-      ret_val.assign(value, value +value_length);
+      ret_val.reserve(value_length +1); // Always provide null
+      ret_val.assign(value, value +value_length +1);
+      ret_val.resize(value_length);
       free(value);
+
       return true;
     }
 
@@ -321,15 +324,17 @@ public:
     memcached_return_t rc;
     size_t value_length= 0;
 
-    char *value= memcached_get_by_key(memc,
+    char *value= memcached_get_by_key(memc_,
                                       master_key.c_str(), master_key.length(),
                                       key.c_str(), key.length(),
                                       &value_length, &flags, &rc);
     if (value)
     {
-      ret_val.reserve(value_length);
-      ret_val.assign(value, value +value_length);
+      ret_val.reserve(value_length +1); // Always provide null
+      ret_val.assign(value, value +value_length +1);
+      ret_val.resize(value_length);
       free(value);
+
       return true;
     }
     return false;
@@ -370,7 +375,7 @@ public:
      */
     if (not real_keys.empty())
     {
-      return memcached_success(memcached_mget(memc, &real_keys[0], &key_len[0], real_keys.size()));
+      return memcached_success(memcached_mget(memc_, &real_keys[0], &key_len[0], real_keys.size()));
     }
 
     return false;
@@ -392,13 +397,25 @@ public:
            time_t expiration,
            uint32_t flags)
   {
-    memcached_return_t rc= memcached_set(memc,
+    memcached_return_t rc= memcached_set(memc_,
                                          key.c_str(), key.length(),
                                          &value[0], value.size(),
                                          expiration, flags);
     return memcached_success(rc);
   }
 
+  bool set(const std::string &key,
+           const char* value, const size_t value_length,
+           time_t expiration,
+           uint32_t flags)
+  {
+    memcached_return_t rc= memcached_set(memc_,
+                                         key.c_str(), key.length(),
+                                         value, value_length,
+                                         expiration, flags);
+    return memcached_success(rc);
+  }
+
   /**
    * Writes an object to a server specified by the master_key parameter.
    * If the object already exists, it will overwrite the existing object.
@@ -416,7 +433,7 @@ public:
                 time_t expiration,
                 uint32_t flags)
   {
-    return memcached_success(memcached_set_by_key(memc, master_key.c_str(),
+    return memcached_success(memcached_set_by_key(memc_, master_key.c_str(),
                                                   master_key.length(),
                                                   key.c_str(), key.length(),
                                                   &value[0], value.size(),
@@ -497,7 +514,7 @@ public:
    */
   bool increment(const std::string& key, uint32_t offset, uint64_t *value)
   {
-    return memcached_success(memcached_increment(memc, key.c_str(), key.length(), offset, value));
+    return memcached_success(memcached_increment(memc_, key.c_str(), key.length(), offset, value));
   }
 
   /**
@@ -512,7 +529,7 @@ public:
    */
   bool decrement(const std::string& key, uint32_t offset, uint64_t *value)
   {
-    return memcached_success(memcached_decrement(memc, key.c_str(),
+    return memcached_success(memcached_decrement(memc_, key.c_str(),
                                                  key.length(),
                                                  offset, value));
   }
@@ -528,7 +545,7 @@ public:
    */
   bool add(const std::string& key, const std::vector<char>& value)
   {
-    return memcached_success(memcached_add(memc, key.c_str(), key.length(),
+    return memcached_success(memcached_add(memc_, key.c_str(), key.length(),
                                            &value[0], value.size(), 0, 0));
   }
 
@@ -546,7 +563,7 @@ public:
                 const std::string& key,
                 const std::vector<char>& value)
   {
-    return memcached_success(memcached_add_by_key(memc,
+    return memcached_success(memcached_add_by_key(memc_,
                                                   master_key.c_str(),
                                                   master_key.length(),
                                                   key.c_str(),
@@ -566,7 +583,7 @@ public:
    */
   bool replace(const std::string& key, const std::vector<char>& value)
   {
-    return memcached_success(memcached_replace(memc, key.c_str(), key.length(),
+    return memcached_success(memcached_replace(memc_, key.c_str(), key.length(),
                                                &value[0], value.size(),
                                                0, 0));
   }
@@ -585,7 +602,7 @@ public:
                     const std::string& key,
                     const std::vector<char>& value)
   {
-    return memcached_success(memcached_replace_by_key(memc,
+    return memcached_success(memcached_replace_by_key(memc_,
                                                       master_key.c_str(),
                                                       master_key.length(),
                                                       key.c_str(),
@@ -604,7 +621,7 @@ public:
    */
   bool prepend(const std::string& key, const std::vector<char>& value)
   {
-    return memcached_success(memcached_prepend(memc, key.c_str(), key.length(),
+    return memcached_success(memcached_prepend(memc_, key.c_str(), key.length(),
                                                &value[0], value.size(), 0, 0));
   }
 
@@ -622,7 +639,7 @@ public:
                     const std::string& key,
                     const std::vector<char>& value)
   {
-    return memcached_success(memcached_prepend_by_key(memc,
+    return memcached_success(memcached_prepend_by_key(memc_,
                                                       master_key.c_str(),
                                                       master_key.length(),
                                                       key.c_str(),
@@ -642,7 +659,7 @@ public:
    */
   bool append(const std::string& key, const std::vector<char>& value)
   {
-    return memcached_success(memcached_append(memc,
+    return memcached_success(memcached_append(memc_,
                                               key.c_str(),
                                               key.length(),
                                               &value[0],
@@ -664,7 +681,7 @@ public:
                    const std::string& key,
                    const std::vector<char> &value)
   {
-    return memcached_success(memcached_append_by_key(memc,
+    return memcached_success(memcached_append_by_key(memc_,
                                                      master_key.c_str(),
                                                      master_key.length(),
                                                      key.c_str(),
@@ -686,7 +703,7 @@ public:
            const std::vector<char>& value,
            uint64_t cas_arg)
   {
-    return memcached_success(memcached_cas(memc, key.c_str(), key.length(),
+    return memcached_success(memcached_cas(memc_, key.c_str(), key.length(),
                                            &value[0], value.size(),
                                            0, 0, cas_arg));
   }
@@ -706,7 +723,7 @@ public:
                 const std::vector<char> &value,
                 uint64_t cas_arg)
   {
-    return memcached_success(memcached_cas_by_key(memc,
+    return memcached_success(memcached_cas_by_key(memc_,
                                                   master_key.c_str(),
                                                   master_key.length(),
                                                   key.c_str(),
@@ -724,7 +741,7 @@ public:
    */
   bool remove(const std::string& key)
   {
-    return memcached_success(memcached_delete(memc, key.c_str(), key.length(), 0));
+    return memcached_success(memcached_delete(memc_, key.c_str(), key.length(), 0));
   }
 
   /**
@@ -736,7 +753,7 @@ public:
    */
   bool remove(const std::string& key, time_t expiration)
   {
-    return memcached_success(memcached_delete(memc,
+    return memcached_success(memcached_delete(memc_,
                                               key.c_str(),
                                               key.length(),
                                               expiration));
@@ -752,7 +769,7 @@ public:
   bool removeByKey(const std::string& master_key,
                    const std::string& key)
   {
-    return memcached_success(memcached_delete_by_key(memc,
+    return memcached_success(memcached_delete_by_key(memc_,
                                                      master_key.c_str(),
                                                      master_key.length(),
                                                      key.c_str(),
@@ -772,7 +789,7 @@ public:
                    const std::string& key,
                    time_t expiration)
   {
-    return memcached_success(memcached_delete_by_key(memc,
+    return memcached_success(memcached_delete_by_key(memc_,
                                                      master_key.c_str(),
                                                      master_key.length(),
                                                      key.c_str(),
@@ -789,7 +806,7 @@ public:
    */
   bool flush(time_t expiration= 0)
   {
-    return memcached_success(memcached_flush(memc, expiration));
+    return memcached_success(memcached_flush(memc_, expiration));
   }
 
   /**
@@ -814,7 +831,7 @@ public:
   bool getStats(std::map< std::string, std::map<std::string, std::string> >& stats_map)
   {
     memcached_return_t rc;
-    memcached_stat_st *stats= memcached_stat(memc, NULL, &rc);
+    memcached_stat_st *stats= memcached_stat(memc_, NULL, &rc);
 
     if (rc != MEMCACHED_SUCCESS &&
         rc != MEMCACHED_SOME_ERRORS)
@@ -822,7 +839,7 @@ public:
       return false;
     }
 
-    uint32_t server_count= memcached_server_count(memc);
+    uint32_t server_count= memcached_server_count(memc_);
 
     /*
      * For each memcached server, construct a std::map for its stats and add
@@ -830,7 +847,7 @@ public:
      */
     for (uint32_t x= 0; x < server_count; x++)
     {
-      memcached_server_instance_st instance= memcached_server_instance_by_position(memc, x);
+      memcached_server_instance_st instance= memcached_server_instance_by_position(memc_, x);
       std::ostringstream strstm;
       std::string server_name(memcached_server_name(instance));
       server_name.append(":");
@@ -838,10 +855,10 @@ public:
       server_name.append(strstm.str());
 
       std::map<std::string, std::string> server_stats;
-      char **list= memcached_stat_get_keys(memc, &stats[x], &rc);
+      char **list= memcached_stat_get_keys(memc_, &stats[x], &rc);
       for (char** ptr= list; *ptr; ptr++)
       {
-        char *value= memcached_stat_get_value(memc, &stats[x], *ptr, &rc);
+        char *value= memcached_stat_get_value(memc_, &stats[x], *ptr, &rc);
         server_stats[*ptr]= value;
         free(value);
       }
@@ -850,12 +867,12 @@ public:
       free(list);
     }
 
-    memcached_stat_free(memc, stats);
+    memcached_stat_free(memc_, stats);
     return true;
   }
 
 private:
-  memcached_st *memc;
+  memcached_st *memc_;
 };
 
 }

diff --git a/libmemcached-1.0/server.h b/libmemcached-1.0/server.h
index f6430ecadee90c8cf00839ebdb4af147753ce586..dc650d2a041867a2f17b59e96f941ef36d114494 100644 (file)
--- a/libmemcached-1.0/server.h
+++ b/libmemcached-1.0/server.h
@@ -103,6 +103,9 @@ const char *memcached_server_name(const memcached_server_instance_st self);
 LIBMEMCACHED_API
 in_port_t memcached_server_port(const memcached_server_instance_st self);
 
+LIBMEMCACHED_API
+void memcached_instance_next_retry(memcached_server_instance_st self, const time_t absolute_time);
+
 LIBMEMCACHED_API
 const char *memcached_server_type(const memcached_server_instance_st ptr);
 

diff --git a/libmemcached-1.0/struct/memcached.h b/libmemcached-1.0/struct/memcached.h
index 138f9ef9ea623e9c88bc5fcd6ee90d1a07298702..63b07a00e80a8b3b6219524515e6ef756a51ac94 100644 (file)
--- a/libmemcached-1.0/struct/memcached.h
+++ b/libmemcached-1.0/struct/memcached.h
@@ -45,6 +45,7 @@ struct memcached_st {
     bool is_purging:1;
     bool is_processing_input:1;
     bool is_time_for_rebuild:1;
+    bool not_used:1;
   } state;
 
   struct {
@@ -63,6 +64,8 @@ struct memcached_st {
     bool verify_key:1;
     bool tcp_keepalive:1;
     bool is_aes:1;
+    bool is_fetching_version:1;
+    bool not_used:1;
   } flags;
 
   memcached_server_distribution_t distribution;
@@ -71,8 +74,13 @@ struct memcached_st {
     unsigned int version;
   } server_info;
   uint32_t number_of_hosts;
-  struct memcached_instance_st *servers;
-  struct memcached_instance_st *last_disconnected_server;
+#ifdef __cplusplus
+  org::libmemcached::Instance* servers;
+  org::libmemcached::Instance* last_disconnected_server;
+#else
+  void *servers;
+  void *last_disconnected_server;
+#endif
   int32_t snd_timeout;
   int32_t rcv_timeout;
   uint32_t server_failure_limit;
@@ -92,11 +100,11 @@ struct memcached_st {
   memcached_result_st result;
 
   struct {
-    bool weighted;
+    bool weighted_;
     uint32_t continuum_count; // Ketama
     uint32_t continuum_points_counter; // Ketama
     time_t next_distribution_rebuild; // Ketama
-    memcached_continuum_item_st *continuum; // Ketama
+    struct memcached_continuum_item_st *continuum; // Ketama
   } ketama;
 
   struct memcached_virtual_bucket_t *virtual_bucket;

diff --git a/libmemcached-1.0/struct/server.h b/libmemcached-1.0/struct/server.h
index fe984d1ce991bd92baf4a334569879b9641691ea..a8a30565bc3c8fcb7d60bf3acf49da48b37face4 100644 (file)
--- a/libmemcached-1.0/struct/server.h
+++ b/libmemcached-1.0/struct/server.h
@@ -59,7 +59,8 @@ enum memcached_server_state_t {
   MEMCACHED_SERVER_STATE_ADDRINFO, // ADDRRESS information has been gathered
   MEMCACHED_SERVER_STATE_IN_PROGRESS,
   MEMCACHED_SERVER_STATE_CONNECTED,
-  MEMCACHED_SERVER_STATE_IN_TIMEOUT
+  MEMCACHED_SERVER_STATE_IN_TIMEOUT,
+  MEMCACHED_SERVER_STATE_DISABLED
 };
 
 struct memcached_server_st {

diff --git a/libmemcached-1.0/types.h b/libmemcached-1.0/types.h
index 7ae29c2e495b021683b9ebd5fc82bf85d3f5fe5f..dc61a819c5457a5f1350a7a7a5ab618349c15138 100644 (file)
--- a/libmemcached-1.0/types.h
+++ b/libmemcached-1.0/types.h
@@ -39,6 +39,9 @@
 #pragma once
 
 #ifdef __cplusplus
+
+namespace org { namespace libmemcached { class Instance; } }
+
 struct memcached_st;
 struct memcached_stat_st;
 struct memcached_analysis_st;
@@ -49,7 +52,7 @@ struct memcached_error_t;
 // All of the flavors of memcache_server_st
 struct memcached_server_st;
 struct memcached_instance_st;
-typedef const struct memcached_instance_st *memcached_server_instance_st;
+typedef const org::libmemcached::Instance* memcached_server_instance_st;
 typedef struct memcached_server_st *memcached_server_list_st;
 
 struct memcached_callback_st;
@@ -70,7 +73,7 @@ typedef struct memcached_error_t memcached_error_t;
 
 // All of the flavors of memcache_server_st
 typedef struct memcached_server_st memcached_server_st;
-typedef const struct memcached_server_st *memcached_server_instance_st;
+typedef const void *memcached_server_instance_st;
 typedef struct memcached_server_st *memcached_server_list_st;
 
 typedef struct memcached_callback_st memcached_callback_st;
@@ -78,6 +81,5 @@ typedef struct memcached_callback_st memcached_callback_st;
 // The following two structures are internal, and never exposed to users.
 typedef struct memcached_string_st memcached_string_st;
 typedef struct memcached_string_t memcached_string_t;
-typedef struct memcached_continuum_item_st memcached_continuum_item_st;
 
 #endif

diff --git a/libmemcached/auto.cc b/libmemcached/auto.cc
index adce334873fe69b15bc0abe8ec6abfe195d313ec..4196b6683deb4fc8a8affa6db2bd29ca584a4103 100644 (file)
--- a/libmemcached/auto.cc
+++ b/libmemcached/auto.cc
@@ -37,7 +37,7 @@
 
 #include <libmemcached/common.h>
 
-static void auto_response(memcached_server_write_instance_st instance, const bool reply,  memcached_return_t& rc, uint64_t* value)
+static void auto_response(org::libmemcached::Instance* instance, const bool reply,  memcached_return_t& rc, uint64_t* value)
 {
   // If the message was successfully sent, then get the response, otherwise
   // fail.
@@ -62,7 +62,7 @@ static void auto_response(memcached_server_write_instance_st instance, const boo
   }
 }
 
-static memcached_return_t text_incr_decr(memcached_server_write_instance_st instance,
+static memcached_return_t text_incr_decr(org::libmemcached::Instance* instance,
                                          const bool is_incr,
                                          const char *key, size_t key_length,
                                          const uint64_t offset,
@@ -96,7 +96,7 @@ static memcached_return_t text_incr_decr(memcached_server_write_instance_st inst
   return memcached_vdo(instance, vector, 7, true);
 }
 
-static memcached_return_t binary_incr_decr(memcached_server_write_instance_st instance,
+static memcached_return_t binary_incr_decr(org::libmemcached::Instance* instance,
                                            protocol_binary_command cmd,
                                            const char *key, const size_t key_length,
                                            const uint64_t offset,
@@ -179,7 +179,7 @@ static memcached_return_t increment_decrement_by_key(const protocol_binary_comma
   }
 
   uint32_t server_key= memcached_generate_hash_with_redistribution(memc, group_key, group_key_length);
-  memcached_server_write_instance_st instance= memcached_server_instance_fetch(memc, server_key);
+  org::libmemcached::Instance* instance= memcached_instance_fetch(memc, server_key);
 
   bool reply= memcached_is_replying(instance->root);
 
@@ -238,7 +238,7 @@ static memcached_return_t increment_decrement_with_initial_by_key(const protocol
   }
 
   uint32_t server_key= memcached_generate_hash_with_redistribution(memc, group_key, group_key_length);
-  memcached_server_write_instance_st instance= memcached_server_instance_fetch(memc, server_key);
+  org::libmemcached::Instance* instance= memcached_instance_fetch(memc, server_key);
 
   bool reply= memcached_is_replying(instance->root);
 

diff --git a/libmemcached/behavior.cc b/libmemcached/behavior.cc
index fd096db24f5043cabceb7f2caae15f0b924205f5..c381a513cfbceab5322de4507da5b29698e0403b 100644 (file)
--- a/libmemcached/behavior.cc
+++ b/libmemcached/behavior.cc
@@ -42,9 +42,9 @@
 #include <ctime>
 #include <sys/types.h>
 
-static bool __is_ketama(memcached_st *ptr)
+bool memcached_is_consistent_distribution(const memcached_st* memc)
 {
-  switch (ptr->distribution)
+  switch (memc->distribution)
   {
   case MEMCACHED_DISTRIBUTION_CONSISTENT:
   case MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA:
@@ -355,9 +355,9 @@ uint64_t memcached_behavior_get(memcached_st *ptr,
     return ptr->flags.verify_key;
 
   case MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED:
-    if (__is_ketama(ptr))
+    if (memcached_is_consistent_distribution(ptr))
     {
-      return ptr->ketama.weighted;
+      return memcached_is_weighted_ketama(ptr);
     }
     return false;
 
@@ -365,7 +365,7 @@ uint64_t memcached_behavior_get(memcached_st *ptr,
     return ptr->distribution;
 
   case MEMCACHED_BEHAVIOR_KETAMA:
-    return __is_ketama(ptr);
+    return memcached_is_consistent_distribution(ptr);
 
   case MEMCACHED_BEHAVIOR_HASH:
     return hashkit_get_function(&ptr->hashkit);
@@ -411,7 +411,7 @@ uint64_t memcached_behavior_get(memcached_st *ptr,
         return (uint64_t) ptr->send_size;
       }
 
-      memcached_server_write_instance_st instance= memcached_server_instance_fetch(ptr, 0);
+      org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, 0);
 
       if (instance) // If we have an instance we test, otherwise we just set and pray
       {
@@ -445,7 +445,7 @@ uint64_t memcached_behavior_get(memcached_st *ptr,
       if (ptr->recv_size != -1) // If value is -1 then we are using the default
         return (uint64_t) ptr->recv_size;
 
-      memcached_server_write_instance_st instance= memcached_server_instance_fetch(ptr, 0);
+      org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, 0);
 
       /**
         @note REFACTOR
@@ -522,7 +522,7 @@ memcached_return_t memcached_behavior_set_distribution(memcached_st *ptr, memcac
 
   case MEMCACHED_DISTRIBUTION_CONSISTENT:
   case MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA:
-    ptr->ketama.weighted= false;
+    memcached_set_weighted_ketama(ptr, false);
     break;
 
   case MEMCACHED_DISTRIBUTION_RANDOM:
@@ -532,7 +532,7 @@ memcached_return_t memcached_behavior_set_distribution(memcached_st *ptr, memcac
     break;
 
   case MEMCACHED_DISTRIBUTION_CONSISTENT_WEIGHTED:
-    ptr->ketama.weighted= true;
+    memcached_set_weighted_ketama(ptr, true);
     break;
 
   case MEMCACHED_DISTRIBUTION_VIRTUAL_BUCKET:

diff --git a/libmemcached/behavior.hpp b/libmemcached/behavior.hpp
index ee38f97a0f29be315f2a085122884d32ea9672c8..0b06c0caf23a1131e38e4fe01ce94c5d6429d902 100644 (file)
--- a/libmemcached/behavior.hpp
+++ b/libmemcached/behavior.hpp
@@ -36,4 +36,5 @@
 
 #pragma once
 
+bool memcached_is_consistent_distribution(const memcached_st*);
 bool _is_auto_eject_host(const memcached_st *ptr);

diff --git a/libmemcached/common.h b/libmemcached/common.h
index 92f44de4f7198ac489eec4d2efa7ae7578703e8c..a3e4ea90310b73ae02808babd0142d6886949912 100644 (file)
--- a/libmemcached/common.h
+++ b/libmemcached/common.h
@@ -82,25 +82,24 @@
 #include "poll/poll.h"
 #endif
 
-
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 typedef memcached_return_t (*memcached_server_execute_fn)(memcached_st *ptr, memcached_server_write_instance_st server, void *context);
 
-LIBMEMCACHED_LOCAL
-memcached_server_write_instance_st memcached_server_instance_fetch(memcached_st *ptr, uint32_t server_key);
-
-LIBMEMCACHED_LOCAL
-memcached_return_t memcached_server_execute(memcached_st *ptr,
-                                            memcached_server_execute_fn callback,
-                                            void *context);
 #ifdef __cplusplus
 } // extern "C"
 #endif
 
 
+#ifdef __cplusplus
+org::libmemcached::Instance* memcached_instance_fetch(memcached_st *ptr, uint32_t server_key);
+#endif
+
+memcached_return_t memcached_server_execute(memcached_st *ptr,
+                                            memcached_server_execute_fn callback,
+                                            void *context);
 /* These are private not to be installed headers */
 #include <libmemcached/error.hpp>
 #include <libmemcached/memory.h>
@@ -118,6 +117,7 @@ memcached_return_t memcached_server_execute(memcached_st *ptr,
 #include <libmemcached/quit.hpp>
 #include <libmemcached/instance.hpp>
 #include <libmemcached/server.hpp>
+#include <libmemcached/flag.hpp>
 #include <libmemcached/behavior.hpp>
 #include <libmemcached/sasl.hpp>
 #include <libmemcached/server_list.hpp>
@@ -140,6 +140,7 @@ memcached_return_t memcached_server_execute(memcached_st *ptr,
 #include <libmemcached/key.hpp>
 #include <libmemcached/encoding_key.h>
 #include <libmemcached/result.h>
+#include <libmemcached/version.hpp>
 #endif
 
 #include <libmemcached/continuum.hpp>
@@ -164,21 +165,21 @@ memcached_return_t memcached_server_execute(memcached_st *ptr,
 extern "C" {
 #endif
 
-LIBMEMCACHED_LOCAL
 memcached_return_t run_distribution(memcached_st *ptr);
 
-#define memcached_server_response_increment(A) (A)->cursor_active++
-#define memcached_server_response_decrement(A) (A)->cursor_active--
-#define memcached_server_response_reset(A) (A)->cursor_active=0
-
-#define memcached_instance_response_increment(A) (A)->cursor_active++
-#define memcached_instance_response_decrement(A) (A)->cursor_active--
-#define memcached_instance_response_reset(A) (A)->cursor_active=0
+#define memcached_server_response_increment(A) (A)->cursor_active_++
+#define memcached_server_response_decrement(A) (A)->cursor_active_--
+#define memcached_server_response_reset(A) (A)->cursor_active_=0
 
-bool memcached_purge(memcached_server_write_instance_st ptr);
-
-struct memcached_instance_st* memcached_instance_by_position(const memcached_st *ptr, uint32_t server_key);
+#define memcached_instance_response_increment(A) (A)->cursor_active_++
+#define memcached_instance_response_decrement(A) (A)->cursor_active_--
+#define memcached_instance_response_reset(A) (A)->cursor_active_=0
 
 #ifdef __cplusplus
 }
 #endif
+
+#ifdef __cplusplus
+bool memcached_purge(org::libmemcached::Instance*);
+org::libmemcached::Instance* memcached_instance_by_position(const memcached_st *ptr, uint32_t server_key);
+#endif

diff --git a/libmemcached/connect.cc b/libmemcached/connect.cc
index a8a2c5a4631126cef98200eacfe263a7ab680579..5a5d899d23786d8f9ccebe5fb113e21887e8461a 100644 (file)
--- a/libmemcached/connect.cc
+++ b/libmemcached/connect.cc
@@ -46,7 +46,7 @@
 #define SOCK_CLOEXEC 0
 #endif
 
-static memcached_return_t connect_poll(memcached_instance_st *server)
+static memcached_return_t connect_poll(org::libmemcached::Instance* server)
 {
   struct pollfd fds[1];
   fds[0].fd= server->fd;
@@ -139,7 +139,7 @@ static memcached_return_t connect_poll(memcached_instance_st *server)
   return memcached_set_errno(*server, get_socket_errno(), MEMCACHED_AT);
 }
 
-static memcached_return_t set_hostinfo(memcached_instance_st *server)
+static memcached_return_t set_hostinfo(org::libmemcached::Instance* server)
 {
   assert(server->type != MEMCACHED_CONNECTION_UNIX_SOCKET);
   if (server->address_info)
@@ -150,8 +150,8 @@ static memcached_return_t set_hostinfo(memcached_instance_st *server)
   }
 
   char str_port[NI_MAXSERV];
-  int length= snprintf(str_port, NI_MAXSERV, "%u", (uint32_t)server->port);
-  if (length >= NI_MAXSERV or length < 0)
+  int length= snprintf(str_port, NI_MAXSERV, "%u", uint32_t(server->port()));
+  if (length >= NI_MAXSERV or length <= 0)
   {
     return MEMCACHED_FAILURE;
   }
@@ -203,7 +203,7 @@ static memcached_return_t set_hostinfo(memcached_instance_st *server)
   return MEMCACHED_SUCCESS;
 }
 
-static inline void set_socket_nonblocking(memcached_instance_st *server)
+static inline void set_socket_nonblocking(org::libmemcached::Instance* server)
 {
 #ifdef WIN32
   u_long arg= 1;
@@ -240,7 +240,7 @@ static inline void set_socket_nonblocking(memcached_instance_st *server)
 #endif
 }
 
-static void set_socket_options(memcached_instance_st *server)
+static void set_socket_options(org::libmemcached::Instance* server)
 {
   assert_msg(server->fd != INVALID_SOCKET, "invalid socket was passed to set_socket_options()");
 
@@ -349,7 +349,7 @@ static void set_socket_options(memcached_instance_st *server)
   set_socket_nonblocking(server);
 }
 
-static memcached_return_t unix_socket_connect(memcached_instance_st *server)
+static memcached_return_t unix_socket_connect(org::libmemcached::Instance* server)
 {
 #ifndef WIN32
   WATCHPOINT_ASSERT(server->fd == INVALID_SOCKET);
@@ -400,12 +400,12 @@ static memcached_return_t unix_socket_connect(memcached_instance_st *server)
 #endif
 }
 
-static memcached_return_t network_connect(memcached_instance_st *server)
+static memcached_return_t network_connect(org::libmemcached::Instance* server)
 {
   bool timeout_error_occured= false;
 
   WATCHPOINT_ASSERT(server->fd == INVALID_SOCKET);
-  WATCHPOINT_ASSERT(server->cursor_active == 0);
+  WATCHPOINT_ASSERT(server->cursor_active_ == 0);
 
   /*
     We want to check both of these because if address_info_next has been fully tried, we want to do a new lookup to make sure we have picked up on any new DNS information.
@@ -572,7 +572,7 @@ static memcached_return_t network_connect(memcached_instance_st *server)
   Based on time/failure count fail the connect without trying. This prevents waiting in a state where
   we get caught spending cycles just waiting.
 */
-static memcached_return_t backoff_handling(memcached_server_write_instance_st server, bool& in_timeout)
+static memcached_return_t backoff_handling(org::libmemcached::Instance* server, bool& in_timeout)
 {
   struct timeval curr_time;
   bool _gettime_success= (gettimeofday(&curr_time, NULL) == 0);
@@ -639,8 +639,9 @@ static memcached_return_t backoff_handling(memcached_server_write_instance_st se
   return MEMCACHED_SUCCESS;
 }
 
-static memcached_return_t _memcached_connect(memcached_server_write_instance_st server, const bool set_last_disconnected)
+static memcached_return_t _memcached_connect(org::libmemcached::Instance* server, const bool set_last_disconnected)
 {
+  assert(server);
   if (server->fd != INVALID_SOCKET)
   {
     return MEMCACHED_SUCCESS;
@@ -695,7 +696,8 @@ static memcached_return_t _memcached_connect(memcached_server_write_instance_st
 
   if (memcached_success(rc))
   {
-    memcached_mark_server_as_clean(server);
+    server->mark_server_as_clean();
+    memcached_version_instance(server);
     return rc;
   }
   else if (set_last_disconnected)
@@ -717,7 +719,7 @@ static memcached_return_t _memcached_connect(memcached_server_write_instance_st
     if (in_timeout)
     {
       char buffer[1024];
-      int snprintf_length= snprintf(buffer, sizeof(buffer), "%s:%d", server->hostname, int(server->port));
+      int snprintf_length= snprintf(buffer, sizeof(buffer), "%s:%d", server->hostname, int(server->port()));
       return memcached_set_error(*server, MEMCACHED_SERVER_TEMPORARILY_DISABLED, MEMCACHED_AT, buffer, snprintf_length);
     }
   }
@@ -725,12 +727,12 @@ static memcached_return_t _memcached_connect(memcached_server_write_instance_st
   return rc;
 }
 
-memcached_return_t memcached_connect_try(memcached_server_write_instance_st server)
+memcached_return_t memcached_connect_try(org::libmemcached::Instance* server)
 {
   return _memcached_connect(server, false);
 }
 
-memcached_return_t memcached_connect(memcached_server_write_instance_st server)
+memcached_return_t memcached_connect(org::libmemcached::Instance* server)
 {
   return _memcached_connect(server, true);
 }

diff --git a/libmemcached/connect.hpp b/libmemcached/connect.hpp
index a37dbd76aaeb4502c8a9fc41ee36a8fed08a0194..964195130e49950e7e6c19e2fe32b529ff864b7d 100644 (file)
--- a/libmemcached/connect.hpp
+++ b/libmemcached/connect.hpp
@@ -37,6 +37,6 @@
 
 #pragma once
 
-memcached_return_t memcached_connect_try(memcached_server_write_instance_st ptr);
-memcached_return_t memcached_connect(memcached_server_write_instance_st ptr);
+memcached_return_t memcached_connect_try(org::libmemcached::Instance*);
+memcached_return_t memcached_connect(org::libmemcached::Instance*);
 

diff --git a/libmemcached/csl/parser.cc b/libmemcached/csl/parser.cc
index 62f7eaa7cb304af7720a997f035b62a0e3125935..926621444ff810d6cf299f6471d6285ab0eaf7a1 100644 (file)
--- a/libmemcached/csl/parser.cc
+++ b/libmemcached/csl/parser.cc
@@ -185,32 +185,33 @@ inline void __config_error(Context *context, yyscan_t *scanner, const char *erro
      _TCP_KEEPALIVE = 298,
      _TCP_KEEPIDLE = 299,
      _TCP_NODELAY = 300,
-     NAMESPACE = 301,
-     POOL_MIN = 302,
-     POOL_MAX = 303,
-     MD5 = 304,
-     CRC = 305,
-     FNV1_64 = 306,
-     FNV1A_64 = 307,
-     FNV1_32 = 308,
-     FNV1A_32 = 309,
-     HSIEH = 310,
-     MURMUR = 311,
-     JENKINS = 312,
-     CONSISTENT = 313,
-     MODULA = 314,
-     RANDOM = 315,
-     TRUE = 316,
-     FALSE = 317,
-     FLOAT = 318,
-     NUMBER = 319,
-     PORT = 320,
-     WEIGHT_START = 321,
-     IPADDRESS = 322,
-     HOSTNAME = 323,
-     STRING = 324,
-     QUOTED_STRING = 325,
-     FILE_PATH = 326
+     FETCH_VERSION = 301,
+     NAMESPACE = 302,
+     POOL_MIN = 303,
+     POOL_MAX = 304,
+     MD5 = 305,
+     CRC = 306,
+     FNV1_64 = 307,
+     FNV1A_64 = 308,
+     FNV1_32 = 309,
+     FNV1A_32 = 310,
+     HSIEH = 311,
+     MURMUR = 312,
+     JENKINS = 313,
+     CONSISTENT = 314,
+     MODULA = 315,
+     RANDOM = 316,
+     TRUE = 317,
+     FALSE = 318,
+     FLOAT = 319,
+     NUMBER = 320,
+     PORT = 321,
+     WEIGHT_START = 322,
+     IPADDRESS = 323,
+     HOSTNAME = 324,
+     STRING = 325,
+     QUOTED_STRING = 326,
+     FILE_PATH = 327
    };
 #endif
 
@@ -227,7 +228,7 @@ inline void __config_error(Context *context, yyscan_t *scanner, const char *erro
 
 
 /* Line 343 of yacc.c  */
-#line 231 "libmemcached/csl/parser.cc"
+#line 232 "libmemcached/csl/parser.cc"
 
 #ifdef short
 # undef short
@@ -444,22 +445,22 @@ union yyalloc
 #endif /* !YYCOPY_NEEDED */
 
 /* YYFINAL -- State number of the termination state.  */
-#define YYFINAL  71
+#define YYFINAL  72
 /* YYLAST -- Last index in YYTABLE.  */
-#define YYLAST   74
+#define YYLAST   75
 
 /* YYNTOKENS -- Number of terminals.  */
-#define YYNTOKENS  75
+#define YYNTOKENS  76
 /* YYNNTS -- Number of nonterminals.  */
 #define YYNNTS  12
 /* YYNRULES -- Number of rules.  */
-#define YYNRULES  67
+#define YYNRULES  68
 /* YYNRULES -- Number of states.  */
-#define YYNSTATES  85
+#define YYNSTATES  86
 
 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 #define YYUNDEFTOK  2
-#define YYMAXUTOK   326
+#define YYMAXUTOK   327
 
 #define YYTRANSLATE(YYX)                                               \
   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
@@ -470,10 +471,10 @@ static const yytype_uint8 yytranslate[] =
        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,    74,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,    63,     2,     2,     2,     2,     2,
+       2,     2,    75,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,    64,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,    64,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,    65,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
@@ -498,8 +499,8 @@ static const yytype_uint8 yytranslate[] =
       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
       35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
-      55,    56,    57,    58,    59,    60,    61,    62,    65,    66,
-      67,    68,    69,    70,    71,    72,    73
+      55,    56,    57,    58,    59,    60,    61,    62,    63,    66,
+      67,    68,    69,    70,    71,    72,    73,    74
 };
 
 #if YYDEBUG
@@ -509,44 +510,44 @@ static const yytype_uint8 yyprhs[] =
 {
        0,     0,     3,     5,     9,    11,    13,    15,    17,    19,
       21,    23,    27,    32,    37,    41,    44,    47,    50,    52,
-      55,    58,    63,    66,    69,    71,    73,    75,    77,    79,
+      55,    57,    60,    65,    68,    71,    73,    75,    77,    79,
       81,    83,    85,    87,    89,    91,    93,    95,    97,    99,
      101,   103,   105,   107,   109,   111,   113,   115,   117,   119,
-     121,   122,   124,   125,   127,   129,   131,   133,   135,   137,
-     139,   141,   143,   145,   147,   149,   151,   153
+     121,   123,   124,   126,   127,   129,   131,   133,   135,   137,
+     139,   141,   143,   145,   147,   149,   151,   153,   155
 };
 
 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
 static const yytype_int8 yyrhs[] =
 {
-      76,     0,    -1,    77,    -1,    76,    74,    77,    -1,    78,
+      77,     0,    -1,    78,    -1,    77,    75,    78,    -1,    79,
       -1,     3,    -1,    10,    -1,     4,    -1,     5,    -1,     6,
-      -1,     7,    -1,     8,    74,    85,    -1,    11,    70,    82,
-      83,    -1,    11,    69,    82,    83,    -1,    12,    85,    83,
-      -1,     9,    85,    -1,    47,    66,    -1,    48,    66,    -1,
-      79,    -1,    46,    85,    -1,    20,    86,    -1,    20,    86,
-      63,    84,    -1,    21,    84,    -1,    80,    66,    -1,    81,
-      -1,    40,    -1,    33,    -1,    19,    -1,    25,    -1,    23,
-      -1,    24,    -1,    29,    -1,    30,    -1,    32,    -1,    34,
-      -1,    35,    -1,    36,    -1,    37,    -1,    17,    -1,    18,
-      -1,    22,    -1,    28,    -1,    31,    -1,    38,    -1,    39,
-      -1,    45,    -1,    43,    -1,    44,    -1,    41,    -1,    42,
-      -1,    -1,    67,    -1,    -1,    68,    -1,    49,    -1,    50,
+      -1,     7,    -1,     8,    75,    86,    -1,    11,    71,    83,
+      84,    -1,    11,    70,    83,    84,    -1,    12,    86,    84,
+      -1,     9,    86,    -1,    48,    67,    -1,    49,    67,    -1,
+      80,    -1,    47,    86,    -1,    46,    -1,    20,    87,    -1,
+      20,    87,    64,    85,    -1,    21,    85,    -1,    81,    67,
+      -1,    82,    -1,    40,    -1,    33,    -1,    19,    -1,    25,
+      -1,    23,    -1,    24,    -1,    29,    -1,    30,    -1,    32,
+      -1,    34,    -1,    35,    -1,    36,    -1,    37,    -1,    17,
+      -1,    18,    -1,    22,    -1,    28,    -1,    31,    -1,    38,
+      -1,    39,    -1,    45,    -1,    43,    -1,    44,    -1,    41,
+      -1,    42,    -1,    -1,    68,    -1,    -1,    69,    -1,    50,
       -1,    51,    -1,    52,    -1,    53,    -1,    54,    -1,    55,
-      -1,    56,    -1,    57,    -1,    71,    -1,    72,    -1,    58,
-      -1,    59,    -1,    60,    -1
+      -1,    56,    -1,    57,    -1,    58,    -1,    72,    -1,    73,
+      -1,    59,    -1,    60,    -1,    61,    -1
 };
 
 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
 static const yytype_uint16 yyrline[] =
 {
-       0,   188,   188,   189,   193,   195,   197,   199,   204,   209,
-     213,   217,   228,   238,   248,   257,   261,   265,   269,   273,
-     285,   298,   311,   318,   325,   334,   340,   344,   348,   352,
-     356,   360,   364,   368,   372,   376,   380,   384,   391,   395,
-     399,   403,   407,   411,   415,   419,   423,   427,   431,   435,
-     442,   443,   448,   449,   454,   458,   462,   466,   470,   474,
-     478,   482,   486,   493,   497,   504,   508,   512
+       0,   189,   189,   190,   194,   196,   198,   200,   205,   210,
+     214,   218,   229,   239,   249,   258,   262,   266,   270,   274,
+     286,   290,   303,   316,   323,   330,   339,   345,   349,   353,
+     357,   361,   365,   369,   373,   377,   381,   385,   389,   396,
+     400,   404,   408,   412,   416,   420,   424,   428,   432,   436,
+     440,   447,   448,   453,   454,   459,   463,   467,   471,   475,
+     479,   483,   487,   491,   498,   502,   509,   513,   517
 };
 #endif
 
@@ -565,10 +566,10 @@ static const char *const yytname[] =
   "RCV_TIMEOUT", "REMOVE_FAILED_SERVERS", "RETRY_TIMEOUT", "SND_TIMEOUT",
   "SOCKET_RECV_SIZE", "SOCKET_SEND_SIZE", "SORT_HOSTS", "SUPPORT_CAS",
   "USER_DATA", "USE_UDP", "VERIFY_KEY", "_TCP_KEEPALIVE", "_TCP_KEEPIDLE",
-  "_TCP_NODELAY", "NAMESPACE", "POOL_MIN", "POOL_MAX", "MD5", "CRC",
-  "FNV1_64", "FNV1A_64", "FNV1_32", "FNV1A_32", "HSIEH", "MURMUR",
-  "JENKINS", "CONSISTENT", "MODULA", "RANDOM", "TRUE", "FALSE", "','",
-  "'='", "FLOAT", "NUMBER", "PORT", "WEIGHT_START", "IPADDRESS",
+  "_TCP_NODELAY", "FETCH_VERSION", "NAMESPACE", "POOL_MIN", "POOL_MAX",
+  "MD5", "CRC", "FNV1_64", "FNV1A_64", "FNV1_32", "FNV1A_32", "HSIEH",
+  "MURMUR", "JENKINS", "CONSISTENT", "MODULA", "RANDOM", "TRUE", "FALSE",
+  "','", "'='", "FLOAT", "NUMBER", "PORT", "WEIGHT_START", "IPADDRESS",
   "HOSTNAME", "STRING", "QUOTED_STRING", "FILE_PATH", "' '", "$accept",
   "begin", "statement", "expression", "behaviors", "behavior_number",
   "behavior_boolean", "optional_port", "optional_weight", "hash", "string",
@@ -587,21 +588,21 @@ static const yytype_uint16 yytoknum[] =
      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
      295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
      305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
-     315,   316,   317,    44,    61,   318,   319,   320,   321,   322,
-     323,   324,   325,   326,    32
+     315,   316,   317,   318,    44,    61,   319,   320,   321,   322,
+     323,   324,   325,   326,   327,    32
 };
 # endif
 
 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 static const yytype_uint8 yyr1[] =
 {
-       0,    75,    76,    76,    77,    77,    77,    77,    77,    77,
-      77,    77,    78,    78,    78,    78,    78,    78,    78,    79,
-      79,    79,    79,    79,    79,    79,    80,    80,    80,    80,
-      80,    80,    80,    80,    80,    80,    80,    80,    81,    81,
-      81,    81,    81,    81,    81,    81,    81,    81,    81,    81,
-      82,    82,    83,    83,    84,    84,    84,    84,    84,    84,
-      84,    84,    84,    85,    85,    86,    86,    86
+       0,    76,    77,    77,    78,    78,    78,    78,    78,    78,
+      78,    78,    79,    79,    79,    79,    79,    79,    79,    80,
+      80,    80,    80,    80,    80,    80,    80,    81,    81,    81,
+      81,    81,    81,    81,    81,    81,    81,    81,    81,    82,
+      82,    82,    82,    82,    82,    82,    82,    82,    82,    82,
+      82,    83,    83,    84,    84,    85,    85,    85,    85,    85,
+      85,    85,    85,    85,    86,    86,    87,    87,    87
 };
 
 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
@@ -609,11 +610,11 @@ static const yytype_uint8 yyr2[] =
 {
        0,     2,     1,     3,     1,     1,     1,     1,     1,     1,
        1,     3,     4,     4,     3,     2,     2,     2,     1,     2,
-       2,     4,     2,     2,     1,     1,     1,     1,     1,     1,
+       1,     2,     4,     2,     2,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       0,     1,     0,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     1,     1,     1,     1
+       1,     0,     1,     0,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     1
 };
 
 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
@@ -622,44 +623,44 @@ static const yytype_uint8 yyr2[] =
 static const yytype_uint8 yydefact[] =
 {
        0,     5,     7,     8,     9,    10,     0,     0,     6,     0,
-       0,    38,    39,    27,     0,     0,    40,    29,    30,    28,
-      41,    31,    32,    42,    33,    26,    34,    35,    36,    37,
-      43,    44,    25,    48,    49,    46,    47,    45,     0,     0,
-       0,     0,     2,     4,    18,     0,    24,     0,    63,    64,
-      15,    50,    50,    52,    65,    66,    67,    20,    54,    55,
-      56,    57,    58,    59,    60,    61,    62,    22,    19,    16,
-      17,     1,     0,    23,    11,    51,    52,    52,    53,    14,
-       0,     3,    13,    12,    21
+       0,    39,    40,    28,     0,     0,    41,    30,    31,    29,
+      42,    32,    33,    43,    34,    27,    35,    36,    37,    38,
+      44,    45,    26,    49,    50,    47,    48,    46,    20,     0,
+       0,     0,     0,     2,     4,    18,     0,    25,     0,    64,
+      65,    15,    51,    51,    53,    66,    67,    68,    21,    55,
+      56,    57,    58,    59,    60,    61,    62,    63,    23,    19,
+      16,    17,     1,     0,    24,    11,    52,    53,    53,    54,
+      14,     0,     3,    13,    12,    22
 };
 
 /* YYDEFGOTO[NTERM-NUM].  */
 static const yytype_int8 yydefgoto[] =
 {
-      -1,    41,    42,    43,    44,    45,    46,    76,    79,    67,
-      50,    57
+      -1,    42,    43,    44,    45,    46,    47,    77,    80,    68,
+      51,    58
 };
 
 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
    STATE-NUM.  */
-#define YYPACT_NINF -61
+#define YYPACT_NINF -62
 static const yytype_int8 yypact[] =
 {
-      -2,   -61,   -61,   -61,   -61,   -61,   -60,   -24,   -61,   -20,
-     -24,   -61,   -61,   -61,   -47,    13,   -61,   -61,   -61,   -61,
-     -61,   -61,   -61,   -61,   -61,   -61,   -61,   -61,   -61,   -61,
-     -61,   -61,   -61,   -61,   -61,   -61,   -61,   -61,   -24,   -41,
-     -15,     0,   -61,   -61,   -61,   -11,   -61,   -24,   -61,   -61,
-     -61,   -10,   -10,   -12,   -61,   -61,   -61,    -5,   -61,   -61,
-     -61,   -61,   -61,   -61,   -61,   -61,   -61,   -61,   -61,   -61,
-     -61,   -61,    -2,   -61,   -61,   -61,   -12,   -12,   -61,   -61,
-      13,   -61,   -61,   -61,   -61
+      -2,   -62,   -62,   -62,   -62,   -62,   -61,   -24,   -62,   -20,
+     -24,   -62,   -62,   -62,   -48,    13,   -62,   -62,   -62,   -62,
+     -62,   -62,   -62,   -62,   -62,   -62,   -62,   -62,   -62,   -62,
+     -62,   -62,   -62,   -62,   -62,   -62,   -62,   -62,   -62,   -24,
+     -42,   -15,     0,   -62,   -62,   -62,   -11,   -62,   -24,   -62,
+     -62,   -62,   -10,   -10,   -12,   -62,   -62,   -62,    -5,   -62,
+     -62,   -62,   -62,   -62,   -62,   -62,   -62,   -62,   -62,   -62,
+     -62,   -62,   -62,    -2,   -62,   -62,   -62,   -12,   -12,   -62,
+     -62,    13,   -62,   -62,   -62,   -62
 };
 
 /* YYPGOTO[NTERM-NUM].  */
 static const yytype_int8 yypgoto[] =
 {
-     -61,   -61,   -13,   -61,   -61,   -61,   -61,     8,   -23,    -9,
-      14,   -61
+     -62,   -62,   -13,   -62,   -62,   -62,   -62,     8,   -23,    -9,
+      14,   -62
 };
 
 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
@@ -668,18 +669,18 @@ static const yytype_int8 yypgoto[] =
 #define YYTABLE_NINF -1
 static const yytype_uint8 yytable[] =
 {
-      71,     1,     2,     3,     4,     5,     6,     7,     8,     9,
-      10,    54,    55,    56,    47,    11,    12,    13,    14,    15,
-      16,    17,    18,    19,    53,    69,    20,    21,    22,    23,
+      72,     1,     2,     3,     4,     5,     6,     7,     8,     9,
+      10,    55,    56,    57,    48,    11,    12,    13,    14,    15,
+      16,    17,    18,    19,    54,    70,    20,    21,    22,    23,
       24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
-      34,    35,    36,    37,    38,    39,    40,    48,    49,    51,
-      52,    70,    68,    82,    83,    73,    78,    75,    80,    81,
-      77,    74,    58,    59,    60,    61,    62,    63,    64,    65,
-      66,    84,     0,     0,    72
+      34,    35,    36,    37,    38,    39,    40,    41,    49,    50,
+      52,    53,    71,    69,    83,    84,    74,    79,    76,    81,
+      82,    78,    75,    59,    60,    61,    62,    63,    64,    65,
+      66,    67,    85,     0,     0,    73
 };
 
 #define yypact_value_is_default(yystate) \
-  ((yystate) == (-61))
+  ((yystate) == (-62))
 
 #define yytable_value_is_error(yytable_value) \
   YYID (0)
@@ -687,13 +688,13 @@ static const yytype_uint8 yytable[] =
 static const yytype_int8 yycheck[] =
 {
        0,     3,     4,     5,     6,     7,     8,     9,    10,    11,
-      12,    58,    59,    60,    74,    17,    18,    19,    20,    21,
-      22,    23,    24,    25,    10,    66,    28,    29,    30,    31,
+      12,    59,    60,    61,    75,    17,    18,    19,    20,    21,
+      22,    23,    24,    25,    10,    67,    28,    29,    30,    31,
       32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
-      42,    43,    44,    45,    46,    47,    48,    71,    72,    69,
-      70,    66,    38,    76,    77,    66,    68,    67,    63,    72,
-      52,    47,    49,    50,    51,    52,    53,    54,    55,    56,
-      57,    80,    -1,    -1,    74
+      42,    43,    44,    45,    46,    47,    48,    49,    72,    73,
+      70,    71,    67,    39,    77,    78,    67,    69,    68,    64,
+      73,    53,    48,    50,    51,    52,    53,    54,    55,    56,
+      57,    58,    81,    -1,    -1,    75
 };
 
 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
@@ -704,11 +705,11 @@ static const yytype_uint8 yystos[] =
       12,    17,    18,    19,    20,    21,    22,    23,    24,    25,
       28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
       38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
-      48,    76,    77,    78,    79,    80,    81,    74,    71,    72,
-      85,    69,    70,    85,    58,    59,    60,    86,    49,    50,
-      51,    52,    53,    54,    55,    56,    57,    84,    85,    66,
-      66,     0,    74,    66,    85,    67,    82,    82,    68,    83,
-      63,    77,    83,    83,    84
+      48,    49,    77,    78,    79,    80,    81,    82,    75,    72,
+      73,    86,    70,    71,    86,    59,    60,    61,    87,    50,
+      51,    52,    53,    54,    55,    56,    57,    58,    85,    86,
+      67,    67,     0,    75,    67,    86,    68,    83,    83,    69,
+      84,    64,    78,    84,    84,    85
 };
 
 #define yyerrok                (yyerrstatus = 0)
@@ -1557,28 +1558,28 @@ yyreduce:
         case 4:
 
 /* Line 1806 of yacc.c  */
-#line 194 "libmemcached/csl/parser.yy"
+#line 195 "libmemcached/csl/parser.yy"
     { }
     break;
 
   case 5:
 
 /* Line 1806 of yacc.c  */
-#line 196 "libmemcached/csl/parser.yy"
+#line 197 "libmemcached/csl/parser.yy"
     { }
     break;
 
   case 6:
 
 /* Line 1806 of yacc.c  */
-#line 198 "libmemcached/csl/parser.yy"
+#line 199 "libmemcached/csl/parser.yy"
     { }
     break;
 
   case 7:
 
 /* Line 1806 of yacc.c  */
-#line 200 "libmemcached/csl/parser.yy"
+#line 201 "libmemcached/csl/parser.yy"
     {
             context->set_end();
             YYACCEPT;
@@ -1588,7 +1589,7 @@ yyreduce:
   case 8:
 
 /* Line 1806 of yacc.c  */
-#line 205 "libmemcached/csl/parser.yy"
+#line 206 "libmemcached/csl/parser.yy"
     {
             context->rc= MEMCACHED_PARSE_USER_ERROR;
             parser_abort(context, "ERROR called directly");
@@ -1598,7 +1599,7 @@ yyreduce:
   case 9:
 
 /* Line 1806 of yacc.c  */
-#line 210 "libmemcached/csl/parser.yy"
+#line 211 "libmemcached/csl/parser.yy"
     {
             memcached_reset(context->memc);
           }
@@ -1607,7 +1608,7 @@ yyreduce:
   case 10:
 
 /* Line 1806 of yacc.c  */
-#line 214 "libmemcached/csl/parser.yy"
+#line 215 "libmemcached/csl/parser.yy"
     {
             yydebug= 1;
           }
@@ -1616,7 +1617,7 @@ yyreduce:
   case 11:
 
 /* Line 1806 of yacc.c  */
-#line 218 "libmemcached/csl/parser.yy"
+#line 219 "libmemcached/csl/parser.yy"
     {
             if ((context->rc= memcached_parse_configure_file(*context->memc, (yyvsp[(3) - (3)].string).c_str, (yyvsp[(3) - (3)].string).size)) != MEMCACHED_SUCCESS)
             {
@@ -1628,7 +1629,7 @@ yyreduce:
   case 12:
 
 /* Line 1806 of yacc.c  */
-#line 229 "libmemcached/csl/parser.yy"
+#line 230 "libmemcached/csl/parser.yy"
     {
             if (memcached_failed(context->rc= memcached_server_add_with_weight(context->memc, (yyvsp[(2) - (4)].server).c_str, (yyvsp[(3) - (4)].number), (yyvsp[(4) - (4)].number))))
             {
@@ -1643,7 +1644,7 @@ yyreduce:
   case 13:
 
 /* Line 1806 of yacc.c  */
-#line 239 "libmemcached/csl/parser.yy"
+#line 240 "libmemcached/csl/parser.yy"
     {
             if (memcached_failed(context->rc= memcached_server_add_with_weight(context->memc, (yyvsp[(2) - (4)].server).c_str, (yyvsp[(3) - (4)].number), (yyvsp[(4) - (4)].number))))
             {
@@ -1658,7 +1659,7 @@ yyreduce:
   case 14:
 
 /* Line 1806 of yacc.c  */
-#line 249 "libmemcached/csl/parser.yy"
+#line 250 "libmemcached/csl/parser.yy"
     {
             if (memcached_failed(context->rc= memcached_server_add_unix_socket_with_weight(context->memc, (yyvsp[(2) - (3)].string).c_str, (yyvsp[(3) - (3)].number))))
             {
@@ -1672,7 +1673,7 @@ yyreduce:
   case 15:
 
 /* Line 1806 of yacc.c  */
-#line 258 "libmemcached/csl/parser.yy"
+#line 259 "libmemcached/csl/parser.yy"
     {
             memcached_set_configuration_file(context->memc, (yyvsp[(2) - (2)].string).c_str, (yyvsp[(2) - (2)].string).size);
           }
@@ -1681,7 +1682,7 @@ yyreduce:
   case 16:
 
 /* Line 1806 of yacc.c  */
-#line 262 "libmemcached/csl/parser.yy"
+#line 263 "libmemcached/csl/parser.yy"
     {
             context->memc->configure.initial_pool_size= (yyvsp[(2) - (2)].number);
           }
@@ -1690,7 +1691,7 @@ yyreduce:
   case 17:
 
 /* Line 1806 of yacc.c  */
-#line 266 "libmemcached/csl/parser.yy"
+#line 267 "libmemcached/csl/parser.yy"
     {
             context->memc->configure.max_pool_size= (yyvsp[(2) - (2)].number);
           }
@@ -1699,7 +1700,7 @@ yyreduce:
   case 19:
 
 /* Line 1806 of yacc.c  */
-#line 274 "libmemcached/csl/parser.yy"
+#line 275 "libmemcached/csl/parser.yy"
     {
             if (memcached_callback_get(context->memc, MEMCACHED_CALLBACK_PREFIX_KEY, NULL))
             {
@@ -1716,7 +1717,16 @@ yyreduce:
   case 20:
 
 /* Line 1806 of yacc.c  */
-#line 286 "libmemcached/csl/parser.yy"
+#line 287 "libmemcached/csl/parser.yy"
+    {
+            memcached_flag(*context->memc, MEMCACHED_FLAG_IS_FETCHING_VERSION, true);
+          }
+    break;
+
+  case 21:
+
+/* Line 1806 of yacc.c  */
+#line 291 "libmemcached/csl/parser.yy"
     {
             // Check to see if DISTRIBUTION has already been set
             if ((context->rc= memcached_behavior_set(context->memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, (yyvsp[(2) - (2)].distribution))) != MEMCACHED_SUCCESS)
@@ -1731,10 +1741,10 @@ yyreduce:
           }
     break;
 
-  case 21:
+  case 22:
 
 /* Line 1806 of yacc.c  */
-#line 299 "libmemcached/csl/parser.yy"
+#line 304 "libmemcached/csl/parser.yy"
     {
             // Check to see if DISTRIBUTION has already been set
             if ((context->rc= memcached_behavior_set(context->memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, (yyvsp[(2) - (4)].distribution))) != MEMCACHED_SUCCESS)
@@ -1749,10 +1759,10 @@ yyreduce:
           }
     break;
 
-  case 22:
+  case 23:
 
 /* Line 1806 of yacc.c  */
-#line 312 "libmemcached/csl/parser.yy"
+#line 317 "libmemcached/csl/parser.yy"
     {
             if (context->set_hash((yyvsp[(2) - (2)].hash)) == false)
             {
@@ -1761,10 +1771,10 @@ yyreduce:
           }
     break;
 
-  case 23:
+  case 24:
 
 /* Line 1806 of yacc.c  */
-#line 319 "libmemcached/csl/parser.yy"
+#line 324 "libmemcached/csl/parser.yy"
     {
             if ((context->rc= memcached_behavior_set(context->memc, (yyvsp[(1) - (2)].behavior), (yyvsp[(2) - (2)].number))) != MEMCACHED_SUCCESS)
             {
@@ -1773,10 +1783,10 @@ yyreduce:
           }
     break;
 
-  case 24:
+  case 25:
 
 /* Line 1806 of yacc.c  */
-#line 326 "libmemcached/csl/parser.yy"
+#line 331 "libmemcached/csl/parser.yy"
     {
             if ((context->rc= memcached_behavior_set(context->memc, (yyvsp[(1) - (1)].behavior), true)) != MEMCACHED_SUCCESS)
             {
@@ -1787,379 +1797,379 @@ yyreduce:
           }
     break;
 
-  case 25:
+  case 26:
 
 /* Line 1806 of yacc.c  */
-#line 335 "libmemcached/csl/parser.yy"
+#line 340 "libmemcached/csl/parser.yy"
     {
           }
     break;
 
-  case 26:
+  case 27:
 
 /* Line 1806 of yacc.c  */
-#line 341 "libmemcached/csl/parser.yy"
+#line 346 "libmemcached/csl/parser.yy"
     {
             (yyval.behavior)= MEMCACHED_BEHAVIOR_REMOVE_FAILED_SERVERS;
           }
     break;
 
-  case 27:
+  case 28:
 
 /* Line 1806 of yacc.c  */
-#line 345 "libmemcached/csl/parser.yy"
+#line 350 "libmemcached/csl/parser.yy"
     {
             (yyval.behavior)= MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT;
           }
     break;
 
-  case 28:
+  case 29:
 
 /* Line 1806 of yacc.c  */
-#line 349 "libmemcached/csl/parser.yy"
+#line 354 "libmemcached/csl/parser.yy"
     {
             (yyval.behavior)= MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK;
           }
     break;
 
-  case 29:
+  case 30:
 
 /* Line 1806 of yacc.c  */
-#line 353 "libmemcached/csl/parser.yy"
+#line 358 "libmemcached/csl/parser.yy"
     {
             (yyval.behavior)= MEMCACHED_BEHAVIOR_IO_BYTES_WATERMARK;
           }
     break;
 
-  case 30:
+  case 31:
 
 /* Line 1806 of yacc.c  */
-#line 357 "libmemcached/csl/parser.yy"
+#line 362 "libmemcached/csl/parser.yy"
     {
             (yyval.behavior)= MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH;
           }
     break;
 
-  case 31:
+  case 32:
 
 /* Line 1806 of yacc.c  */
-#line 361 "libmemcached/csl/parser.yy"
+#line 366 "libmemcached/csl/parser.yy"
     {
             (yyval.behavior)= MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS;
           }
     break;
 
-  case 32:
+  case 33:
 
 /* Line 1806 of yacc.c  */
-#line 365 "libmemcached/csl/parser.yy"
+#line 370 "libmemcached/csl/parser.yy"
     {
             (yyval.behavior)= MEMCACHED_BEHAVIOR_POLL_TIMEOUT;
           }
     break;
 
-  case 33:
+  case 34:
 
 /* Line 1806 of yacc.c  */
-#line 369 "libmemcached/csl/parser.yy"
+#line 374 "libmemcached/csl/parser.yy"
     {
             (yyval.behavior)= MEMCACHED_BEHAVIOR_RCV_TIMEOUT;
           }
     break;
 
-  case 34:
+  case 35:
 
 /* Line 1806 of yacc.c  */
-#line 373 "libmemcached/csl/parser.yy"
+#line 378 "libmemcached/csl/parser.yy"
     {
             (yyval.behavior)= MEMCACHED_BEHAVIOR_RETRY_TIMEOUT;
           }
     break;
 
-  case 35:
+  case 36:
 
 /* Line 1806 of yacc.c  */
-#line 377 "libmemcached/csl/parser.yy"
+#line 382 "libmemcached/csl/parser.yy"
     {
             (yyval.behavior)= MEMCACHED_BEHAVIOR_SND_TIMEOUT;
           }
     break;
 
-  case 36:
+  case 37:
 
 /* Line 1806 of yacc.c  */
-#line 381 "libmemcached/csl/parser.yy"
+#line 386 "libmemcached/csl/parser.yy"
     {
             (yyval.behavior)= MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE;
           }
     break;
 
-  case 37:
+  case 38:
 
 /* Line 1806 of yacc.c  */
-#line 385 "libmemcached/csl/parser.yy"
+#line 390 "libmemcached/csl/parser.yy"
     {
             (yyval.behavior)= MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE;
           }
     break;
 
-  case 38:
+  case 39:
 
 /* Line 1806 of yacc.c  */
-#line 392 "libmemcached/csl/parser.yy"
+#line 397 "libmemcached/csl/parser.yy"
     {
             (yyval.behavior)= MEMCACHED_BEHAVIOR_BINARY_PROTOCOL;
           }
     break;
 
-  case 39:
+  case 40:
 
 /* Line 1806 of yacc.c  */
-#line 396 "libmemcached/csl/parser.yy"
+#line 401 "libmemcached/csl/parser.yy"
     {
             (yyval.behavior)= MEMCACHED_BEHAVIOR_BUFFER_REQUESTS;
           }
     break;
 
-  case 40:
+  case 41:
 
 /* Line 1806 of yacc.c  */
-#line 400 "libmemcached/csl/parser.yy"
+#line 405 "libmemcached/csl/parser.yy"
     {
             (yyval.behavior)= MEMCACHED_BEHAVIOR_HASH_WITH_PREFIX_KEY;
           }
     break;
 
-  case 41:
+  case 42:
 
 /* Line 1806 of yacc.c  */
-#line 404 "libmemcached/csl/parser.yy"
+#line 409 "libmemcached/csl/parser.yy"
     {
             (yyval.behavior)= MEMCACHED_BEHAVIOR_NOREPLY;
           }
     break;
 
-  case 42:
+  case 43:
 
 /* Line 1806 of yacc.c  */
-#line 408 "libmemcached/csl/parser.yy"
+#line 413 "libmemcached/csl/parser.yy"
     {
             (yyval.behavior)= MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ;
           }
     break;
 
-  case 43:
+  case 44:
 
 /* Line 1806 of yacc.c  */
-#line 412 "libmemcached/csl/parser.yy"
+#line 417 "libmemcached/csl/parser.yy"
     {
             (yyval.behavior)= MEMCACHED_BEHAVIOR_SORT_HOSTS;
           }
     break;
 
-  case 44:
+  case 45:
 
 /* Line 1806 of yacc.c  */
-#line 416 "libmemcached/csl/parser.yy"
+#line 421 "libmemcached/csl/parser.yy"
     {
             (yyval.behavior)= MEMCACHED_BEHAVIOR_SUPPORT_CAS;
           }
     break;
 
-  case 45:
+  case 46:
 
 /* Line 1806 of yacc.c  */
-#line 420 "libmemcached/csl/parser.yy"
+#line 425 "libmemcached/csl/parser.yy"
     {
             (yyval.behavior)= MEMCACHED_BEHAVIOR_TCP_NODELAY;
           }
     break;
 
-  case 46:
+  case 47:
 
 /* Line 1806 of yacc.c  */
-#line 424 "libmemcached/csl/parser.yy"
+#line 429 "libmemcached/csl/parser.yy"
     {
             (yyval.behavior)= MEMCACHED_BEHAVIOR_TCP_KEEPALIVE;
           }
     break;
 
-  case 47:
+  case 48:
 
 /* Line 1806 of yacc.c  */
-#line 428 "libmemcached/csl/parser.yy"
+#line 433 "libmemcached/csl/parser.yy"
     {
             (yyval.behavior)= MEMCACHED_BEHAVIOR_TCP_KEEPIDLE;
           }
     break;
 
-  case 48:
+  case 49:
 
 /* Line 1806 of yacc.c  */
-#line 432 "libmemcached/csl/parser.yy"
+#line 437 "libmemcached/csl/parser.yy"
     {
             (yyval.behavior)= MEMCACHED_BEHAVIOR_USE_UDP;
           }
     break;
 
-  case 49:
+  case 50:
 
 /* Line 1806 of yacc.c  */
-#line 436 "libmemcached/csl/parser.yy"
+#line 441 "libmemcached/csl/parser.yy"
     {
             (yyval.behavior)= MEMCACHED_BEHAVIOR_VERIFY_KEY;
           }
     break;
 
-  case 50:
+  case 51:
 
 /* Line 1806 of yacc.c  */
-#line 442 "libmemcached/csl/parser.yy"
+#line 447 "libmemcached/csl/parser.yy"
     { (yyval.number)= MEMCACHED_DEFAULT_PORT;}
     break;
 
-  case 51:
+  case 52:
 
 /* Line 1806 of yacc.c  */
-#line 444 "libmemcached/csl/parser.yy"
+#line 449 "libmemcached/csl/parser.yy"
     { }
     break;
 
-  case 52:
+  case 53:
 
 /* Line 1806 of yacc.c  */
-#line 448 "libmemcached/csl/parser.yy"
+#line 453 "libmemcached/csl/parser.yy"
     { (yyval.number)= 1; }
     break;
 
-  case 53:
+  case 54:
 
 /* Line 1806 of yacc.c  */
-#line 450 "libmemcached/csl/parser.yy"
+#line 455 "libmemcached/csl/parser.yy"
     { }
     break;
 
-  case 54:
+  case 55:
 
 /* Line 1806 of yacc.c  */
-#line 455 "libmemcached/csl/parser.yy"
+#line 460 "libmemcached/csl/parser.yy"
     {
             (yyval.hash)= MEMCACHED_HASH_MD5;
           }
     break;
 
-  case 55:
+  case 56:
 
 /* Line 1806 of yacc.c  */
-#line 459 "libmemcached/csl/parser.yy"
+#line 464 "libmemcached/csl/parser.yy"
     {
             (yyval.hash)= MEMCACHED_HASH_CRC;
           }
     break;
 
-  case 56:
+  case 57:
 
 /* Line 1806 of yacc.c  */
-#line 463 "libmemcached/csl/parser.yy"
+#line 468 "libmemcached/csl/parser.yy"
     {
             (yyval.hash)= MEMCACHED_HASH_FNV1_64;
           }
     break;
 
-  case 57:
+  case 58:
 
 /* Line 1806 of yacc.c  */
-#line 467 "libmemcached/csl/parser.yy"
+#line 472 "libmemcached/csl/parser.yy"
     {
             (yyval.hash)= MEMCACHED_HASH_FNV1A_64;
           }
     break;
 
-  case 58:
+  case 59:
 
 /* Line 1806 of yacc.c  */
-#line 471 "libmemcached/csl/parser.yy"
+#line 476 "libmemcached/csl/parser.yy"
     {
             (yyval.hash)= MEMCACHED_HASH_FNV1_32;
           }
     break;
 
-  case 59:
+  case 60:
 
 /* Line 1806 of yacc.c  */
-#line 475 "libmemcached/csl/parser.yy"
+#line 480 "libmemcached/csl/parser.yy"
     {
             (yyval.hash)= MEMCACHED_HASH_FNV1A_32;
           }
     break;
 
-  case 60:
+  case 61:
 
 /* Line 1806 of yacc.c  */
-#line 479 "libmemcached/csl/parser.yy"
+#line 484 "libmemcached/csl/parser.yy"
     {
             (yyval.hash)= MEMCACHED_HASH_HSIEH;
           }
     break;
 
-  case 61:
+  case 62:
 
 /* Line 1806 of yacc.c  */
-#line 483 "libmemcached/csl/parser.yy"
+#line 488 "libmemcached/csl/parser.yy"
     {
             (yyval.hash)= MEMCACHED_HASH_MURMUR;
           }
     break;
 
-  case 62:
+  case 63:
 
 /* Line 1806 of yacc.c  */
-#line 487 "libmemcached/csl/parser.yy"
+#line 492 "libmemcached/csl/parser.yy"
     {
             (yyval.hash)= MEMCACHED_HASH_JENKINS;
           }
     break;
 
-  case 63:
+  case 64:
 
 /* Line 1806 of yacc.c  */
-#line 494 "libmemcached/csl/parser.yy"
+#line 499 "libmemcached/csl/parser.yy"
     {
             (yyval.string)= (yyvsp[(1) - (1)].string);
           }
     break;
 
-  case 64:
+  case 65:
 
 /* Line 1806 of yacc.c  */
-#line 498 "libmemcached/csl/parser.yy"
+#line 503 "libmemcached/csl/parser.yy"
     {
             (yyval.string)= (yyvsp[(1) - (1)].string);
           }
     break;
 
-  case 65:
+  case 66:
 
 /* Line 1806 of yacc.c  */
-#line 505 "libmemcached/csl/parser.yy"
+#line 510 "libmemcached/csl/parser.yy"
     {
             (yyval.distribution)= MEMCACHED_DISTRIBUTION_CONSISTENT;
           }
     break;
 
-  case 66:
+  case 67:
 
 /* Line 1806 of yacc.c  */
-#line 509 "libmemcached/csl/parser.yy"
+#line 514 "libmemcached/csl/parser.yy"
     {
             (yyval.distribution)= MEMCACHED_DISTRIBUTION_MODULA;
           }
     break;
 
-  case 67:
+  case 68:
 
 /* Line 1806 of yacc.c  */
-#line 513 "libmemcached/csl/parser.yy"
+#line 518 "libmemcached/csl/parser.yy"
     {
             (yyval.distribution)= MEMCACHED_DISTRIBUTION_RANDOM;
           }
@@ -2168,7 +2178,7 @@ yyreduce:
 
 
 /* Line 1806 of yacc.c  */
-#line 2172 "libmemcached/csl/parser.cc"
+#line 2182 "libmemcached/csl/parser.cc"
       default: break;
     }
   /* User semantic actions sometimes alter yychar, and that requires
@@ -2399,7 +2409,7 @@ yyreturn:
 
 
 /* Line 2067 of yacc.c  */
-#line 518 "libmemcached/csl/parser.yy"
+#line 523 "libmemcached/csl/parser.yy"
  
 
 void Context::start() 

diff --git a/libmemcached/csl/parser.h b/libmemcached/csl/parser.h
index 4112d74899c31e1d6e2be44ffa0cfb9dd13693e2..7feab59532a71dcc2db84f8bbe44a80a6968464f 100644 (file)
--- a/libmemcached/csl/parser.h
+++ b/libmemcached/csl/parser.h
@@ -80,32 +80,33 @@
      _TCP_KEEPALIVE = 298,
      _TCP_KEEPIDLE = 299,
      _TCP_NODELAY = 300,
-     NAMESPACE = 301,
-     POOL_MIN = 302,
-     POOL_MAX = 303,
-     MD5 = 304,
-     CRC = 305,
-     FNV1_64 = 306,
-     FNV1A_64 = 307,
-     FNV1_32 = 308,
-     FNV1A_32 = 309,
-     HSIEH = 310,
-     MURMUR = 311,
-     JENKINS = 312,
-     CONSISTENT = 313,
-     MODULA = 314,
-     RANDOM = 315,
-     TRUE = 316,
-     FALSE = 317,
-     FLOAT = 318,
-     NUMBER = 319,
-     PORT = 320,
-     WEIGHT_START = 321,
-     IPADDRESS = 322,
-     HOSTNAME = 323,
-     STRING = 324,
-     QUOTED_STRING = 325,
-     FILE_PATH = 326
+     FETCH_VERSION = 301,
+     NAMESPACE = 302,
+     POOL_MIN = 303,
+     POOL_MAX = 304,
+     MD5 = 305,
+     CRC = 306,
+     FNV1_64 = 307,
+     FNV1A_64 = 308,
+     FNV1_32 = 309,
+     FNV1A_32 = 310,
+     HSIEH = 311,
+     MURMUR = 312,
+     JENKINS = 313,
+     CONSISTENT = 314,
+     MODULA = 315,
+     RANDOM = 316,
+     TRUE = 317,
+     FALSE = 318,
+     FLOAT = 319,
+     NUMBER = 320,
+     PORT = 321,
+     WEIGHT_START = 322,
+     IPADDRESS = 323,
+     HOSTNAME = 324,
+     STRING = 325,
+     QUOTED_STRING = 326,
+     FILE_PATH = 327
    };
 #endif
 

diff --git a/libmemcached/csl/parser.yy b/libmemcached/csl/parser.yy
index 21a035264d177c264a9b4577bfd9982e3790af69..e70bba975a12da3c11768d4da92153bbde87eb19 100644 (file)
--- a/libmemcached/csl/parser.yy
+++ b/libmemcached/csl/parser.yy
@@ -133,6 +133,7 @@ inline void __config_error(Context *context, yyscan_t *scanner, const char *erro
 %token _TCP_KEEPALIVE
 %token _TCP_KEEPIDLE
 %token _TCP_NODELAY
+%token FETCH_VERSION
 
 /* Callbacks */
 %token NAMESPACE
@@ -282,6 +283,10 @@ behaviors:
               parser_abort(context, memcached_last_error_message(context->memc));
             }
           }
+        | FETCH_VERSION
+          {
+            memcached_flag(*context->memc, MEMCACHED_FLAG_IS_FETCHING_VERSION, true);
+          }
         | DISTRIBUTION distribution
           {
             // Check to see if DISTRIBUTION has already been set

diff --git a/libmemcached/csl/scanner.cc b/libmemcached/csl/scanner.cc
index 757d907164902e0f44a08bffb4e0c0bafc3be00f..76242dfbc98eac52decec1ae5e7a64214f6780d7 100644 (file)
--- a/libmemcached/csl/scanner.cc
+++ b/libmemcached/csl/scanner.cc
@@ -10,6 +10,7 @@
 #pragma GCC diagnostic ignored "-Wold-style-cast"
 #pragma GCC diagnostic ignored "-Wsign-compare"
 #pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
 #endif
 
 #define YY_NO_INPUT
@@ -19,7 +20,7 @@
 
 
 
-#line 23 "libmemcached/csl/scanner.cc"
+#line 24 "libmemcached/csl/scanner.cc"
 
 #define  YY_INT_ALIGNED short int
 
@@ -97,7 +98,6 @@ typedef int flex_int32_t;
 typedef unsigned char flex_uint8_t; 
 typedef unsigned short int flex_uint16_t;
 typedef unsigned int flex_uint32_t;
-#endif /* ! C99 */
 
 /* Limits of integral types. */
 #ifndef INT8_MIN
@@ -128,6 +128,8 @@ typedef unsigned int flex_uint32_t;
 #define UINT32_MAX             (4294967295U)
 #endif
 
+#endif /* ! C99 */
+
 #endif /* ! FLEXINT_H */
 
 /* %endif */
@@ -219,7 +221,15 @@ typedef void* yyscan_t;
 
 /* Size of default input buffer. */
 #ifndef YY_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k.
+ * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
+ * Ditto for the __ia64__ case accordingly.
+ */
+#define YY_BUF_SIZE 32768
+#else
 #define YY_BUF_SIZE 16384
+#endif /* __ia64__ */
 #endif
 
 /* The state buf must be large enough to hold one state per character in the main buffer.
@@ -453,8 +463,8 @@ static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner );
        yyg->yy_c_buf_p = yy_cp;
 
 /* %% [4.0] data tables for the DFA and the user's section 1 definitions go here */
-#define YY_NUM_RULES 65
-#define YY_END_OF_BUFFER 66
+#define YY_NUM_RULES 66
+#define YY_END_OF_BUFFER 67
 /* This struct is not used in this scanner,
    but its presence is necessary. */
 struct yy_trans_info
@@ -462,65 +472,67 @@ struct yy_trans_info
        flex_int32_t yy_verify;
        flex_int32_t yy_nxt;
        };
-static yyconst flex_int16_t yy_accept[521] =
+static yyconst flex_int16_t yy_accept[534] =
     {   0,
-        0,    0,   66,   64,    5,    5,    1,   64,   64,   64,
-        2,   64,   64,   64,   64,   64,   64,   64,   64,   64,
-       64,   64,   64,   64,   64,   64,    0,   63,    0,   48,
+        0,    0,   67,   65,    5,    5,    1,   65,   65,   65,
+        2,   65,   65,   65,   65,   65,   65,   65,   65,   65,
+       65,   65,   65,   65,   65,   65,    0,   64,    0,   49,
         0,    0,    0,    2,    3,    0,    0,    0,    0,    0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-        0,    0,    0,    0,    6,   48,   48,   48,   48,   48,
-       48,   48,   48,   48,   48,   48,   48,   48,    4,   62,
-       62,    2,    3,   62,   53,   62,   44,   62,   62,   62,
-       62,   62,   62,   63,    0,   62,   52,   62,   62,   62,
-       62,   62,   62,   48,   48,   48,   48,   48,   48,   48,
-
-       48,   48,   48,   48,   48,   48,   48,   48,   48,   48,
-       48,   48,   48,    4,    0,   62,    2,    3,   62,   62,
-       62,   62,   62,   62,   62,   62,   62,   62,   62,   62,
-       62,   46,   48,   48,   48,   48,   48,    0,   48,   48,
-       48,   48,   48,   48,   48,   48,   48,   48,   48,   48,
-       48,   48,   48,   48,   48,    4,   62,   62,    3,   62,
-       42,   45,   47,   62,    0,   58,   62,   62,   62,   62,
-       62,   41,   62,   48,   48,   48,   48,   48,   48,    0,
-        0,    0,   48,   48,   48,   48,   48,   48,    0,   48,
-       48,   48,    0,   48,   48,   48,    0,    0,   48,   48,
-
-        4,    0,   62,    3,   62,    0,   62,   62,   62,   62,
-       50,   59,   51,   62,   48,   48,   48,   48,   48,    0,
-       15,    0,    0,    0,   48,   48,   48,    0,    0,   48,
-        0,   48,   48,   48,    0,   48,    0,   48,    0,    0,
-        0,    0,   48,    4,   61,   62,   62,   62,   62,   56,
-       54,   40,   60,   43,   48,   48,   48,   48,   48,    0,
-        0,    0,    0,   48,   48,   48,    0,    0,   48,    0,
-       48,    0,   48,    0,   48,    0,   48,    0,    0,    0,
-        0,   48,   61,   62,   57,   55,    0,    0,   48,   48,
-       48,    0,    0,    0,    0,   48,   19,    0,    0,    0,
-
-        0,   48,    0,    0,    0,    7,    0,    0,    8,    0,
-       48,    0,    0,   34,    0,    0,   61,   62,    0,    0,
-       48,    0,   48,    0,    0,    0,    0,   48,    0,    0,
-        0,    0,   48,    0,    0,    0,    0,    0,    0,    0,
-        0,    0,    0,    0,    0,   49,    0,    0,   48,    0,
-       48,    0,    0,    0,    0,   48,    0,    0,   38,   37,
-       48,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-        0,    0,   35,    0,    0,    0,    0,    0,   48,    0,
+        0,    0,    0,    0,    6,   49,   49,   49,   49,   49,
+       49,   49,   49,   49,   49,   49,   49,   49,   49,    4,
+       63,   63,    2,    3,   63,   54,   63,   45,   63,   63,
+       63,   63,   63,   63,   64,    0,   63,   53,   63,   63,
+       63,   63,   63,   63,   49,   49,   49,   49,   49,   49,
+
+       49,   49,   49,   49,   49,   49,   49,   49,   49,   49,
+       49,   49,   49,   49,   49,    4,    0,   63,    2,    3,
+       63,   63,   63,   63,   63,   63,   63,   63,   63,   63,
+       63,   63,   63,   47,   49,   49,   49,   49,   49,   49,
+        0,   49,   49,   49,   49,   49,   49,   49,   49,   49,
+       49,   49,   49,   49,   49,   49,   49,   49,    4,   63,
+       63,    3,   63,   43,   46,   48,   63,    0,   59,   63,
+       63,   63,   63,   63,   42,   63,   49,   49,   49,   49,
+       49,   49,   49,    0,    0,    0,   49,   49,   49,   49,
+       49,   49,    0,   49,   49,   49,    0,   49,   49,   49,
+
+        0,    0,   49,   49,    4,    0,   63,    3,   63,    0,
+       63,   63,   63,   63,   51,   60,   52,   63,   49,   49,
+       49,   49,   49,   49,    0,   15,    0,    0,    0,   49,
+       49,   49,    0,    0,   49,    0,   49,   49,   49,    0,
+       49,    0,   49,    0,    0,    0,    0,   49,    4,   62,
+       63,   63,   63,   63,   57,   55,   41,   61,   44,   49,
+       49,   49,   49,   49,    0,    0,    0,    0,    0,   49,
+       49,   49,    0,    0,   49,    0,   49,    0,   49,    0,
+       49,    0,   49,    0,    0,    0,    0,   49,   62,   63,
+       58,   56,    0,    0,   49,   49,   49,    0,    0,    0,
+
+        0,    0,   49,   19,    0,    0,    0,    0,   49,    0,
+        0,    0,    7,    0,    0,    8,    0,   49,    0,    0,
+       34,    0,    0,   62,   63,    0,    0,   49,    0,   49,
+        0,    0,    0,    0,    0,   49,    0,    0,    0,    0,
+       49,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,    0,   50,    0,    0,   49,    0,   49,    0,
+        0,    0,    0,    0,   49,    0,    0,   38,   37,   49,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,   35,    0,    0,    0,    0,    0,   49,    0,    0,
         0,    0,    0,   39,    0,    0,    0,    0,    0,    0,
-        0,    0,    0,   29,    0,    0,    0,    0,   36,    0,
 
-        0,    0,    0,   48,    0,    0,    0,    0,    0,    0,
-        0,    0,    0,    0,    0,    0,    0,   30,    0,    0,
-       33,    0,    0,    0,    0,   48,    0,    0,    0,    0,
-        0,    0,    0,   23,    0,    0,   26,    0,    0,    0,
-       32,    0,    0,    0,    0,   13,    0,    0,    0,    0,
-        0,   21,    0,    0,    0,    0,    0,   31,    0,    0,
-        0,    0,    0,    0,    0,    0,    0,    0,    0,   25,
-        0,    0,    9,   10,   11,    0,    0,    0,    0,    0,
-        0,    0,    0,    0,    0,   12,    0,    0,   17,    0,
-        0,    0,    0,    0,    0,    0,    0,   18,    0,    0,
-
-        0,   27,   28,    0,    0,    0,    0,    0,   14,   16,
-       20,    0,    0,    0,    0,    0,    0,   22,   24,    0
+        0,    0,    0,   29,    0,    0,    0,    0,   36,    0,
+        0,    0,    0,   49,    0,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,    0,    0,    0,    0,   30,    0,
+        0,   33,    0,    0,    0,    0,   49,    0,    0,    0,
+        0,    0,    0,    0,    0,   23,    0,    0,   26,    0,
+        0,    0,   32,    0,    0,    0,    0,   13,   40,    0,
+        0,    0,    0,    0,   21,    0,    0,    0,    0,    0,
+       31,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,   25,    0,    0,    9,   10,   11,    0,    0,
+        0,    0,    0,    0,    0,    0,    0,    0,   12,    0,
+
+        0,   17,    0,    0,    0,    0,    0,    0,    0,    0,
+       18,    0,    0,    0,   27,   28,    0,    0,    0,    0,
+        0,   14,   16,   20,    0,    0,    0,    0,    0,    0,
+       22,   24,    0
     } ;
 
 static yyconst flex_int32_t yy_ec[256] =
@@ -567,131 +579,133 @@ static yyconst flex_int32_t yy_meta[75] =
         2,    2,    2,    2
     } ;
 
-static yyconst flex_int16_t yy_base[526] =
+static yyconst flex_int16_t yy_base[539] =
     {   0,
-        0,  622,  626, 1711, 1711, 1711, 1711,   70,  617,  597,
+        0,  628,  628, 1740, 1740, 1740, 1740,   70,  618,  605,
        67,   74,    0,   57,   52,   59,   73,   57,   64,   74,
-      610,   77,   79,   77,   65,  609,  101, 1711,  606,  138,
+      612,   77,   79,   77,   65,  612,  101, 1740,  609,  138,
       202,  215,  217,  230,  237,  250,  252,  259,  265,  277,
       282,  287,  297,  271,  315,  377,  323,  342,  350,  359,
-      364,  396,  401,  591, 1711,  449,  242,   73,   80,   89,
-       76,  378,   78,  397,  398,   91,   76,   91,  441,  328,
-      515,  528,  481,  499,  421,  541,  543,  548,  553,  559,
-      565,  576,  590,  595,  649,    0,  597,  622,  614,  624,
-      656,  632,  674,   85,  131,  124,  230,  249,  572,  260,
-
-      272,  285,  403,  300,  319,  375,  336,  376,  650,  381,
-      401,  415,  436,  717,  730,  743,  756,  768,  781,  787,
-      789,  797,  803,  808,  825,  810,  838,  852,  854,  863,
-      870,  702,  454,  455,  651,  442,  456,  656,  461,  534,
-      538,  533,  537,  562,  571,  581,  628,  642,  570,  655,
-      650,  656,  569,  687,  664,  893,  921,  872,  928,  907,
-      879,  942,  944,  949,  951,  958,  967,  973,  975,  980,
-      993,  995, 1000,  660,  683,  720,  750,  755,  126,  755,
-      795,  786,  787,  805,  860,  567,  564,  856,  856,  855,
-      941,  969,  971,  987,  547,  981,  996,  976,  546,  999,
-
-     1048, 1062, 1075, 1711, 1088, 1090, 1024, 1097, 1106, 1112,
-     1117, 1124, 1132, 1134, 1012, 1043, 1089, 1095, 1090, 1081,
-     1711, 1087, 1085, 1107, 1099, 1116, 1111, 1110, 1120, 1124,
-     1132, 1139,  527, 1128, 1138, 1128, 1141, 1132, 1146, 1139,
-     1151, 1159, 1139, 1711, 1205, 1182, 1199, 1218, 1220, 1228,
-     1233, 1235, 1240, 1246,  526,  517, 1165, 1192, 1217, 1217,
-     1225,  514,  513, 1235, 1212,  472, 1229, 1240, 1230, 1229,
-      471, 1223,  457, 1231,  258, 1230, 1230, 1246, 1248, 1237,
-     1254,  456, 1297, 1310, 1312, 1317, 1243, 1257, 1258,  451,
-     1263, 1287, 1289, 1293, 1288, 1310,    0, 1299, 1302, 1292,
-
-     1304, 1293, 1315, 1315, 1313, 1711, 1318, 1308, 1711, 1309,
-      406, 1313, 1325, 1711, 1311, 1321, 1376, 1378, 1316, 1348,
-     1363, 1349, 1351, 1364,  403, 1355, 1373, 1370, 1371, 1374,
-      373,  372, 1375, 1367, 1382, 1371, 1370, 1381, 1382, 1368,
-     1386, 1418, 1378, 1391, 1388, 1406, 1394, 1405,  367, 1414,
-     1415,  362, 1402, 1423, 1409,  346,  352, 1415, 1711, 1711,
-      348, 1410, 1423, 1428, 1414, 1433, 1424, 1420, 1439, 1429,
-     1438, 1442, 1711, 1419, 1425, 1425, 1442, 1436, 1439, 1448,
-     1464, 1469, 1473, 1711, 1461, 1459, 1463, 1463, 1472, 1470,
-     1466, 1465, 1484, 1711, 1470, 1482, 1480, 1469, 1711, 1480,
-
-     1491, 1488, 1493, 1485, 1499, 1481, 1497, 1486, 1500, 1490,
-     1513,  334, 1516, 1510,  333,  340,  336, 1711, 1512, 1530,
-     1711, 1533, 1518, 1527, 1525,  322, 1528, 1537, 1523, 1531,
-     1529,  321, 1531, 1711, 1544, 1530, 1711, 1532, 1533, 1548,
-     1711, 1539, 1535, 1551, 1536, 1711, 1553, 1542, 1558, 1565,
-     1562, 1711, 1565,  319,  289, 1578, 1581, 1711, 1579, 1573,
-      285, 1573, 1576, 1583, 1589, 1580, 1590, 1591, 1582, 1711,
-     1577, 1578, 1711, 1711, 1711,  282, 1590, 1606,  253, 1597,
-     1606, 1607, 1606, 1607, 1608, 1711, 1613, 1598, 1711,  243,
-     1616, 1621, 1612,  237,  221, 1630, 1632, 1711, 1627,  229,
-
-     1625, 1711, 1711, 1643,  217,  208, 1631, 1646, 1711, 1711,
-     1711, 1647, 1635, 1653, 1636, 1652,  202, 1711, 1711, 1711,
-     1704,  154, 1706,  131, 1708
+      364,  396,  401,  606, 1740,  449,  242,   73,   80,   85,
+       90,   78,  378,   79,  397,  398,   92,   77,   94,  441,
+      328,  515,  528,  481,  499,  421,  541,  543,  548,  553,
+      559,  565,  576,  590,  595,  649,    0,  597,  622,  614,
+      624,  656,  632,  674,  123,  132,  235,  249,  253,  271,
+
+      586,  285,  296,  328,  403,  340,  358,  375,  379,  413,
+      650,  404,  438,  456,  444,  717,  730,  743,  756,  768,
+      781,  787,  789,  797,  803,  808,  825,  810,  838,  852,
+      854,  863,  870,  702,  463,  460,  651,  519,  537,  537,
+      656,  544,  561,  594,  634,  652,  662,  572,  655,  654,
+      651,  571,  664,  658,  672,  570,  711,  696,  893,  921,
+      872,  928,  907,  879,  942,  944,  949,  951,  958,  967,
+      973,  975,  980,  993,  995, 1000,  737,  768,  771,  795,
+      787,  798,  126,  796,  860,  852,  857,  861,  961,  569,
+      567,  959,  971,  970,  971,  992,  985, 1002,  564,  994,
+
+      999,  990,  547, 1006, 1056, 1069, 1082, 1740, 1095, 1097,
+     1107, 1113, 1124, 1118, 1131, 1133, 1139, 1145,  989,  998,
+     1010, 1024, 1022,  546, 1066, 1740, 1084, 1086, 1107, 1110,
+     1126, 1122, 1124, 1134, 1135, 1140, 1145,  527, 1133, 1144,
+     1135, 1148, 1140, 1155, 1147, 1159, 1165, 1145, 1740, 1211,
+     1224, 1226, 1232, 1234, 1239, 1245, 1247, 1252, 1257,  526,
+      517, 1161, 1196, 1236, 1221, 1239, 1244,  514,  513, 1249,
+     1226,  472, 1244, 1254, 1247, 1245,  471, 1241,  457, 1251,
+      258, 1250, 1248, 1264, 1266, 1256, 1273,  456, 1316, 1329,
+     1331, 1336, 1271, 1276, 1277,  451, 1278, 1298, 1286, 1307,
+
+     1312, 1307, 1329,    0, 1318, 1322, 1313, 1324, 1313, 1335,
+     1335, 1333, 1740, 1340, 1328, 1740, 1329,  406, 1333, 1345,
+     1740, 1331, 1341, 1396, 1398, 1344, 1367, 1377, 1368, 1369,
+     1373, 1384,  403, 1375, 1393, 1390, 1391, 1394,  373,  372,
+     1396, 1387, 1402, 1391, 1390, 1401, 1402, 1388, 1406, 1438,
+     1400, 1412, 1409, 1460, 1400, 1411,  367, 1429, 1435, 1431,
+      362, 1428, 1447, 1433,  346,  352, 1439, 1740, 1740,  348,
+     1434, 1448, 1453, 1438, 1458, 1448, 1444, 1463, 1453, 1464,
+     1468, 1740, 1445, 1451, 1452, 1468, 1463, 1462, 1475, 1480,
+     1494, 1494, 1498, 1740, 1488, 1486, 1490, 1489, 1498, 1496,
+
+     1493, 1492, 1511, 1740, 1497, 1508, 1506, 1494, 1740, 1505,
+     1516, 1515, 1520, 1512, 1512, 1528, 1510, 1527, 1515, 1535,
+     1530, 1546,  334, 1551, 1538,  333,  340,  336, 1740, 1540,
+     1558, 1740, 1561, 1546, 1554, 1552,  322, 1555, 1557, 1566,
+     1552, 1560, 1558,  321, 1559, 1740, 1572, 1557, 1740, 1561,
+     1562, 1577, 1740, 1568, 1565, 1581, 1567, 1740, 1740, 1584,
+     1578, 1603, 1606, 1600, 1740, 1603,  319,  289, 1609, 1610,
+     1740, 1608, 1602,  285, 1602, 1604, 1612, 1618, 1609, 1619,
+     1620, 1611, 1740, 1605, 1606, 1740, 1740, 1740,  282, 1617,
+     1635,  253, 1626, 1635, 1636, 1636, 1637, 1639, 1740, 1644,
+
+     1634, 1740,  243, 1661, 1662, 1650,  237,  221, 1668, 1663,
+     1740, 1656,  229, 1654, 1740, 1740, 1672,  217,  208, 1660,
+     1674, 1740, 1740, 1740, 1676, 1664, 1682, 1665, 1681,  202,
+     1740, 1740, 1740, 1733,  154, 1735,  131, 1737
     } ;
 
-static yyconst flex_int16_t yy_def[526] =
+static yyconst flex_int16_t yy_def[539] =
     {   0,
-      520,    1,  520,  520,  520,  520,  520,  521,  520,  520,
-      522,  520,  522,  522,  522,  522,  522,  522,  522,  522,
-      522,  522,  522,  522,  522,  523,  521,  520,  521,  520,
-      520,  524,  524,  524,  520,  524,  524,  524,  524,  524,
-      524,  524,  524,  524,  524,  525,  524,  524,  524,  524,
-      524,  524,  524,  523,  520,   30,   56,   56,   56,   56,
-       56,   56,   56,   56,   56,   56,   56,   56,  520,  524,
-      524,  524,  520,  524,  524,  524,  524,  524,  524,  524,
-      524,  524,  524,  524,  525,   85,  524,  524,  524,  524,
-      524,  524,  524,   56,   56,   56,   56,   56,   56,   56,
+      533,    1,  533,  533,  533,  533,  533,  534,  533,  533,
+      535,  533,  535,  535,  535,  535,  535,  535,  535,  535,
+      535,  535,  535,  535,  535,  536,  534,  533,  534,  533,
+      533,  537,  537,  537,  533,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,  537,  538,  537,  537,  537,  537,
+      537,  537,  537,  536,  533,   30,   56,   56,   56,   56,
+       56,   56,   56,   56,   56,   56,   56,   56,   56,  533,
+      537,  537,  537,  533,  537,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,  537,  538,   86,  537,  537,  537,
+      537,  537,  537,  537,   56,   56,   56,   56,   56,   56,
 
        56,   56,   56,   56,   56,   56,   56,   56,   56,   56,
-       56,   56,   56,  520,  524,  524,  524,  520,  524,  524,
-      524,  524,  524,  524,  524,  524,  524,  524,  524,  524,
-      524,  524,   56,   56,   56,   56,   56,  520,   56,   56,
-       56,   56,   56,   56,   56,   56,   56,   56,   56,   56,
-       56,   56,   56,   56,   56,  520,  524,  524,  520,  524,
-      524,  524,  524,  524,  524,  524,  524,  524,  524,  524,
-      524,  524,  524,   56,   56,   56,   56,   56,   56,  520,
-      520,  520,   56,   56,   56,   56,   56,   56,  520,   56,
-       56,   56,  520,   56,   56,   56,  520,  520,   56,   56,
-
-      520,  524,  524,  520,  524,  524,  524,  524,  524,  524,
-      524,  524,  524,  524,   56,   56,   56,   56,   56,  520,
-      520,  520,  520,  520,   56,   56,   56,  520,  520,   56,
-      520,   56,   56,   56,  520,   56,  520,   56,  520,  520,
-      520,  520,   56,  520,  524,  524,  524,  524,  524,  524,
-      524,  524,  524,  524,   56,   56,   56,   56,   56,  520,
-      520,  520,  520,   56,   56,   56,  520,  520,   56,  520,
-       56,  520,   56,  520,   56,  520,   56,  520,  520,  520,
-      520,   56,  524,  524,  524,  524,  520,  520,   56,   56,
-       56,  520,  520,  520,  520,   56,   56,  520,  520,  520,
-
-      520,   56,  520,  520,  520,  520,  520,  520,  520,  520,
-       56,  520,  520,  520,  520,  520,  524,  524,  520,  520,
-       56,  520,   56,  520,  520,  520,  520,   56,  520,  520,
-      520,  520,   56,  520,  520,  520,  520,  520,  520,  520,
-      520,  520,  520,  520,  520,  524,  520,  520,   56,  520,
-       56,  520,  520,  520,  520,   56,  520,  520,  520,  520,
-       56,  520,  520,  520,  520,  520,  520,  520,  520,  520,
-      520,  520,  520,  520,  520,  520,  520,  520,   56,  520,
-      520,  520,  520,  520,  520,  520,  520,  520,  520,  520,
-      520,  520,  520,  520,  520,  520,  520,  520,  520,  520,
-
-      520,  520,  520,   56,  520,  520,  520,  520,  520,  520,
-      520,  520,  520,  520,  520,  520,  520,  520,  520,  520,
-      520,  520,  520,  520,  520,   56,  520,  520,  520,  520,
-      520,  520,  520,  520,  520,  520,  520,  520,  520,  520,
-      520,  520,  520,  520,  520,  520,  520,  520,  520,  520,
-      520,  520,  520,  520,  520,  520,  520,  520,  520,  520,
-      520,  520,  520,  520,  520,  520,  520,  520,  520,  520,
-      520,  520,  520,  520,  520,  520,  520,  520,  520,  520,
-      520,  520,  520,  520,  520,  520,  520,  520,  520,  520,
-      520,  520,  520,  520,  520,  520,  520,  520,  520,  520,
-
-      520,  520,  520,  520,  520,  520,  520,  520,  520,  520,
-      520,  520,  520,  520,  520,  520,  520,  520,  520,    0,
-      520,  520,  520,  520,  520
+       56,   56,   56,   56,   56,  533,  537,  537,  537,  533,
+      537,  537,  537,  537,  537,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,   56,   56,   56,   56,   56,   56,
+      533,   56,   56,   56,   56,   56,   56,   56,   56,   56,
+       56,   56,   56,   56,   56,   56,   56,   56,  533,  537,
+      537,  533,  537,  537,  537,  537,  537,  537,  537,  537,
+      537,  537,  537,  537,  537,  537,   56,   56,   56,   56,
+       56,   56,   56,  533,  533,  533,   56,   56,   56,   56,
+       56,   56,  533,   56,   56,   56,  533,   56,   56,   56,
+
+      533,  533,   56,   56,  533,  537,  537,  533,  537,  537,
+      537,  537,  537,  537,  537,  537,  537,  537,   56,   56,
+       56,   56,   56,   56,  533,  533,  533,  533,  533,   56,
+       56,   56,  533,  533,   56,  533,   56,   56,   56,  533,
+       56,  533,   56,  533,  533,  533,  533,   56,  533,  537,
+      537,  537,  537,  537,  537,  537,  537,  537,  537,   56,
+       56,   56,   56,   56,  533,  533,  533,  533,  533,   56,
+       56,   56,  533,  533,   56,  533,   56,  533,   56,  533,
+       56,  533,   56,  533,  533,  533,  533,   56,  537,  537,
+      537,  537,  533,  533,   56,   56,   56,  533,  533,  533,
+
+      533,  533,   56,   56,  533,  533,  533,  533,   56,  533,
+      533,  533,  533,  533,  533,  533,  533,   56,  533,  533,
+      533,  533,  533,  537,  537,  533,  533,   56,  533,   56,
+      533,  533,  533,  533,  533,   56,  533,  533,  533,  533,
+       56,  533,  533,  533,  533,  533,  533,  533,  533,  533,
+      533,  533,  533,  537,  533,  533,   56,  533,   56,  533,
+      533,  533,  533,  533,   56,  533,  533,  533,  533,   56,
+      533,  533,  533,  533,  533,  533,  533,  533,  533,  533,
+      533,  533,  533,  533,  533,  533,  533,   56,  533,  533,
+      533,  533,  533,  533,  533,  533,  533,  533,  533,  533,
+
+      533,  533,  533,  533,  533,  533,  533,  533,  533,  533,
+      533,  533,  533,   56,  533,  533,  533,  533,  533,  533,
+      533,  533,  533,  533,  533,  533,  533,  533,  533,  533,
+      533,  533,  533,  533,  533,  533,   56,  533,  533,  533,
+      533,  533,  533,  533,  533,  533,  533,  533,  533,  533,
+      533,  533,  533,  533,  533,  533,  533,  533,  533,  533,
+      533,  533,  533,  533,  533,  533,  533,  533,  533,  533,
+      533,  533,  533,  533,  533,  533,  533,  533,  533,  533,
+      533,  533,  533,  533,  533,  533,  533,  533,  533,  533,
+      533,  533,  533,  533,  533,  533,  533,  533,  533,  533,
+
+      533,  533,  533,  533,  533,  533,  533,  533,  533,  533,
+      533,  533,  533,  533,  533,  533,  533,  533,  533,  533,
+      533,  533,  533,  533,  533,  533,  533,  533,  533,  533,
+      533,  533,    0,  533,  533,  533,  533,  533
     } ;
 
-static yyconst flex_int16_t yy_nxt[1786] =
+static yyconst flex_int16_t yy_nxt[1815] =
     {   0,
         4,    5,    6,    7,    8,    4,    7,    9,    4,   10,
        11,   11,   11,   11,   11,   11,   11,   12,    7,    4,
@@ -704,194 +718,198 @@ static yyconst flex_int16_t yy_nxt[1786] =
        34,   34,   34,   34,   35,   35,   35,   35,   35,   35,
        35,   36,   39,   41,   37,   43,   40,   44,   45,   50,
 
-       47,   52,   53,   51,   38,   28,   42,   96,   97,   98,
-       99,   48,  103,  111,  112,  113,   29,   49,  133,   36,
+       47,   52,   53,   51,   38,   28,   42,   97,   98,   99,
+      100,   48,  101,  105,  113,  114,   29,   49,  115,   36,
        39,   41,   37,   43,   40,   44,   45,   50,   47,   52,
-       53,   51,   70,  220,   42,   96,   97,   98,   99,   48,
-      103,  111,  112,  113,  221,   49,  133,   29,   56,   56,
-       56,   56,   56,   56,   56,   32,  134,  135,   56,   57,
-       58,   59,   56,   56,   56,   60,   61,   56,   56,   56,
-       56,   62,   56,   63,   56,   64,   65,   66,   67,   68,
-       56,   56,   56,   56,  134,  135,   56,   57,   58,   59,
-       56,   56,   56,   60,   61,   56,   56,   56,   56,   62,
-
-       56,   63,   56,   64,   65,   66,   67,   68,   56,   56,
-       56,   56,   69,   69,   69,   69,   69,   69,   69,   32,
-      519,   32,   32,   32,   32,   32,  511,   71,   71,   71,
-       71,   71,   71,   71,   32,  510,  507,   32,   33,  503,
-       72,   72,   72,   72,   72,   72,   72,   73,   73,   73,
-       73,   73,   73,   73,   32,  502,   32,   32,   32,   32,
-       32,  498,   32,   32,   32,  308,   32,   32,  136,   32,
-       94,  489,   32,   32,   75,   32,  309,   32,   32,   32,
-       76,   32,   95,   74,   32,   32,   32,  137,   77,   32,
-       32,   32,  139,   82,   32,   32,  136,   32,   94,   32,
-
-      486,   32,   75,  475,   32,   32,   32,  470,   76,  140,
-       95,   74,   32,   79,   78,  137,   77,  141,   32,   32,
-      139,   82,   32,   32,   32,   81,  469,   32,   80,   32,
-       32,   32,   32,  144,   32,   32,   32,  140,   87,  452,
-      446,   79,   78,  439,   32,  141,   32,  438,   83,   32,
-       32,  437,  434,   81,   32,  387,   80,   32,   32,  385,
-      145,  144,   32,   32,  384,   88,   32,   32,   32,  380,
-       32,   32,   32,  148,  377,   32,   83,   27,   27,   27,
-       27,   84,   27,   27,   85,   85,   27,   89,  145,   32,
-      360,  359,   90,   88,   27,   27,   27,   32,  100,  149,
-
-       32,  148,   91,   32,   32,   32,   32,  146,   32,   32,
-      353,   32,  101,  341,  147,   89,  152,  104,  102,  105,
-       90,  106,  107,   29,   85,   32,  100,  149,   32,   32,
-       91,  108,  109,   92,  142,  146,  153,  143,  110,  154,
-      101,   93,  147,   32,  152,  104,  102,  105,   32,  106,
-      107,  114,  114,  114,  114,  114,  114,  114,  322,  108,
-      109,   92,  142,  316,  153,  143,  110,  154,   32,   93,
-       56,   56,   56,  155,  174,  306,   56,   56,  304,  298,
-      175,  178,   56,  179,   56,  183,   56,   56,   56,   56,
-       56,  118,  118,  118,  118,  118,  118,  118,   56,   56,
-
-       56,  155,  174,   32,   56,   56,   32,   32,  175,  178,
-       56,  179,   56,  183,   56,   56,   56,   56,   56,   32,
-      295,  294,   32,  115,  288,  116,  116,  116,  116,  116,
-      116,  116,   32,  287,  272,   32,   33,  119,  117,  117,
-      117,  117,  117,  117,  117,   32,   32,   32,   32,   32,
-       32,   32,   32,  242,  237,   32,   32,   32,  184,  185,
-       32,   32,   32,   32,  186,  119,   32,   32,  187,   32,
-      123,  229,   32,   32,  228,   32,  197,  193,  189,  138,
-       32,  120,  121,   32,   32,  188,  184,  185,   32,  124,
-       32,  122,  186,   55,   32,   32,  187,   32,   32,   32,
-
-       32,   32,   32,   32,   32,   32,   32,  125,  520,  120,
-      121,   55,   32,  188,   46,  190,   31,  124,   32,  122,
-      126,   32,   32,   32,   30,  520,   32,   26,   32,   32,
-       32,   32,   32,  520,  520,  125,   32,   32,  520,   32,
-       32,  520,   32,  190,   32,  520,  128,  129,  126,   27,
-       27,   27,   27,   84,   27,   27,   85,   85,   27,  520,
-       32,   32,  127,   32,   32,  191,   27,   27,   27,   32,
-      520,   32,  150,  131,  128,  129,  176,  180,   32,   32,
-      130,   32,   32,  192,  177,  194,  181,  151,  182,  195,
-      127,  196,  200,  191,  198,   29,   85,  215,  132,  520,
-
-      150,  131,  520,   32,  176,  180,   32,  216,  130,   32,
-       32,  192,  177,  194,  181,  151,  182,  195,  520,  196,
-      200,   32,  520,  520,  199,  215,  132,  156,  156,  156,
-      156,  156,  156,  156,   32,  216,  520,   32,   32,  520,
-      157,  157,  157,  157,  157,  157,  157,   32,  217,   32,
-       32,  115,  199,  158,  158,  158,  158,  158,  158,  158,
-       32,  520,  520,   32,   32,  520,  117,  117,  117,  117,
-      117,  117,  117,  520,  218,  520,  217,   32,  159,  159,
-      159,  159,  159,  159,  159,   32,  520,  520,   32,   32,
-       32,   32,  219,   32,   32,   32,   32,   32,  520,  222,
-
-      520,   32,  218,   32,   32,   32,  520,   32,  520,  160,
-       32,   32,   32,  161,   32,   32,   32,   32,   32,  223,
-      219,  163,  520,  164,  224,  225,  162,  222,   32,   32,
-      520,  520,   32,   32,   32,  166,   32,  160,  168,  520,
-      226,  161,   32,  520,   32,   32,   32,  223,  520,  163,
-      165,  164,  224,  225,  162,   32,   32,   32,   32,   32,
-       32,   32,   32,  166,  520,  167,  168,   32,  226,  169,
-       32,   32,   32,  520,   32,  520,   32,   32,   32,   32,
-      115,  520,  520,   32,  227,   32,   32,   32,  171,  520,
-      230,  520,  170,  167,  173,  231,  232,  169,  520,   32,
-
-      520,   32,  172,  201,  201,  201,  201,  201,  201,  201,
-       32,   32,  227,  520,   32,   32,  171,   32,  230,   32,
-      170,  520,  173,  231,  232,   32,   32,  520,   32,  202,
-      172,  203,  203,  203,  203,  203,  203,  203,  204,  204,
-      204,  204,  204,  204,  204,  205,   32,  520,   32,   32,
+       53,   51,   71,  225,   42,   97,   98,   99,  100,   48,
+      101,  105,  113,  114,  226,   49,  115,   29,   56,   56,
+       56,   56,   56,   56,   56,   32,  135,  136,   56,   57,
+       58,   59,   56,   60,   56,   61,   62,   56,   56,   56,
+       56,   63,   56,   64,   56,   65,   66,   67,   68,   69,
+       56,   56,   56,   56,  135,  136,   56,   57,   58,   59,
+       56,   60,   56,   61,   62,   56,   56,   56,   56,   63,
+
+       56,   64,   56,   65,   66,   67,   68,   69,   56,   56,
+       56,   56,   70,   70,   70,   70,   70,   70,   70,   32,
+      532,   32,   32,   32,   32,   32,  524,   72,   72,   72,
+       72,   72,   72,   72,   32,  523,  520,   32,   33,  516,
+       73,   73,   73,   73,   73,   73,   73,   74,   74,   74,
+       74,   74,   74,   74,   32,  515,   32,   32,   32,   32,
+       32,  511,   32,   32,   32,  315,   32,   32,  137,   32,
+       95,  502,   32,   32,   76,   32,  316,   32,   32,   32,
+       77,   32,   96,   75,   32,   32,   32,  138,   78,   32,
+       32,   32,  139,   83,   32,   32,  137,   32,   95,   32,
+
+      499,   32,   76,  488,   32,   32,   32,  483,   77,  140,
+       96,   75,   32,   80,   79,  138,   78,  142,   32,   32,
+      139,   83,   32,   32,   32,   82,  482,   32,   81,   32,
+       32,   32,   32,  143,   32,   32,   32,  140,   88,  465,
+      458,   80,   79,  451,   32,  142,   32,  450,   84,   32,
+       32,  449,  446,   82,   32,  397,   81,   32,   32,  395,
+      144,  143,   32,   32,  394,   89,   32,   32,   32,  390,
+       32,   32,   32,  147,  386,   32,   84,   27,   27,   27,
+       27,   85,   27,   27,   86,   86,   27,   90,  144,   32,
+      369,  368,   91,   89,   27,   27,   27,   32,  102,  148,
+
+       32,  147,   92,   32,   32,   32,   32,  149,   32,   32,
+      362,   32,  103,  349,  150,   90,  151,  106,  104,  107,
+       91,  108,  109,   29,   86,   32,  102,  148,   32,   32,
+       92,  110,  111,   93,  145,  149,  152,  146,  112,  155,
+      103,   94,  150,   32,  151,  106,  104,  107,   32,  108,
+      109,  116,  116,  116,  116,  116,  116,  116,  329,  110,
+      111,   93,  145,  323,  152,  146,  112,  155,   32,   94,
+       56,   56,   56,  156,   56,  313,   56,   56,  311,  305,
+      157,  158,   56,  177,   56,  178,   56,   56,   56,   56,
+       56,  120,  120,  120,  120,  120,  120,  120,   56,   56,
+
+       56,  156,   56,   32,   56,   56,   32,   32,  157,  158,
+       56,  177,   56,  178,   56,   56,   56,   56,   56,   32,
+      302,  301,   32,  117,  294,  118,  118,  118,  118,  118,
+      118,  118,   32,  293,  278,   32,   33,  121,  119,  119,
+      119,  119,  119,  119,  119,   32,   32,   32,   32,   32,
+       32,   32,   32,  265,  247,   32,   32,   32,  181,  182,
+       32,   32,   32,   32,  183,  121,   32,   32,  187,   32,
+      125,  242,   32,   32,  234,   32,  233,  201,  197,  193,
+       32,  122,  123,   32,   32,  188,  181,  182,   32,  126,
+       32,  124,  183,  141,   32,   32,  187,   32,   32,   32,
+
+       32,   32,   32,   32,   32,   32,   32,  127,   55,  122,
+      123,  533,   32,  188,   55,  189,   46,  126,   32,  124,
+      128,   32,   32,   32,   31,   30,   32,  533,   32,   32,
+       32,   32,   32,   26,  533,  127,   32,   32,  533,   32,
+       32,  533,   32,  189,   32,  533,  130,  131,  128,   27,
+       27,   27,   27,   85,   27,   27,   86,   86,   27,  533,
+       32,   32,  129,   32,   32,  190,   27,   27,   27,   32,
+      533,   32,  153,  133,  130,  131,  179,  184,   32,   32,
+      132,   32,   32,  191,  180,  192,  185,  154,  186,  194,
+      129,  195,  196,  190,  198,   29,   86,  199,  134,  533,
+
+      153,  133,  533,   32,  179,  184,   32,  200,  132,   32,
+       32,  191,  180,  192,  185,  154,  186,  194,  202,  195,
+      196,   32,  198,  533,  204,  199,  134,  159,  159,  159,
+      159,  159,  159,  159,   32,  200,  533,   32,   32,  533,
+      160,  160,  160,  160,  160,  160,  160,   32,  203,   32,
+       32,  117,  204,  161,  161,  161,  161,  161,  161,  161,
+       32,  533,  533,   32,   32,  533,  119,  119,  119,  119,
+      119,  119,  119,  533,  219,  533,  203,   32,  162,  162,
+      162,  162,  162,  162,  162,   32,  533,  533,   32,   32,
+       32,   32,  220,   32,   32,   32,   32,   32,  533,  221,
+
+      533,   32,  219,   32,   32,   32,  533,   32,  533,  163,
+       32,   32,   32,  164,   32,   32,   32,   32,   32,  222,
+      220,  166,  533,  167,  223,  224,  165,  221,   32,   32,
+      533,  533,   32,   32,   32,  169,   32,  163,  171,  533,
+      227,  164,   32,  533,   32,   32,   32,  222,  533,  166,
+      168,  167,  223,  224,  165,   32,   32,   32,   32,   32,
+       32,   32,   32,  169,  533,  170,  171,   32,  227,  172,
+       32,   32,   32,  533,   32,  533,   32,   32,   32,   32,
+      117,  533,  533,   32,  228,   32,   32,   32,  174,  533,
+      229,  533,  173,  170,  176,  230,  231,  172,  533,   32,
+
+      533,   32,  175,  205,  205,  205,  205,  205,  205,  205,
+       32,   32,  228,  533,   32,   32,  174,   32,  229,   32,
+      173,  533,  176,  230,  231,   32,   32,  533,   32,  206,
+      175,  207,  207,  207,  207,  207,  207,  207,  208,  208,
+      208,  208,  208,  208,  208,  209,   32,  533,   32,   32,
        32,   32,   32,   32,   32,   32,   32,   32,   32,   32,
-      520,  520,   32,  520,  207,   32,   32,  208,   32,  520,
-      520,   32,  520,  205,   32,   32,  520,   32,  520,   32,
-       32,   32,   32,   32,   32,  233,  520,   32,   32,   32,
-      209,   32,  520,  234,  520,  211,  206,   32,   32,   32,
-
-       32,   32,   32,   32,   32,   32,  210,   32,   32,  520,
-      235,  236,  520,  233,   32,  238,  241,  212,  209,  520,
-       32,  234,   32,  211,  243,  213,  239,   32,   32,  240,
-      520,   32,   32,  520,  210,  520,  250,  214,  235,  236,
-       32,  520,   32,  238,  241,  212,  520,   32,  520,  520,
-      520,  520,  243,  213,  239,  520,  255,  240,  244,  244,
-      244,  244,  244,  244,  244,  214,   32,  520,  520,   32,
-       32,   32,  245,  245,  245,  245,  245,  245,  245,   32,
-      256,  520,   32,  202,  255,  246,  246,  246,  246,  246,
-      246,  246,   32,  520,   32,   32,   32,   32,   32,  520,
-
-      520,   32,  520,  248,   32,   32,  249,  520,  256,   32,
-       32,  251,  520,   32,   32,  257,   32,  258,  259,   32,
-       32,   32,   32,  260,   32,   32,  261,  247,   32,  262,
-      252,   32,   32,  263,  264,   32,   32,   32,   32,   32,
-       32,   32,   32,  257,   32,  258,  259,  265,  266,  267,
-      253,  260,  268,   32,  261,  247,  269,  262,  252,   32,
-      270,  263,  264,  271,   32,  273,  274,  275,  276,  277,
-      278,   32,  254,  279,  280,  265,  266,  267,  253,   32,
-      268,   32,  281,  282,  269,  520,   32,  520,  270,   32,
-      202,  271,  520,  273,  274,  275,  276,  277,  278,  520,
-
-      254,  279,  280,   32,  520,  289,   32,   32,  520,   32,
-      281,  282,   32,   32,  520,  283,  283,  283,  283,  283,
-      283,  283,   32,  284,   32,   32,   32,   32,   32,   32,
-      285,  290,   32,  289,  286,   32,   32,   32,  291,   32,
-       32,   32,   32,   32,   32,  292,   32,   32,   32,  293,
-       32,  284,   32,   32,   32,  296,  297,  299,  302,  290,
-      300,  303,  305,  307,  310,   32,  291,   32,  301,  311,
-      312,  313,  314,  292,  315,   32,  520,  293,  319,  520,
-       32,  520,   32,  296,  297,  299,  302,   32,  300,  303,
-      305,  307,  310,   32,  320,  321,  301,  311,  312,  313,
-
-      314,   32,  315,  323,   32,   32,  319,  317,  317,  317,
-      317,  317,  317,  317,   32,  520,   32,   32,   32,   32,
-       32,   32,  320,  321,   32,   32,  324,  325,  326,  520,
-      327,  323,  328,  329,  330,  331,  520,  332,  333,  334,
-      335,  336,  337,  318,   32,  338,  339,  340,  342,  343,
-      344,  345,  520,  347,  324,  325,  326,   32,  327,   32,
-      328,  329,  330,  331,   32,  332,  333,  334,  335,  336,
-      337,  318,  348,  338,  339,  340,  342,  343,  344,  345,
-       32,  347,   32,   32,   32,   32,   32,  349,  350,  520,
-      351,  352,  354,  355,  356,  520,  357,  520,  358,  361,
-
-      348,  362,  363,  364,  365,  366,  367,  368,  369,  372,
-       32,  373,  374,   32,   32,  349,  350,  346,  351,  352,
-      354,  355,  356,   32,  357,   32,  358,  361,  375,  362,
-      363,  364,  365,  366,  367,  368,  369,  372,  370,  373,
-      374,  376,  378,  379,  381,  346,  371,  382,  383,  386,
-      388,  389,  390,   32,  391,  392,  375,  393,  394,  395,
-      396,  397,  398,  399,  400,  401,  370,  402,  403,  376,
-      378,  379,  381,  404,  371,  382,  383,  386,  388,  389,
-      390,  405,  391,  392,  406,  393,  394,  395,  396,  397,
-      398,  399,  400,  401,  407,  402,  403,  408,  409,  410,
-
-      411,  404,  412,  413,  414,  415,  416,  417,  418,  405,
-      419,  420,  406,  421,  422,  423,  424,  425,  426,  427,
-      428,  429,  407,  430,  431,  408,  409,  410,  411,  432,
-      412,  413,  414,  415,  416,  417,  418,  433,  419,  420,
-      435,  421,  422,  423,  424,  425,  426,  427,  428,  429,
-      436,  430,  431,  440,  441,  442,  443,  432,  444,  445,
-      447,  448,  449,  450,  451,  433,  453,  454,  435,  455,
-      456,  457,  458,  459,  460,  461,  462,  463,  436,  464,
-      465,  440,  441,  442,  443,  466,  444,  445,  447,  448,
-      449,  450,  451,  467,  453,  454,  468,  455,  456,  457,
-
-      458,  459,  460,  461,  462,  463,  471,  464,  465,  472,
-      473,  474,  476,  466,  477,  478,  479,  480,  481,  482,
-      483,  467,  484,  485,  468,  487,  488,  490,  491,  492,
-      493,  494,  495,  496,  471,  497,  499,  472,  473,  474,
-      476,  500,  477,  478,  479,  480,  481,  482,  483,  501,
-      484,  485,  504,  487,  488,  490,  491,  492,  493,  494,
-      495,  496,  505,  497,  499,  506,  508,  509,  512,  500,
-      513,  514,  515,  516,  517,  518,  520,  501,  520,  520,
-      504,  520,  520,  520,  520,  520,  520,  520,  520,  520,
-      505,  520,  520,  506,  508,  509,  512,  520,  513,  514,
-
-      515,  516,  517,  518,   27,   27,   54,   54,   86,   86,
-        3,  520,  520,  520,  520,  520,  520,  520,  520,  520,
-      520,  520,  520,  520,  520,  520,  520,  520,  520,  520,
-      520,  520,  520,  520,  520,  520,  520,  520,  520,  520,
-      520,  520,  520,  520,  520,  520,  520,  520,  520,  520,
-      520,  520,  520,  520,  520,  520,  520,  520,  520,  520,
-      520,  520,  520,  520,  520,  520,  520,  520,  520,  520,
-      520,  520,  520,  520,  520,  520,  520,  520,  520,  520,
-      520,  520,  520,  520,  520
+      533,  533,   32,  533,  211,   32,   32,  212,   32,  533,
+      533,   32,  533,  209,   32,   32,  533,   32,  533,   32,
+       32,   32,   32,   32,   32,  232,  533,   32,   32,   32,
+      213,   32,  533,  235,  533,  215,  210,   32,   32,   32,
+
+       32,   32,   32,   32,   32,   32,  214,   32,   32,  533,
+      236,  237,  533,  232,   32,  238,  239,  216,  213,  533,
+       32,  235,   32,  215,  240,  217,  241,   32,  243,  244,
+      246,  248,  245,  260,  214,  261,  262,  218,  236,  237,
+       32,  533,   32,  238,  239,  216,  263,   32,  533,  533,
+      264,  533,  240,  217,  241,  533,  243,  244,  246,  248,
+      245,  260,  533,  261,  262,  218,  249,  249,  249,  249,
+      249,  249,  249,   32,  263,  533,   32,   32,  264,  250,
+      250,  250,  250,  250,  250,  250,   32,  533,  533,   32,
+      206,  533,  251,  251,  251,  251,  251,  251,  251,   32,
+
+      533,   32,   32,   32,   32,   32,  533,  533,  266,  533,
+      253,   32,  533,  254,   32,   32,   32,   32,  533,  255,
+       32,   32,   32,  267,  533,   32,   32,  256,   32,   32,
+      268,   32,   32,  269,  252,   32,  266,   32,   32,   32,
+       32,   32,   32,   32,   32,  270,   32,   32,  257,   32,
+      533,  267,   32,   32,   32,  533,  258,  271,  268,  272,
+       32,  269,  252,  273,  533,   32,  274,  275,  276,  277,
+      279,   32,  280,  270,  281,  282,  257,  283,   32,  284,
+       32,  285,  286,  259,  258,  271,   32,  272,  287,  288,
+      533,  273,   32,  533,  274,  275,  276,  277,  279,  533,
+
+      280,  295,  281,  282,  533,  283,  533,  284,  533,  285,
+      286,  259,  533,  533,  533,   32,  287,  288,   32,   32,
+      533,  289,  289,  289,  289,  289,  289,  289,   32,  295,
+       32,   32,  206,   32,   32,  296,   32,  533,   32,   32,
+       32,   32,   32,   32,  291,  533,   32,   32,  292,   32,
+      290,   32,   32,   32,   32,   32,   32,  297,   32,   32,
+       32,   32,  298,  296,   32,   32,  533,  299,  300,  303,
+      304,   32,  306,   32,  307,  309,  533,  310,  290,   32,
+      312,   32,  308,  314,  317,  297,   32,  318,  319,  320,
+      298,  321,   32,  322,   32,  299,  300,  303,  304,   32,
+
+      306,  533,  307,  309,   32,  310,  326,  533,  312,  533,
+      308,  314,  317,  327,  328,  318,  319,  320,  330,  321,
+       32,  322,  331,   32,   32,  332,  324,  324,  324,  324,
+      324,  324,  324,   32,  326,   32,   32,   32,   32,   32,
+       32,  327,  328,   32,   32,  333,  330,  334,  533,  335,
+      331,  336,  337,  332,  338,  533,  339,  340,  341,  342,
+      343,  344,  325,   32,  345,  346,  347,  348,  350,  351,
+      352,  353,  533,  333,  533,  334,   32,  335,   32,  336,
+      337,  355,  338,   32,  339,  340,  341,  342,  343,  344,
+      325,  356,  345,  346,  347,  348,  350,  351,  352,  353,
+
+       32,  357,   32,   32,   32,   32,   32,  358,  359,  355,
+      360,  361,  363,  364,  365,  533,  366,  533,  367,  356,
+      370,  371,  372,  373,  374,  375,  376,  377,  378,  357,
+      533,  381,  382,  383,  384,  358,  359,  354,  360,  361,
+      363,  364,  365,   32,  366,   32,  367,  385,  370,  371,
+      372,  373,  374,  375,  376,  377,  378,  387,  379,  381,
+      382,  383,  384,  388,   32,  354,  380,   32,   32,  389,
+      391,  392,  393,  396,  398,  385,  399,  400,  401,  533,
+      402,  403,  404,  405,  406,  387,  379,  407,  408,  409,
+      410,  388,  411,  412,  380,  413,  414,  389,  391,  392,
+
+      393,  396,  398,  415,  399,  400,  401,   32,  402,  403,
+      404,  405,  406,  416,  417,  407,  408,  409,  410,  418,
+      411,  412,  419,  413,  414,  420,  421,  422,  423,  424,
+      425,  415,  426,  427,  428,  429,  430,  431,  432,  433,
+      434,  416,  417,  435,  436,  437,  438,  418,  439,  440,
+      419,  441,  442,  420,  421,  422,  423,  424,  425,  443,
+      426,  427,  428,  429,  430,  431,  432,  433,  434,  444,
+      445,  435,  436,  437,  438,  447,  439,  440,  448,  441,
+      442,  452,  453,  454,  455,  456,  457,  443,  459,  460,
+      461,  462,  463,  464,  466,  467,  468,  444,  445,  469,
+
+      470,  471,  472,  447,  473,  474,  448,  475,  476,  452,
+      453,  454,  455,  456,  457,  477,  459,  460,  461,  462,
+      463,  464,  466,  467,  468,  478,  479,  469,  470,  471,
+      472,  480,  473,  474,  481,  475,  476,  484,  485,  486,
+      487,  489,  490,  477,  491,  492,  493,  494,  495,  496,
+      497,  498,  500,  478,  479,  501,  503,  504,  505,  480,
+      506,  507,  481,  508,  509,  484,  485,  486,  487,  489,
+      490,  510,  491,  492,  493,  494,  495,  496,  497,  498,
+      500,  512,  513,  501,  503,  504,  505,  514,  506,  507,
+      517,  508,  509,  518,  519,  521,  522,  525,  526,  510,
+
+      527,  528,  529,  530,  531,  533,  533,  533,  533,  512,
+      513,  533,  533,  533,  533,  514,  533,  533,  517,  533,
+      533,  518,  519,  521,  522,  525,  526,  533,  527,  528,
+      529,  530,  531,   27,   27,   54,   54,   87,   87,    3,
+      533,  533,  533,  533,  533,  533,  533,  533,  533,  533,
+      533,  533,  533,  533,  533,  533,  533,  533,  533,  533,
+      533,  533,  533,  533,  533,  533,  533,  533,  533,  533,
+      533,  533,  533,  533,  533,  533,  533,  533,  533,  533,
+      533,  533,  533,  533,  533,  533,  533,  533,  533,  533,
+      533,  533,  533,  533,  533,  533,  533,  533,  533,  533,
+
+      533,  533,  533,  533,  533,  533,  533,  533,  533,  533,
+      533,  533,  533,  533
     } ;
 
-static yyconst flex_int16_t yy_chk[1786] =
+static yyconst flex_int16_t yy_chk[1815] =
     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
@@ -905,11 +923,11 @@ static yyconst flex_int16_t yy_chk[1786] =
        12,   14,   16,   17,   14,   18,   16,   19,   20,   23,
 
        22,   24,   25,   23,   15,   27,   17,   58,   59,   60,
-       61,   22,   63,   66,   67,   68,    8,   22,   94,   14,
+       61,   22,   62,   64,   67,   68,    8,   22,   69,   14,
        16,   17,   14,   18,   16,   19,   20,   23,   22,   24,
-       25,   23,  524,  179,   17,   58,   59,   60,   61,   22,
-       63,   66,   67,   68,  179,   22,   94,   27,   30,   30,
-       30,   30,   30,   30,   30,  522,   95,   96,   30,   30,
+       25,   23,  537,  183,   17,   58,   59,   60,   61,   22,
+       62,   64,   67,   68,  183,   22,   69,   27,   30,   30,
+       30,   30,   30,   30,   30,  535,   95,   96,   30,   30,
        30,   30,   30,   30,   30,   30,   30,   30,   30,   30,
        30,   30,   30,   30,   30,   30,   30,   30,   30,   30,
        30,   30,   30,   30,   95,   96,   30,   30,   30,   30,
@@ -917,189 +935,193 @@ static yyconst flex_int16_t yy_chk[1786] =
 
        30,   30,   30,   30,   30,   30,   30,   30,   30,   30,
        30,   30,   31,   31,   31,   31,   31,   31,   31,   32,
-      517,   33,   32,   32,   33,   33,  506,   33,   33,   33,
-       33,   33,   33,   33,   34,  505,  500,   34,   34,  495,
+      530,   33,   32,   32,   33,   33,  519,   33,   33,   33,
+       33,   33,   33,   33,   34,  518,  513,   34,   34,  508,
        34,   34,   34,   34,   34,   34,   34,   35,   35,   35,
-       35,   35,   35,   35,   36,  494,   37,   36,   36,   37,
-       37,  490,   32,   38,   33,  275,   38,   38,   97,   39,
-       57,  479,   39,   39,   37,   44,  275,   34,   44,   44,
+       35,   35,   35,   35,   36,  507,   37,   36,   36,   37,
+       37,  503,   32,   38,   33,  281,   38,   38,   97,   39,
+       57,  492,   39,   39,   37,   44,  281,   34,   44,   44,
        38,   40,   57,   36,   40,   40,   41,   98,   39,   41,
-       41,   42,  100,   44,   42,   42,   97,   36,   57,   37,
+       41,   42,   99,   44,   42,   42,   97,   36,   57,   37,
 
-      476,   43,   37,  461,   43,   43,   38,  455,   38,  101,
+      489,   43,   37,  474,   43,   43,   38,  468,   38,  100,
        57,   36,   39,   41,   40,   98,   39,  102,   44,   45,
-      100,   44,   45,   45,   40,   43,  454,   47,   42,   41,
-       47,   47,   70,  104,   42,   70,   70,  101,   47,  432,
-      426,   41,   40,  417,   43,  102,   48,  416,   45,   48,
-       48,  415,  412,   43,   49,  361,   42,   49,   49,  357,
-      105,  104,   45,   50,  356,   48,   50,   50,   51,  352,
-       47,   51,   51,  107,  349,   70,   45,   46,   46,   46,
-       46,   46,   46,   46,   46,   46,   46,   49,  105,   48,
-      332,  331,   50,   48,   46,   46,   46,   49,   62,  108,
-
-       52,  107,   51,   52,   52,   53,   50,  106,   53,   53,
-      325,   51,   62,  311,  106,   49,  110,   64,   62,   64,
-       50,   64,   65,   46,   46,   75,   62,  108,   75,   75,
-       51,   65,   65,   52,  103,  106,  111,  103,   65,  112,
-       62,   53,  106,   52,  110,   64,   62,   64,   53,   64,
-       65,   69,   69,   69,   69,   69,   69,   69,  290,   65,
-       65,   52,  103,  282,  111,  103,   65,  112,   75,   53,
-       56,   56,   56,  113,  133,  273,   56,   56,  271,  266,
-      134,  136,   56,  137,   56,  139,   56,   56,   56,   56,
-       56,   73,   73,   73,   73,   73,   73,   73,   56,   56,
-
-       56,  113,  133,   74,   56,   56,   74,   74,  134,  136,
-       56,  137,   56,  139,   56,   56,   56,   56,   56,   71,
-      263,  262,   71,   71,  256,   71,   71,   71,   71,   71,
-       71,   71,   72,  255,  233,   72,   72,   74,   72,   72,
-       72,   72,   72,   72,   72,   76,   74,   77,   76,   76,
-       77,   77,   78,  199,  195,   78,   78,   79,  140,  141,
-       79,   79,   71,   80,  142,   74,   80,   80,  143,   81,
-       80,  187,   81,   81,  186,   72,  153,  149,  145,   99,
-       82,   76,   78,   82,   82,  144,  140,  141,   76,   81,
-       77,   79,  142,   54,   83,   78,  143,   83,   83,   84,
-
-       79,   87,   84,   84,   87,   87,   80,   82,   29,   76,
-       78,   26,   81,  144,   21,  146,   10,   81,   89,   79,
-       83,   89,   89,   82,    9,    3,   88,    2,   90,   88,
-       88,   90,   90,    0,    0,   82,   92,   83,    0,   92,
-       92,    0,   84,  146,   87,    0,   89,   90,   83,   85,
-       85,   85,   85,   85,   85,   85,   85,   85,   85,    0,
-       91,   89,   88,   91,   91,  147,   85,   85,   85,   88,
-        0,   90,  109,   92,   89,   90,  135,  138,   93,   92,
-       91,   93,   93,  148,  135,  150,  138,  109,  138,  151,
-       88,  152,  155,  147,  154,   85,   85,  174,   93,    0,
-
-      109,   92,    0,   91,  135,  138,  132,  175,   91,  132,
-      132,  148,  135,  150,  138,  109,  138,  151,    0,  152,
-      155,   93,    0,    0,  154,  174,   93,  114,  114,  114,
-      114,  114,  114,  114,  115,  175,    0,  115,  115,    0,
-      115,  115,  115,  115,  115,  115,  115,  116,  176,  132,
-      116,  116,  154,  116,  116,  116,  116,  116,  116,  116,
-      117,    0,    0,  117,  117,    0,  117,  117,  117,  117,
-      117,  117,  117,    0,  177,    0,  176,  115,  118,  118,
-      118,  118,  118,  118,  118,  119,    0,    0,  119,  119,
-      116,  120,  178,  121,  120,  120,  121,  121,    0,  180,
-
-        0,  122,  177,  117,  122,  122,    0,  123,    0,  119,
-      123,  123,  124,  120,  126,  124,  124,  126,  126,  181,
-      178,  122,    0,  123,  182,  183,  121,  180,  119,  125,
-        0,    0,  125,  125,  120,  124,  121,  119,  126,    0,
-      184,  120,  127,    0,  122,  127,  127,  181,    0,  122,
-      123,  123,  182,  183,  121,  124,  128,  126,  129,  128,
-      128,  129,  129,  124,    0,  125,  126,  130,  184,  127,
-      130,  130,  125,    0,  131,    0,  158,  131,  131,  158,
-      158,    0,    0,  161,  185,  127,  161,  161,  129,    0,
-      188,    0,  128,  125,  131,  189,  190,  127,    0,  128,
-
-        0,  129,  130,  156,  156,  156,  156,  156,  156,  156,
-      130,  160,  185,    0,  160,  160,  129,  131,  188,  158,
-      128,    0,  131,  189,  190,  157,  161,    0,  157,  157,
-      130,  157,  157,  157,  157,  157,  157,  157,  159,  159,
-      159,  159,  159,  159,  159,  160,  162,    0,  163,  162,
-      162,  163,  163,  164,  160,  165,  164,  164,  165,  165,
-        0,    0,  166,    0,  165,  166,  166,  165,  157,    0,
-        0,  167,    0,  160,  167,  167,    0,  168,    0,  169,
-      168,  168,  169,  169,  170,  191,    0,  170,  170,  162,
-      167,  163,    0,  192,    0,  169,  164,  171,  165,  172,
-
-      171,  171,  172,  172,  173,  166,  168,  173,  173,    0,
-      193,  194,    0,  191,  167,  196,  198,  170,  167,    0,
-      168,  192,  169,  169,  200,  171,  197,  170,  207,  197,
-        0,  207,  207,    0,  168,    0,  207,  173,  193,  194,
-      171,    0,  172,  196,  198,  170,    0,  173,    0,    0,
-        0,    0,  200,  171,  197,    0,  215,  197,  201,  201,
-      201,  201,  201,  201,  201,  173,  202,    0,    0,  202,
-      202,  207,  202,  202,  202,  202,  202,  202,  202,  203,
-      216,    0,  203,  203,  215,  203,  203,  203,  203,  203,
-      203,  203,  205,    0,  206,  205,  205,  206,  206,    0,
-
-        0,  208,    0,  206,  208,  208,  206,    0,  216,  202,
-      209,  208,    0,  209,  209,  217,  210,  218,  219,  210,
-      210,  211,  203,  220,  211,  211,  222,  205,  212,  223,
-      209,  212,  212,  224,  225,  205,  213,  206,  214,  213,
-      213,  214,  214,  217,  208,  218,  219,  226,  227,  228,
-      210,  220,  229,  209,  222,  205,  230,  223,  209,  210,
-      231,  224,  225,  232,  211,  234,  235,  236,  237,  238,
-      239,  212,  214,  240,  241,  226,  227,  228,  210,  213,
-      229,  214,  242,  243,  230,    0,  246,    0,  231,  246,
-      246,  232,    0,  234,  235,  236,  237,  238,  239,    0,
-
-      214,  240,  241,  247,    0,  257,  247,  247,    0,  245,
-      242,  243,  245,  245,    0,  245,  245,  245,  245,  245,
-      245,  245,  248,  247,  249,  248,  248,  249,  249,  246,
-      248,  258,  250,  257,  249,  250,  250,  251,  259,  252,
-      251,  251,  252,  252,  253,  260,  247,  253,  253,  261,
-      254,  247,  245,  254,  254,  264,  265,  267,  269,  258,
-      268,  270,  272,  274,  276,  248,  259,  249,  268,  277,
-      278,  279,  280,  260,  281,  250,    0,  261,  287,    0,
-      251,    0,  252,  264,  265,  267,  269,  253,  268,  270,
-      272,  274,  276,  254,  288,  289,  268,  277,  278,  279,
-
-      280,  283,  281,  291,  283,  283,  287,  283,  283,  283,
-      283,  283,  283,  283,  284,    0,  285,  284,  284,  285,
-      285,  286,  288,  289,  286,  286,  292,  293,  294,    0,
-      295,  291,  296,  298,  299,  300,    0,  301,  302,  303,
-      304,  305,  307,  284,  283,  308,  308,  310,  312,  313,
-      315,  316,    0,  319,  292,  293,  294,  284,  295,  285,
-      296,  298,  299,  300,  286,  301,  302,  303,  304,  305,
-      307,  284,  320,  308,  308,  310,  312,  313,  315,  316,
-      317,  319,  318,  317,  317,  318,  318,  321,  322,    0,
-      323,  324,  326,  327,  328,    0,  329,    0,  330,  333,
-
-      320,  334,  335,  336,  337,  338,  339,  340,  341,  343,
-      346,  344,  345,  346,  346,  321,  322,  318,  323,  324,
-      326,  327,  328,  317,  329,  318,  330,  333,  347,  334,
-      335,  336,  337,  338,  339,  340,  341,  343,  342,  344,
-      345,  348,  350,  351,  353,  318,  342,  354,  355,  358,
-      362,  363,  364,  346,  365,  366,  347,  367,  368,  369,
-      370,  371,  372,  374,  375,  376,  342,  377,  378,  348,
-      350,  351,  353,  379,  342,  354,  355,  358,  362,  363,
-      364,  380,  365,  366,  381,  367,  368,  369,  370,  371,
-      372,  374,  375,  376,  382,  377,  378,  383,  385,  386,
-
-      387,  379,  388,  389,  390,  391,  392,  393,  395,  380,
-      396,  397,  381,  398,  400,  401,  402,  403,  404,  405,
-      406,  407,  382,  408,  409,  383,  385,  386,  387,  410,
-      388,  389,  390,  391,  392,  393,  395,  411,  396,  397,
-      413,  398,  400,  401,  402,  403,  404,  405,  406,  407,
-      414,  408,  409,  419,  420,  422,  423,  410,  424,  425,
-      427,  428,  429,  430,  431,  411,  433,  435,  413,  436,
-      438,  439,  440,  442,  443,  444,  445,  447,  414,  448,
-      449,  419,  420,  422,  423,  450,  424,  425,  427,  428,
-      429,  430,  431,  451,  433,  435,  453,  436,  438,  439,
-
-      440,  442,  443,  444,  445,  447,  456,  448,  449,  457,
-      459,  460,  462,  450,  463,  464,  465,  466,  467,  468,
-      469,  451,  471,  472,  453,  477,  478,  480,  481,  482,
-      483,  484,  485,  487,  456,  488,  491,  457,  459,  460,
-      462,  492,  463,  464,  465,  466,  467,  468,  469,  493,
-      471,  472,  496,  477,  478,  480,  481,  482,  483,  484,
-      485,  487,  497,  488,  491,  499,  501,  504,  507,  492,
-      508,  512,  513,  514,  515,  516,    0,  493,    0,    0,
-      496,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-      497,    0,    0,  499,  501,  504,  507,    0,  508,  512,
-
-      513,  514,  515,  516,  521,  521,  523,  523,  525,  525,
-      520,  520,  520,  520,  520,  520,  520,  520,  520,  520,
-      520,  520,  520,  520,  520,  520,  520,  520,  520,  520,
-      520,  520,  520,  520,  520,  520,  520,  520,  520,  520,
-      520,  520,  520,  520,  520,  520,  520,  520,  520,  520,
-      520,  520,  520,  520,  520,  520,  520,  520,  520,  520,
-      520,  520,  520,  520,  520,  520,  520,  520,  520,  520,
-      520,  520,  520,  520,  520,  520,  520,  520,  520,  520,
-      520,  520,  520,  520,  520
+       99,   44,   45,   45,   40,   43,  467,   47,   42,   41,
+       47,   47,   71,  103,   42,   71,   71,  100,   47,  444,
+      437,   41,   40,  428,   43,  102,   48,  427,   45,   48,
+       48,  426,  423,   43,   49,  370,   42,   49,   49,  366,
+      104,  103,   45,   50,  365,   48,   50,   50,   51,  361,
+       47,   51,   51,  106,  357,   71,   45,   46,   46,   46,
+       46,   46,   46,   46,   46,   46,   46,   49,  104,   48,
+      340,  339,   50,   48,   46,   46,   46,   49,   63,  107,
+
+       52,  106,   51,   52,   52,   53,   50,  108,   53,   53,
+      333,   51,   63,  318,  108,   49,  109,   65,   63,   65,
+       50,   65,   66,   46,   46,   76,   63,  107,   76,   76,
+       51,   66,   66,   52,  105,  108,  110,  105,   66,  112,
+       63,   53,  108,   52,  109,   65,   63,   65,   53,   65,
+       66,   70,   70,   70,   70,   70,   70,   70,  296,   66,
+       66,   52,  105,  288,  110,  105,   66,  112,   76,   53,
+       56,   56,   56,  113,   56,  279,   56,   56,  277,  272,
+      114,  115,   56,  135,   56,  136,   56,   56,   56,   56,
+       56,   74,   74,   74,   74,   74,   74,   74,   56,   56,
+
+       56,  113,   56,   75,   56,   56,   75,   75,  114,  115,
+       56,  135,   56,  136,   56,   56,   56,   56,   56,   72,
+      269,  268,   72,   72,  261,   72,   72,   72,   72,   72,
+       72,   72,   73,  260,  238,   73,   73,   75,   73,   73,
+       73,   73,   73,   73,   73,   77,   75,   78,   77,   77,
+       78,   78,   79,  224,  203,   79,   79,   80,  138,  139,
+       80,   80,   72,   81,  140,   75,   81,   81,  142,   82,
+       81,  199,   82,   82,  191,   73,  190,  156,  152,  148,
+       83,   77,   79,   83,   83,  143,  138,  139,   77,   82,
+       78,   80,  140,  101,   84,   79,  142,   84,   84,   85,
+
+       80,   88,   85,   85,   88,   88,   81,   83,   54,   77,
+       79,   29,   82,  143,   26,  144,   21,   82,   90,   80,
+       84,   90,   90,   83,   10,    9,   89,    3,   91,   89,
+       89,   91,   91,    2,    0,   83,   93,   84,    0,   93,
+       93,    0,   85,  144,   88,    0,   90,   91,   84,   86,
+       86,   86,   86,   86,   86,   86,   86,   86,   86,    0,
+       92,   90,   89,   92,   92,  145,   86,   86,   86,   89,
+        0,   91,  111,   93,   90,   91,  137,  141,   94,   93,
+       92,   94,   94,  146,  137,  147,  141,  111,  141,  149,
+       89,  150,  151,  145,  153,   86,   86,  154,   94,    0,
+
+      111,   93,    0,   92,  137,  141,  134,  155,   92,  134,
+      134,  146,  137,  147,  141,  111,  141,  149,  157,  150,
+      151,   94,  153,    0,  158,  154,   94,  116,  116,  116,
+      116,  116,  116,  116,  117,  155,    0,  117,  117,    0,
+      117,  117,  117,  117,  117,  117,  117,  118,  157,  134,
+      118,  118,  158,  118,  118,  118,  118,  118,  118,  118,
+      119,    0,    0,  119,  119,    0,  119,  119,  119,  119,
+      119,  119,  119,    0,  177,    0,  157,  117,  120,  120,
+      120,  120,  120,  120,  120,  121,    0,    0,  121,  121,
+      118,  122,  178,  123,  122,  122,  123,  123,    0,  179,
+
+        0,  124,  177,  119,  124,  124,    0,  125,    0,  121,
+      125,  125,  126,  122,  128,  126,  126,  128,  128,  180,
+      178,  124,    0,  125,  181,  182,  123,  179,  121,  127,
+        0,    0,  127,  127,  122,  126,  123,  121,  128,    0,
+      184,  122,  129,    0,  124,  129,  129,  180,    0,  124,
+      125,  125,  181,  182,  123,  126,  130,  128,  131,  130,
+      130,  131,  131,  126,    0,  127,  128,  132,  184,  129,
+      132,  132,  127,    0,  133,    0,  161,  133,  133,  161,
+      161,    0,    0,  164,  185,  129,  164,  164,  131,    0,
+      186,    0,  130,  127,  133,  187,  188,  129,    0,  130,
+
+        0,  131,  132,  159,  159,  159,  159,  159,  159,  159,
+      132,  163,  185,    0,  163,  163,  131,  133,  186,  161,
+      130,    0,  133,  187,  188,  160,  164,    0,  160,  160,
+      132,  160,  160,  160,  160,  160,  160,  160,  162,  162,
+      162,  162,  162,  162,  162,  163,  165,    0,  166,  165,
+      165,  166,  166,  167,  163,  168,  167,  167,  168,  168,
+        0,    0,  169,    0,  168,  169,  169,  168,  160,    0,
+        0,  170,    0,  163,  170,  170,    0,  171,    0,  172,
+      171,  171,  172,  172,  173,  189,    0,  173,  173,  165,
+      170,  166,    0,  192,    0,  172,  167,  174,  168,  175,
+
+      174,  174,  175,  175,  176,  169,  171,  176,  176,    0,
+      193,  194,    0,  189,  170,  195,  196,  173,  170,    0,
+      171,  192,  172,  172,  197,  174,  198,  173,  200,  201,
+      202,  204,  201,  219,  171,  220,  221,  176,  193,  194,
+      174,    0,  175,  195,  196,  173,  222,  176,    0,    0,
+      223,    0,  197,  174,  198,    0,  200,  201,  202,  204,
+      201,  219,    0,  220,  221,  176,  205,  205,  205,  205,
+      205,  205,  205,  206,  222,    0,  206,  206,  223,  206,
+      206,  206,  206,  206,  206,  206,  207,    0,    0,  207,
+      207,    0,  207,  207,  207,  207,  207,  207,  207,  209,
+
+        0,  210,  209,  209,  210,  210,    0,    0,  225,    0,
+      210,  211,    0,  210,  211,  211,  206,  212,    0,  211,
+      212,  212,  214,  227,    0,  214,  214,  212,  213,  207,
+      228,  213,  213,  229,  209,  215,  225,  216,  215,  215,
+      216,  216,  209,  217,  210,  230,  217,  217,  213,  218,
+        0,  227,  218,  218,  211,    0,  214,  231,  228,  232,
+      212,  229,  209,  233,    0,  214,  234,  235,  236,  237,
+      239,  213,  240,  230,  241,  242,  213,  243,  215,  244,
+      216,  245,  246,  218,  214,  231,  217,  232,  247,  248,
+        0,  233,  218,    0,  234,  235,  236,  237,  239,    0,
+
+      240,  262,  241,  242,    0,  243,    0,  244,    0,  245,
+      246,  218,    0,    0,    0,  250,  247,  248,  250,  250,
+        0,  250,  250,  250,  250,  250,  250,  250,  251,  262,
+      252,  251,  251,  252,  252,  263,  253,    0,  254,  253,
+      253,  254,  254,  255,  253,    0,  255,  255,  254,  256,
+      252,  257,  256,  256,  257,  257,  258,  264,  250,  258,
+      258,  259,  265,  263,  259,  259,    0,  266,  267,  270,
+      271,  251,  273,  252,  274,  275,    0,  276,  252,  253,
+      278,  254,  274,  280,  282,  264,  255,  283,  284,  285,
+      265,  286,  256,  287,  257,  266,  267,  270,  271,  258,
+
+      273,    0,  274,  275,  259,  276,  293,    0,  278,    0,
+      274,  280,  282,  294,  295,  283,  284,  285,  297,  286,
+      289,  287,  298,  289,  289,  299,  289,  289,  289,  289,
+      289,  289,  289,  290,  293,  291,  290,  290,  291,  291,
+      292,  294,  295,  292,  292,  300,  297,  301,    0,  302,
+      298,  303,  305,  299,  306,    0,  307,  308,  309,  310,
+      311,  312,  290,  289,  314,  315,  315,  317,  319,  320,
+      322,  323,    0,  300,    0,  301,  290,  302,  291,  303,
+      305,  326,  306,  292,  307,  308,  309,  310,  311,  312,
+      290,  327,  314,  315,  315,  317,  319,  320,  322,  323,
+
+      324,  328,  325,  324,  324,  325,  325,  329,  330,  326,
+      331,  332,  334,  335,  336,    0,  337,    0,  338,  327,
+      341,  342,  343,  344,  345,  346,  347,  348,  349,  328,
+        0,  351,  352,  353,  355,  329,  330,  325,  331,  332,
+      334,  335,  336,  324,  337,  325,  338,  356,  341,  342,
+      343,  344,  345,  346,  347,  348,  349,  358,  350,  351,
+      352,  353,  355,  359,  354,  325,  350,  354,  354,  360,
+      362,  363,  364,  367,  371,  356,  372,  373,  374,    0,
+      375,  376,  377,  378,  379,  358,  350,  380,  381,  383,
+      384,  359,  385,  386,  350,  387,  388,  360,  362,  363,
+
+      364,  367,  371,  389,  372,  373,  374,  354,  375,  376,
+      377,  378,  379,  390,  391,  380,  381,  383,  384,  392,
+      385,  386,  393,  387,  388,  395,  396,  397,  398,  399,
+      400,  389,  401,  402,  403,  405,  406,  407,  408,  410,
+      411,  390,  391,  412,  413,  414,  415,  392,  416,  417,
+      393,  418,  419,  395,  396,  397,  398,  399,  400,  420,
+      401,  402,  403,  405,  406,  407,  408,  410,  411,  421,
+      422,  412,  413,  414,  415,  424,  416,  417,  425,  418,
+      419,  430,  431,  433,  434,  435,  436,  420,  438,  439,
+      440,  441,  442,  443,  445,  447,  448,  421,  422,  450,
+
+      451,  452,  454,  424,  455,  456,  425,  457,  460,  430,
+      431,  433,  434,  435,  436,  461,  438,  439,  440,  441,
+      442,  443,  445,  447,  448,  462,  463,  450,  451,  452,
+      454,  464,  455,  456,  466,  457,  460,  469,  470,  472,
+      473,  475,  476,  461,  477,  478,  479,  480,  481,  482,
+      484,  485,  490,  462,  463,  491,  493,  494,  495,  464,
+      496,  497,  466,  498,  500,  469,  470,  472,  473,  475,
+      476,  501,  477,  478,  479,  480,  481,  482,  484,  485,
+      490,  504,  505,  491,  493,  494,  495,  506,  496,  497,
+      509,  498,  500,  510,  512,  514,  517,  520,  521,  501,
+
+      525,  526,  527,  528,  529,    0,    0,    0,    0,  504,
+      505,    0,    0,    0,    0,  506,    0,    0,  509,    0,
+        0,  510,  512,  514,  517,  520,  521,    0,  525,  526,
+      527,  528,  529,  534,  534,  536,  536,  538,  538,  533,
+      533,  533,  533,  533,  533,  533,  533,  533,  533,  533,
+      533,  533,  533,  533,  533,  533,  533,  533,  533,  533,
+      533,  533,  533,  533,  533,  533,  533,  533,  533,  533,
+      533,  533,  533,  533,  533,  533,  533,  533,  533,  533,
+      533,  533,  533,  533,  533,  533,  533,  533,  533,  533,
+      533,  533,  533,  533,  533,  533,  533,  533,  533,  533,
+
+      533,  533,  533,  533,  533,  533,  533,  533,  533,  533,
+      533,  533,  533,  533
     } ;
 
-static yyconst flex_int16_t yy_rule_linenum[65] =
+static yyconst flex_int16_t yy_rule_linenum[66] =
     {   0,
-       98,  100,  102,  104,  106,  109,  113,  115,  117,  118,
-      119,  120,  121,  122,  123,  124,  125,  126,  127,  128,
-      129,  130,  131,  132,  133,  134,  135,  136,  137,  138,
-      139,  140,  141,  142,  143,  144,  146,  147,  149,  151,
-      152,  153,  154,  155,  156,  158,  159,  162,  167,  168,
-      169,  171,  172,  173,  174,  175,  176,  177,  178,  179,
-      181,  190,  208,  215
+       99,  101,  103,  105,  107,  110,  114,  116,  118,  119,
+      120,  121,  122,  123,  124,  125,  126,  127,  128,  129,
+      130,  131,  132,  133,  134,  135,  136,  137,  138,  139,
+      140,  141,  142,  143,  144,  145,  147,  148,  150,  152,
+      154,  155,  156,  157,  158,  159,  161,  162,  165,  170,
+      171,  172,  174,  175,  176,  177,  178,  179,  180,  181,
+      182,  184,  193,  211,  218
     } ;
 
 /* The intent behind this definition is that it'll catch
@@ -1146,7 +1168,7 @@ static yyconst flex_int16_t yy_rule_linenum[65] =
  *
  */
 
-#line 59 "libmemcached/csl/scanner.l"
+#line 60 "libmemcached/csl/scanner.l"
 #include <cstdlib>
 #include <cstring>
 
@@ -1170,7 +1192,7 @@ static yyconst flex_int16_t yy_rule_linenum[65] =
 
 #define YY_INPUT(buffer, result, max_size) get_lex_chars(buffer, result, max_size, PARAM)
 
-#line 1174 "libmemcached/csl/scanner.cc"
+#line 1196 "libmemcached/csl/scanner.cc"
 
 #define INITIAL 0
 
@@ -1278,10 +1300,6 @@ int config_get_lineno (yyscan_t yyscanner );
 
 void config_set_lineno (int line_number ,yyscan_t yyscanner );
 
-int config_get_column  (yyscan_t yyscanner );
-
-void config_set_column (int column_no ,yyscan_t yyscanner );
-
 /* %if-bison-bridge */
 
 YYSTYPE * config_get_lval (yyscan_t yyscanner );
@@ -1336,7 +1354,12 @@ static int input (yyscan_t yyscanner );
 
 /* Amount of stuff to slurp up with each read. */
 #ifndef YY_READ_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k */
+#define YY_READ_BUF_SIZE 16384
+#else
 #define YY_READ_BUF_SIZE 8192
+#endif /* __ia64__ */
 #endif
 
 /* Copy whatever the last rule matched to the standard output. */
@@ -1360,7 +1383,7 @@ static int input (yyscan_t yyscanner );
        if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
                { \
                int c = '*'; \
-               unsigned n; \
+               size_t n; \
                for ( n = 0; n < max_size && \
                             (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
                        buf[n] = (char) c; \
@@ -1473,11 +1496,11 @@ YY_DECL
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 
 /* %% [7.0] user's declarations go here */
-#line 95 "libmemcached/csl/scanner.l"
+#line 96 "libmemcached/csl/scanner.l"
 
 
 
-#line 1481 "libmemcached/csl/scanner.cc"
+#line 1504 "libmemcached/csl/scanner.cc"
 
     yylval = yylval_param;
 
@@ -1543,13 +1566,13 @@ yy_match:
                        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
                                {
                                yy_current_state = (int) yy_def[yy_current_state];
-                               if ( yy_current_state >= 521 )
+                               if ( yy_current_state >= 534 )
                                        yy_c = yy_meta[(unsigned int) yy_c];
                                }
                        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
                        ++yy_cp;
                        }
-               while ( yy_base[yy_current_state] != 1711 );
+               while ( yy_base[yy_current_state] != 1740 );
 
 yy_find_action:
 /* %% [10.0] code to find the action number goes here */
@@ -1572,13 +1595,13 @@ do_action:      /* This label is used only to access EOF actions. */
                        {
                        if ( yy_act == 0 )
                                fprintf( stderr, "--scanner backing up\n" );
-                       else if ( yy_act < 65 )
+                       else if ( yy_act < 66 )
                                fprintf( stderr, "--accepting rule at line %ld (\"%s\")\n",
                                         (long)yy_rule_linenum[yy_act], yytext );
-                       else if ( yy_act == 65 )
+                       else if ( yy_act == 66 )
                                fprintf( stderr, "--accepting default rule (\"%s\")\n",
                                         yytext );
-                       else if ( yy_act == 66 )
+                       else if ( yy_act == 67 )
                                fprintf( stderr, "--(end of buffer or a NUL)\n" );
                        else
                                fprintf( stderr, "--EOF (start condition %d)\n", YY_START );
@@ -1596,28 +1619,28 @@ do_action:      /* This label is used only to access EOF actions. */
 
 case 1:
 YY_RULE_SETUP
-#line 98 "libmemcached/csl/scanner.l"
+#line 99 "libmemcached/csl/scanner.l"
 { return yytext[0];}
        YY_BREAK
 case 2:
 YY_RULE_SETUP
-#line 100 "libmemcached/csl/scanner.l"
+#line 101 "libmemcached/csl/scanner.l"
 { yylval->number= atoi(yytext); return (NUMBER); }
        YY_BREAK
 case 3:
 YY_RULE_SETUP
-#line 102 "libmemcached/csl/scanner.l"
+#line 103 "libmemcached/csl/scanner.l"
 { yylval->number= atoi(yytext +1); return PORT; }
        YY_BREAK
 case 4:
 YY_RULE_SETUP
-#line 104 "libmemcached/csl/scanner.l"
+#line 105 "libmemcached/csl/scanner.l"
 { yylval->number= atoi(yytext +2); return WEIGHT_START; }
        YY_BREAK
 case 5:
 /* rule 5 can match eol */
 YY_RULE_SETUP
-#line 106 "libmemcached/csl/scanner.l"
+#line 107 "libmemcached/csl/scanner.l"
 ; /* skip whitespace */
        YY_BREAK
 case 6:
@@ -1625,287 +1648,292 @@ case 6:
 yyg->yy_c_buf_p = yy_cp -= 1;
 YY_DO_BEFORE_ACTION; /* set up yytext again */
 YY_RULE_SETUP
-#line 109 "libmemcached/csl/scanner.l"
+#line 110 "libmemcached/csl/scanner.l"
 {
       return COMMENT;
     }
        YY_BREAK
 case 7:
 YY_RULE_SETUP
-#line 113 "libmemcached/csl/scanner.l"
+#line 114 "libmemcached/csl/scanner.l"
 { yyextra->begin= yytext; yyextra->set_server(); return yyextra->previous_token= SERVER; }
        YY_BREAK
 case 8:
 YY_RULE_SETUP
-#line 115 "libmemcached/csl/scanner.l"
+#line 116 "libmemcached/csl/scanner.l"
 { yyextra->begin= yytext; return yyextra->previous_token= SOCKET; }
        YY_BREAK
 case 9:
 YY_RULE_SETUP
-#line 117 "libmemcached/csl/scanner.l"
+#line 118 "libmemcached/csl/scanner.l"
 { yyextra->begin= yytext; return yyextra->previous_token= BINARY_PROTOCOL; }
        YY_BREAK
 case 10:
 YY_RULE_SETUP
-#line 118 "libmemcached/csl/scanner.l"
+#line 119 "libmemcached/csl/scanner.l"
 { yyextra->begin= yytext; return yyextra->previous_token= BUFFER_REQUESTS; }
        YY_BREAK
 case 11:
 YY_RULE_SETUP
-#line 119 "libmemcached/csl/scanner.l"
+#line 120 "libmemcached/csl/scanner.l"
 { yyextra->begin= yytext; return yyextra->previous_token= CONFIGURE_FILE; }
        YY_BREAK
 case 12:
 YY_RULE_SETUP
-#line 120 "libmemcached/csl/scanner.l"
+#line 121 "libmemcached/csl/scanner.l"
 { yyextra->begin= yytext; return yyextra->previous_token= CONNECT_TIMEOUT; }
        YY_BREAK
 case 13:
 YY_RULE_SETUP
-#line 121 "libmemcached/csl/scanner.l"
+#line 122 "libmemcached/csl/scanner.l"
 { yyextra->begin= yytext; return yyextra->previous_token= DISTRIBUTION; }
        YY_BREAK
 case 14:
 YY_RULE_SETUP
-#line 122 "libmemcached/csl/scanner.l"
+#line 123 "libmemcached/csl/scanner.l"
 { yyextra->begin= yytext; return yyextra->previous_token= HASH_WITH_NAMESPACE; }
        YY_BREAK
 case 15:
 YY_RULE_SETUP
-#line 123 "libmemcached/csl/scanner.l"
+#line 124 "libmemcached/csl/scanner.l"
 { yyextra->begin= yytext; return yyextra->previous_token= HASH; }
        YY_BREAK
 case 16:
 YY_RULE_SETUP
-#line 124 "libmemcached/csl/scanner.l"
+#line 125 "libmemcached/csl/scanner.l"
 { yyextra->begin= yytext; return yyextra->previous_token= IO_BYTES_WATERMARK; }
        YY_BREAK
 case 17:
 YY_RULE_SETUP
-#line 125 "libmemcached/csl/scanner.l"
+#line 126 "libmemcached/csl/scanner.l"
 { yyextra->begin= yytext; return yyextra->previous_token= IO_KEY_PREFETCH; }
        YY_BREAK
 case 18:
 YY_RULE_SETUP
-#line 126 "libmemcached/csl/scanner.l"
+#line 127 "libmemcached/csl/scanner.l"
 { yyextra->begin= yytext; return yyextra->previous_token= IO_MSG_WATERMARK; }
        YY_BREAK
 case 19:
 YY_RULE_SETUP
-#line 127 "libmemcached/csl/scanner.l"
+#line 128 "libmemcached/csl/scanner.l"
 { yyextra->begin= yytext; return yyextra->previous_token= NOREPLY; }
        YY_BREAK
 case 20:
 YY_RULE_SETUP
-#line 128 "libmemcached/csl/scanner.l"
+#line 129 "libmemcached/csl/scanner.l"
 { yyextra->begin= yytext; return yyextra->previous_token= NUMBER_OF_REPLICAS; }
        YY_BREAK
 case 21:
 YY_RULE_SETUP
-#line 129 "libmemcached/csl/scanner.l"
+#line 130 "libmemcached/csl/scanner.l"
 { yyextra->begin= yytext; return yyextra->previous_token= POLL_TIMEOUT; }
        YY_BREAK
 case 22:
 YY_RULE_SETUP
-#line 130 "libmemcached/csl/scanner.l"
+#line 131 "libmemcached/csl/scanner.l"
 { yyextra->begin= yytext; return yyextra->previous_token= RANDOMIZE_REPLICA_READ; }
        YY_BREAK
 case 23:
 YY_RULE_SETUP
-#line 131 "libmemcached/csl/scanner.l"
+#line 132 "libmemcached/csl/scanner.l"
 { yyextra->begin= yytext; return yyextra->previous_token= RCV_TIMEOUT; }
        YY_BREAK
 case 24:
 YY_RULE_SETUP
-#line 132 "libmemcached/csl/scanner.l"
+#line 133 "libmemcached/csl/scanner.l"
 { yyextra->begin= yytext; return yyextra->previous_token= REMOVE_FAILED_SERVERS; }
        YY_BREAK
 case 25:
 YY_RULE_SETUP
-#line 133 "libmemcached/csl/scanner.l"
+#line 134 "libmemcached/csl/scanner.l"
 { yyextra->begin= yytext; return yyextra->previous_token= RETRY_TIMEOUT; }
        YY_BREAK
 case 26:
 YY_RULE_SETUP
-#line 134 "libmemcached/csl/scanner.l"
+#line 135 "libmemcached/csl/scanner.l"
 { yyextra->begin= yytext; return yyextra->previous_token= SND_TIMEOUT; }
        YY_BREAK
 case 27:
 YY_RULE_SETUP
-#line 135 "libmemcached/csl/scanner.l"
+#line 136 "libmemcached/csl/scanner.l"
 { yyextra->begin= yytext; return yyextra->previous_token= SOCKET_RECV_SIZE; }
        YY_BREAK
 case 28:
 YY_RULE_SETUP
-#line 136 "libmemcached/csl/scanner.l"
+#line 137 "libmemcached/csl/scanner.l"
 { yyextra->begin= yytext; return yyextra->previous_token= SOCKET_SEND_SIZE; }
        YY_BREAK
 case 29:
 YY_RULE_SETUP
-#line 137 "libmemcached/csl/scanner.l"
+#line 138 "libmemcached/csl/scanner.l"
 { yyextra->begin= yytext; return yyextra->previous_token= SORT_HOSTS; }
        YY_BREAK
 case 30:
 YY_RULE_SETUP
-#line 138 "libmemcached/csl/scanner.l"
+#line 139 "libmemcached/csl/scanner.l"
 { yyextra->begin= yytext; return yyextra->previous_token= SUPPORT_CAS; }
        YY_BREAK
 case 31:
 YY_RULE_SETUP
-#line 139 "libmemcached/csl/scanner.l"
+#line 140 "libmemcached/csl/scanner.l"
 { yyextra->begin= yytext; return yyextra->previous_token= _TCP_KEEPALIVE; }
        YY_BREAK
 case 32:
 YY_RULE_SETUP
-#line 140 "libmemcached/csl/scanner.l"
+#line 141 "libmemcached/csl/scanner.l"
 { yyextra->begin= yytext; return yyextra->previous_token= _TCP_KEEPIDLE; }
        YY_BREAK
 case 33:
 YY_RULE_SETUP
-#line 141 "libmemcached/csl/scanner.l"
+#line 142 "libmemcached/csl/scanner.l"
 { yyextra->begin= yytext; return yyextra->previous_token= _TCP_NODELAY; }
        YY_BREAK
 case 34:
 YY_RULE_SETUP
-#line 142 "libmemcached/csl/scanner.l"
+#line 143 "libmemcached/csl/scanner.l"
 { yyextra->begin= yytext; return yyextra->previous_token= USE_UDP; }
        YY_BREAK
 case 35:
 YY_RULE_SETUP
-#line 143 "libmemcached/csl/scanner.l"
+#line 144 "libmemcached/csl/scanner.l"
 { yyextra->begin= yytext; return yyextra->previous_token= USER_DATA; }
        YY_BREAK
 case 36:
 YY_RULE_SETUP
-#line 144 "libmemcached/csl/scanner.l"
+#line 145 "libmemcached/csl/scanner.l"
 { yyextra->begin= yytext; return yyextra->previous_token= VERIFY_KEY; }
        YY_BREAK
 case 37:
 YY_RULE_SETUP
-#line 146 "libmemcached/csl/scanner.l"
+#line 147 "libmemcached/csl/scanner.l"
 { yyextra->begin= yytext; return yyextra->previous_token= POOL_MIN; }
        YY_BREAK
 case 38:
 YY_RULE_SETUP
-#line 147 "libmemcached/csl/scanner.l"
+#line 148 "libmemcached/csl/scanner.l"
 { yyextra->begin= yytext; return yyextra->previous_token= POOL_MAX; }
        YY_BREAK
 case 39:
 YY_RULE_SETUP
-#line 149 "libmemcached/csl/scanner.l"
+#line 150 "libmemcached/csl/scanner.l"
 { yyextra->begin= yytext; return yyextra->previous_token= NAMESPACE; }
        YY_BREAK
 case 40:
 YY_RULE_SETUP
-#line 151 "libmemcached/csl/scanner.l"
-{ yyextra->begin= yytext; return yyextra->previous_token= INCLUDE; }
+#line 152 "libmemcached/csl/scanner.l"
+{ yyextra->begin= yytext; return yyextra->previous_token= FETCH_VERSION; }
        YY_BREAK
 case 41:
 YY_RULE_SETUP
-#line 152 "libmemcached/csl/scanner.l"
-{ yyextra->begin= yytext; return yyextra->previous_token= RESET; }
+#line 154 "libmemcached/csl/scanner.l"
+{ yyextra->begin= yytext; return yyextra->previous_token= INCLUDE; }
        YY_BREAK
 case 42:
 YY_RULE_SETUP
-#line 153 "libmemcached/csl/scanner.l"
-{ yyextra->begin= yytext; return yyextra->previous_token= PARSER_DEBUG; }
+#line 155 "libmemcached/csl/scanner.l"
+{ yyextra->begin= yytext; return yyextra->previous_token= RESET; }
        YY_BREAK
 case 43:
 YY_RULE_SETUP
-#line 154 "libmemcached/csl/scanner.l"
-{ yyextra->begin= yytext; return yyextra->previous_token= SERVERS; }
+#line 156 "libmemcached/csl/scanner.l"
+{ yyextra->begin= yytext; return yyextra->previous_token= PARSER_DEBUG; }
        YY_BREAK
 case 44:
 YY_RULE_SETUP
-#line 155 "libmemcached/csl/scanner.l"
-{ yyextra->begin= yytext; return yyextra->previous_token= END; }
+#line 157 "libmemcached/csl/scanner.l"
+{ yyextra->begin= yytext; return yyextra->previous_token= SERVERS; }
        YY_BREAK
 case 45:
 YY_RULE_SETUP
-#line 156 "libmemcached/csl/scanner.l"
-{ yyextra->begin= yytext; return yyextra->previous_token= ERROR; }
+#line 158 "libmemcached/csl/scanner.l"
+{ yyextra->begin= yytext; return yyextra->previous_token= END; }
        YY_BREAK
 case 46:
 YY_RULE_SETUP
-#line 158 "libmemcached/csl/scanner.l"
-{ return yyextra->previous_token= TRUE; }
+#line 159 "libmemcached/csl/scanner.l"
+{ yyextra->begin= yytext; return yyextra->previous_token= ERROR; }
        YY_BREAK
 case 47:
 YY_RULE_SETUP
-#line 159 "libmemcached/csl/scanner.l"
-{ return yyextra->previous_token= FALSE; }
+#line 161 "libmemcached/csl/scanner.l"
+{ return yyextra->previous_token= TRUE; }
        YY_BREAK
 case 48:
 YY_RULE_SETUP
 #line 162 "libmemcached/csl/scanner.l"
+{ return yyextra->previous_token= FALSE; }
+       YY_BREAK
+case 49:
+YY_RULE_SETUP
+#line 165 "libmemcached/csl/scanner.l"
 {
       yyextra->begin= yytext;
       return UNKNOWN_OPTION;
     }
        YY_BREAK
-case 49:
+case 50:
 YY_RULE_SETUP
-#line 167 "libmemcached/csl/scanner.l"
+#line 170 "libmemcached/csl/scanner.l"
 { return CONSISTENT; }
        YY_BREAK
-case 50:
+case 51:
 YY_RULE_SETUP
-#line 168 "libmemcached/csl/scanner.l"
+#line 171 "libmemcached/csl/scanner.l"
 { return MODULA; }
        YY_BREAK
-case 51:
+case 52:
 YY_RULE_SETUP
-#line 169 "libmemcached/csl/scanner.l"
+#line 172 "libmemcached/csl/scanner.l"
 { return RANDOM; }
        YY_BREAK
-case 52:
+case 53:
 YY_RULE_SETUP
-#line 171 "libmemcached/csl/scanner.l"
+#line 174 "libmemcached/csl/scanner.l"
 { return MD5; }
        YY_BREAK
-case 53:
+case 54:
 YY_RULE_SETUP
-#line 172 "libmemcached/csl/scanner.l"
+#line 175 "libmemcached/csl/scanner.l"
 { return CRC; }
        YY_BREAK
-case 54:
+case 55:
 YY_RULE_SETUP
-#line 173 "libmemcached/csl/scanner.l"
+#line 176 "libmemcached/csl/scanner.l"
 { return FNV1_64; }
        YY_BREAK
-case 55:
+case 56:
 YY_RULE_SETUP
-#line 174 "libmemcached/csl/scanner.l"
+#line 177 "libmemcached/csl/scanner.l"
 { return FNV1A_64; }
        YY_BREAK
-case 56:
+case 57:
 YY_RULE_SETUP
-#line 175 "libmemcached/csl/scanner.l"
+#line 178 "libmemcached/csl/scanner.l"
 { return FNV1_32; }
        YY_BREAK
-case 57:
+case 58:
 YY_RULE_SETUP
-#line 176 "libmemcached/csl/scanner.l"
+#line 179 "libmemcached/csl/scanner.l"
 { return FNV1A_32; }
        YY_BREAK
-case 58:
+case 59:
 YY_RULE_SETUP
-#line 177 "libmemcached/csl/scanner.l"
+#line 180 "libmemcached/csl/scanner.l"
 { return HSIEH; }
        YY_BREAK
-case 59:
+case 60:
 YY_RULE_SETUP
-#line 178 "libmemcached/csl/scanner.l"
+#line 181 "libmemcached/csl/scanner.l"
 { return MURMUR; }
        YY_BREAK
-case 60:
+case 61:
 YY_RULE_SETUP
-#line 179 "libmemcached/csl/scanner.l"
+#line 182 "libmemcached/csl/scanner.l"
 { return JENKINS; }
        YY_BREAK
-case 61:
+case 62:
 YY_RULE_SETUP
-#line 181 "libmemcached/csl/scanner.l"
+#line 184 "libmemcached/csl/scanner.l"
 {
       yylval->server.port= MEMCACHED_DEFAULT_PORT;
       yylval->server.weight= 1;
@@ -1915,9 +1943,9 @@ YY_RULE_SETUP
       return IPADDRESS;
     }
        YY_BREAK
-case 62:
+case 63:
 YY_RULE_SETUP
-#line 190 "libmemcached/csl/scanner.l"
+#line 193 "libmemcached/csl/scanner.l"
 {
       if (yyextra->is_server())
       {
@@ -1936,10 +1964,10 @@ YY_RULE_SETUP
       return STRING;
     }
        YY_BREAK
-case 63:
-/* rule 63 can match eol */
+case 64:
+/* rule 64 can match eol */
 YY_RULE_SETUP
-#line 208 "libmemcached/csl/scanner.l"
+#line 211 "libmemcached/csl/scanner.l"
 {
       config_get_text(yyscanner)[yyleng -1]= 0;
       yylval->string.c_str= yytext +1;
@@ -1947,20 +1975,20 @@ YY_RULE_SETUP
       return QUOTED_STRING;
     }
        YY_BREAK
-case 64:
+case 65:
 YY_RULE_SETUP
-#line 215 "libmemcached/csl/scanner.l"
+#line 218 "libmemcached/csl/scanner.l"
 {
       yyextra->begin= yytext;
       return UNKNOWN;
     }
        YY_BREAK
-case 65:
+case 66:
 YY_RULE_SETUP
-#line 220 "libmemcached/csl/scanner.l"
+#line 223 "libmemcached/csl/scanner.l"
 ECHO;
        YY_BREAK
-#line 1964 "libmemcached/csl/scanner.cc"
+#line 1992 "libmemcached/csl/scanner.cc"
 case YY_STATE_EOF(INITIAL):
        yyterminate();
 
@@ -2276,7 +2304,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
                while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
                        {
                        yy_current_state = (int) yy_def[yy_current_state];
-                       if ( yy_current_state >= 521 )
+                       if ( yy_current_state >= 534 )
                                yy_c = yy_meta[(unsigned int) yy_c];
                        }
                yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
@@ -2310,11 +2338,11 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
                {
                yy_current_state = (int) yy_def[yy_current_state];
-               if ( yy_current_state >= 521 )
+               if ( yy_current_state >= 534 )
                        yy_c = yy_meta[(unsigned int) yy_c];
                }
        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-       yy_is_jam = (yy_current_state == 520);
+       yy_is_jam = (yy_current_state == 533);
 
        return yy_is_jam ? 0 : yy_current_state;
 }
@@ -2797,8 +2825,8 @@ YY_BUFFER_STATE config__scan_string (yyconst char * yystr , yyscan_t yyscanner)
 /* %if-c-only */
 /** Setup the input buffer state to scan the given bytes. The next call to config_lex() will
  * scan from a @e copy of @a bytes.
- * @param bytes the byte buffer to scan
- * @param len the number of bytes in the buffer pointed to by @a bytes.
+ * @param yybytes the byte buffer to scan
+ * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
  * @param yyscanner The scanner object.
  * @return the newly allocated buffer state object.
  */
@@ -3226,7 +3254,7 @@ void config_free (void * ptr , yyscan_t yyscanner)
 
 /* %ok-for-header */
 
-#line 220 "libmemcached/csl/scanner.l"
+#line 223 "libmemcached/csl/scanner.l"
 
 
 

diff --git a/libmemcached/csl/scanner.h b/libmemcached/csl/scanner.h
index 74fa65dae27331b517d695961cc9c39d83564ae9..6aa08a64206c65554bc2601c879d3b74d735453c 100644 (file)
--- a/libmemcached/csl/scanner.h
+++ b/libmemcached/csl/scanner.h
@@ -14,6 +14,7 @@
 #pragma GCC diagnostic ignored "-Wold-style-cast"
 #pragma GCC diagnostic ignored "-Wsign-compare"
 #pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
 #endif
 
 #define YY_NO_INPUT
@@ -23,7 +24,7 @@
 
 
 
-#line 27 "libmemcached/csl/scanner.h"
+#line 28 "libmemcached/csl/scanner.h"
 
 #define  YY_INT_ALIGNED short int
 
@@ -95,7 +96,6 @@ typedef int flex_int32_t;
 typedef unsigned char flex_uint8_t; 
 typedef unsigned short int flex_uint16_t;
 typedef unsigned int flex_uint32_t;
-#endif /* ! C99 */
 
 /* Limits of integral types. */
 #ifndef INT8_MIN
@@ -126,6 +126,8 @@ typedef unsigned int flex_uint32_t;
 #define UINT32_MAX             (4294967295U)
 #endif
 
+#endif /* ! C99 */
+
 #endif /* ! FLEXINT_H */
 
 /* %endif */
@@ -184,7 +186,15 @@ typedef void* yyscan_t;
 
 /* Size of default input buffer. */
 #ifndef YY_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k.
+ * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
+ * Ditto for the __ia64__ case accordingly.
+ */
+#define YY_BUF_SIZE 32768
+#else
 #define YY_BUF_SIZE 16384
+#endif /* __ia64__ */
 #endif
 
 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
@@ -372,10 +382,6 @@ int config_get_lineno (yyscan_t yyscanner );
 
 void config_set_lineno (int line_number ,yyscan_t yyscanner );
 
-int config_get_column  (yyscan_t yyscanner );
-
-void config_set_column (int column_no ,yyscan_t yyscanner );
-
 /* %if-bison-bridge */
 
 YYSTYPE * config_get_lval (yyscan_t yyscanner );
@@ -421,7 +427,12 @@ static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
 
 /* Amount of stuff to slurp up with each read. */
 #ifndef YY_READ_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k */
+#define YY_READ_BUF_SIZE 16384
+#else
 #define YY_READ_BUF_SIZE 8192
+#endif /* __ia64__ */
 #endif
 
 /* Number of entries by which start-condition stack grows. */
@@ -475,9 +486,9 @@ extern int config_lex \
 #undef YY_DECL
 #endif
 
-#line 220 "libmemcached/csl/scanner.l"
+#line 223 "libmemcached/csl/scanner.l"
 
 
-#line 482 "libmemcached/csl/scanner.h"
+#line 493 "libmemcached/csl/scanner.h"
 #undef config_IN_HEADER
 #endif /* config_HEADER_H */

diff --git a/libmemcached/csl/scanner.l b/libmemcached/csl/scanner.l
index a139c75e4db1030cd4b72c2e93a6ceb8f5fecfdf..8e404b5f9531aa3bd659be5ff3c3de853059bd72 100644 (file)
--- a/libmemcached/csl/scanner.l
+++ b/libmemcached/csl/scanner.l
@@ -46,6 +46,7 @@
 #pragma GCC diagnostic ignored "-Wold-style-cast"
 #pragma GCC diagnostic ignored "-Wsign-compare"
 #pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wmissing-declarations"
 #endif
 
 #define YY_NO_INPUT
@@ -148,6 +149,8 @@
 
 "--NAMESPACE="                         { yyextra->begin= yytext; return yyextra->previous_token= NAMESPACE; }
 
+"--FETCH-VERSION"                              { yyextra->begin= yytext; return yyextra->previous_token= FETCH_VERSION; }
+
 INCLUDE           { yyextra->begin= yytext; return yyextra->previous_token= INCLUDE; }
 RESET           { yyextra->begin= yytext; return yyextra->previous_token= RESET; }
 DEBUG           { yyextra->begin= yytext; return yyextra->previous_token= PARSER_DEBUG; }

diff --git a/libmemcached/delete.cc b/libmemcached/delete.cc
index a96ecbace8627b5f66e978ae63ab783febad826b..a7526dfcf5dfe9573db1df3a00c73a30417eaf8f 100644 (file)
--- a/libmemcached/delete.cc
+++ b/libmemcached/delete.cc
@@ -44,7 +44,7 @@ memcached_return_t memcached_delete(memcached_st *memc, const char *key, size_t
   return memcached_delete_by_key(memc, key, key_length, key, key_length, expiration);
 }
 
-static inline memcached_return_t ascii_delete(memcached_server_write_instance_st instance,
+static inline memcached_return_t ascii_delete(org::libmemcached::Instance* instance,
                                               uint32_t ,
                                               const char *key,
                                               const size_t key_length,
@@ -65,7 +65,7 @@ static inline memcached_return_t ascii_delete(memcached_server_write_instance_st
   return memcached_vdo(instance, vector, 6, is_buffering ? false : true);
 }
 
-static inline memcached_return_t binary_delete(memcached_server_write_instance_st instance,
+static inline memcached_return_t binary_delete(org::libmemcached::Instance* instance,
                                                uint32_t server_key,
                                                const char *key,
                                                const size_t key_length,
@@ -117,7 +117,7 @@ static inline memcached_return_t binary_delete(memcached_server_write_instance_s
         server_key= 0;
       }
 
-      memcached_server_write_instance_st replica= memcached_server_instance_fetch(instance->root, server_key);
+      org::libmemcached::Instance* replica= memcached_instance_fetch(instance->root, server_key);
 
       if (memcached_fatal(memcached_vdo(replica, vector, 4, should_flush)))
       {
@@ -158,7 +158,7 @@ memcached_return_t memcached_delete_by_key(memcached_st *memc,
   }
 
   uint32_t server_key= memcached_generate_hash_with_redistribution(memc, group_key, group_key_length);
-  memcached_server_write_instance_st instance= memcached_server_instance_fetch(memc, server_key);
+  org::libmemcached::Instance* instance= memcached_instance_fetch(memc, server_key);
   
   bool is_buffering= memcached_is_buffering(instance->root);
   bool is_replying= memcached_is_replying(instance->root);

diff --git a/libmemcached/do.cc b/libmemcached/do.cc
index 61a143b888d798ace2a3361a63db912ab183b9a7..0d05ea6d4523675a6d89e0987e2ccd44b6b6c837 100644 (file)
--- a/libmemcached/do.cc
+++ b/libmemcached/do.cc
@@ -11,7 +11,7 @@
 
 #include <libmemcached/common.h>
 
-memcached_return_t memcached_vdo(memcached_server_write_instance_st instance,
+memcached_return_t memcached_vdo(org::libmemcached::Instance* instance,
                                  libmemcached_io_vector_st vector[],
                                  const size_t count,
                                  const bool with_flush)
@@ -23,7 +23,7 @@ memcached_return_t memcached_vdo(memcached_server_write_instance_st instance,
   if (memcached_failed(rc= memcached_connect(instance)))
   {
     WATCHPOINT_ERROR(rc);
-    assert_msg(instance->error_messages, "memcached_connect() returned an error but the memcached_server_write_instance_st showed none.");
+    assert_msg(instance->error_messages, "memcached_connect() returned an error but the Instance showed none.");
     return rc;
   }
 

diff --git a/libmemcached/do.hpp b/libmemcached/do.hpp
index 560c131829f3daef0906d9fc598d4c57395a3a36..109c0ac1e06317720f06591ba8021a4092759d11 100644 (file)
--- a/libmemcached/do.hpp
+++ b/libmemcached/do.hpp
@@ -37,7 +37,7 @@
 
 #pragma once
 
-memcached_return_t memcached_vdo(memcached_server_write_instance_st ptr,
+memcached_return_t memcached_vdo(org::libmemcached::Instance* ptr,
                                  libmemcached_io_vector_st vector[],
                                  const size_t count,
                                  const bool with_flush);

diff --git a/libmemcached/dump.cc b/libmemcached/dump.cc
index 05b4e5d6c8cf4b81fd50d6dcf5725dc5aa7c511f..618a63cd319b7e4d09cbe48a1e1cc224f2f23e3b 100644 (file)
--- a/libmemcached/dump.cc
+++ b/libmemcached/dump.cc
@@ -68,7 +68,7 @@ static memcached_return_t ascii_dump(memcached_st *memc, memcached_dump_fn *call
     // Send message to all servers
     for (uint32_t server_key= 0; server_key < memcached_server_count(memc); server_key++)
     {
-      memcached_server_write_instance_st instance= memcached_server_instance_fetch(memc, server_key);
+      org::libmemcached::Instance* instance= memcached_instance_fetch(memc, server_key);
 
       memcached_return_t vdo_rc;
       if (memcached_success((vdo_rc= memcached_vdo(instance, vector, 3, true))))
@@ -82,7 +82,7 @@ static memcached_return_t ascii_dump(memcached_st *memc, memcached_dump_fn *call
     }
 
     // Collect the returned items
-    memcached_server_write_instance_st instance;
+    org::libmemcached::Instance* instance;
     while ((instance= memcached_io_get_readable_server(memc)))
     {
       memcached_return_t response_rc= memcached_response(instance, buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, NULL);

diff --git a/libmemcached/error.cc b/libmemcached/error.cc
index 62616b3099dab8ac63dc3331c873dffcebd1d7d7..38c568c91cdf48dd4b51088169646e6bfa44b2ed 100644 (file)
--- a/libmemcached/error.cc
+++ b/libmemcached/error.cc
@@ -50,7 +50,7 @@ struct memcached_error_t
   char message[MAX_ERROR_LENGTH];
 };
 
-static void _set(memcached_instance_st& server, memcached_st& memc)
+static void _set(org::libmemcached::Instance& server, memcached_st& memc)
 {
   if (server.error_messages and server.error_messages->query_id != server.root->query_id)
   {
@@ -204,10 +204,10 @@ memcached_return_t memcached_set_error(memcached_st& memc, memcached_return_t rc
   return memcached_set_error(memc, rc, at, tmp);
 }
 
-memcached_return_t memcached_set_error(memcached_instance_st& self, memcached_return_t rc, const char *at, const char *str, size_t length)
+memcached_return_t memcached_set_error(org::libmemcached::Instance& self, memcached_return_t rc, const char *at, const char *str, size_t length)
 {
   assert_msg(rc != MEMCACHED_ERRNO, "Programmer error, MEMCACHED_ERRNO was set to be returned to client");
-  assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a memcached_instance_st");
+  assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a Instance");
 
   memcached_string_t tmp= { str, length };
   return memcached_set_error(self, rc, at, tmp);
@@ -240,7 +240,7 @@ memcached_return_t memcached_set_parser_error(memcached_st& memc,
   return memcached_set_error(memc, MEMCACHED_PARSE_ERROR, at, buffer, length);
 }
 
-static inline size_t append_host_to_string(memcached_instance_st& self, char* buffer, const size_t buffer_length)
+static inline size_t append_host_to_string(org::libmemcached::Instance& self, char* buffer, const size_t buffer_length)
 {
   size_t size= 0;
   switch (self.type)
@@ -248,7 +248,7 @@ static inline size_t append_host_to_string(memcached_instance_st& self, char* bu
   case MEMCACHED_CONNECTION_TCP:
   case MEMCACHED_CONNECTION_UDP:
     size+= snprintf(buffer, buffer_length, " host: %s:%d",
-                    self.hostname, int(self.port));
+                    self.hostname, int(self.port()));
     break;
 
   case MEMCACHED_CONNECTION_UNIX_SOCKET:
@@ -260,10 +260,10 @@ static inline size_t append_host_to_string(memcached_instance_st& self, char* bu
   return size;
 }
 
-memcached_return_t memcached_set_error(memcached_instance_st& self, memcached_return_t rc, const char *at, memcached_string_t& str)
+memcached_return_t memcached_set_error(org::libmemcached::Instance& self, memcached_return_t rc, const char *at, memcached_string_t& str)
 {
   assert_msg(rc != MEMCACHED_ERRNO, "Programmer error, MEMCACHED_ERRNO was set to be returned to client");
-  assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a memcached_instance_st");
+  assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a org::libmemcached::Instance");
   if (memcached_fatal(rc) == false)
   {
     return rc;
@@ -297,9 +297,9 @@ memcached_return_t memcached_set_error(memcached_instance_st& self, memcached_re
   return rc;
 }
 
-memcached_return_t memcached_set_error(memcached_instance_st& self, memcached_return_t rc, const char *at)
+memcached_return_t memcached_set_error(org::libmemcached::Instance& self, memcached_return_t rc, const char *at)
 {
-  assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a memcached_instance_st");
+  assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a org::libmemcached::Instance");
   if (memcached_fatal(rc) == false)
   {
     return rc;
@@ -340,7 +340,7 @@ memcached_return_t memcached_set_errno(memcached_st& self, int local_errno, cons
   return memcached_set_errno(self, local_errno, at, tmp);
 }
 
-memcached_return_t memcached_set_errno(memcached_instance_st& self, int local_errno, const char *at, const char *str, size_t length)
+memcached_return_t memcached_set_errno(org::libmemcached::Instance& self, int local_errno, const char *at, const char *str, size_t length)
 {
   memcached_string_t tmp= { str, length };
   return memcached_set_errno(self, local_errno, at, tmp);
@@ -372,7 +372,7 @@ memcached_return_t memcached_set_errno(memcached_st& memc, int local_errno, cons
   return rc;
 }
 
-memcached_return_t memcached_set_errno(memcached_instance_st& self, int local_errno, const char *at, memcached_string_t& str)
+memcached_return_t memcached_set_errno(org::libmemcached::Instance& self, int local_errno, const char *at, memcached_string_t& str)
 {
   if (local_errno == 0)
   {
@@ -402,7 +402,7 @@ memcached_return_t memcached_set_errno(memcached_instance_st& self, int local_er
   return rc;
 }
 
-memcached_return_t memcached_set_errno(memcached_instance_st& self, int local_errno, const char *at)
+memcached_return_t memcached_set_errno(org::libmemcached::Instance& self, int local_errno, const char *at)
 {
   if (local_errno == 0)
   {
@@ -456,7 +456,7 @@ void memcached_error_print(const memcached_st *self)
 
   for (uint32_t x= 0; x < memcached_server_count(self); x++)
   {
-    memcached_server_instance_st instance= memcached_server_instance_by_position(self, x);
+    org::libmemcached::Instance* instance= memcached_instance_by_position(self, x);
 
     _error_print(instance->error_messages);
   }
@@ -478,7 +478,7 @@ void memcached_error_free(memcached_st& self)
   self.error_messages= NULL;
 }
 
-void memcached_error_free(memcached_instance_st& self)
+void memcached_error_free(org::libmemcached::Instance& self)
 {
   _error_free(self.error_messages);
   self.error_messages= NULL;
@@ -522,7 +522,7 @@ bool memcached_has_current_error(memcached_st &memc)
   return false;
 }
 
-bool memcached_has_current_error(memcached_instance_st& server)
+bool memcached_has_current_error(org::libmemcached::Instance& server)
 {
   return memcached_has_current_error(*(server.root));
 }
@@ -578,7 +578,7 @@ const char *memcached_server_error(const memcached_server_instance_st server)
 }
 
 
-memcached_error_t *memcached_error_copy(const memcached_instance_st& server)
+memcached_error_t *memcached_error_copy(const org::libmemcached::Instance& server)
 {
   if (server.error_messages == NULL)
   {
@@ -607,7 +607,7 @@ memcached_return_t memcached_server_error_return(memcached_server_instance_st pt
   return MEMCACHED_SUCCESS;
 }
 
-memcached_return_t memcached_instance_error_return(memcached_instance_st* instance)
+memcached_return_t memcached_instance_error_return(org::libmemcached::Instance* instance)
 {
   if (instance == NULL)
   {

diff --git a/libmemcached/error.hpp b/libmemcached/error.hpp
index 26c563670536bc4434c9fe77e221bf3f372a9e20..5b82d13ac48362050f920a95b0f91ea127c0b40a 100644 (file)
--- a/libmemcached/error.hpp
+++ b/libmemcached/error.hpp
@@ -45,64 +45,46 @@
 #define TOSTRING(x) STRINGIFY(x)
 #define MEMCACHED_AT __FILE__ ":" TOSTRING(__LINE__)
 
-LIBMEMCACHED_LOCAL
 memcached_return_t memcached_set_parser_error(memcached_st& memc,
                                               const char *at,
                                               const char *format, ...);
 
-LIBMEMCACHED_LOCAL
-  memcached_return_t memcached_set_error(memcached_st&, memcached_return_t rc, const char *at);
+memcached_return_t memcached_set_error(memcached_st&, memcached_return_t rc, const char *at);
 
-LIBMEMCACHED_LOCAL
-  memcached_return_t memcached_set_error(memcached_instance_st&, memcached_return_t rc, const char *at);
+memcached_return_t memcached_set_error(org::libmemcached::Instance&, memcached_return_t rc, const char *at);
 
-LIBMEMCACHED_LOCAL
-  memcached_return_t memcached_set_error(memcached_st&, memcached_return_t rc, const char *at, const char *str, size_t length);
+memcached_return_t memcached_set_error(memcached_st&, memcached_return_t rc, const char *at, const char *str, size_t length);
 
-LIBMEMCACHED_LOCAL
-  memcached_return_t memcached_set_error(memcached_instance_st&, memcached_return_t rc, const char *at, const char *str, size_t length);
+memcached_return_t memcached_set_error(org::libmemcached::Instance&, memcached_return_t rc, const char *at, const char *str, size_t length);
 
-LIBMEMCACHED_LOCAL
-  memcached_return_t memcached_set_error(memcached_st& memc, memcached_return_t rc, const char *at, memcached_string_t& str);
+memcached_return_t memcached_set_error(memcached_st& memc, memcached_return_t rc, const char *at, memcached_string_t& str);
 
-LIBMEMCACHED_LOCAL
-  memcached_return_t memcached_set_error(memcached_instance_st&, memcached_return_t rc, const char *at, memcached_string_t& str);
+memcached_return_t memcached_set_error(org::libmemcached::Instance&, memcached_return_t rc, const char *at, memcached_string_t& str);
 
-LIBMEMCACHED_LOCAL
-  memcached_return_t memcached_set_errno(memcached_st& memc, int local_errno, const char *at, memcached_string_t& str);
+memcached_return_t memcached_set_errno(memcached_st& memc, int local_errno, const char *at, memcached_string_t& str);
 
-LIBMEMCACHED_LOCAL
-  memcached_return_t memcached_set_errno(memcached_instance_st&, int local_errno, const char *at, memcached_string_t& str);
+memcached_return_t memcached_set_errno(org::libmemcached::Instance&, int local_errno, const char *at, memcached_string_t& str);
 
-LIBMEMCACHED_LOCAL
-  memcached_return_t memcached_set_errno(memcached_st& memc, int local_errno, const char *at, const char *str, size_t length);
+memcached_return_t memcached_set_errno(memcached_st& memc, int local_errno, const char *at, const char *str, size_t length);
 
-LIBMEMCACHED_LOCAL
-  memcached_return_t memcached_set_errno(memcached_instance_st&, int local_errno, const char *at, const char *str, size_t length);
+memcached_return_t memcached_set_errno(org::libmemcached::Instance&, int local_errno, const char *at, const char *str, size_t length);
 
-LIBMEMCACHED_LOCAL
-  memcached_return_t memcached_set_errno(memcached_st& memc, int local_errno, const char *at);
+memcached_return_t memcached_set_errno(memcached_st& memc, int local_errno, const char *at);
 
-LIBMEMCACHED_LOCAL
-  memcached_return_t memcached_set_errno(memcached_instance_st&, int local_errno, const char *at);
+memcached_return_t memcached_set_errno(org::libmemcached::Instance&, int local_errno, const char *at);
 
-LIBMEMCACHED_LOCAL
 bool memcached_has_current_error(memcached_st&);
 
-LIBMEMCACHED_LOCAL
-bool memcached_has_current_error(memcached_instance_st&);
+bool memcached_has_current_error(org::libmemcached::Instance&);
 
-LIBMEMCACHED_LOCAL
 void memcached_error_free(memcached_st&);
 
-void memcached_error_free(memcached_server_st& self);
+void memcached_error_free(memcached_server_st&);
 
-LIBMEMCACHED_LOCAL
-void memcached_error_free(memcached_instance_st&);
+void memcached_error_free(org::libmemcached::Instance& self);
 
-LIBMEMCACHED_LOCAL
-memcached_error_t *memcached_error_copy(const memcached_instance_st&);
+memcached_error_t *memcached_error_copy(const org::libmemcached::Instance&);
 
-memcached_return_t memcached_instance_error_return(memcached_instance_st*);
+memcached_return_t memcached_instance_error_return(org::libmemcached::Instance*);
 
 #endif

diff --git a/libmemcached/exist.cc b/libmemcached/exist.cc
index 58408fd747d2e0795257e468c6c1982fbfeb5bee..56c1efcec6194c601aa3bae608f19f9d5aa2f673 100644 (file)
--- a/libmemcached/exist.cc
+++ b/libmemcached/exist.cc
@@ -36,7 +36,7 @@
 
 #include <libmemcached/common.h>
 
-static memcached_return_t ascii_exist(memcached_st *memc, memcached_server_write_instance_st instance, const char *key, size_t key_length)
+static memcached_return_t ascii_exist(memcached_st *memc, org::libmemcached::Instance* instance, const char *key, size_t key_length)
 {
   libmemcached_io_vector_st vector[]=
   {
@@ -74,7 +74,7 @@ static memcached_return_t ascii_exist(memcached_st *memc, memcached_server_write
   return rc;
 }
 
-static memcached_return_t binary_exist(memcached_st *memc, memcached_server_write_instance_st instance, const char *key, size_t key_length)
+static memcached_return_t binary_exist(memcached_st *memc, org::libmemcached::Instance* instance, const char *key, size_t key_length)
 {
   protocol_binary_request_set request= {};
   size_t send_length= sizeof(request.bytes);
@@ -143,7 +143,7 @@ memcached_return_t memcached_exist_by_key(memcached_st *memc,
   }
 
   uint32_t server_key= memcached_generate_hash_with_redistribution(memc, group_key, group_key_length);
-  memcached_server_write_instance_st instance= memcached_server_instance_fetch(memc, server_key);
+  org::libmemcached::Instance* instance= memcached_instance_fetch(memc, server_key);
 
   if (memcached_is_binary(memc))
   {

diff --git a/libmemcached/fetch.cc b/libmemcached/fetch.cc
index 2fd0dc51e845a96a4f02194ec6e9679958936bdb..70e5bf75ef30989c5845a276357bf84553e799bf 100644 (file)
--- a/libmemcached/fetch.cc
+++ b/libmemcached/fetch.cc
@@ -191,7 +191,7 @@ memcached_result_st *memcached_fetch_result(memcached_st *ptr,
   }
 
   *error= MEMCACHED_MAXIMUM_RETURN; // We use this to see if we ever go into the loop
-  memcached_instance_st *server;
+  org::libmemcached::Instance *server;
   while ((server= memcached_io_get_readable_server(ptr)))
   {
     char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];

diff --git a/libmemcached/flag.cc b/libmemcached/flag.cc
new file mode 100644 (file)
index 0000000..09b401e
--- /dev/null
+++ b/libmemcached/flag.cc
@@ -0,0 +1,156 @@
+/*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ * 
+ *  Libmemcached library
+ *
+ *  Copyright (C) 2012 Data Differential, http://datadifferential.com/
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions are
+ *  met:
+ *
+ *      * Redistributions of source code must retain the above copyright
+ *  notice, this list of conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above
+ *  copyright notice, this list of conditions and the following disclaimer
+ *  in the documentation and/or other materials provided with the
+ *  distribution.
+ *
+ *      * The names of its contributors may not be used to endorse or
+ *  promote products derived from this software without specific prior
+ *  written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <libmemcached/common.h>
+
+bool memcached_flag(const memcached_st& memc, const memcached_flag_t flag)
+{
+  switch (flag)
+  {
+  case MEMCACHED_FLAG_AUTO_EJECT_HOSTS:
+    return memcached_is_auto_eject_hosts(&memc);
+
+  case MEMCACHED_FLAG_BINARY_PROTOCOL:
+    return memcached_is_binary(&memc);
+
+  case MEMCACHED_FLAG_BUFFER_REQUESTS:
+    return memcached_is_buffering(&memc);
+
+  case MEMCACHED_FLAG_HASH_WITH_NAMESPACE:
+    return memcached_is_hash_with_namespace(&memc);
+
+  case MEMCACHED_FLAG_NO_BLOCK:
+    return memcached_is_no_block(&memc);
+
+  case MEMCACHED_FLAG_REPLY:
+    return memcached_is_replying(&memc);
+
+  case MEMCACHED_FLAG_RANDOMIZE_REPLICA_READ:
+    return memcached_is_randomize_replica_read(&memc);
+
+  case MEMCACHED_FLAG_SUPPORT_CAS:
+    return memcached_is_cas(&memc);
+
+  case MEMCACHED_FLAG_TCP_NODELAY:
+    return memcached_is_tcp_nodelay(&memc);
+
+  case MEMCACHED_FLAG_USE_SORT_HOSTS:
+    return memcached_is_use_sort_hosts(&memc);
+
+  case MEMCACHED_FLAG_USE_UDP:
+    return memcached_is_udp(&memc);
+
+  case MEMCACHED_FLAG_VERIFY_KEY:
+    return memcached_is_verify_key(&memc);
+
+  case MEMCACHED_FLAG_TCP_KEEPALIVE:
+    return memcached_is_use_sort_hosts(&memc);
+
+  case MEMCACHED_FLAG_IS_AES:
+    return memcached_is_aes(&memc);
+
+  case MEMCACHED_FLAG_IS_FETCHING_VERSION:
+    return memcached_is_fetching_version(&memc);
+  }
+
+  abort();
+}
+
+void memcached_flag(memcached_st& memc, const memcached_flag_t flag, const bool arg)
+{
+  switch (flag)
+  {
+  case MEMCACHED_FLAG_AUTO_EJECT_HOSTS:
+    memcached_set_auto_eject_hosts(memc, arg);
+    break;
+
+  case MEMCACHED_FLAG_BINARY_PROTOCOL:
+    memcached_set_binary(memc, arg);
+    break;
+
+  case MEMCACHED_FLAG_BUFFER_REQUESTS:
+    memcached_set_buffering(memc, arg);
+    break;
+
+  case MEMCACHED_FLAG_HASH_WITH_NAMESPACE:
+    memcached_set_hash_with_namespace(memc, arg);
+    break;
+
+  case MEMCACHED_FLAG_NO_BLOCK:
+    memcached_set_no_block(memc, arg);
+    break;
+
+  case MEMCACHED_FLAG_REPLY:
+    memcached_set_replying(memc, arg);
+    break;
+
+  case MEMCACHED_FLAG_RANDOMIZE_REPLICA_READ:
+    memcached_set_randomize_replica_read(memc, arg);
+    break;
+
+  case MEMCACHED_FLAG_SUPPORT_CAS:
+    memcached_set_cas(memc, arg);
+    break;
+
+  case MEMCACHED_FLAG_TCP_NODELAY:
+    memcached_set_tcp_nodelay(memc, arg);
+    break;
+
+  case MEMCACHED_FLAG_USE_SORT_HOSTS:
+    memcached_set_use_sort_hosts(memc, arg);
+    break;
+
+  case MEMCACHED_FLAG_USE_UDP:
+    memcached_set_udp(memc, arg);
+    break;
+
+  case MEMCACHED_FLAG_VERIFY_KEY:
+    memcached_set_verify_key(memc, arg);
+    break;
+
+  case MEMCACHED_FLAG_TCP_KEEPALIVE:
+    memcached_set_use_sort_hosts(memc, arg);
+    break;
+
+  case MEMCACHED_FLAG_IS_AES:
+    memcached_set_aes(memc, arg);
+    break;
+
+  case MEMCACHED_FLAG_IS_FETCHING_VERSION:
+    memcached_set_fetching_version(memc, arg);
+    break;
+  }
+}

diff --git a/libmemcached/flag.hpp b/libmemcached/flag.hpp
new file mode 100644 (file)
index 0000000..6efe2ef
--- /dev/null
+++ b/libmemcached/flag.hpp
@@ -0,0 +1,59 @@
+/*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ * 
+ *  Libmemcached library
+ *
+ *  Copyright (C) 2012 Data Differential, http://datadifferential.com/
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions are
+ *  met:
+ *
+ *      * Redistributions of source code must retain the above copyright
+ *  notice, this list of conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above
+ *  copyright notice, this list of conditions and the following disclaimer
+ *  in the documentation and/or other materials provided with the
+ *  distribution.
+ *
+ *      * The names of its contributors may not be used to endorse or
+ *  promote products derived from this software without specific prior
+ *  written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#pragma once
+
+enum memcached_flag_t
+{
+  MEMCACHED_FLAG_AUTO_EJECT_HOSTS,
+  MEMCACHED_FLAG_BINARY_PROTOCOL,
+  MEMCACHED_FLAG_BUFFER_REQUESTS,
+  MEMCACHED_FLAG_HASH_WITH_NAMESPACE,
+  MEMCACHED_FLAG_NO_BLOCK,
+  MEMCACHED_FLAG_REPLY,
+  MEMCACHED_FLAG_RANDOMIZE_REPLICA_READ,
+  MEMCACHED_FLAG_SUPPORT_CAS,
+  MEMCACHED_FLAG_TCP_NODELAY,
+  MEMCACHED_FLAG_USE_SORT_HOSTS,
+  MEMCACHED_FLAG_USE_UDP,
+  MEMCACHED_FLAG_VERIFY_KEY,
+  MEMCACHED_FLAG_TCP_KEEPALIVE,
+  MEMCACHED_FLAG_IS_AES,
+  MEMCACHED_FLAG_IS_FETCHING_VERSION
+};
+
+bool memcached_flag(const memcached_st&, const memcached_flag_t);
+void memcached_flag(memcached_st&, const memcached_flag_t, const bool);

diff --git a/libmemcached/flush.cc b/libmemcached/flush.cc
index ef79092287ead37bc1a0fa3b1edb3b0fdfa0a890..1e1533ddaf35a2af31bec0a85a181670ba50d327 100644 (file)
--- a/libmemcached/flush.cc
+++ b/libmemcached/flush.cc
@@ -52,7 +52,7 @@ static memcached_return_t memcached_flush_binary(memcached_st *ptr,
 
   for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
   {
-    memcached_server_write_instance_st instance= memcached_server_instance_fetch(ptr, x);
+    org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, x);
     initialize_binary_request(instance, request.message.header);
 
     if (reply)
@@ -84,7 +84,7 @@ static memcached_return_t memcached_flush_binary(memcached_st *ptr,
 
   for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
   {
-    memcached_server_write_instance_st instance= memcached_server_instance_fetch(ptr, x);
+    org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, x);
 
     if (memcached_instance_response_count(instance) > 0)
     {
@@ -115,7 +115,7 @@ static memcached_return_t memcached_flush_textual(memcached_st *ptr,
   memcached_return_t rc= MEMCACHED_SUCCESS;
   for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
   {
-    memcached_server_write_instance_st instance= memcached_server_instance_fetch(ptr, x);
+    org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, x);
 
     libmemcached_io_vector_st vector[]=
     {

diff --git a/libmemcached/flush_buffers.cc b/libmemcached/flush_buffers.cc
index 58260fc10cb785dc7fe44749f92ddb43aca930db..af6942b4a79c6e9b9f1b2fee6658835186303c80 100644 (file)
--- a/libmemcached/flush_buffers.cc
+++ b/libmemcached/flush_buffers.cc
@@ -43,8 +43,7 @@ memcached_return_t memcached_flush_buffers(memcached_st *memc)
 
   for (uint32_t x= 0; x < memcached_server_count(memc); ++x)
   {
-    memcached_server_write_instance_st instance=
-      memcached_server_instance_fetch(memc, x);
+    org::libmemcached::Instance* instance= memcached_instance_fetch(memc, x);
 
     if (instance->write_buffer_offset != 0) 
     {

diff --git a/libmemcached/get.cc b/libmemcached/get.cc
index cc6af2d83357cf4c56e48f7dc879a7b87a4df311..b774e7d5e775eea011caff5d2171d93d39378578 100644 (file)
--- a/libmemcached/get.cc
+++ b/libmemcached/get.cc
@@ -244,7 +244,7 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
   */
   for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
   {
-    memcached_server_write_instance_st instance= memcached_server_instance_fetch(ptr, x);
+    org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, x);
 
     if (memcached_instance_response_count(instance))
     {
@@ -282,7 +282,6 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
   size_t hosts_connected= 0;
   for (uint32_t x= 0; x < number_of_keys; x++)
   {
-    memcached_server_write_instance_st instance;
     uint32_t server_key;
 
     if (is_group_key_set)
@@ -294,7 +293,7 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
       server_key= memcached_generate_hash_with_redistribution(ptr, keys[x], key_length[x]);
     }
 
-    instance= memcached_server_instance_fetch(ptr, server_key);
+    org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, server_key);
 
     libmemcached_io_vector_st vector[]=
     {
@@ -321,9 +320,9 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
         failures_occured_in_sending= true;
         continue;
       }
-      WATCHPOINT_ASSERT(instance->cursor_active == 0);
+      WATCHPOINT_ASSERT(instance->cursor_active_ == 0);
       memcached_instance_response_increment(instance);
-      WATCHPOINT_ASSERT(instance->cursor_active == 1);
+      WATCHPOINT_ASSERT(instance->cursor_active_ == 1);
     }
     else
     {
@@ -355,8 +354,7 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
   bool success_happened= false;
   for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
   {
-    memcached_server_write_instance_st instance=
-      memcached_server_instance_fetch(ptr, x);
+    org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, x);
 
     if (memcached_instance_response_count(instance))
     {
@@ -480,7 +478,7 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr,
       server_key= memcached_generate_hash_with_redistribution(ptr, keys[x], key_length[x]);
     }
 
-    memcached_server_write_instance_st instance= memcached_server_instance_fetch(ptr, server_key);
+    org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, server_key);
 
     if (memcached_instance_response_count(instance) == 0)
     {
@@ -553,7 +551,7 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr,
 
     for (uint32_t x= 0; x < memcached_server_count(ptr); ++x)
     {
-      memcached_server_write_instance_st instance= memcached_server_instance_fetch(ptr, x);
+      org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, x);
       initialize_binary_request(instance, request.message.header);
 
       if (memcached_instance_response_count(instance))
@@ -624,7 +622,7 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr,
         continue;
       }
 
-      memcached_server_write_instance_st instance= memcached_server_instance_fetch(ptr, server);
+      org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, server);
 
       if (memcached_instance_response_count(instance) == 0)
       {

diff --git a/libmemcached/hosts.cc b/libmemcached/hosts.cc
index 898bff9dfe3fdabc48d65c306147f23a4b1cb171..4875615f4ae3c3a2bd37d6d1dbb5443794697e34 100644 (file)
--- a/libmemcached/hosts.cc
+++ b/libmemcached/hosts.cc
@@ -52,7 +52,7 @@ static int compare_servers(const void *p1, const void *p2)
 
   if (return_value == 0)
   {
-    return_value= (int) (a->port - b->port);
+    return_value= int(a->port() - b->port());
   }
 
   return return_value;
@@ -62,11 +62,7 @@ static void sort_hosts(memcached_st *ptr)
 {
   if (memcached_server_count(ptr))
   {
-    memcached_server_write_instance_st instance;
-
-    qsort(memcached_instance_list(ptr), memcached_server_count(ptr), sizeof(memcached_instance_st), compare_servers);
-    instance= memcached_server_instance_fetch(ptr, 0);
-    instance->number_of_hosts= memcached_server_count(ptr);
+    qsort(memcached_instance_list(ptr), memcached_server_count(ptr), sizeof(org::libmemcached::Instance), compare_servers);
   }
 }
 
@@ -122,11 +118,17 @@ static int continuum_item_cmp(const void *t1, const void *t2)
   /* Why 153? Hmmm... */
   WATCHPOINT_ASSERT(ct1->value != 153);
   if (ct1->value == ct2->value)
+  {
     return 0;
+  }
   else if (ct1->value > ct2->value)
+  {
     return 1;
+  }
   else
+  {
     return -1;
+  }
 }
 
 static memcached_return_t update_continuum(memcached_st *ptr)
@@ -143,7 +145,7 @@ static memcached_return_t update_continuum(memcached_st *ptr)
     return memcached_set_errno(*ptr, errno, MEMCACHED_AT);
   }
 
-  memcached_instance_st *list= memcached_instance_list(ptr);
+  org::libmemcached::Instance* list= memcached_instance_list(ptr);
 
   /* count live servers (those without a retry delay set) */
   bool is_auto_ejecting= _is_auto_eject_host(ptr);
@@ -171,10 +173,9 @@ static memcached_return_t update_continuum(memcached_st *ptr)
     live_servers= memcached_server_count(ptr);
   }
 
-  uint64_t is_ketama_weighted= memcached_behavior_get(ptr, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
-  uint32_t points_per_server= (uint32_t) (is_ketama_weighted ? MEMCACHED_POINTS_PER_SERVER_KETAMA : MEMCACHED_POINTS_PER_SERVER);
+  uint32_t points_per_server= (uint32_t) (memcached_is_weighted_ketama(ptr) ? MEMCACHED_POINTS_PER_SERVER_KETAMA : MEMCACHED_POINTS_PER_SERVER);
 
-  if (not live_servers)
+  if (live_servers == 0)
   {
     return MEMCACHED_SUCCESS;
   }
@@ -195,7 +196,7 @@ static memcached_return_t update_continuum(memcached_st *ptr)
   }
 
   uint64_t total_weight= 0;
-  if (is_ketama_weighted)
+  if (memcached_is_weighted_ketama(ptr))
   {
     for (uint32_t host_index = 0; host_index < memcached_server_count(ptr); ++host_index)
     {
@@ -213,7 +214,7 @@ static memcached_return_t update_continuum(memcached_st *ptr)
       continue;
     }
 
-    if (is_ketama_weighted)
+    if (memcached_is_weighted_ketama(ptr))
     {
         float pct= (float)list[host_index].weight / (float)total_weight;
         pointer_per_server= (uint32_t) ((::floor((float) (pct * MEMCACHED_POINTS_PER_SERVER_KETAMA / 4 * (float)live_servers + 0.0000000001))) * 4);
@@ -222,7 +223,7 @@ static memcached_return_t update_continuum(memcached_st *ptr)
         {
           printf("ketama_weighted:%s|%d|%llu|%u\n",
                  list[host_index].hostname,
-                 list[host_index].port,
+                 list[host_index].port(),
                  (unsigned long long)list[host_index].weight,
                  pointer_per_server);
         }
@@ -243,7 +244,7 @@ static memcached_return_t update_continuum(memcached_st *ptr)
         sort_host_length= snprintf(sort_host, sizeof(sort_host),
                                    "/%s:%u-%u",
                                    list[host_index].hostname,
-                                   (uint32_t)list[host_index].port,
+                                   (uint32_t)list[host_index].port(),
                                    pointer_index);
 
         if (size_t(sort_host_length) >= sizeof(sort_host) or sort_host_length < 0)
@@ -257,7 +258,7 @@ static memcached_return_t update_continuum(memcached_st *ptr)
           fprintf(stdout, "update_continuum: key is %s\n", sort_host);
         }
 
-        if (is_ketama_weighted)
+        if (memcached_is_weighted_ketama(ptr))
         {
           for (uint32_t x= 0; x < pointer_per_hash; x++)
           {
@@ -283,7 +284,7 @@ static memcached_return_t update_continuum(memcached_st *ptr)
         char sort_host[MEMCACHED_NI_MAXHOST +1 +MEMCACHED_NI_MAXSERV +1 +MEMCACHED_NI_MAXSERV]= "";
         int sort_host_length;
 
-        if (list[host_index].port == MEMCACHED_DEFAULT_PORT)
+        if (list[host_index].port() == MEMCACHED_DEFAULT_PORT)
         {
           sort_host_length= snprintf(sort_host, sizeof(sort_host),
                                      "%s-%u",
@@ -295,7 +296,7 @@ static memcached_return_t update_continuum(memcached_st *ptr)
           sort_host_length= snprintf(sort_host, sizeof(sort_host),
                                      "%s:%u-%u",
                                      list[host_index].hostname,
-                                     (uint32_t)list[host_index].port,
+                                     (uint32_t)list[host_index].port(),
                                      pointer_index - 1);
         }
 
@@ -305,7 +306,7 @@ static memcached_return_t update_continuum(memcached_st *ptr)
                                      memcached_literal_param("snprintf(sizeof(sort_host)))"));
         }
 
-        if (is_ketama_weighted)
+        if (memcached_is_weighted_ketama(ptr))
         {
           for (uint32_t x = 0; x < pointer_per_hash; x++)
           {
@@ -351,7 +352,7 @@ static memcached_return_t server_add(memcached_st *ptr,
 {
   assert_msg(ptr, "Programmer mistake, somehow server_add() was passed a NULL memcached_st");
 
-  memcached_instance_st *new_host_list= libmemcached_xrealloc(ptr, memcached_instance_list(ptr), (ptr->number_of_hosts + 1), memcached_instance_st);
+  org::libmemcached::Instance* new_host_list= libmemcached_xrealloc(ptr, memcached_instance_list(ptr), (ptr->number_of_hosts + 1), org::libmemcached::Instance);
 
   if (new_host_list == NULL)
   {
@@ -361,7 +362,7 @@ static memcached_return_t server_add(memcached_st *ptr,
   memcached_instance_set(ptr, new_host_list);
 
   /* TODO: Check return type */
-  memcached_server_write_instance_st instance= memcached_server_instance_fetch(ptr, memcached_server_count(ptr));
+  org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, memcached_server_count(ptr));
 
   if (__instance_create_with(ptr, instance, hostname, port, weight, type) == NULL)
   {
@@ -370,15 +371,14 @@ static memcached_return_t server_add(memcached_st *ptr,
 
   if (weight > 1)
   {
-    ptr->ketama.weighted= true;
+    if (memcached_is_consistent_distribution(ptr))
+    {
+      memcached_set_weighted_ketama(ptr, true);
+    }
   }
 
   ptr->number_of_hosts++;
 
-  // @note we place the count in the bottom of the server list
-  instance= memcached_server_instance_fetch(ptr, 0);
-  memcached_instance_set_count(instance, memcached_server_count(ptr));
-
   return run_distribution(ptr);
 }
 
@@ -392,7 +392,7 @@ memcached_return_t memcached_server_push(memcached_st *ptr, const memcached_serv
 
   uint32_t count= memcached_server_list_count(list);
 
-  memcached_instance_st *new_host_list= libmemcached_xrealloc(ptr, memcached_instance_list(ptr), (count + memcached_server_count(ptr)), memcached_instance_st);
+  org::libmemcached::Instance* new_host_list= libmemcached_xrealloc(ptr, memcached_instance_list(ptr), (count + memcached_server_count(ptr)), org::libmemcached::Instance);
 
   if (new_host_list == NULL)
   {
@@ -403,12 +403,10 @@ memcached_return_t memcached_server_push(memcached_st *ptr, const memcached_serv
 
   for (uint32_t x= 0; x < count; x++)
   {
-    memcached_server_write_instance_st instance;
-
     WATCHPOINT_ASSERT(list[x].hostname[0] != 0);
 
     // We have extended the array, and now we will find it, and use it.
-    instance= memcached_server_instance_fetch(ptr, memcached_server_count(ptr));
+    org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, memcached_server_count(ptr));
     WATCHPOINT_ASSERT(instance);
 
     memcached_string_t hostname= { memcached_string_make_from_cstr(list[x].hostname) };
@@ -421,30 +419,23 @@ memcached_return_t memcached_server_push(memcached_st *ptr, const memcached_serv
 
     if (list[x].weight > 1)
     {
-      ptr->ketama.weighted= true;
+      memcached_set_weighted_ketama(ptr, true);
     }
 
     ptr->number_of_hosts++;
   }
 
-  // Provides backwards compatibility with server list.
-  {
-    memcached_server_write_instance_st instance;
-    instance= memcached_server_instance_fetch(ptr, 0);
-    instance->number_of_hosts= memcached_server_count(ptr);
-  }
-
   return run_distribution(ptr);
 }
 
-memcached_return_t memcached_instance_push(memcached_st *ptr, const struct memcached_instance_st* list, uint32_t number_of_hosts)
+memcached_return_t memcached_instance_push(memcached_st *ptr, const struct org::libmemcached::Instance* list, uint32_t number_of_hosts)
 {
   if (list == NULL)
   {
     return MEMCACHED_SUCCESS;
   }
 
-  memcached_instance_st* new_host_list= libmemcached_xrealloc(ptr, memcached_instance_list(ptr), (number_of_hosts +memcached_server_count(ptr)), memcached_instance_st);
+  org::libmemcached::Instance* new_host_list= libmemcached_xrealloc(ptr, memcached_instance_list(ptr), (number_of_hosts +memcached_server_count(ptr)), org::libmemcached::Instance);
 
   if (new_host_list == NULL)
   {
@@ -455,37 +446,29 @@ memcached_return_t memcached_instance_push(memcached_st *ptr, const struct memca
 
   for (uint32_t x= 0; x < number_of_hosts; x++)
   {
-    memcached_server_write_instance_st instance;
 
     WATCHPOINT_ASSERT(list[x].hostname[0] != 0);
 
     // We have extended the array, and now we will find it, and use it.
-    instance= memcached_server_instance_fetch(ptr, memcached_server_count(ptr));
+    org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, memcached_server_count(ptr));
     WATCHPOINT_ASSERT(instance);
 
     memcached_string_t hostname= { memcached_string_make_from_cstr(list[x].hostname) };
     if (__instance_create_with(ptr, instance, 
                                hostname,
-                               list[x].port, list[x].weight, list[x].type) == NULL)
+                               list[x].port(), list[x].weight, list[x].type) == NULL)
     {
       return memcached_set_error(*ptr, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT);
     }
 
     if (list[x].weight > 1)
     {
-      ptr->ketama.weighted= true;
+      memcached_set_weighted_ketama(ptr, true);
     }
 
     ptr->number_of_hosts++;
   }
 
-  // Provides backwards compatibility with server list.
-  {
-    memcached_server_write_instance_st instance;
-    instance= memcached_server_instance_fetch(ptr, 0);
-    instance->number_of_hosts= memcached_server_count(ptr);
-  }
-
   return run_distribution(ptr);
 }
 

diff --git a/libmemcached/include.am b/libmemcached/include.am
index be04712c830237245331a4881a1437a57432009a..bfa2f140111f6c9ab0b9df4b4ee41695bc26963b 100644 (file)
--- a/libmemcached/include.am
+++ b/libmemcached/include.am
@@ -16,6 +16,7 @@ nobase_include_HEADERS+= libmemcached/util.h
 noinst_HEADERS+= libmemcached/array.h 
 noinst_HEADERS+= libmemcached/assert.hpp 
 noinst_HEADERS+= libmemcached/backtrace.hpp 
+noinst_HEADERS+= libmemcached/behavior.hpp
 noinst_HEADERS+= libmemcached/byteorder.h 
 noinst_HEADERS+= libmemcached/common.h 
 noinst_HEADERS+= libmemcached/connect.hpp 
@@ -23,6 +24,7 @@ noinst_HEADERS+= libmemcached/continuum.hpp
 noinst_HEADERS+= libmemcached/do.hpp 
 noinst_HEADERS+= libmemcached/encoding_key.h 
 noinst_HEADERS+= libmemcached/error.hpp 
+noinst_HEADERS+= libmemcached/flag.hpp 
 noinst_HEADERS+= libmemcached/initialize_query.h 
 noinst_HEADERS+= libmemcached/instance.h 
 noinst_HEADERS+= libmemcached/instance.hpp
@@ -45,6 +47,7 @@ noinst_HEADERS+= libmemcached/server_instance.h
 noinst_HEADERS+= libmemcached/socket.hpp 
 noinst_HEADERS+= libmemcached/string.hpp 
 noinst_HEADERS+= libmemcached/udp.hpp 
+noinst_HEADERS+= libmemcached/version.hpp 
 noinst_HEADERS+= libmemcached/virtual_bucket.h 
 noinst_HEADERS+= libmemcached/watchpoint.h
 
@@ -62,7 +65,6 @@ libmemcached_libmemcached_la_SOURCES+= libmemcached/array.c
 libmemcached_libmemcached_la_SOURCES+= libmemcached/auto.cc
 libmemcached_libmemcached_la_SOURCES+= libmemcached/backtrace.cc
 libmemcached_libmemcached_la_SOURCES+= libmemcached/behavior.cc
-libmemcached_libmemcached_la_SOURCES+= libmemcached/behavior.hpp
 libmemcached_libmemcached_la_SOURCES+= libmemcached/byteorder.cc
 libmemcached_libmemcached_la_SOURCES+= libmemcached/callback.cc
 libmemcached_libmemcached_la_SOURCES+= libmemcached/connect.cc
@@ -72,6 +74,7 @@ libmemcached_libmemcached_la_SOURCES+= libmemcached/dump.cc
 libmemcached_libmemcached_la_SOURCES+= libmemcached/error.cc
 libmemcached_libmemcached_la_SOURCES+= libmemcached/exist.cc
 libmemcached_libmemcached_la_SOURCES+= libmemcached/fetch.cc
+libmemcached_libmemcached_la_SOURCES+= libmemcached/flag.cc
 libmemcached_libmemcached_la_SOURCES+= libmemcached/flush.cc
 libmemcached_libmemcached_la_SOURCES+= libmemcached/flush_buffers.cc
 libmemcached_libmemcached_la_SOURCES+= libmemcached/get.cc

diff --git a/libmemcached/instance.cc b/libmemcached/instance.cc
index 0662b8f627c60c27959880c132efd787bfead4f8..aacdad64a3d2262f92a4e137a6c5250e32715c46 100644 (file)
--- a/libmemcached/instance.cc
+++ b/libmemcached/instance.cc
@@ -35,21 +35,17 @@
  *
  */
 
-/*
-  This is a partial implementation for fetching/creating memcached_instance_st objects.
-*/
 #include <libmemcached/common.h>
 
-static inline void _server_init(memcached_instance_st *self, memcached_st *root,
+static inline void _server_init(org::libmemcached::Instance* self, memcached_st *root,
                                 const memcached_string_t& hostname,
                                 in_port_t port,
                                 uint32_t weight, memcached_connection_t type)
 {
   self->options.is_shutting_down= false;
   self->options.is_dead= false;
-  self->number_of_hosts= 0;
-  self->cursor_active= 0;
-  self->port= port;
+  self->cursor_active_= 0;
+  self->port_= port;
   self->fd= INVALID_SOCKET;
   self->io_bytes_sent= 0;
   self->request_id= 0;
@@ -89,11 +85,11 @@ static inline void _server_init(memcached_instance_st *self, memcached_st *root,
   self->hostname[hostname.size]= 0;
 }
 
-static memcached_instance_st *_server_create(memcached_instance_st *self, const memcached_st *memc)
+static org::libmemcached::Instance* _server_create(org::libmemcached::Instance* self, const memcached_st *memc)
 {
   if (self == NULL)
   {
-   self= libmemcached_xmalloc(memc, struct memcached_instance_st);
+   self= libmemcached_xmalloc(memc, org::libmemcached::Instance);
 
     if (self == NULL)
     {
@@ -112,12 +108,12 @@ static memcached_instance_st *_server_create(memcached_instance_st *self, const
   return self;
 }
 
-memcached_instance_st *__instance_create_with(memcached_st *memc,
-                                              memcached_instance_st* self,
-                                              const memcached_string_t& hostname,
-                                              const in_port_t port,
-                                              uint32_t weight, 
-                                              const memcached_connection_t type)
+org::libmemcached::Instance* __instance_create_with(memcached_st *memc,
+                                                    org::libmemcached::Instance* self,
+                                                    const memcached_string_t& hostname,
+                                                    const in_port_t port,
+                                                    uint32_t weight, 
+                                                    const memcached_connection_t type)
 {
   if (memcached_is_valid_servername(hostname) == false)
   {
@@ -148,7 +144,7 @@ memcached_instance_st *__instance_create_with(memcached_st *memc,
   return self;
 }
 
-void __instance_free(memcached_instance_st *self)
+void __instance_free(org::libmemcached::Instance* self)
 {
   memcached_quit_server(self, false);
 
@@ -171,26 +167,20 @@ void __instance_free(memcached_instance_st *self)
   }
 }
 
-void memcached_instance_free(memcached_instance_st *self)
+void memcached_instance_free(org::libmemcached::Instance* self)
 {
   if (self == NULL)
   {
     return;
   }
 
-  if (memcached_instance_count(self))
-  {
-    memcached_instance_list_free(self, memcached_instance_count(self));
-    return;
-  }
-
   __instance_free(self);
 }
 
 /*
   If we do not have a valid object to clone from, we toss an error.
 */
-memcached_server_st *memcached_instance_2_server(memcached_instance_st *source)
+memcached_server_st *memcached_instance_2_server(org::libmemcached::Instance* source)
 {
   /* We just do a normal create if source is missing */
   if (source == NULL)
@@ -201,7 +191,7 @@ memcached_server_st *memcached_instance_2_server(memcached_instance_st *source)
   memcached_string_t hostname= { memcached_string_make_from_cstr(source->hostname) };
   return __server_create_with(source->root, NULL,
                               hostname,
-                              source->port, source->weight,
+                              source->port(), source->weight,
                               source->type);
 
 }
@@ -220,8 +210,7 @@ memcached_return_t memcached_server_cursor(const memcached_st *ptr,
   size_t errors= 0;
   for (uint32_t x= 0; x < memcached_instance_list_count(ptr); x++)
   {
-    memcached_server_instance_st instance=
-      memcached_server_instance_by_position(ptr, x);
+    org::libmemcached::Instance* instance= memcached_instance_by_position(ptr, x);
 
     for (uint32_t y= 0; y < number_of_callbacks; y++)
     {
@@ -250,7 +239,7 @@ memcached_return_t memcached_server_execute(memcached_st *ptr,
   bool some_errors= false;;
   for (uint32_t x= 0; x < memcached_instance_list_count(ptr); x++)
   {
-    memcached_instance_st* instance= memcached_server_instance_fetch(ptr, x);
+    org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, x);
 
     memcached_return_t rc= (*callback)(ptr, instance, context);
     if (rc == MEMCACHED_INVALID_ARGUMENTS)
@@ -273,7 +262,7 @@ memcached_server_instance_st memcached_server_by_key(memcached_st *ptr,
                                                      memcached_return_t *error)
 {
   memcached_return_t unused;
-  if (not error)
+  if (error == NULL)
   {
     error= &unused;
   }
@@ -293,13 +282,13 @@ memcached_server_instance_st memcached_server_by_key(memcached_st *ptr,
   }
 
   uint32_t server_key= memcached_generate_hash(ptr, key, key_length);
-  return memcached_server_instance_by_position(ptr, server_key);
+  return memcached_instance_by_position(ptr, server_key);
 }
 
 /*
   If we do not have a valid object to clone from, we toss an error.
 */
-static memcached_instance_st *memcached_instance_clone(memcached_instance_st *source)
+static org::libmemcached::Instance* memcached_instance_clone(org::libmemcached::Instance* source)
 {
   /* We just do a normal create if source is missing */
   if (source == NULL)
@@ -311,11 +300,11 @@ static memcached_instance_st *memcached_instance_clone(memcached_instance_st *so
   return __instance_create_with(source->root,
                                 NULL,
                                 hostname,
-                                source->port, source->weight,
+                                source->port(), source->weight,
                                 source->type);
 }
 
-void set_last_disconnected_host(memcached_server_write_instance_st self)
+void set_last_disconnected_host(org::libmemcached::Instance* self)
 {
   assert(self->root);
   if (self->root == NULL)
@@ -323,7 +312,8 @@ void set_last_disconnected_host(memcached_server_write_instance_st self)
     return;
   }
 
-  if (self->root->last_disconnected_server and self->root->last_disconnected_server->version == self->version)
+  if (memcached_server_get_last_disconnect(self->root) and
+      memcached_server_get_last_disconnect(self->root)->version == self->version)
   {
     return;
   }
@@ -331,9 +321,9 @@ void set_last_disconnected_host(memcached_server_write_instance_st self)
   // const_cast
   memcached_st *root= (memcached_st *)self->root;
 
-  memcached_instance_free(root->last_disconnected_server);
+  memcached_instance_free((org::libmemcached::Instance*)(root->last_disconnected_server));
   root->last_disconnected_server= memcached_instance_clone(self);
-  root->last_disconnected_server->version= self->version;
+  ((org::libmemcached::Instance*)memcached_server_get_last_disconnect(root))->version= self->version;
 }
 
 memcached_server_instance_st memcached_server_get_last_disconnect(const memcached_st *self)
@@ -344,18 +334,7 @@ memcached_server_instance_st memcached_server_get_last_disconnect(const memcache
     return 0;
   }
 
-  return self->last_disconnected_server;
-}
-
-uint32_t memcached_instance_set_count(memcached_instance_st *servers, uint32_t count)
-{
-  WATCHPOINT_ASSERT(servers);
-  if (servers == NULL)
-  {
-    return 0;
-  }
-
-  return servers->number_of_hosts= count;
+  return (memcached_server_instance_st)self->last_disconnected_server;
 }
 
 const char *memcached_instance_name(const memcached_server_instance_st self)
@@ -375,10 +354,19 @@ in_port_t memcached_instance_port(const memcached_server_instance_st self)
     return 0;
   }
 
-  return self->port;
+  return self->port();
+}
+
+void memcached_instance_next_retry(memcached_server_instance_st self, const time_t absolute_time)
+{
+  WATCHPOINT_ASSERT(self);
+  if (self)
+  {
+    ((org::libmemcached::Instance*)self)->next_retry= absolute_time;
+  }
 }
 
-uint32_t memcached_instance_response_count(const memcached_instance_st* self)
+uint32_t memcached_instance_response_count(const org::libmemcached::Instance* self)
 {
   WATCHPOINT_ASSERT(self);
   if (self == NULL)
@@ -386,5 +374,5 @@ uint32_t memcached_instance_response_count(const memcached_instance_st* self)
     return 0;
   }
 
-  return self->cursor_active;
+  return self->cursor_active_;
 }

diff --git a/libmemcached/instance.h b/libmemcached/instance.h
index 16d509f02a6f6bd798872edb1d444018f307c3e0..6a56aa4c7b20f22b0f97238d6eab299e8ea48802 100644 (file)
--- a/libmemcached/instance.h
+++ b/libmemcached/instance.h
@@ -54,16 +54,49 @@
 #define MEMCACHED_NI_MAXSERV 32
 #endif
 
-struct memcached_instance_st {
+#ifdef __cplusplus
+
+namespace org {
+namespace libmemcached {
+
+struct Instance {
+  in_port_t port() const
+  {
+    return port_;
+  }
+
+  void port(in_port_t arg)
+  {
+    port_= arg;
+  }
+
+  void mark_server_as_clean()
+  {
+    server_failure_counter= 0;
+    next_retry= 0;
+  }
+
+  void disable()
+  {
+  }
+
+  void enable()
+  {
+  }
+
+  uint32_t response_count() const
+  {
+    return cursor_active_;
+  }
+
   struct {
     bool is_allocated:1;
     bool is_initialized:1;
     bool is_shutting_down:1;
     bool is_dead:1;
   } options;
-  uint32_t number_of_hosts;
-  uint32_t cursor_active;
-  in_port_t port;
+  uint32_t cursor_active_;
+  in_port_t port_;
   memcached_socket_t fd;
   uint32_t io_bytes_sent; /* # bytes sent since last read */
   uint32_t request_id;
@@ -96,3 +129,8 @@ struct memcached_instance_st {
   char write_buffer[MEMCACHED_MAX_BUFFER];
   char hostname[MEMCACHED_NI_MAXHOST];
 };
+
+} // namespace libmemcached
+} // namespace org
+
+#endif

diff --git a/libmemcached/instance.hpp b/libmemcached/instance.hpp
index 9ab3622a7be0959462dcc55d0d2c60a218f048da..e8d44058a535dffa75ca0a6a3c5fb233f35786af 100644 (file)
--- a/libmemcached/instance.hpp
+++ b/libmemcached/instance.hpp
@@ -38,24 +38,21 @@
 
 #pragma once
 
-struct memcached_instance_st *__instance_create_with(memcached_st *memc,
-                                                     struct memcached_instance_st* self,
-                                                     const memcached_string_t& hostname,
-                                                     const in_port_t port,
-                                                     uint32_t weight, 
-                                                     const memcached_connection_t type);
-const char *memcached_instance_name(const memcached_server_instance_st self);
+org::libmemcached::Instance* __instance_create_with(memcached_st *memc,
+                                                    org::libmemcached::Instance* self,
+                                                    const memcached_string_t& hostname,
+                                                    const in_port_t port,
+                                                    uint32_t weight, 
+                                                    const memcached_connection_t type);
 
-in_port_t memcached_instance_port(const memcached_server_instance_st self);
+const char *memcached_instance_name(const org::libmemcached::Instance* self);
 
-memcached_return_t memcached_instance_push(memcached_st *ptr, const struct memcached_instance_st*, uint32_t);
+in_port_t memcached_instance_port(const org::libmemcached::Instance* self);
 
-memcached_server_st *memcached_instance_2_server(struct memcached_instance_st*);
+memcached_return_t memcached_instance_push(memcached_st *ptr, const org::libmemcached::Instance*, uint32_t);
 
-uint32_t memcached_instance_count(const memcached_st* self);
+memcached_server_st *memcached_instance_2_server(org::libmemcached::Instance* source);
 
-uint32_t memcached_instance_response_count(const memcached_instance_st* self);
+uint32_t memcached_instance_response_count(const org::libmemcached::Instance* self);
 
-uint32_t memcached_instance_set_count(memcached_instance_st *servers, uint32_t count);
-
-void __instance_free(struct memcached_instance_st *);
+void __instance_free(org::libmemcached::Instance *);

diff --git a/libmemcached/io.cc b/libmemcached/io.cc
index d2e40043dfaa1c958ae1e346ed8dc1dbacb6bd3a..866830aa5528d016004e4539a0b010b8f0c5a279 100644 (file)
--- a/libmemcached/io.cc
+++ b/libmemcached/io.cc
@@ -39,7 +39,7 @@
 
 #include <libmemcached/common.h>
 
-void initialize_binary_request(memcached_server_write_instance_st server, protocol_binary_request_header& header)
+void initialize_binary_request(org::libmemcached::Instance* server, protocol_binary_request_header& header)
 {
   server->request_id++;
   header.request.magic= PROTOCOL_BINARY_REQ;
@@ -57,7 +57,7 @@ enum memc_read_or_write {
  *
  * @param ptr the server to pack
  */
-static bool repack_input_buffer(memcached_server_write_instance_st ptr)
+static bool repack_input_buffer(org::libmemcached::Instance* ptr)
 {
   if (ptr->read_ptr != ptr->read_buffer)
   {
@@ -130,7 +130,7 @@ static bool repack_input_buffer(memcached_server_write_instance_st ptr)
  * @param ptr the server to star processing iput messages for
  * @return true if we processed anything, false otherwise
  */
-static bool process_input_buffer(memcached_server_write_instance_st ptr)
+static bool process_input_buffer(org::libmemcached::Instance* ptr)
 {
   /*
    ** We might be able to process some of the response messages if we
@@ -172,7 +172,7 @@ static bool process_input_buffer(memcached_server_write_instance_st ptr)
   return false;
 }
 
-static memcached_return_t io_wait(memcached_server_write_instance_st ptr,
+static memcached_return_t io_wait(org::libmemcached::Instance* ptr,
                                   const memc_read_or_write read_or_write)
 {
   /*
@@ -294,7 +294,7 @@ static memcached_return_t io_wait(memcached_server_write_instance_st ptr,
                              memcached_literal_param("number of attempts to call io_wait() failed"));
 }
 
-static bool io_flush(memcached_server_write_instance_st ptr,
+static bool io_flush(org::libmemcached::Instance* ptr,
                      const bool with_flush,
                      memcached_return_t& error)
 {
@@ -330,7 +330,16 @@ static bool io_flush(memcached_server_write_instance_st ptr,
     WATCHPOINT_ASSERT(ptr->fd != INVALID_SOCKET);
     WATCHPOINT_ASSERT(write_length > 0);
 
-    int flags= with_flush ? MSG_NOSIGNAL|MSG_DONTWAIT : MSG_NOSIGNAL|MSG_DONTWAIT|MSG_MORE;
+    int flags;
+    if (with_flush)
+    {
+      flags= MSG_NOSIGNAL|MSG_DONTWAIT;
+    }
+    else
+    {
+      flags= MSG_NOSIGNAL|MSG_DONTWAIT|MSG_MORE;
+    }
+
     ssize_t sent_length= ::send(ptr->fd, local_write_ptr, write_length, flags);
 
     if (sent_length == SOCKET_ERROR)
@@ -396,12 +405,12 @@ static bool io_flush(memcached_server_write_instance_st ptr,
   return true;
 }
 
-memcached_return_t memcached_io_wait_for_write(memcached_server_write_instance_st ptr)
+memcached_return_t memcached_io_wait_for_write(org::libmemcached::Instance* ptr)
 {
   return io_wait(ptr, MEM_WRITE);
 }
 
-static memcached_return_t _io_fill(memcached_server_write_instance_st ptr)
+static memcached_return_t _io_fill(org::libmemcached::Instance* ptr)
 {
   ssize_t data_read;
   do
@@ -477,11 +486,11 @@ static memcached_return_t _io_fill(memcached_server_write_instance_st ptr)
   return MEMCACHED_SUCCESS;
 }
 
-memcached_return_t memcached_io_read(memcached_server_write_instance_st ptr,
+memcached_return_t memcached_io_read(org::libmemcached::Instance* ptr,
                                      void *buffer, size_t length, ssize_t& nread)
 {
   assert(memcached_is_udp(ptr->root) == false);
-  assert_msg(ptr, "Programmer error, memcached_io_read() recieved an invalid memcached_server_write_instance_st"); // Programmer error
+  assert_msg(ptr, "Programmer error, memcached_io_read() recieved an invalid Instance"); // Programmer error
   char *buffer_ptr= static_cast<char *>(buffer);
 
   if (ptr->fd == INVALID_SOCKET)
@@ -529,9 +538,9 @@ memcached_return_t memcached_io_read(memcached_server_write_instance_st ptr,
   return MEMCACHED_SUCCESS;
 }
 
-memcached_return_t memcached_io_slurp(memcached_server_write_instance_st ptr)
+memcached_return_t memcached_io_slurp(org::libmemcached::Instance* ptr)
 {
-  assert_msg(ptr, "Programmer error, invalid memcached_server_write_instance_st");
+  assert_msg(ptr, "Programmer error, invalid Instance");
   assert(memcached_is_udp(ptr->root) == false);
 
   if (ptr->fd == INVALID_SOCKET)
@@ -586,7 +595,7 @@ memcached_return_t memcached_io_slurp(memcached_server_write_instance_st ptr)
   return MEMCACHED_CONNECTION_FAILURE;
 }
 
-static bool _io_write(memcached_server_write_instance_st ptr,
+static bool _io_write(org::libmemcached::Instance* ptr,
                       const void *buffer, size_t length, bool with_flush,
                       size_t& written)
 {
@@ -639,13 +648,13 @@ static bool _io_write(memcached_server_write_instance_st ptr,
   return true;
 }
 
-bool memcached_io_write(memcached_server_write_instance_st ptr)
+bool memcached_io_write(org::libmemcached::Instance* ptr)
 {
   size_t written;
   return _io_write(ptr, NULL, 0, true, written);
 }
 
-ssize_t memcached_io_write(memcached_server_write_instance_st ptr,
+ssize_t memcached_io_write(org::libmemcached::Instance* ptr,
                            const void *buffer, const size_t length, const bool with_flush)
 {
   size_t written;
@@ -658,9 +667,9 @@ ssize_t memcached_io_write(memcached_server_write_instance_st ptr,
   return ssize_t(written);
 }
 
-bool memcached_io_writev(memcached_server_write_instance_st ptr,
-                            libmemcached_io_vector_st vector[],
-                            const size_t number_of, const bool with_flush)
+bool memcached_io_writev(org::libmemcached::Instance* ptr,
+                         libmemcached_io_vector_st vector[],
+                         const size_t number_of, const bool with_flush)
 {
   ssize_t complete_total= 0;
   ssize_t total= 0;
@@ -691,7 +700,7 @@ bool memcached_io_writev(memcached_server_write_instance_st ptr,
 }
 
 
-void memcached_io_close(memcached_server_write_instance_st ptr)
+void memcached_io_close(org::libmemcached::Instance* ptr)
 {
   if (ptr->fd == INVALID_SOCKET)
   {
@@ -714,7 +723,7 @@ void memcached_io_close(memcached_server_write_instance_st ptr)
   ptr->fd= INVALID_SOCKET;
 }
 
-memcached_server_write_instance_st memcached_io_get_readable_server(memcached_st *memc)
+org::libmemcached::Instance* memcached_io_get_readable_server(memcached_st *memc)
 {
 #define MAX_SERVERS_TO_POLL 100
   struct pollfd fds[MAX_SERVERS_TO_POLL];
@@ -722,7 +731,7 @@ memcached_server_write_instance_st memcached_io_get_readable_server(memcached_st
 
   for (uint32_t x= 0; x < memcached_server_count(memc) and host_index < MAX_SERVERS_TO_POLL; ++x)
   {
-    memcached_server_write_instance_st instance= memcached_server_instance_fetch(memc, x);
+    org::libmemcached::Instance* instance= memcached_instance_fetch(memc, x);
 
     if (instance->read_buffer_length > 0) /* I have data in the buffer */
     {
@@ -743,7 +752,7 @@ memcached_server_write_instance_st memcached_io_get_readable_server(memcached_st
     /* We have 0 or 1 server with pending events.. */
     for (uint32_t x= 0; x< memcached_server_count(memc); ++x)
     {
-      memcached_server_write_instance_st instance= memcached_server_instance_fetch(memc, x);
+      org::libmemcached::Instance* instance= memcached_instance_fetch(memc, x);
 
       if (memcached_instance_response_count(instance) > 0)
       {
@@ -770,7 +779,7 @@ memcached_server_write_instance_st memcached_io_get_readable_server(memcached_st
       {
         for (uint32_t y= 0; y < memcached_server_count(memc); ++y)
         {
-          memcached_server_write_instance_st instance= memcached_server_instance_fetch(memc, y);
+          org::libmemcached::Instance* instance= memcached_instance_fetch(memc, y);
 
           if (instance->fd == fds[x].fd)
           {
@@ -787,7 +796,7 @@ memcached_server_write_instance_st memcached_io_get_readable_server(memcached_st
 /*
   Eventually we will just kill off the server with the problem.
 */
-void memcached_io_reset(memcached_server_write_instance_st ptr)
+void memcached_io_reset(org::libmemcached::Instance* ptr)
 {
   memcached_quit_server(ptr, true);
 }
@@ -796,7 +805,7 @@ void memcached_io_reset(memcached_server_write_instance_st ptr)
  * Read a given number of bytes from the server and place it into a specific
  * buffer. Reset the IO channel on this server if an error occurs.
  */
-memcached_return_t memcached_safe_read(memcached_server_write_instance_st ptr,
+memcached_return_t memcached_safe_read(org::libmemcached::Instance* ptr,
                                        void *dta,
                                        const size_t size)
 {
@@ -821,7 +830,7 @@ memcached_return_t memcached_safe_read(memcached_server_write_instance_st ptr,
   return MEMCACHED_SUCCESS;
 }
 
-memcached_return_t memcached_io_readline(memcached_server_write_instance_st ptr,
+memcached_return_t memcached_io_readline(org::libmemcached::Instance* ptr,
                                          char *buffer_ptr,
                                          size_t size,
                                          size_t& total_nr)

diff --git a/libmemcached/io.hpp b/libmemcached/io.hpp
index bff6b83db205ae8edc6b638e48eb9ff0c035c1f6..5625ce94492134ea628a1a39b63dba64ca943774 100644 (file)
--- a/libmemcached/io.hpp
+++ b/libmemcached/io.hpp
@@ -38,37 +38,37 @@
 
 #pragma once
 
-void initialize_binary_request(memcached_server_write_instance_st server, protocol_binary_request_header&);
+void initialize_binary_request(org::libmemcached::Instance* server, protocol_binary_request_header&);
 
-bool memcached_io_write(memcached_server_write_instance_st ptr);
+bool memcached_io_write(org::libmemcached::Instance* ptr);
 
-ssize_t memcached_io_write(memcached_server_write_instance_st ptr,
+ssize_t memcached_io_write(org::libmemcached::Instance* ptr,
                            const void *buffer, size_t length, bool with_flush);
 
-bool memcached_io_writev(memcached_server_write_instance_st ptr,
+bool memcached_io_writev(org::libmemcached::Instance* ptr,
                          libmemcached_io_vector_st vector[],
                          const size_t number_of, const bool with_flush);
 
-memcached_return_t memcached_io_wait_for_write(memcached_server_write_instance_st ptr);
+memcached_return_t memcached_io_wait_for_write(org::libmemcached::Instance* ptr);
 
-void memcached_io_reset(memcached_server_write_instance_st ptr);
+void memcached_io_reset(org::libmemcached::Instance* ptr);
 
-memcached_return_t memcached_io_read(memcached_server_write_instance_st ptr,
+memcached_return_t memcached_io_read(org::libmemcached::Instance* ptr,
                                      void *buffer, size_t length, ssize_t& nread);
 
 /* Read a line (terminated by '\n') into the buffer */
-memcached_return_t memcached_io_readline(memcached_server_write_instance_st ptr,
+memcached_return_t memcached_io_readline(org::libmemcached::Instance* ptr,
                                          char *buffer_ptr,
                                          size_t size,
                                          size_t& total);
 
-void memcached_io_close(memcached_server_write_instance_st ptr);
+void memcached_io_close(org::libmemcached::Instance* ptr);
 
 /* Read n bytes of data from the server and store them in dta */
-memcached_return_t memcached_safe_read(memcached_server_write_instance_st ptr,
+memcached_return_t memcached_safe_read(org::libmemcached::Instance* ptr,
                                        void *dta,
                                        const size_t size);
 
-memcached_server_write_instance_st memcached_io_get_readable_server(memcached_st *memc);
+org::libmemcached::Instance* memcached_io_get_readable_server(memcached_st *memc);
 
-memcached_return_t memcached_io_slurp(memcached_server_write_instance_st ptr);
+memcached_return_t memcached_io_slurp(org::libmemcached::Instance* ptr);

diff --git a/libmemcached/is.h b/libmemcached/is.h
index 4c4d6f314301777aaa3f5594fc052c787af09185..126bc9a71566f921f18ccf6df04b49a27e102343 100644 (file)
--- a/libmemcached/is.h
+++ b/libmemcached/is.h
@@ -40,15 +40,43 @@
 /* These are private */ 
 #define memcached_is_allocated(__object) ((__object)->options.is_allocated)
 #define memcached_is_encrypted(__object) ((__object)->hashkit._key)
-#define memcached_is_udp(__object) ((__object)->flags.use_udp)
-#define memcached_is_verify_key(__object) ((__object)->flags.verify_key)
-#define memcached_is_binary(__object) ((__object)->flags.binary_protocol)
 #define memcached_is_initialized(__object) ((__object)->options.is_initialized)
 #define memcached_is_purging(__object) ((__object)->state.is_purging)
 #define memcached_is_processing_input(__object) ((__object)->state.is_processing_input)
 
+#define memcached_is_aes(__object) ((__object)->flags.is_aes)
+#define memcached_is_udp(__object) ((__object)->flags.use_udp)
+#define memcached_is_verify_key(__object) ((__object)->flags.verify_key)
+#define memcached_is_binary(__object) ((__object)->flags.binary_protocol)
+#define memcached_is_fetching_version(__object) ((__object)->flags.is_fetching_version)
 #define memcached_is_buffering(__object) ((__object)->flags.buffer_requests)
 #define memcached_is_replying(__object) ((__object)->flags.reply)
+#define memcached_is_cas(__object) ((__object)->flags.reply)
+#define memcached_is_randomize_replica_read(__object) ((__object)->flags.randomize_replica_read)
+#define memcached_is_no_block(__object) ((__object)->flags.no_block)
+#define memcached_is_hash_with_namespace(__object) ((__object)->flags.hash_with_namespace)
+#define memcached_is_tcp_nodelay(__object) ((__object)->flags.tcp_nodelay)
+#define memcached_is_auto_eject_hosts(__object) ((__object)->flags.auto_eject_hosts)
+#define memcached_is_use_sort_hosts(__object) ((__object)->flags.use_sort_hosts)
+
+#define memcached_is_weighted_ketama(__object) ((__object)->ketama.weighted_)
+
+#define memcached_set_aes(__object, __flag) ((__object).flags.is_aes= __flag)
+#define memcached_set_udp(__object, __flag) ((__object).flags.use_udp= __flag)
+#define memcached_set_verify_key(__object, __flag) ((__object).flags.verify_key= __flag)
+#define memcached_set_binary(__object, __flag) ((__object).flags.binary_protocol= __flag)
+#define memcached_set_fetching_version(__object, __flag) ((__object).flags.is_fetching_version= __flag)
+#define memcached_set_buffering(__object, __flag) ((__object).flags.buffer_requests= __flag)
+#define memcached_set_replying(__object, __flag) ((__object).flags.reply= __flag)
+#define memcached_set_cas(__object, __flag) ((__object).flags.reply= __flag)
+#define memcached_set_randomize_replica_read(__object, __flag) ((__object).flags.randomize_replica_read= __flag)
+#define memcached_set_no_block(__object, __flag) ((__object).flags.no_block= __flag)
+#define memcached_set_hash_with_namespace(__object, __flag) ((__object).flags.hash_with_namespace= __flag)
+#define memcached_set_tcp_nodelay(__object, __flag) ((__object).flags.tcp_nodelay= __flag)
+#define memcached_set_auto_eject_hosts(__object, __flag) ((__object).flags.auto_eject_hosts= __flag)
+#define memcached_set_use_sort_hosts(__object, __flag) ((__object).flags.use_sort_hosts= __flag)
+
+#define memcached_has_root(__object) ((__object)->root)
 
 #define memcached_has_error(__object) ((__object)->error_messages)
 
@@ -57,3 +85,5 @@
 #define memcached_set_processing_input(__object, __value) ((__object)->state.is_processing_input= (__value))
 #define memcached_set_initialized(__object, __value) ((__object)->options.is_initialized(= (__value))
 #define memcached_set_allocated(__object, __value) ((__object)->options.is_allocated= (__value))
+
+#define memcached_set_weighted_ketama(__object, __value) ((__object)->ketama.weighted_= (__value))

diff --git a/libmemcached/memcached.cc b/libmemcached/memcached.cc
index 0574cc6cb40ae46fc36f9acac8a69c3d36dccac5..c52873ad3d4fcbccecb86ded6961a9844dc48dcf 100644 (file)
--- a/libmemcached/memcached.cc
+++ b/libmemcached/memcached.cc
@@ -59,6 +59,8 @@ static inline bool _memcached_init(memcached_st *self)
   self->flags.use_udp= false;
   self->flags.verify_key= false;
   self->flags.tcp_keepalive= false;
+  self->flags.is_aes= false;
+  self->flags.is_fetching_version= false;
 
   self->virtual_bucket= NULL;
 
@@ -75,7 +77,7 @@ static inline bool _memcached_init(memcached_st *self)
   self->ketama.continuum_count= 0;
   self->ketama.continuum_points_counter= 0;
   self->ketama.next_distribution_rebuild= 0;
-  self->ketama.weighted= false;
+  self->ketama.weighted_= false;
 
   self->number_of_hosts= 0;
   self->servers= NULL;
@@ -133,7 +135,7 @@ static void __memcached_free(memcached_st *ptr, bool release_st)
 
   memcached_virtual_bucket_free(ptr);
 
-  memcached_instance_free(ptr->last_disconnected_server);
+  memcached_instance_free((org::libmemcached::Instance*)ptr->last_disconnected_server);
 
   if (ptr->on_cleanup)
   {
@@ -279,7 +281,7 @@ void memcached_servers_reset(memcached_st *self)
 
     memcached_instance_set(self, NULL);
     self->number_of_hosts= 0;
-    memcached_instance_free(self->last_disconnected_server);
+    memcached_instance_free((org::libmemcached::Instance*)self->last_disconnected_server);
     self->last_disconnected_server= NULL;
   }
 }
@@ -288,7 +290,7 @@ void memcached_reset_last_disconnected_server(memcached_st *self)
 {
   if (self)
   {
-    memcached_instance_free(self->last_disconnected_server);
+    memcached_instance_free((org::libmemcached::Instance*)self->last_disconnected_server);
     self->last_disconnected_server= NULL;
   }
 }
@@ -421,10 +423,10 @@ void *memcached_set_user_data(memcached_st *ptr, void *data)
 
 memcached_return_t memcached_push(memcached_st *destination, const memcached_st *source)
 {
-  return memcached_instance_push(destination, source->servers, source->number_of_hosts);
+  return memcached_instance_push(destination, (org::libmemcached::Instance*)source->servers, source->number_of_hosts);
 }
 
-memcached_server_write_instance_st memcached_server_instance_fetch(memcached_st *ptr, uint32_t server_key)
+org::libmemcached::Instance* memcached_instance_fetch(memcached_st *ptr, uint32_t server_key)
 {
   if (ptr == NULL)
   {
@@ -444,6 +446,16 @@ memcached_server_instance_st memcached_server_instance_by_position(const memcach
   return &ptr->servers[server_key];
 }
 
+org::libmemcached::Instance* memcached_instance_by_position(const memcached_st *ptr, uint32_t server_key)
+{
+  if (ptr == NULL)
+  {
+    return NULL;
+  }
+
+  return &ptr->servers[server_key];
+}
+
 uint64_t memcached_query_id(const memcached_st *self)
 {
   if (self == NULL)
@@ -453,3 +465,14 @@ uint64_t memcached_query_id(const memcached_st *self)
 
   return self->query_id;
 }
+
+org::libmemcached::Instance* memcached_instance_list(const memcached_st *self)
+{
+  if (self)
+  {
+    return (org::libmemcached::Instance*)self->servers;
+  }
+
+  return NULL;
+}
+

diff --git a/libmemcached/purge.cc b/libmemcached/purge.cc
index 841af82ebe5c989170cfeb811c16dfb9d8a60a43..b45e02a4a67738957498137f2177b9acf80e4788 100644 (file)
--- a/libmemcached/purge.cc
+++ b/libmemcached/purge.cc
@@ -79,7 +79,7 @@ private:
   int32_t& _origin;
 };
 
-bool memcached_purge(memcached_server_write_instance_st ptr)
+bool memcached_purge(org::libmemcached::Instance* ptr)
 {
   memcached_st *root= (memcached_st *)ptr->root;
 

diff --git a/libmemcached/quit.cc b/libmemcached/quit.cc
index 4bf72f64adf94b985e4a2eb9506414de171122a5..77924fb4930ee277bf4c3a506e8bd6d0ca78884c 100644 (file)
--- a/libmemcached/quit.cc
+++ b/libmemcached/quit.cc
@@ -46,7 +46,7 @@
   will force data to be completed.
 */
 
-void memcached_quit_server(memcached_instance_st *ptr, bool io_death)
+void memcached_quit_server(org::libmemcached::Instance* ptr, bool io_death)
 {
   if (ptr->fd != INVALID_SOCKET)
   {
@@ -116,7 +116,7 @@ void memcached_quit_server(memcached_instance_st *ptr, bool io_death)
   }
 
   ptr->state= MEMCACHED_SERVER_STATE_NEW;
-  ptr->cursor_active= 0;
+  ptr->cursor_active_= 0;
   ptr->io_bytes_sent= 0;
   ptr->write_buffer_offset= size_t(ptr->root and memcached_is_udp(ptr->root) ? UDP_DATAGRAM_HEADER_LENGTH : 0);
   ptr->read_buffer_length= 0;
@@ -138,8 +138,7 @@ void send_quit(memcached_st *ptr)
 {
   for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
   {
-    memcached_server_write_instance_st instance=
-      memcached_server_instance_fetch(ptr, x);
+    org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, x);
 
     memcached_quit_server(instance, false);
   }

diff --git a/libmemcached/quit.hpp b/libmemcached/quit.hpp
index 888cde46ae40f63b54b8cc9c7f49fa27f008e00c..76737b9551667b41775b96357f8002c1abc40dec 100644 (file)
--- a/libmemcached/quit.hpp
+++ b/libmemcached/quit.hpp
@@ -36,6 +36,6 @@
 
 #pragma once
 
-void memcached_quit_server(memcached_instance_st *ptr, bool io_death);
+void memcached_quit_server(org::libmemcached::Instance* ptr, bool io_death);
 
 void send_quit(memcached_st *ptr);

diff --git a/libmemcached/response.cc b/libmemcached/response.cc
index 809d5b6fb7606793b71d06c9c60e21e47d515958..67b0999f7f2afff67e462ec9c2c5a4894577aea8 100644 (file)
--- a/libmemcached/response.cc
+++ b/libmemcached/response.cc
@@ -38,7 +38,7 @@
 #include <libmemcached/common.h>
 #include <libmemcached/string.hpp>
 
-static memcached_return_t textual_value_fetch(memcached_server_write_instance_st instance,
+static memcached_return_t textual_value_fetch(org::libmemcached::Instance* instance,
                                               char *buffer,
                                               memcached_result_st *result)
 {
@@ -207,7 +207,7 @@ read_error:
   return MEMCACHED_PARTIAL_READ;
 }
 
-static memcached_return_t textual_read_one_response(memcached_server_write_instance_st instance,
+static memcached_return_t textual_read_one_response(org::libmemcached::Instance* instance,
                                                     char *buffer, const size_t buffer_length,
                                                     memcached_result_st *result)
 {
@@ -470,7 +470,7 @@ static memcached_return_t textual_read_one_response(memcached_server_write_insta
                              buffer, total_read);
 }
 
-static memcached_return_t binary_read_one_response(memcached_server_write_instance_st instance,
+static memcached_return_t binary_read_one_response(org::libmemcached::Instance* instance,
                                                    char *buffer, const size_t buffer_length,
                                                    memcached_result_st *result)
 {
@@ -787,7 +787,7 @@ static memcached_return_t binary_read_one_response(memcached_server_write_instan
   return rc;
 }
 
-static memcached_return_t _read_one_response(memcached_server_write_instance_st instance,
+static memcached_return_t _read_one_response(org::libmemcached::Instance* instance,
                                              char *buffer, const size_t buffer_length,
                                              memcached_result_st *result)
 {
@@ -817,7 +817,7 @@ static memcached_return_t _read_one_response(memcached_server_write_instance_st
   return rc;
 }
 
-memcached_return_t memcached_read_one_response(memcached_server_write_instance_st instance,
+memcached_return_t memcached_read_one_response(org::libmemcached::Instance* instance,
                                                memcached_result_st *result)
 {
   char buffer[SMALL_STRING_LEN];
@@ -831,7 +831,7 @@ memcached_return_t memcached_read_one_response(memcached_server_write_instance_s
   return _read_one_response(instance, buffer, sizeof(buffer), result);
 }
 
-memcached_return_t memcached_response(memcached_server_write_instance_st instance,
+memcached_return_t memcached_response(org::libmemcached::Instance* instance,
                                       memcached_result_st *result)
 {
   char buffer[1024];
@@ -839,7 +839,7 @@ memcached_return_t memcached_response(memcached_server_write_instance_st instanc
   return memcached_response(instance, buffer, sizeof(buffer), result);
 }
 
-memcached_return_t memcached_response(memcached_server_write_instance_st instance,
+memcached_return_t memcached_response(org::libmemcached::Instance* instance,
                                       char *buffer, size_t buffer_length,
                                       memcached_result_st *result)
 {

diff --git a/libmemcached/response.h b/libmemcached/response.h
index 8827aea043a84a9a60661010f07387865cf223ba..6d6d56442584946c8ab34fb37ba927125a61aa38 100644 (file)
--- a/libmemcached/response.h
+++ b/libmemcached/response.h
@@ -38,12 +38,12 @@
 #pragma once
 
 /* Read a single response from the server */
-memcached_return_t memcached_read_one_response(memcached_server_write_instance_st ptr,
+memcached_return_t memcached_read_one_response(org::libmemcached::Instance* ptr,
                                                memcached_result_st *result);
 
-memcached_return_t memcached_response(memcached_server_write_instance_st ptr,
+memcached_return_t memcached_response(org::libmemcached::Instance* ptr,
                                       memcached_result_st *result);
 
-memcached_return_t memcached_response(memcached_server_write_instance_st ptr,
+memcached_return_t memcached_response(org::libmemcached::Instance* ptr,
                                       char *buffer, size_t buffer_length,
                                       memcached_result_st *result);

diff --git a/libmemcached/sasl.cc b/libmemcached/sasl.cc
index cb609257cac36dc634e9ccef3be56d5ff6697695..67a31bbd132c5f4f5ac73779df1887c2e215c5ce 100644 (file)
--- a/libmemcached/sasl.cc
+++ b/libmemcached/sasl.cc
@@ -123,7 +123,7 @@ static void sasl_startup_function(void)
 
 } // extern "C"
 
-memcached_return_t memcached_sasl_authenticate_connection(memcached_instance_st *server)
+memcached_return_t memcached_sasl_authenticate_connection(org::libmemcached::Instance* server)
 {
   if (LIBMEMCACHED_WITH_SASL_SUPPORT == 0)
   {

diff --git a/libmemcached/sasl.hpp b/libmemcached/sasl.hpp
index c5d3f81c236ca92931474329d4704d3703f84d07..c990cfb88fce3638415609dc1fe28d77daff5227 100644 (file)
--- a/libmemcached/sasl.hpp
+++ b/libmemcached/sasl.hpp
@@ -39,4 +39,4 @@
 
 memcached_return_t memcached_clone_sasl(memcached_st *clone, const  memcached_st *source);
 
-memcached_return_t memcached_sasl_authenticate_connection(memcached_instance_st *server);
+memcached_return_t memcached_sasl_authenticate_connection(org::libmemcached::Instance* server);

diff --git a/libmemcached/server.cc b/libmemcached/server.cc
index a9d7c7284184ff3111a0c87b73d958486692b8f2..f68e1f6b81bf3ad734fc8535540cb5d869c3319a 100644 (file)
--- a/libmemcached/server.cc
+++ b/libmemcached/server.cc
@@ -106,7 +106,7 @@ static memcached_server_st *_server_create(memcached_server_st *self, const memc
 }
 
 memcached_server_st *__server_create_with(memcached_st *memc,
-                                          memcached_server_st* self,
+                                          memcached_server_st* allocated_instance,
                                           const memcached_string_t& hostname,
                                           const in_port_t port,
                                           uint32_t weight, 
@@ -118,16 +118,16 @@ memcached_server_st *__server_create_with(memcached_st *memc,
     return NULL;
   }
 
-  self= _server_create(self, memc);
+  allocated_instance= _server_create(allocated_instance, memc);
 
-  if (self == NULL)
+  if (allocated_instance == NULL)
   {
     return NULL;
   }
 
-  _server_init(self, const_cast<memcached_st *>(memc), hostname, port, weight, type);
+  _server_init(allocated_instance, const_cast<memcached_st *>(memc), hostname, port, weight, type);
 
-  return self;
+  return allocated_instance;
 }
 
 void __server_free(memcached_server_st *self)
@@ -208,7 +208,7 @@ in_port_t memcached_server_port(const memcached_server_instance_st self)
     return 0;
   }
 
-  return self->port;
+  return self->port();
 }
 
 uint32_t memcached_server_response_count(const memcached_server_instance_st self)
@@ -219,7 +219,7 @@ uint32_t memcached_server_response_count(const memcached_server_instance_st self
     return 0;
   }
 
-  return self->cursor_active;
+  return self->cursor_active_;
 }
 
 const char *memcached_server_type(const memcached_server_instance_st ptr)

diff --git a/libmemcached/server.hpp b/libmemcached/server.hpp
index 191402e8a8b56a66f17e444fa7c3470d0445716c..74816fdc1af1457b34378e84c0061d19803b8d9e 100644 (file)
--- a/libmemcached/server.hpp
+++ b/libmemcached/server.hpp
@@ -63,17 +63,11 @@ static inline bool memcached_is_valid_servername(const memcached_string_t& arg)
   return arg.size > 0 or arg.size < NI_MAXHOST;
 }
 
-static inline void memcached_mark_server_as_clean(memcached_server_write_instance_st server)
-{
-  server->server_failure_counter= 0;
-  server->next_retry= 0;
-}
-
-void memcached_instance_free(memcached_instance_st *);
+void memcached_instance_free(org::libmemcached::Instance *);
 
-void set_last_disconnected_host(memcached_server_write_instance_st self);
+void set_last_disconnected_host(org::libmemcached::Instance* self);
 
-static inline void memcached_mark_server_for_timeout(memcached_server_write_instance_st server)
+static inline void memcached_mark_server_for_timeout(org::libmemcached::Instance* server)
 {
   if (server->state != MEMCACHED_SERVER_STATE_IN_TIMEOUT)
   {

diff --git a/libmemcached/server_instance.h b/libmemcached/server_instance.h
index 69613499072e20885f8a5078f364ff94bbadfdbe..c840384ab3a4216797eebfdc08e48a8c94a60a95 100644 (file)
--- a/libmemcached/server_instance.h
+++ b/libmemcached/server_instance.h
@@ -38,11 +38,7 @@
 #pragma once
 
 #ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct memcached_instance_st * memcached_server_write_instance_st;
-
-#ifdef __cplusplus
-}
+typedef struct org::libmemcached::Instance* memcached_server_write_instance_st;
+#else
+typedef void* memcached_server_write_instance_st;
 #endif

diff --git a/libmemcached/server_list.cc b/libmemcached/server_list.cc
index d2a00922594e9c13fe555d811a838caec37d6244..8205edc90cf21a2179e0d9528f571c9f5b876774 100644 (file)
--- a/libmemcached/server_list.cc
+++ b/libmemcached/server_list.cc
@@ -89,6 +89,7 @@ memcached_server_list_append_with_weight(memcached_server_list_st ptr,
 #if 0
     *error= memcached_set_errno(*ptr, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT);
 #endif
+    free(new_host_list);
     return NULL;
   }
 
@@ -126,26 +127,9 @@ uint32_t memcached_instance_list_count(const memcached_st* self)
     : self->number_of_hosts;
 }
 
-uint32_t memcached_instance_count(const memcached_instance_st* self)
+void memcached_instance_set(memcached_st* memc, org::libmemcached::Instance* list)
 {
-  return (self == NULL)
-    ? 0
-    : self->number_of_hosts;
-}
-
-memcached_instance_st *memcached_instance_list(const memcached_st *self)
-{
-  if (self)
-  {
-    return self->servers;
-  }
-
-  return NULL;
-}
-
-void memcached_instance_set(memcached_st *self, memcached_instance_st *list)
-{
-  self->servers= list;
+  memc->servers= list;
 }
 
 void memcached_server_list_free(memcached_server_list_st self)
@@ -164,7 +148,7 @@ void memcached_server_list_free(memcached_server_list_st self)
   libmemcached_free(self->root, self);
 }
 
-void memcached_instance_list_free(memcached_instance_st* self, uint32_t instance_count)
+void memcached_instance_list_free(org::libmemcached::Instance* self, uint32_t instance_count)
 {
   if (self == NULL)
   {

diff --git a/libmemcached/server_list.hpp b/libmemcached/server_list.hpp
index 3dfe5fee84042ef9baf30c358e028eb1a9005955..95920194b5d6913313e68a01c3aa835b763c6158 100644 (file)
--- a/libmemcached/server_list.hpp
+++ b/libmemcached/server_list.hpp
@@ -36,14 +36,12 @@
 
 #pragma once
 
-memcached_instance_st *memcached_instance_list(const memcached_st *);
-
-uint32_t memcached_instance_count(const memcached_instance_st*);
+org::libmemcached::Instance* memcached_instance_list(const memcached_st *);
 
 uint32_t memcached_instance_list_count(const memcached_st*);
 
 uint32_t memcached_servers_set_count(memcached_server_list_st servers, uint32_t count);
 
-void memcached_instance_list_free(memcached_instance_st* self, uint32_t count);
+void memcached_instance_list_free(org::libmemcached::Instance* self, uint32_t count);
 
-void memcached_instance_set(memcached_st *self, memcached_instance_st* list);
+void memcached_instance_set(memcached_st*, org::libmemcached::Instance*);

diff --git a/libmemcached/stats.cc b/libmemcached/stats.cc
index cfe870b9985c7f7d817638f6fb698dc113713183..ab00d4b8051363f891a6853f743d10db61c15619 100644 (file)
--- a/libmemcached/stats.cc
+++ b/libmemcached/stats.cc
@@ -346,7 +346,7 @@ char *memcached_stat_get_value(const memcached_st *ptr, memcached_stat_st *memc_
 static memcached_return_t binary_stats_fetch(memcached_stat_st *memc_stat,
                                              const char *args,
                                              const size_t args_length,
-                                             memcached_server_write_instance_st instance,
+                                             org::libmemcached::Instance* instance,
                                              struct local_context *check)
 {
   char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
@@ -428,7 +428,7 @@ static memcached_return_t binary_stats_fetch(memcached_stat_st *memc_stat,
    * memcached_response will decrement the counter, so I need to reset it..
    * todo: look at this and try to find a better solution.  
    * */
-  instance->cursor_active= 0;
+  instance->cursor_active_= 0;
 
   return MEMCACHED_SUCCESS;
 }
@@ -436,7 +436,7 @@ static memcached_return_t binary_stats_fetch(memcached_stat_st *memc_stat,
 static memcached_return_t ascii_stats_fetch(memcached_stat_st *memc_stat,
                                             const char *args,
                                             const size_t args_length,
-                                            memcached_server_write_instance_st instance,
+                                            org::libmemcached::Instance* instance,
                                             struct local_context *check)
 {
   libmemcached_io_vector_st vector[]=
@@ -552,7 +552,7 @@ memcached_stat_st *memcached_stat(memcached_st *self, char *args, memcached_retu
     stat_instance->pid= -1;
     stat_instance->root= self;
 
-    memcached_server_write_instance_st instance= memcached_server_instance_fetch(self, x);
+    org::libmemcached::Instance* instance= memcached_instance_fetch(self, x);
 
     memcached_return_t temp_return;
     if (memcached_is_binary(self))
@@ -613,7 +613,7 @@ memcached_return_t memcached_stat_servername(memcached_stat_st *memc_stat, char
 
     if (memcached_success(rc))
     {
-      memcached_server_write_instance_st instance= memcached_server_instance_fetch(memc_ptr, 0);
+      org::libmemcached::Instance* instance= memcached_instance_fetch(memc_ptr, 0);
       if (memc.flags.binary_protocol)
       {
         rc= binary_stats_fetch(memc_stat, args, args_length, instance, NULL);
@@ -675,7 +675,7 @@ void memcached_stat_free(const memcached_st *, memcached_stat_st *memc_stat)
 }
 
 static memcached_return_t call_stat_fn(memcached_st *ptr,
-                                       memcached_server_write_instance_st instance,
+                                       org::libmemcached::Instance* instance,
                                        void *context)
 {
   memcached_return_t rc;

diff --git a/libmemcached/storage.cc b/libmemcached/storage.cc
index 88d87fe36ec1aaaa0abe6f6235e39234deb2a015..cd29670df1183750e66358668dad3e223125a823 100644 (file)
--- a/libmemcached/storage.cc
+++ b/libmemcached/storage.cc
@@ -139,7 +139,7 @@ static inline uint8_t get_com_code(const memcached_storage_action_t verb, const
 }
 
 static memcached_return_t memcached_send_binary(memcached_st *ptr,
-                                                memcached_server_write_instance_st server,
+                                                org::libmemcached::Instance* server,
                                                 uint32_t server_key,
                                                 const char *key,
                                                 const size_t key_length,
@@ -217,7 +217,7 @@ static memcached_return_t memcached_send_binary(memcached_st *ptr,
         server_key= 0;
       }
 
-      memcached_server_write_instance_st instance= memcached_server_instance_fetch(ptr, server_key);
+      org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, server_key);
 
       if (memcached_vdo(instance, vector, 5, false) != MEMCACHED_SUCCESS)
       {
@@ -245,7 +245,7 @@ static memcached_return_t memcached_send_binary(memcached_st *ptr,
 }
 
 static memcached_return_t memcached_send_ascii(memcached_st *ptr,
-                                               memcached_server_write_instance_st instance,
+                                               org::libmemcached::Instance* instance,
                                                const char *key,
                                                const size_t key_length,
                                                const char *value,
@@ -371,7 +371,7 @@ static inline memcached_return_t memcached_send(memcached_st *ptr,
   }
 
   uint32_t server_key= memcached_generate_hash_with_redistribution(ptr, group_key, group_key_length);
-  memcached_server_write_instance_st instance= memcached_server_instance_fetch(ptr, server_key);
+  org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, server_key);
 
   WATCHPOINT_SET(instance->io_wait_count.read= 0);
   WATCHPOINT_SET(instance->io_wait_count.write= 0);

diff --git a/libmemcached/touch.cc b/libmemcached/touch.cc
index 757ddfdfa1426f92d9d6da92f59a61afb3988673..7a8c7cee57659bed33a4f8e2ffdb6c28b001221b 100644 (file)
--- a/libmemcached/touch.cc
+++ b/libmemcached/touch.cc
@@ -38,7 +38,7 @@
 #include <libmemcached/common.h>
 #include <libmemcached/memcached/protocol_binary.h>
 
-static memcached_return_t ascii_touch(memcached_server_write_instance_st instance,
+static memcached_return_t ascii_touch(org::libmemcached::Instance* instance,
                                       const char *key, size_t key_length,
                                       time_t expiration)
 {
@@ -70,7 +70,7 @@ static memcached_return_t ascii_touch(memcached_server_write_instance_st instanc
   return rc;
 }
 
-static memcached_return_t binary_touch(memcached_server_write_instance_st instance,
+static memcached_return_t binary_touch(org::libmemcached::Instance* instance,
                                        const char *key, size_t key_length,
                                        time_t expiration)
 {
@@ -129,7 +129,7 @@ memcached_return_t memcached_touch_by_key(memcached_st *ptr,
   }
 
   uint32_t server_key= memcached_generate_hash_with_redistribution(ptr, group_key, group_key_length);
-  memcached_server_write_instance_st instance= memcached_server_instance_fetch(ptr, server_key);
+  org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, server_key);
 
   if (ptr->flags.binary_protocol)
   {

diff --git a/libmemcached/udp.cc b/libmemcached/udp.cc
index 905eedd78c53aa2f8c79d277602f4689c38a72dc..923e2734569326a38f70b51b8640d0806011ebc5 100644 (file)
--- a/libmemcached/udp.cc
+++ b/libmemcached/udp.cc
@@ -48,7 +48,7 @@
  * extracts the message number from message_id, increments it and then
  * writes the new value back into the header
  */
-void increment_udp_message_id(memcached_server_write_instance_st ptr)
+void increment_udp_message_id(org::libmemcached::Instance* ptr)
 {
   struct udp_datagram_header_st *header= (struct udp_datagram_header_st *)ptr->write_buffer;
   uint16_t cur_req= get_udp_datagram_request_id(header);
@@ -61,7 +61,7 @@ void increment_udp_message_id(memcached_server_write_instance_st ptr)
   header->request_id= htons((uint16_t) (thread_id | msg_num));
 }
 
-bool memcached_io_init_udp_header(memcached_server_write_instance_st ptr, const uint16_t thread_id)
+bool memcached_io_init_udp_header(org::libmemcached::Instance* ptr, const uint16_t thread_id)
 {
   if (thread_id > UDP_REQUEST_ID_MAX_THREAD_ID)
   {

diff --git a/libmemcached/udp.hpp b/libmemcached/udp.hpp
index 9cc53889c96e93a59d66fc4f5ef1fdbfcf6becd3..b2d2e9e9a51925ca6a191a98885cc4605bf34622 100644 (file)
--- a/libmemcached/udp.hpp
+++ b/libmemcached/udp.hpp
@@ -55,5 +55,5 @@ struct udp_datagram_header_st
   uint16_t reserved;
 };
 
-bool memcached_io_init_udp_header(memcached_server_write_instance_st ptr, const uint16_t thread_id);
-void increment_udp_message_id(memcached_server_write_instance_st ptr);
+bool memcached_io_init_udp_header(org::libmemcached::Instance*, const uint16_t thread_id);
+void increment_udp_message_id(org::libmemcached::Instance*);

diff --git a/libmemcached/verbosity.cc b/libmemcached/verbosity.cc
index 7b05ef42ddcc4f0a681a5fdad4b98a2ed865fc39..4a9918d25f82aeb0f675be0d1f6ff8ef52451ea4 100644 (file)
--- a/libmemcached/verbosity.cc
+++ b/libmemcached/verbosity.cc
@@ -56,7 +56,7 @@ static memcached_return_t _set_verbosity(const memcached_st *,
 
   if (rc == MEMCACHED_SUCCESS)
   {
-    memcached_server_write_instance_st instance= memcached_server_instance_fetch(memc_ptr, 0);
+    org::libmemcached::Instance* instance= memcached_instance_fetch(memc_ptr, 0);
 
 
     rc= memcached_vdo(instance, vector, 4, true);

diff --git a/libmemcached/version.cc b/libmemcached/version.cc
index 9f41c97ae6ac10e7224cb576d81027dc21615fd7..e9a54050977de0843004f1e3e41dcc196d0f9c86 100644 (file)
--- a/libmemcached/version.cc
+++ b/libmemcached/version.cc
@@ -52,7 +52,7 @@ static inline memcached_return_t memcached_version_textual(memcached_st *ptr)
   bool errors_happened= false;
   for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
   {
-    memcached_server_write_instance_st instance= memcached_server_instance_fetch(ptr, x);
+    org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, x);
 
     // Optimization, we only fetch version once.
     if (instance->major_version != UINT8_MAX)
@@ -73,7 +73,7 @@ static inline memcached_return_t memcached_version_textual(memcached_st *ptr)
   if (success)
   {
     // Collect the returned items
-    memcached_server_write_instance_st instance;
+    org::libmemcached::Instance* instance;
     while ((instance= memcached_io_get_readable_server(ptr)))
     {
       memcached_return_t rrc= memcached_response(instance, NULL);
@@ -104,7 +104,7 @@ static inline memcached_return_t memcached_version_binary(memcached_st *ptr)
   bool errors_happened= false;
   for (uint32_t x= 0; x < memcached_server_count(ptr); x++) 
   {
-    memcached_server_write_instance_st instance= memcached_server_instance_fetch(ptr, x);
+    org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, x);
 
     initialize_binary_request(instance, request.message.header);
 
@@ -127,7 +127,7 @@ static inline memcached_return_t memcached_version_binary(memcached_st *ptr)
   if (success)
   {
     // Collect the returned items
-    memcached_server_write_instance_st instance;
+    org::libmemcached::Instance* instance;
     while ((instance= memcached_io_get_readable_server(ptr)))
     {
       char buffer[32];
@@ -143,23 +143,85 @@ static inline memcached_return_t memcached_version_binary(memcached_st *ptr)
   return errors_happened ? MEMCACHED_SOME_ERRORS : MEMCACHED_SUCCESS;
 }
 
-memcached_return_t memcached_version(memcached_st *ptr)
+static inline void version_ascii_instance(org::libmemcached::Instance* instance)
 {
-  memcached_return_t rc;
-  if (memcached_failed(rc= initialize_query(ptr, true)))
+  if (instance->major_version != UINT8_MAX)
   {
-    return rc;
+    libmemcached_io_vector_st vector[]=
+    {
+      { memcached_literal_param("version\r\n") },
+    };
+
+    (void)memcached_vdo(instance, vector, 1, false);
   }
+}
 
-  if (memcached_is_udp(ptr))
+static inline void version_binary_instance(org::libmemcached::Instance* instance)
+{
+  if (instance->major_version != UINT8_MAX)
   {
-    return MEMCACHED_NOT_SUPPORTED;
+    protocol_binary_request_version request= {};
+
+    request.message.header.request.opcode= PROTOCOL_BINARY_CMD_VERSION;
+    request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES;
+
+    libmemcached_io_vector_st vector[]=
+    {
+      { request.bytes, sizeof(request.bytes) }
+    };
+
+    initialize_binary_request(instance, request.message.header);
+
+    (void)memcached_vdo(instance, vector, 1, false);
+  }
+}
+
+void memcached_version_instance(org::libmemcached::Instance* instance)
+{
+  if (instance)
+  {
+    if (memcached_has_root(instance))
+    {
+      if (memcached_is_fetching_version(instance->root))
+      {
+        if (memcached_is_udp(instance->root) == false)
+        {
+
+          if (memcached_is_binary(instance->root))
+          {
+            version_binary_instance(instance);
+            return;
+          }
+
+          version_ascii_instance(instance);      
+        }
+      }
+    }
   }
+}
 
-  if (memcached_is_binary(ptr))
+memcached_return_t memcached_version(memcached_st *ptr)
+{
+  if (ptr)
   {
-    return memcached_version_binary(ptr);
+    memcached_return_t rc;
+    if (memcached_failed(rc= initialize_query(ptr, true)))
+    {
+      return rc;
+    }
+
+    if (memcached_is_udp(ptr))
+    {
+      return MEMCACHED_NOT_SUPPORTED;
+    }
+
+    if (memcached_is_binary(ptr))
+    {
+      return memcached_version_binary(ptr);
+    }
+
+    return memcached_version_textual(ptr);      
   }
 
-  return memcached_version_textual(ptr);      
+  return MEMCACHED_INVALID_ARGUMENTS;
 }

diff --git a/libmemcached/version.hpp b/libmemcached/version.hpp
new file mode 100644 (file)
index 0000000..b4a8234
--- /dev/null
+++ b/libmemcached/version.hpp
@@ -0,0 +1,44 @@
+/*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ * 
+ *  LibMemcached
+ *
+ *  Copyright (C) 2012 Data Differential, http://datadifferential.com/ All
+ *  rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions are
+ *  met:
+ *
+ *      * Redistributions of source code must retain the above copyright
+ *  notice, this list of conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above
+ *  copyright notice, this list of conditions and the following disclaimer
+ *  in the documentation and/or other materials provided with the
+ *  distribution.
+ *
+ *      * The names of its contributors may not be used to endorse or
+ *  promote products derived from this software without specific prior
+ *  written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+/*
+  Common include file for libmemached
+*/
+
+#pragma once
+
+void memcached_version_instance(org::libmemcached::Instance*);

diff --git a/libtest/port.cc b/libtest/port.cc
index 17e03e494b6ca01f330db4adb6afe02d256055d4..01e0e88b34426e1f014db5fd43346903d004570e 100644 (file)
--- a/libtest/port.cc
+++ b/libtest/port.cc
@@ -120,7 +120,7 @@ in_port_t get_free_port()
 
   int retries= 1024;
 
-  while (retries--)
+  while (--retries)
   {
     int sd;
     if ((sd= socket(AF_INET, SOCK_STREAM, 0)) != -1)
@@ -155,11 +155,21 @@ in_port_t get_free_port()
   }
 
   // We handle the case where if we max out retries, we still abort.
-  if (ret_port <= 1024)
+  if (retries == 0)
+  {
+    fatal_message("No port could be found, exhausted retry");
+  }
+
+  if (ret_port == 0)
   {
     fatal_message("No port could be found");
   }
 
+  if (ret_port <= 1024)
+  {
+    fatal_message("No port could be found, though some where available below or at 1024");
+  }
+
   return ret_port;
 }
 

diff --git a/libtest/server_container.cc b/libtest/server_container.cc
index 2bea1ad96bac82040aed43edaf3380e5cf7dea82..6973937bc6f8749de1ef7da815c027336fd1ba0f 100644 (file)
--- a/libtest/server_container.cc
+++ b/libtest/server_container.cc
@@ -99,7 +99,6 @@ Server* server_startup_st::pop_server()
 // host_to_shutdown => host number to shutdown in array
 bool server_startup_st::shutdown(uint32_t host_to_shutdown)
 {
-  Error << servers.size() << " > " << host_to_shutdown;
   if (servers.size() > host_to_shutdown)
   {
     Server* tmp= servers[host_to_shutdown];

diff --git a/m4/bottom.m4 b/m4/bottom.m4
index a772e05945054718d2d1f8a1db8f2cc927e6277f..6306aee178a873508c98976a5ea32c86dfba1019 100644 (file)
--- a/m4/bottom.m4
+++ b/m4/bottom.m4
@@ -30,6 +30,12 @@ typedef unsigned long int ulong;
 #define RPACKAGE "memcached" 
  
 #define RVERSION "1.4.13"
+
+#ifdef WORDS_BIGENDIAN 
+# define ENDIAN_BIG 1
+#else
+# define ENDIAN_LITTLE 1
+#endif
  
 ])
 

diff --git a/tests/include.am b/tests/include.am
index 8063be75cb15909498fe36d612b5b6cdf27d4bbf..b8e9e17f52f10e89cab1d8f927e2f5609342212a 100644 (file)
--- a/tests/include.am
+++ b/tests/include.am
@@ -98,9 +98,6 @@ test-sasl: tests/sasl
 test-atom: tests/atomsmasher
        @tests/atomsmasher
 
-test-plus: tests/testplus
-       @tests/testplus
-
 test-hashplus: tests/hash_plus
        @tests/hash_plus
 
@@ -122,9 +119,6 @@ gdb-sasl: tests/sasl
 gdb-atom: tests/atomsmasher
        @$(DEBUG_COMMAND) tests/atomsmasher
 
-gdb-plus: tests/testplus
-       $(DEBUG_COMMAND) tests/testplus
-
 gdb-hash: tests/testhashkit
        @$(DEBUG_COMMAND) tests/testhashkit
 
@@ -146,9 +140,6 @@ valgrind-failure: tests/failure
 valgrind-atom: tests/atomsmasher
        $(VALGRIND_COMMAND) tests/atomsmasher
 
-valgrind-plus: tests/testplus
-       @$(VALGRIND_COMMAND) tests/testplus
-
 valgrind-sasl: tests/sasl
        @$(VALGRIND_COMMAND) tests/sasl
 
@@ -167,9 +158,6 @@ helgrind-mem: tests/libmemcached-1.0/testapp
 helgrind-atom: tests/atomsmasher
        @$(HELGRIND_COMMAND) tests/atomsmasher
 
-helgrind-plus: tests/testplus
-       @$(HELGRIND_COMMAND) tests/testplus
-
 helgrind-hash: tests/testhashkit
        @$(HELGRIND_COMMAND) tests/testhashkit
 

diff --git a/tests/keys.hpp b/tests/keys.hpp
index 54d6e4f5eb0923f454e5a36660d55a1c5b94e785..342346fc4d19217715530f7891f2215747932aa5 100644 (file)
--- a/tests/keys.hpp
+++ b/tests/keys.hpp
@@ -85,7 +85,7 @@ public:
   {
     for (libtest::vchar_ptr_t::iterator iter= _keys.begin();
          iter != _keys.end();
-         iter++)
+         ++iter)
     {
       ::free(*iter);
     }

diff --git a/tests/libmemcached-1.0/all_tests.cc b/tests/libmemcached-1.0/all_tests.cc
index bfa64c24aff64d5957df34b49e488ab16b35a808..8aeac4d9694b5cfa7af03744d2a86c291f2daf3b 100644 (file)
--- a/tests/libmemcached-1.0/all_tests.cc
+++ b/tests/libmemcached-1.0/all_tests.cc
@@ -82,7 +82,7 @@ void get_world(Framework *world)
   else
   {
     // Assume a minimum of 3, and a maximum of 8
-    world->servers().set_servers_to_run(libtest::number_of_cpus() > 3 ? 
+    world->servers().set_servers_to_run((libtest::number_of_cpus() > 3) ? 
                                         std::min(libtest::number_of_cpus(), size_t(8)) : 3);
   }
 

diff --git a/tests/libmemcached-1.0/debug.cc b/tests/libmemcached-1.0/debug.cc
index 603e15ca4bc7ec3ed8c7a6d32473dea00d252fbb..52ac9b250ceae95732c4c4f3cf64a3cd657b1db1 100644 (file)
--- a/tests/libmemcached-1.0/debug.cc
+++ b/tests/libmemcached-1.0/debug.cc
@@ -67,7 +67,7 @@ static memcached_return_t server_wrapper_for_dump_callback(const memcached_st *,
 {
   memcached_st *memc= memcached_create(NULL);
 
-  if (server->type == MEMCACHED_CONNECTION_UNIX_SOCKET)
+  if (strcmp(memcached_server_type(server), "SOCKET") == 0)
   {
     if (memcached_failed(memcached_server_add_unix_socket(memc, memcached_server_name(server))))
     {

diff --git a/tests/libmemcached-1.0/include.am b/tests/libmemcached-1.0/include.am
index 02dc26a7922ae59c605a6ca5a37d3090deeafac0..06cd87474cbd0b9da2907a679fa63c85a2209ba7 100644 (file)
--- a/tests/libmemcached-1.0/include.am
+++ b/tests/libmemcached-1.0/include.am
@@ -264,3 +264,15 @@ tests_testplus_DEPENDENCIES+= $(TESTS_LDADDS)
 tests_testplus_LDADD+= $(tests_testplus_DEPENDENCIES)
 check_PROGRAMS+= tests/testplus
 noinst_PROGRAMS+= tests/testplus
+
+test-plus: tests/testplus
+       @tests/testplus
+
+gdb-plus: tests/testplus
+       $(DEBUG_COMMAND) tests/testplus
+
+valgrind-plus: tests/testplus
+       @$(VALGRIND_COMMAND) tests/testplus
+
+helgrind-plus: tests/testplus
+       @$(HELGRIND_COMMAND) tests/testplus

diff --git a/tests/libmemcached-1.0/ketama.cc b/tests/libmemcached-1.0/ketama.cc
index 1a70e1cbb8f20b0e2d8cba145ad69eb7749968a2..045ae074ef69559cee40b148dd040e6749e91ee8 100644 (file)
--- a/tests/libmemcached-1.0/ketama.cc
+++ b/tests/libmemcached-1.0/ketama.cc
@@ -160,7 +160,6 @@ test_return_t user_supplied_bug18(memcached_st *trash)
 test_return_t auto_eject_hosts(memcached_st *trash)
 {
   (void) trash;
-  memcached_server_instance_st instance;
 
   memcached_return_t rc;
   memcached_st *memc= memcached_create(NULL);
@@ -201,8 +200,8 @@ test_return_t auto_eject_hosts(memcached_st *trash)
   test_true(server_pool[7].port == 11211);
   test_true(server_pool[7].weight == 100);
 
-  instance= memcached_server_instance_by_position(memc, 2);
-  ((memcached_server_write_instance_st)instance)->next_retry = time(NULL) + 15;
+  memcached_server_instance_st instance= memcached_server_instance_by_position(memc, 2);
+  memcached_instance_next_retry(instance, time(NULL) +15);
   memc->ketama.next_distribution_rebuild= time(NULL) - 1;
 
   /*
@@ -216,8 +215,9 @@ test_return_t auto_eject_hosts(memcached_st *trash)
   }
 
   /* and re-added when it's back. */
-  ((memcached_server_write_instance_st)instance)->next_retry = time(NULL) - 1;
-  memc->ketama.next_distribution_rebuild= time(NULL) - 1;
+  time_t absolute_time= time(NULL) -1;
+  memcached_instance_next_retry(instance, absolute_time);
+  memc->ketama.next_distribution_rebuild= absolute_time;
   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION,
                          memc->distribution);
   for (ptrdiff_t x= 0; x < 99; x++)

diff --git a/tests/libmemcached-1.0/mem_functions.cc b/tests/libmemcached-1.0/mem_functions.cc
index 199ee01b70a33a5c2e98cb3f39688e960642e3b5..9fdf6bf3fdd934990ac415bf239d447ce84dddde 100644 (file)
--- a/tests/libmemcached-1.0/mem_functions.cc
+++ b/tests/libmemcached-1.0/mem_functions.cc
@@ -299,9 +299,9 @@ static memcached_return_t server_display_unsort_function(const memcached_st*,
   /* Do Nothing */
   uint32_t x= *((uint32_t *)(context));
 
-  if (! (test_ports[x] == server->port))
+  if (! (test_ports[x] == memcached_server_port(server)))
   {
-    fprintf(stderr, "%lu -> %lu\n", (unsigned long)test_ports[x], (unsigned long)server->port);
+    fprintf(stderr, "%lu -> %lu\n", (unsigned long)test_ports[x], (unsigned long)memcached_server_port(server));
     return MEMCACHED_FAILURE;
   }
 
@@ -390,7 +390,7 @@ test_return_t clone_test(memcached_st *memc)
       test_true(memc_clone->flags.buffer_requests == memc->flags.buffer_requests);
       test_true(memc_clone->flags.use_sort_hosts == memc->flags.use_sort_hosts);
       test_true(memc_clone->flags.verify_key == memc->flags.verify_key);
-      test_true(memc_clone->ketama.weighted == memc->ketama.weighted);
+      test_true(memc_clone->ketama.weighted_ == memc->ketama.weighted_);
       test_true(memc_clone->flags.binary_protocol == memc->flags.binary_protocol);
       test_true(memc_clone->flags.hash_with_namespace == memc->flags.hash_with_namespace);
       test_true(memc_clone->flags.reply == memc->flags.reply);
@@ -614,7 +614,7 @@ test_return_t memcached_mget_mixed_memcached_get_TEST(memcached_st *memc)
 
   for (libtest::vchar_ptr_t::iterator iter= keys.begin();
        iter != keys.end(); 
-       iter++)
+       ++iter)
   {
     test_compare_hint(MEMCACHED_SUCCESS,
                       memcached_set(memc,
@@ -4044,11 +4044,11 @@ test_return_t regression_bug_447342(memcached_st *memc)
  */
   memcached_server_instance_st instance_one= memcached_server_instance_by_position(memc, 0);
   memcached_server_instance_st instance_two= memcached_server_instance_by_position(memc, 2);
-  in_port_t port0= instance_one->port;
-  in_port_t port2= instance_two->port;
+  in_port_t port0= instance_one->port();
+  in_port_t port2= instance_two->port();
 
-  ((memcached_server_write_instance_st)instance_one)->port= 0;
-  ((memcached_server_write_instance_st)instance_two)->port= 0;
+  ((memcached_server_write_instance_st)instance_one)->port(0);
+  ((memcached_server_write_instance_st)instance_two)->port(0);
 
   test_compare(MEMCACHED_SUCCESS,
                memcached_mget(memc, 
@@ -4060,8 +4060,8 @@ test_return_t regression_bug_447342(memcached_st *memc)
   test_compare(counter, keys.size());
 
   /* restore the memc handle */
-  ((memcached_server_write_instance_st)instance_one)->port= port0;
-  ((memcached_server_write_instance_st)instance_two)->port= port2;
+  ((memcached_server_write_instance_st)instance_one)->port(port0);
+  ((memcached_server_write_instance_st)instance_two)->port(port2);
 
   memcached_quit(memc);
 
@@ -4076,8 +4076,8 @@ test_return_t regression_bug_447342(memcached_st *memc)
   }
 
   memcached_quit(memc);
-  ((memcached_server_write_instance_st)instance_one)->port= 0;
-  ((memcached_server_write_instance_st)instance_two)->port= 0;
+  ((memcached_server_write_instance_st)instance_one)->port(0);
+  ((memcached_server_write_instance_st)instance_two)->port(0);
 
   /* now retry the command, this time we should have cache misses */
   test_compare(MEMCACHED_SUCCESS,
@@ -4090,8 +4090,8 @@ test_return_t regression_bug_447342(memcached_st *memc)
   test_compare(counter, (unsigned int)(keys.size() >> 1));
 
   /* restore the memc handle */
-  ((memcached_server_write_instance_st)instance_one)->port= port0;
-  ((memcached_server_write_instance_st)instance_two)->port= port2;
+  ((memcached_server_write_instance_st)instance_one)->port(port0);
+  ((memcached_server_write_instance_st)instance_two)->port(port2);
 
   return TEST_SUCCESS;
 }

diff --git a/tests/libmemcached-1.0/parser.cc b/tests/libmemcached-1.0/parser.cc
index 3cacd26ccf8d9d62fd2e6a5f7ffbb58978295315..fc9d3375b3b279b8a18e0c691b5078a31fad25b5 100644 (file)
--- a/tests/libmemcached-1.0/parser.cc
+++ b/tests/libmemcached-1.0/parser.cc
@@ -188,6 +188,7 @@ scanner_variable_t test_number_options[]= {
 };
 
 scanner_variable_t test_boolean_options[]= {
+  { ARRAY,  make_scanner_string("--FETCH-VERSION"), scanner_string_null, NULL },
   { ARRAY,  make_scanner_string("--BINARY-PROTOCOL"), scanner_string_null, NULL },
   { ARRAY,  make_scanner_string("--BUFFER-REQUESTS"), scanner_string_null, NULL },
   { ARRAY,  make_scanner_string("--HASH-WITH-NAMESPACE"), scanner_string_null, NULL },

diff --git a/tests/libmemcached-1.0/plus.cpp b/tests/libmemcached-1.0/plus.cpp
index a01544c5c10fd63a87e7ecdbd8f01bedf6208b81..68f1d7e01800893d010637a04ec9d922ef40bf78 100644 (file)
--- a/tests/libmemcached-1.0/plus.cpp
+++ b/tests/libmemcached-1.0/plus.cpp
@@ -203,6 +203,36 @@ static test_return_t mget_test(memcached_st *original)
   return TEST_SUCCESS;
 }
 
+static test_return_t lp_1010899_TEST(void*)
+{
+  // Check to see everything is setup internally even when no initial hosts are
+  // given.
+  Memcache memc;
+
+  test_false(memc.increment(__func__, 0, NULL));
+
+  return TEST_SUCCESS;
+}
+
+static test_return_t lp_1010899_with_args_TEST(memcached_st *original)
+{
+  // Check to see everything is setup internally even when a host is specified
+  // on creation.
+  memcached_server_instance_st instance= memcached_server_instance_by_position(original, 0);
+  Memcache memc(memcached_server_name(instance), memcached_server_port(instance));
+
+  test_false(memc.increment(__func__, 0, NULL));
+  test_true(memc.set(__func__, test_literal_param("12"), 0, 0)); 
+  test_true(memc.increment(__func__, 3, NULL));
+
+  std::vector<char> ret_val;
+  test_true(memc.get(__func__, ret_val));
+
+  test_strcmp(&ret_val[0], "15");
+
+  return TEST_SUCCESS;
+}
+
 static test_return_t basic_behavior(memcached_st *original)
 {
   Memcache memc(original);
@@ -273,9 +303,17 @@ test_st tests[] ={
   {0, 0, 0}
 };
 
+test_st regression_TESTS[] ={
+  { "lp:1010899 Memcache()", false, lp_1010899_TEST },
+  { "lp:1010899 Memcache(localhost, port)", false,
+    reinterpret_cast<test_callback_fn*>(lp_1010899_with_args_TEST) },
+  {0, 0, 0}
+};
+
 collection_st collection[] ={
   {"block", 0, 0, tests},
   {"error()", 0, 0, error_tests},
+  {"regression", 0, 0, regression_TESTS},
   {0, 0, 0, 0}
 };
 

diff --git a/tests/libmemcached-1.0/replication.cc b/tests/libmemcached-1.0/replication.cc
index 2b79bc1560e98c9d0336727afde9fa0a79869e95..198b83cccdbbf7a32ccab4fb1f77e6a764c5ea9c 100644 (file)
--- a/tests/libmemcached-1.0/replication.cc
+++ b/tests/libmemcached-1.0/replication.cc
@@ -124,10 +124,9 @@ test_return_t replication_get_test(memcached_st *memc)
   for (uint32_t host= 0; host < memcached_server_count(memc); ++host)
   {
     memcached_st *memc_clone= memcached_clone(NULL, memc);
-    memcached_server_instance_st instance=
-      memcached_server_instance_by_position(memc_clone, host);
+    org::libmemcached::Instance* instance= (org::libmemcached::Instance*)memcached_server_instance_by_position(memc_clone, host);
 
-    ((memcached_server_write_instance_st)instance)->port= 0;
+    instance->port(0);
 
     for (int x= 'a'; x <= 'z'; ++x)
     {
@@ -187,9 +186,8 @@ test_return_t replication_mget_test(memcached_st *memc)
   for (uint32_t host= 0; host < memcached_server_count(memc_clone); host++)
   {
     memcached_st *new_clone= memcached_clone(NULL, memc);
-    memcached_server_instance_st instance=
-      memcached_server_instance_by_position(new_clone, host);
-    ((memcached_server_write_instance_st)instance)->port= 0;
+    memcached_server_instance_st instance= memcached_server_instance_by_position(new_clone, host);
+    ((memcached_server_write_instance_st)instance)->port(0);
 
     for (int x= 'a'; x <= 'z'; ++x)
     {
@@ -295,10 +293,15 @@ test_return_t replication_delete_test(memcached_st *memc_just_cloned)
   /* Delete the items from all of the servers except 1, we use the non replicated memc so that we know we deleted the keys */
   for (size_t x= 0; x < test_array_length(keys); ++x)
   {
-    test_compare(MEMCACHED_SUCCESS,
-                 memcached_delete(memc_replicated,
-                                  test_string_make_from_cstr(keys[x]), // Keys
-                                  0));
+    memcached_return_t del_rc= memcached_delete(memc_replicated,
+                                                test_string_make_from_cstr(keys[x]), // Keys
+                                                0);
+    if (del_rc == MEMCACHED_SUCCESS or del_rc == MEMCACHED_NOTFOUND)
+    { }
+    else 
+    {
+      test_compare(MEMCACHED_SUCCESS, del_rc);
+    }
   }
 
   test_compare(TEST_SUCCESS, confirm_keys_dont_exist(memc_replicated, keys, test_array_length(keys)));
@@ -332,7 +335,7 @@ test_return_t replication_randomize_mget_fail_test(memcached_st *memc)
   // We need to now cause a failure in one server, never do this in your own
   // code.
   close(memc_clone->servers[1].fd);
-  memc_clone->servers[1].port= 1;
+  memc_clone->servers[1].port(1);
   memc_clone->servers[1].address_info_next= NULL;
 
   for (int x= int(MEMCACHED_SUCCESS); x < int(MEMCACHED_MAXIMUM_RETURN); ++x)