Merge lp:~stewart/percona-playback/compiler-warnings-2 into lp:~percona-dev/percona-playback/light

[Stewart Smith]

even more compiler warning fixes. with this tree, we're down to just 6.

[Laurynas Biveinis (laurynas-biveinis)]

LGTM

review: Approve

=== modified file 'm4/pandora_have_libmysqlclient.m4'
--- m4/pandora_have_libmysqlclient.m4	2011-09-29 06:41:38 +0000
+++ m4/pandora_have_libmysqlclient.m4	2011-09-29 06:41:38 +0000
@@ -64,10 +64,11 @@
   AS_IF([test "x$MYSQL_CONFIG" = "xISDIR"],[
     IBASE="-I${with_mysql}"
     MYSQL_CONFIG="${with_mysql}/scripts/mysql_config"
-    ADDIFLAGS="$IBASE/include "
+    ADDIFLAGS="$IBASE/include -isystem $IBASE/include"
     ADDLDFLAGS="-L${with_mysql}/libmysql_r/.libs/ -L${with_mysql}/mysys/.libs -L${with_mysql}/mysys -L${with_mysql}/strings/.libs -L${with_mysql}/strings "
   ],[
     MYSQL_INCLUDES=$(${MYSQL_CONFIG} --include)
+    MYSQL_INCLUDES="$MYSQL_INCLUDES $(echo $MYSQL_INCLUDES|sed -e 's/-I/-isystem /')"
     MYSQL_LIBS=$(${MYSQL_CONFIG} --libs_r)
   ])
 
 
=== modified file 'src/common.h'
--- src/common.h	2011-09-29 06:41:38 +0000
+++ src/common.h	2011-09-29 06:41:38 +0000
@@ -29,7 +29,7 @@
 #include <boost/shared_ptr.hpp>
 #include <pthread.h>
 
-#if DEBUG
+#ifdef DEBUG
 //DEBUG
 
 #include <cassert>
 
=== modified file 'src/long_string.cc'
--- src/long_string.cc	2011-09-29 06:41:38 +0000
+++ src/long_string.cc	2011-09-29 06:41:38 +0000
@@ -123,35 +123,35 @@
   m_length= 0;
   m_data[m_length]= 0;
 }
-void String::set(const char* data)
-{
-  clear();
-  add_last(data);
-}
-void String::set(const char* data, std::size_t length)
-{
-  clear();
-  add_last(data, length);
-}
-void String::set(std::string const &data)
-{
-  clear();
-  add_last(data);
-}
-void String::set(String const &data)
-{
-  clear();
-  add_last(data);
-}
-void String::remove_first(std::size_t length)
+void String::set(const char* str)
+{
+  clear();
+  add_last(str);
+}
+void String::set(const char* str, std::size_t len)
+{
+  clear();
+  add_last(str, len);
+}
+void String::set(std::string const &str)
+{
+  clear();
+  add_last(str);
+}
+void String::set(String const &str)
+{
+  clear();
+  add_last(str);
+}
+void String::remove_first(std::size_t len)
 {
   CHECK_C_STRING_LENGTH(m_data, m_length);
-  if (m_length < length)
-    throw Too_Short_String(m_max, m_length, length);
+  if (m_length < len)
+    throw Too_Short_String(m_max, m_length, len);
   else
     {
-      m_length -= length;
-      memmove(m_data, m_data + length, m_length);
+      m_length -= len;
+      memmove(m_data, m_data + len, m_length);
       m_data[m_length]= 0;
     }
 }
@@ -169,30 +169,30 @@
   CHECK_C_STRING(value);
   add_last(value, strlen(value));
 }
-void String::add_last(const char* value, std::size_t length)
+void String::add_last(const char* value, std::size_t len)
 {
   CHECK_C_STRING_LENGTH(m_data, m_length);
-  if((m_max - m_length) < length)
+  if((m_max - m_length) < len)
   {
     std::cerr << "Too_Long_String, current:\n" << (*this);
     std::cerr << "\nlength: " << m_length << " max: " << m_max;
-    std::cerr << "\nadd_last: " << length << "\n" << std::flush;
-    throw Too_Long_String(m_max, m_length, length);
+    std::cerr << "\nadd_last: " << len << "\n" << std::flush;
+    throw Too_Long_String(m_max, m_length, len);
   }
-  memcpy(m_data + m_length, value, length);
-  m_length += length;
+  memcpy(m_data + m_length, value, len);
+  m_length += len;
   m_data[ m_length ]= 0;
   CHECK_C_STRING_LENGTH(m_data, m_length);
 }
