Fix possible issue with gcc not finding the correct polymorphic method

bin/include.am

@@ -28,9 +28,7 @@ bin_gearadmin_SOURCES= \
 		       util/instance.cc \
 		       util/operation.cc
 bin_gearadmin_CXXFLAGS= $(BOOST_CPPFLAGS)
-bin_gearadmin_LDFLAGS= \
-		       $(AM_LDFLAGS) \
-		       $(BOOST_PROGRAM_OPTIONS_LDFLAGS)
+bin_gearadmin_LDFLAGS= $(BOOST_PROGRAM_OPTIONS_LDFLAGS)
 bin_gearadmin_LDADD= \
 		     $(BOOST_PROGRAM_OPTIONS_LIBS) \
 		     ${BETTER_MALLOC_LIBS}
@@ -41,8 +39,7 @@ bin_gearman_SOURCES= \
 		     bin/gearman.cc \
 		     bin/error.cc \
 		     util/pidfile.cc
-bin_gearman_LDADD= \
-		   libgearman/libgearman.la
+bin_gearman_LDADD= libgearman/libgearman.la
 
 GEARMAN_CLIENT_TEST= bin/gearman
 GEARMAN_VALGRIND_CLIENT_TEST= $(VALGRIND_COMMAND) bin/gearman

libgearman/add.cc

@@ -53,7 +53,7 @@
 #include <uuid/uuid.h>
 #endif
 