-void String::add_last(std::string const &data)
+void String::add_last(std::string const &str)
 {
   CHECK_C_STRING_LENGTH(m_data, m_length);
-  add_last(data.c_str(), data.length());
+  add_last(str.c_str(), str.length());
 }
-void String::add_last(String const &data)
+void String::add_last(String const &str)
 {
   CHECK_C_STRING_LENGTH(m_data, m_length);
-  add_last(data.data(), data.length());
+  add_last(str.data(), str.length());
 }
 std::size_t String::index(char c, std::size_t from) const
 {
@@ -279,12 +279,12 @@
   return p != s.length();
 }
 
-String_Null_Error::String_Null_Error(const char* method_name)
+String_Null_Error::String_Null_Error(const char* where)
 {
-  m_method_name= method_name;
+  m_method_name= where;
   m_method_name_c_str= m_method_name.c_str();
   m_reason= "Impossible call method ";
-  m_reason += method_name;
+  m_reason += where;
   m_reason += " when Nullable_String is null";
   m_reason_c_str= m_reason.c_str();
 }
@@ -300,8 +300,8 @@
 {
 }
 
-Nullable_String::Nullable_String(std::size_t max) :
-  String(max), m_null(true)
+Nullable_String::Nullable_String(std::size_t max_size) :
+  String(max_size), m_null(true)
 {
 }
 Nullable_String::Nullable_String(Nullable_String const &other) :
@@ -349,7 +349,7 @@
   else
     return String::data();
 }
-void Nullable_String::length(std::size_t const &length)
+void Nullable_String::length(std::size_t const &len)
 {
   if (m_null)
     {
@@ -357,7 +357,7 @@
       throw String_Null_Error("length");
     }
   else
-    return String::length(length);
+    return String::length(len);
 }
 std::size_t  Nullable_String::length() const
 {
@@ -387,47 +387,47 @@
   m_null= false;
   String::clear();
 }
-void Nullable_String::set(const char* data)
-{
-  CHECK_NULLABLE_C_STRING(data);
-  clear();
-  add_last(data);
-}
-void Nullable_String::set(const char* data, std::size_t length)
-{
-  clear();
-  add_last(data, length);
-}
-void Nullable_String::set(std::string const &data)
-{
-  clear();
-  add_last(data);
+void Nullable_String::set(const char* str)
+{
+  CHECK_NULLABLE_C_STRING(str);
+  clear();
+  add_last(str);
+}
+void Nullable_String::set(const char* str, std::size_t l)
+{
+  clear();
+  add_last(str, l);
+}
+void Nullable_String::set(std::string const &str)
+{
+  clear();
+  add_last(str);
 }
 void Nullable_String::set(Nullable_String const &other)
 {
   clear();
   add_last(other);
 }
-void Nullable_String::remove_first(std::size_t length)
+void Nullable_String::remove_first(std::size_t n)
 {
   if (m_null)
     throw String_Null_Error("remove_first");
   else
-    String::remove_first(length);
+    String::remove_first(n);
 }
 void Nullable_String::add_last(const char* value)
 {
   if (value)
     add_last(value, strlen(value));
 }
-void Nullable_String::add_last(const char* value, std::size_t length)
+void Nullable_String::add_last(const char* value, std::size_t len)
 {
   if (value)
     {
     if (is_null())
       throw String_Null_Error("add_last");
     else
-      get_string().add_last(value, length);
+      get_string().add_last(value, len);
     }
 }
 void Nullable_String::add_last(std::string const &value)
 
=== modified file 'src/long_string.h'
--- src/long_string.h	2011-09-29 06:41:38 +0000
+++ src/long_string.h	2011-09-29 06:41:38 +0000
@@ -200,7 +200,7 @@
   static void apply(Reader &action, Nullable_String &value)
   {
     action.begin_compound(value);
-    action.member( (const char*)"m_null", value.m_null );
+    action.member("m_null", value.m_null );
     if (!value.is_null())
       {
 	superclass(action, value.get_string());
 
=== modified file 'src/mysql_client.cc'
--- src/mysql_client.cc	2011-07-11 07:34:56 +0000
+++ src/mysql_client.cc	2011-09-29 06:41:38 +0000
@@ -215,20 +215,20 @@
   {
     if (::verbose_error())
     {
-      Nullable_String &error= r.error;
-      if (error.is_null())
+      Nullable_String &err= r.error;
+      if (err.is_null())
 	{
-	  error.set("");
+	  err.set("");
 	}
-      int old_length= (error.is_null() ? 0 : error.length());
-      int new_length= snprintf(error.data() + old_length
-			       , error.max() - old_length
+      int old_length= (err.is_null() ? 0 : err.length());
+      int new_length= snprintf(err.data() + old_length
+			       , err.max() - old_length
 			       , "%s(%d): %s"
 			       , (old_length == 0 ? "" : "\n")
 			       , mysql_errno(handle())
 			       , mysql_error(handle()));
       assert(new_length > 0);
-      error.length(old_length + new_length);
+      err.length(old_length + new_length);
     }
   }
 private:
 
=== modified file 'src/options.cc'
--- src/options.cc	2011-09-29 06:41:38 +0000
+++ src/options.cc	2011-09-29 06:41:38 +0000
@@ -31,12 +31,16 @@
 #include <sys/types.h>
 #include <errno.h>
 
+std::size_t quiet_verbose_callback(char*, std::size_t, Query const &,
+				   Query_Result const &);
 std::size_t status_verbose_callback(char* buffer, std::size_t length,
 				    Query const &q, Query_Result const  &r);
 std::size_t full_verbose_callback(char* buffer, std::size_t length,
 				  Query const &q, Query_Result const &r);
 std::size_t custom_verbose_callback(char* buffer, std::size_t length,
 				    Query const &q, Query_Result const &r);
+std::size_t error_verbose_callback(char* buffer, std::size_t length,
+				   Query const &q, Query_Result const &r);
 
 static const char* query_type_str(Query const &a_query)
 {
@@ -288,18 +292,18 @@
       }
       else
       {
-        Verbose_Callback_Fill *fill= 0;
+        Verbose_Callback_Fill *cb_fill= 0;
         if (!custom_verbose_callback_vector.empty())
         {
-          fill= custom_verbose_callback_vector.back().get()->fill();
+          cb_fill= custom_verbose_callback_vector.back().get()->fill();
         }
-        if (0 == fill)
+        if (0 == cb_fill)
         {
           custom_verbose_callback_vector.push_back(Verbose_Callback_Pointer(new Verbose_Callback_Fill()));
-          fill= custom_verbose_callback_vector.back().get()->fill();
+          cb_fill= custom_verbose_callback_vector.back().get()->fill();
         }
-        assert(fill);
-        fill->add(*mask);
+        assert(cb_fill);
+        cb_fill->add(*mask);
       }
     }
   }
@@ -322,12 +326,13 @@
   return message.str();
 }
 Too_Long_Argument::Too_Long_Argument(std::string const &argument_name
-				     , std::string const &limitation
-				     , std::string const &received) :
-Error(generate_message_Too_Long_Argument(argument_name, limitation, received))
+				     , std::string const &arg_limitation
+				     , std::string const &arg_received) :
+Error(generate_message_Too_Long_Argument(argument_name, arg_limitation,
+					 arg_received))
 , m_name(argument_name)
-  , m_limitation(limitation)
-  , m_received(received)
+  , m_limitation(arg_limitation)
+  , m_received(arg_received)
 {
 }
 std::string const& Too_Long_Argument::name() const
 
=== modified file 'src/query.cc'
--- src/query.cc	2011-09-29 06:41:38 +0000
+++ src/query.cc	2011-09-29 06:41:38 +0000
@@ -153,68 +153,7 @@
    */
 typedef int Query_Parse_State;
 