-gearman_task_st *add_task(gearman_client_st *client,
+gearman_task_st *add_task(gearman_client_st& client,
                           void *context,
                           gearman_command_t command,
                           const gearman_string_t &function,
@@ -65,7 +65,7 @@ gearman_task_st *add_task(gearman_client_st *client,
   return add_task(client, NULL, context, command, function, unique, workload, when, actions);
 }
 
-gearman_task_st *add_task(gearman_client_st *client,
+gearman_task_st *add_task(gearman_client_st& client,
                           gearman_task_st *task,
                           void *context,
                           gearman_command_t command,
@@ -82,13 +82,6 @@ gearman_task_st *add_task(gearman_client_st *client,
     ret_ptr= &unused;
   }
 
-  if (client == NULL)
-  {
-    *ret_ptr= GEARMAN_ERRNO;
-    errno= EINVAL;
-    return NULL;
-  }
-
   gearman_string_t function= { gearman_string_param_cstr(function_name) };
   gearman_unique_t local_unique= gearman_unique_make(unique, unique ? strlen(unique) : 0);
   gearman_string_t workload= { static_cast<const char *>(workload_str), workload_size };
@@ -96,7 +89,7 @@ gearman_task_st *add_task(gearman_client_st *client,
   task= add_task(client, task, context, command, function, local_unique, workload, when, actions);
   if (task == NULL)
   {
-    *ret_ptr= gearman_universal_error_code(client->universal);
+    *ret_ptr= gearman_universal_error_code(client.universal);
     return NULL;
   }
 
@@ -105,7 +98,7 @@ gearman_task_st *add_task(gearman_client_st *client,
   return task;
 }
 
-gearman_task_st *add_task(gearman_client_st *client,
+gearman_task_st *add_task(gearman_client_st& client,
                           gearman_task_st *task,
                           void *context,
                           gearman_command_t command,
@@ -124,11 +117,11 @@ gearman_task_st *add_task(gearman_client_st *client,
   {
     if (gearman_size(function) > GEARMAN_FUNCTION_MAX_SIZE)
     {
-      gearman_error(client->universal, GEARMAN_INVALID_ARGUMENT, "function name longer then GEARMAN_MAX_FUNCTION_SIZE");
+      gearman_error(client.universal, GEARMAN_INVALID_ARGUMENT, "function name longer then GEARMAN_MAX_FUNCTION_SIZE");
     } 
     else
     {
-      gearman_error(client->universal, GEARMAN_INVALID_ARGUMENT, "invalid function");
+      gearman_error(client.universal, GEARMAN_INVALID_ARGUMENT, "invalid function");
     }
 
     return NULL;
@@ -136,21 +129,21 @@ gearman_task_st *add_task(gearman_client_st *client,
 
   if (gearman_size(unique) > GEARMAN_UNIQUE_MAX_SIZE)
   {
-    gearman_error(client->universal, GEARMAN_INVALID_ARGUMENT, "unique name longer then GEARMAN_UNIQUE_MAX_SIZE");
+    gearman_error(client.universal, GEARMAN_INVALID_ARGUMENT, "unique name longer then GEARMAN_UNIQUE_MAX_SIZE");
 
     return NULL;
   }
 
   if ((gearman_size(workload) && gearman_c_str(workload) == NULL) or (gearman_size(workload) == 0 && gearman_c_str(workload)))
   {
-    gearman_error(client->universal, GEARMAN_INVALID_ARGUMENT, "invalid workload");
+    gearman_error(client.universal, GEARMAN_INVALID_ARGUMENT, "invalid workload");
     return NULL;
   }
 
-  task= gearman_task_internal_create(client, task);
+  task= gearman_task_internal_create(&client, task);
   if (task == NULL)
   {
-    gearman_error(client->universal, GEARMAN_MEMORY_ALLOCATION_FAILURE, "");
+    gearman_error(client.universal, GEARMAN_MEMORY_ALLOCATION_FAILURE, "");
     return NULL;
   }
 
@@ -161,11 +154,11 @@ gearman_task_st *add_task(gearman_client_st *client,
     @todo fix it so that NULL is done by default by the API not by happenstance.
   */
   char function_buffer[1024];
-  if (client->universal._namespace)
+  if (client.universal._namespace)
   {
     char *ptr= function_buffer;
-    memcpy(ptr, gearman_string_value(client->universal._namespace), gearman_string_length(client->universal._namespace)); 
-    ptr+= gearman_string_length(client->universal._namespace);
+    memcpy(ptr, gearman_string_value(client.universal._namespace), gearman_string_length(client.universal._namespace)); 
+    ptr+= gearman_string_length(client.universal._namespace);
 
     memcpy(ptr, gearman_c_str(function), gearman_size(function) +1);
     ptr+= gearman_size(function);
@@ -203,7 +196,7 @@ gearman_task_st *add_task(gearman_client_st *client,
     args[3]= gearman_c_str(workload);
     args_size[3]= gearman_size(workload);
 
-    rc= gearman_packet_create_args(client->universal, task->send,
+    rc= gearman_packet_create_args(client.universal, task->send,
                                    GEARMAN_MAGIC_REQUEST, command,
                                    args, args_size,
                                    4);
@@ -213,7 +206,7 @@ gearman_task_st *add_task(gearman_client_st *client,
     args[2]= gearman_c_str(workload);
     args_size[2]= gearman_size(workload);
 
-    rc= gearman_packet_create_args(client->universal, task->send,
+    rc= gearman_packet_create_args(client.universal, task->send,
                                    GEARMAN_MAGIC_REQUEST, command,
                                    args, args_size,
                                    3);
@@ -221,15 +214,15 @@ gearman_task_st *add_task(gearman_client_st *client,
 
   if (gearman_success(rc))
   {
-    client->new_tasks++;
-    client->running_tasks++;
+    client.new_tasks++;
+    client.running_tasks++;
     task->options.send_in_use= true;
 
     return task;
   }
 
   gearman_task_free(task);
-  gearman_gerror(client->universal, rc);
+  gearman_gerror(client.universal, rc);
 
   return NULL;
 }

libgearman/add.hpp

@@ -42,7 +42,7 @@
 
 #pragma once
 
-gearman_task_st *add_task(gearman_client_st *client,
+gearman_task_st *add_task(gearman_client_st& client,
                           void *context,
                           gearman_command_t command,
                           const gearman_string_t &function,
@@ -51,7 +51,7 @@ gearman_task_st *add_task(gearman_client_st *client,
                           time_t when,
                           const gearman_actions_t &actions);
 
-gearman_task_st *add_task(gearman_client_st *client,
+gearman_task_st *add_task(gearman_client_st& client,
                           gearman_task_st *task,
                           void *context,
                           gearman_command_t command,
@@ -62,7 +62,7 @@ gearman_task_st *add_task(gearman_client_st *client,
                           gearman_return_t *ret_ptr,
                           const gearman_actions_t &actions);
 
-gearman_task_st *add_task(gearman_client_st *client,
+gearman_task_st *add_task(gearman_client_st& client,
                           gearman_task_st *task,
                           void *context,
                           gearman_command_t command,

libgearman/client.cc

@@ -702,7 +702,19 @@ gearman_task_st *gearman_client_add_task(gearman_client_st *client,
                                          const void *workload, size_t workload_size,
                                          gearman_return_t *ret_ptr)
 {
-  return add_task(client, task,
+  gearman_return_t unused;
+  if (ret_ptr == NULL)
+  {
+    ret_ptr= &unused;
+  }
+
+  if (client == NULL)
+  {
+    *ret_ptr= GEARMAN_INVALID_ARGUMENT;
+    return NULL;
+  }
+
+  return add_task(*client, task,
                   context, GEARMAN_COMMAND_SUBMIT_JOB,
                   function,
                   unique,
@@ -720,7 +732,19 @@ gearman_task_st *gearman_client_add_task_high(gearman_client_st *client,
                                               const void *workload, size_t workload_size,
                                               gearman_return_t *ret_ptr)
 {
-  return add_task(client, task, context,
+  gearman_return_t unused;
+  if (ret_ptr == NULL)
+  {
+    ret_ptr= &unused;
+  }
+
+  if (client == NULL)
+  {
+    *ret_ptr= GEARMAN_INVALID_ARGUMENT;
+    return NULL;
+  }
+
+  return add_task(*client, task, context,
                   GEARMAN_COMMAND_SUBMIT_JOB_HIGH,
                   function,
                   unique,
@@ -738,7 +762,19 @@ gearman_task_st *gearman_client_add_task_low(gearman_client_st *client,
                                              const void *workload, size_t workload_size,
                                              gearman_return_t *ret_ptr)
 {
-  return add_task(client, task, context, GEARMAN_COMMAND_SUBMIT_JOB_LOW,
+  gearman_return_t unused;
+  if (ret_ptr == NULL)
+  {
+    ret_ptr= &unused;
+  }
+
+  if (client == NULL)
+  {
+    *ret_ptr= GEARMAN_INVALID_ARGUMENT;
+    return NULL;
+  }
+
+  return add_task(*client, task, context, GEARMAN_COMMAND_SUBMIT_JOB_LOW,
                   function,
                   unique,
                   workload, workload_size,
@@ -755,7 +791,19 @@ gearman_task_st *gearman_client_add_task_background(gearman_client_st *client,
                                                     const void *workload, size_t workload_size,
                                                     gearman_return_t *ret_ptr)
 {
-  return add_task(client, task, context, GEARMAN_COMMAND_SUBMIT_JOB_BG,
+  gearman_return_t unused;
+  if (ret_ptr == NULL)
+  {
+    ret_ptr= &unused;
+  }
+
+  if (client == NULL)
+  {
+    *ret_ptr= GEARMAN_INVALID_ARGUMENT;
+    return NULL;
+  }
+
+  return add_task(*client, task, context, GEARMAN_COMMAND_SUBMIT_JOB_BG,
                   function,
                   unique,
                   workload, workload_size,
@@ -773,7 +821,19 @@ gearman_client_add_task_high_background(gearman_client_st *client,
                                         const void *workload, size_t workload_size,
                                         gearman_return_t *ret_ptr)
 {
-  return add_task(client, task, context,
+  gearman_return_t unused;
+  if (ret_ptr == NULL)
+  {
+    ret_ptr= &unused;
+  }
+
+  if (client == NULL)
+  {
+    *ret_ptr= GEARMAN_INVALID_ARGUMENT;
+    return NULL;
+  }
+
+  return add_task(*client, task, context,
                   GEARMAN_COMMAND_SUBMIT_JOB_HIGH_BG,
                   function,
                   unique,
@@ -792,7 +852,19 @@ gearman_client_add_task_low_background(gearman_client_st *client,
                                        const void *workload, size_t workload_size,
                                        gearman_return_t *ret_ptr)
 {
-  return add_task(client, task, context,
+  gearman_return_t unused;
+  if (ret_ptr == NULL)
+  {
+    ret_ptr= &unused;
+  }
+
+  if (client == NULL)
+  {
+    *ret_ptr= GEARMAN_INVALID_ARGUMENT;
+    return NULL;
+  }
+
+  return add_task(*client, task, context,
                   GEARMAN_COMMAND_SUBMIT_JOB_LOW_BG,
                   function,
                   unique,
@@ -811,9 +883,9 @@ gearman_task_st *gearman_client_add_task_status(gearman_client_st *client,
 {
   const void *args[1];
   size_t args_size[1];
-  gearman_return_t unused;
 
-  if (not ret_ptr)
+  gearman_return_t unused;
+  if (ret_ptr == NULL)
   {
     ret_ptr= &unused;
   }
@@ -1336,7 +1408,6 @@ static void *_client_do(gearman_client_st *client, gearman_command_t command,
   if (client == NULL)
   {
     *ret_ptr= GEARMAN_INVALID_ARGUMENT;
-    errno= EINVAL;
     return NULL;
   }
 
@@ -1346,7 +1417,7 @@ static void *_client_do(gearman_client_st *client, gearman_command_t command,
 
 
   gearman_task_st do_task;
-  gearman_task_st *do_task_ptr= add_task(client, &do_task, NULL, command,
+  gearman_task_st *do_task_ptr= add_task(*client, &do_task, NULL, command,
                                          function,
                                          local_unique,
                                          workload,
@@ -1437,7 +1508,6 @@ static gearman_return_t _client_do_background(gearman_client_st *client,
 {
   if (client == NULL)
   {
-    errno= EINVAL;
     return GEARMAN_INVALID_ARGUMENT;
   }
 
@@ -1449,7 +1519,7 @@ static gearman_return_t _client_do_background(gearman_client_st *client,
   client->_do_handle[0]= 0; // Reset the job_handle we store in client
 
   gearman_task_st do_task, *do_task_ptr;
-  do_task_ptr= add_task(client, &do_task, 
+  do_task_ptr= add_task(*client, &do_task, 
                         client, 
                         command,
                         function,

libgearman/do.cc

@@ -71,12 +71,11 @@ void *client_do(gearman_client_st *client, gearman_command_t command,
 
   if (client == NULL)
   {
-    *ret_ptr= GEARMAN_ERRNO;
-    errno= EINVAL;
+    *ret_ptr= GEARMAN_INVALID_ARGUMENT;
     return NULL;
   }
 
-  gearman_task_st *do_task_ptr= add_task(client, &do_task, NULL, command,
+  gearman_task_st *do_task_ptr= add_task(*client, &do_task, NULL, command,
                                          function,
                                          local_unique,
                                          workload,
@@ -139,8 +138,13 @@ gearman_return_t client_do_background(gearman_client_st *client,
                                       gearman_string_t &workload,
                                       gearman_job_handle_t job_handle)
 {
+  if (client == NULL)
+  {
+    return GEARMAN_INVALID_ARGUMENT;
+  }
+
   gearman_task_st do_task;
-  gearman_task_st *do_task_ptr= add_task(client, &do_task, 
+  gearman_task_st *do_task_ptr= add_task(*client, &do_task, 
                                          client, 
                                          command,
                                          function,

libgearman/execute.cc

@@ -71,13 +71,12 @@ gearman_task_st *gearman_execute(gearman_client_st *client,
                                  gearman_argument_t *arguments,
                                  void *context)
 {
-  if (not client)
+  if (client == NULL)
   {
-    errno= EINVAL;
     return NULL;
   }
 
-  if (not function_name or not function_length)
+  if (function_name == NULL or function_length == 0)
   {
     gearman_error(client->universal, GEARMAN_INVALID_ARGUMENT, "function_name was NULL");
     return NULL;
@@ -91,7 +90,7 @@ gearman_task_st *gearman_execute(gearman_client_st *client,
     switch (workload->kind)
     {
     case GEARMAN_TASK_ATTR_BACKGROUND:
-      task= add_task(client,
+      task= add_task(*client,
                      context,
                      pick_command_by_priority_background(workload->priority),
                      function,
@@ -102,7 +101,7 @@ gearman_task_st *gearman_execute(gearman_client_st *client,
       break;
 
     case GEARMAN_TASK_ATTR_EPOCH:
-      task= add_task(client,
+      task= add_task(*client,
                      context,
                      GEARMAN_COMMAND_SUBMIT_JOB_EPOCH,
                      function,
@@ -113,7 +112,7 @@ gearman_task_st *gearman_execute(gearman_client_st *client,
       break;
 
     case GEARMAN_TASK_ATTR_FOREGROUND:
-      task= add_task(client,
+      task= add_task(*client,
                      context,
                      pick_command_by_priority(workload->priority),
                      function,
@@ -126,7 +125,7 @@ gearman_task_st *gearman_execute(gearman_client_st *client,
   }
   else
   {
-    task= add_task(client,
+    task= add_task(*client,
                    NULL,
                    GEARMAN_COMMAND_SUBMIT_JOB,
                    function,
@@ -136,7 +135,7 @@ gearman_task_st *gearman_execute(gearman_client_st *client,
                    gearman_actions_execute_defaults());
   }
 
-  if (not task)
+  if (task == NULL)
   {
     gearman_universal_error_code(client->universal);
 

libgearman/include.am

@@ -84,9 +84,7 @@ libgearman_libgearmancore_la_SOURCES= \
 				      libgearman/universal.cc \
 				      libgearman/vector.cc
 
-libgearman_libgearmancore_la_CXXFLAGS= \
-				       ${AM_CXXFLAGS} \
-				       -DBUILDING_LIBGEARMAN
+libgearman_libgearmancore_la_CXXFLAGS= -DBUILDING_LIBGEARMAN
 
 lib_LTLIBRARIES+= libgearman/libgearman.la
 libgearman_libgearman_la_SOURCES= \
@@ -123,15 +121,9 @@ libgearman_libgearman_la_SOURCES= \
 				  libgearman/vector.cc \
 				  libgearman/worker.cc
 
-libgearman_libgearman_la_DEPENDENCIES=
+libgearman_libgearman_la_CXXFLAGS= -DBUILDING_LIBGEARMAN
 
-libgearman_libgearman_la_CXXFLAGS= \
-				   ${AM_CXXFLAGS} \
-				   -DBUILDING_LIBGEARMAN
-
-libgearman_libgearman_la_LDFLAGS= \
-				  $(AM_LDFLAGS) \
-				  -version-info $(GEARMAN_LIBRARY_VERSION)
+libgearman_libgearman_la_LDFLAGS= -version-info $(GEARMAN_LIBRARY_VERSION)
 
 libgearman_libgearman_la_LIBADD= $(LTLIBUUID)
 

libgearman/job.cc

@@ -104,7 +104,7 @@ struct gearman_job_reducer_st {
   {
     gearman_string_t function= gearman_string(reducer_function);
     gearman_unique_t unique= gearman_unique_make(0, 0);
-    gearman_task_st *task= add_task(client,
+    gearman_task_st *task= add_task(*client,
                                     NULL,
                                     GEARMAN_COMMAND_SUBMIT_JOB,
                                     function,
@@ -112,7 +112,7 @@ struct gearman_job_reducer_st {
                                     arguments.value,
                                     time_t(0),
                                     gearman_actions_execute_defaults());
-    if (not task)
+    if (task = NULL)
     {
       gearman_universal_error_code(client->universal);
 

tests/workers.cc

@@ -58,7 +58,7 @@ using namespace libtest;
 gearman_return_t echo_or_react_worker_v2(gearman_job_st *job, void *)
 {
   const void *workload= gearman_job_workload(job);
-  size_t result_size= gearman_job_workload_size(job);
+  const size_t result_size= gearman_job_workload_size(job);
 
   if (workload == NULL or result_size == 0)
   {
@@ -97,7 +97,7 @@ gearman_return_t echo_or_react_worker_v2(gearman_job_st *job, void *)
 gearman_return_t echo_or_react_chunk_worker_v2(gearman_job_st *job, void *)
 {
   const char *workload= (const char *)gearman_job_workload(job);
-  size_t workload_size= gearman_job_workload_size(job);
+  const size_t workload_size= gearman_job_workload_size(job);
 
   bool fail= false;
   if (workload_size == test_literal_param_size("fail") and (not memcmp(workload, test_literal_param("fail"))))