-const char * to_c_str(Enum_Query_Parse parse)
-{
-#define CONVERT(s) case(s): return #s ;
-  switch(parse)
-    {
-      CONVERT(ZERO);
-      CONVERT(ZERO_BACK);
-      CONVERT(SLASH);
-      CONVERT(C_COMMENT);
-      CONVERT(C_COMMENT_BACK);
-      CONVERT(C_COMMENT_STAR);
-      CONVERT(MINUS);
-      CONVERT(MINUS_COMMENT);
-      CONVERT(MINUS_COMMENT_BACK);
-      CONVERT(SHARP_COMMENT);
-      CONVERT(SHARP_COMMENT_BACK);
-      CONVERT(U);	  
-      CONVERT(US);
-      CONVERT(USE);
-      CONVERT(UP);
-      CONVERT(UPD);
-      CONVERT(UPDA);
-      CONVERT(UPDAT);
-      CONVERT(UPDATE);
-      CONVERT(D);
-      CONVERT(DE);
-      CONVERT(DEL);
-      CONVERT(DELE);
-      CONVERT(DELET);
-      CONVERT(DELETE);
-      CONVERT(I);
-      CONVERT(IN);
-      CONVERT(INS);
-      CONVERT(INSE);
-      CONVERT(INSER);
-      CONVERT(INSERT);
-      CONVERT(S);
-      CONVERT(SE);
-      CONVERT(SET);
-      CONVERT(SEL);
-      CONVERT(SELE);
-      CONVERT(SELEC);
-      CONVERT(SELECT);
-      CONVERT(SH);
-      CONVERT(SHO);
-      CONVERT(SHOW);
-      CONVERT(SINGLE_QUOTE);
-      CONVERT(SINGLE_QUOTE_BACK);
-      CONVERT(DOUBLE_QUOTE);
-      CONVERT(DOUBLE_QUOTE_BACK);
-      CONVERT(FINAL);
-    default:
-      return "Enum_Query_Parse: unknown value";
-    };
-#undef CONVERT
-}
-std::ostream& operator<<(std::ostream &s, Enum_Query_Parse parse)
-{
-  return s << to_c_str(parse);
-}
-
-Query_Parse_State query_parse_state(Enum_Query_Detect detect, Enum_Query_Type type, Enum_Query_Parse parse)
+static Query_Parse_State query_parse_state(Enum_Query_Detect detect, Enum_Query_Type type, Enum_Query_Parse parse)
 {
   return static_cast<Query_Parse_State>(detect) + (static_cast<Query_Parse_State>(type) << 8) + (static_cast<Query_Parse_State>(parse) << 16);
 }
@@ -223,7 +162,7 @@
 {
   return query_parse_state(detect, eQuery_Type_Unknown, ZERO);
 }
-Enum_Query_Detect query_detect(Query_Parse_State state)
+static Enum_Query_Detect query_detect(Query_Parse_State state)
 {
   return static_cast<Enum_Query_Detect>(state & 0xFF);
 }
@@ -231,14 +170,14 @@
 {
   return static_cast<Enum_Query_Type>((state >> 8) & 0xFF);
 }
-Enum_Query_Parse query_parse(Query_Parse_State state)
+static Enum_Query_Parse query_parse(Query_Parse_State state)
 {
   return static_cast<Enum_Query_Parse>((state >> 16) & 0xFF);
 }
-std::size_t query_parse_stupid(Query_Parse_State &state, const char* data, std::size_t length)
+static std::size_t query_parse_stupid(Query_Parse_State &state, const char* data, std::size_t length)
 {
   assert(eQuery_Detect_Stupid == query_detect(state));
-  const char* result= (const char*)memchr(data, ';', length);
+  const char* result= static_cast<const char*>(memchr(data, ';', length));
   if (result == NULL)
     return length;
   else
 
=== modified file 'src/queue.h'
--- src/queue.h	2011-09-29 06:41:38 +0000
+++ src/queue.h	2011-09-29 06:41:38 +0000
@@ -413,7 +413,7 @@
     std::cout << s.str() << std::flush;*/
     m_queue.clear();
   }
-  bool can_push(T* a_item)
+  bool can_push(T*)
   {
     /*std::ostringstream s;
     s << *this << " : " << this << " CAN_PUSH: QUEUE SIZE IS ";
 
=== modified file 'src/slow_query_log_parser.h'
--- src/slow_query_log_parser.h	2011-07-11 14:41:36 +0000
+++ src/slow_query_log_parser.h	2011-09-29 06:41:38 +0000
@@ -51,9 +51,9 @@
   {
     m_scheduler->start();
   }
-  bool run(Query const &query)
+  bool run(Query const &q)
   {
-    return m_scheduler->run(query);
+    return m_scheduler->run(q);
   }
   void flush()
   {
 
=== modified file 'src/supervisor.cc'
--- src/supervisor.cc	2011-07-11 07:34:56 +0000
+++ src/supervisor.cc	2011-09-29 06:41:38 +0000
@@ -22,11 +22,6 @@
 #include "options.h"
 #include "worker.h"
 
-void connection_trace(void */* a_context */, Error const &a_error)
-{
-  std::cerr << a_error << std::endl;
-}
-
 static void               *s_context=             0;
 static troubles s_troubles= 0;
 void set_troubles(void *a_context, troubles a_function)
@@ -106,9 +101,9 @@
   }
   void complete(Worker *a_worker)
   {
-    bool complete= (0 == --m_active) && (m_flush || m_stop);
+    bool is_complete= (0 == --m_active) && (m_flush || m_stop);
     m_join.push(a_worker);
-    if (complete)
+    if (is_complete)
     {
       m_join.flush();
     }