Issue #800: Fix clang function declaration without a prototype errors

include/qpid/dispatch/bitmask.h

@@ -33,7 +33,7 @@
 typedef struct qd_bitmask_t qd_bitmask_t;
 
 /** Number of bits in a bitmask. */
-int qd_bitmask_width();
+int qd_bitmask_width(void);
 
 /** Create a bitmask.
  *@param initial if non-zero set all bits, else clear all bits.

include/qpid/dispatch/delivery_state.h

@@ -54,7 +54,7 @@ typedef struct {
 } qd_delivery_state_t;
 
 // allocate
-qd_delivery_state_t *qd_delivery_state();
+qd_delivery_state_t *qd_delivery_state(void);
 
 // this constructor takes ownership of err. err will be freed by
 // qd_delivery_state_free()

include/qpid/dispatch/error.h

@@ -75,17 +75,17 @@ qd_error_t qd_error_vimpl(qd_error_t code, const char *file, int line, const cha
  * Clear thread-local error code and message.
  *@return QD_ERROR_NONE
  */
-qd_error_t qd_error_clear();
+qd_error_t qd_error_clear(void);
 
 /**
  * @return Thread local error message. Includes text for error code.
  */
-QD_EXPORT const char* qd_error_message();
+QD_EXPORT const char *qd_error_message(void);
 
 /**
  *@return Thread local error code
  */
-QD_EXPORT qd_error_t qd_error_code();
+QD_EXPORT qd_error_t qd_error_code(void);
 
 /** Maximum length of a qd_error_message, useful for temporary buffers. */
 extern const int QD_ERROR_MAX;

include/qpid/dispatch/http1_codec.h

@@ -259,8 +259,7 @@ int h1_codec_tx_begin_multipart_section(h1_codec_request_state_t *hrs);
 //
 int h1_codec_tx_end_multipart(h1_codec_request_state_t *hrs);
 
-uint64_t h1_codec_tx_multipart_section_boundary_length();
-uint64_t h1_codec_tx_multipart_end_boundary_length();
-
+uint64_t h1_codec_tx_multipart_section_boundary_length(void);
+uint64_t h1_codec_tx_multipart_end_boundary_length(void);
 
 #endif // http1_codec_H

include/qpid/dispatch/internal/symbolization.h

@@ -34,7 +34,7 @@ typedef struct qd_backtrace_fileline {
 
 /// Call qd_symbolize_finalize when you are done, to free global state.
 /// This also invalidates all const char pointers previously returned.
-void qd_symbolize_finalize();
+void qd_symbolize_finalize(void);
 
 void qd_print_symbolized_backtrace_line(FILE *dump_file, const char *fallback_symbolization, int i, void *pc);
 qd_backtrace_fileline_t qd_symbolize_backtrace_line(void *target_address);

include/qpid/dispatch/io_module.h

@@ -52,9 +52,12 @@ typedef void (*qdr_adaptor_final_t) (void *adaptor_context);
  * @param on_init Pointer to a function for adaptor initialization, called at core thread startup
  * @param on_final Pointer to a function for adaptor finalization, called at core thread shutdown
  */
-#define QDR_CORE_ADAPTOR_DECLARE_ORD(name,on_init,on_final,ord)      \
-    static void adaptorstart() __attribute__((constructor)); \
-    void adaptorstart() { qdr_register_adaptor(name, on_init, on_final, ord); }
+#define QDR_CORE_ADAPTOR_DECLARE_ORD(name, on_init, on_final, ord) \
+    static void adaptorstart(void) __attribute__((constructor));   \
+    void        adaptorstart(void)                                 \
+    {                                                              \
+        qdr_register_adaptor(name, on_init, on_final, ord);        \
+    }
 #define QDR_CORE_ADAPTOR_DECLARE(name,on_init,on_final) QDR_CORE_ADAPTOR_DECLARE_ORD(name,on_init,on_final,100)
 void qdr_register_adaptor(const char         *name,
                           qdr_adaptor_init_t  on_init,

include/qpid/dispatch/log.h

@@ -78,7 +78,7 @@ void qd_vlog_impl(qd_log_source_t *source, qd_log_level_t level, bool check_leve
     } while(0)
 
 /** Maximum length for a log message */
-int qd_log_max_len();
+int qd_log_max_len(void);
 
 void qd_format_string(char* buf, int buf_size, const char *fmt, ...);
 

include/qpid/dispatch/message.h

@@ -435,9 +435,9 @@ int qd_message_stream_data_append(qd_message_t *msg, qd_buffer_list_t *data, boo
  */
 char* qd_message_repr(qd_message_t *msg, char* buffer, size_t len, qd_log_bits log_message);
 /** Recommended buffer length for qd_message_repr */
-int qd_message_repr_len();
+int qd_message_repr_len(void);
 
-qd_log_source_t* qd_message_log_source();
+qd_log_source_t *qd_message_log_source(void);
 
 /**
  * Accessor for incoming messages ingress router annotation

include/qpid/dispatch/protocol_adaptor.h

@@ -873,9 +873,8 @@ qdr_connection_info_t *qdr_connection_info(bool             is_encrypted,
 
 void qdr_connection_info_set_group_correlator(qdr_connection_info_t *info, const char *correlator);
 
-void qd_adaptor_listener_init();
-void qd_adaptor_listener_finalize();
-
+void qd_adaptor_listener_init(void);
+void qd_adaptor_listener_finalize(void);
 
 /**
  ******************************************************************************

include/qpid/dispatch/server.h

@@ -561,8 +561,7 @@ void qd_connection_invoke_deferred_impl(qd_connection_t *conn, qd_deferred_t cal
 /**
  * Allocate a qd_deferred_call_t object
  */
-void *qd_connection_new_qd_deferred_call_t();
-
+void *qd_connection_new_qd_deferred_call_t(void);
 
 /**
  * Deallocate a qd_deferred_call_t object

include/qpid/dispatch/timer.h

@@ -115,7 +115,7 @@ void qd_timer_cancel(qd_timer_t *timer);
 /**
  * The current time.
  */
-qd_timestamp_t qd_timer_now() ;
+qd_timestamp_t qd_timer_now(void);
 
 /**
  * @}

src/adaptors/adaptor_buffer.c

@@ -27,7 +27,7 @@ const size_t QD_ADAPTOR_MAX_BUFFER_SIZE = 16384;
 
 ALLOC_DEFINE_CONFIG(qd_adaptor_buffer_t, sizeof(qd_adaptor_buffer_t), &QD_ADAPTOR_MAX_BUFFER_SIZE, 0);
 
-qd_adaptor_buffer_t *qd_adaptor_buffer()
+qd_adaptor_buffer_t *qd_adaptor_buffer(void)
 {
     qd_adaptor_buffer_t *adaptor_buff = new_qd_adaptor_buffer_t();
     DEQ_ITEM_INIT(adaptor_buff);

src/adaptors/adaptor_buffer.h

@@ -35,7 +35,7 @@ struct qd_adaptor_buffer_t {
 };
 
 qd_adaptor_buffer_t *qd_adaptor_buffer_raw(pn_raw_buffer_t *buffer);
-qd_adaptor_buffer_t *qd_adaptor_buffer();
+qd_adaptor_buffer_t *qd_adaptor_buffer(void);
 
 ALLOC_DECLARE(qd_adaptor_buffer_t);
 DEQ_DECLARE(qd_adaptor_buffer_t, qd_adaptor_buffer_list_t);

src/adaptors/adaptor_listener.c

@@ -398,16 +398,14 @@ qd_listener_oper_status_t qd_adaptor_listener_oper_status(const qd_adaptor_liste
     return value;
 }
 
-
-void qd_adaptor_listener_init()
+void qd_adaptor_listener_init(void)
 {
     sys_mutex_init(&_listeners_lock);
     DEQ_INIT(_listeners);
     _finalized = false;
 }
 
-
-void qd_adaptor_listener_finalize()
+void qd_adaptor_listener_finalize(void)
 {
     _finalized = true;
     qd_adaptor_listener_t *li = DEQ_HEAD(_listeners);

src/adaptors/http1/http1_codec.c

@@ -1598,13 +1598,12 @@ int h1_codec_tx_end_multipart(h1_codec_request_state_t *hrs)
     return 0;
 }
 
-
-uint64_t h1_codec_tx_multipart_section_boundary_length()
+uint64_t h1_codec_tx_multipart_section_boundary_length(void)
 {
     return QD_DISCRIMINATOR_SIZE + 4 + 2;
 }
 
-uint64_t h1_codec_tx_multipart_end_boundary_length()
+uint64_t h1_codec_tx_multipart_end_boundary_length(void)
 {
     return QD_DISCRIMINATOR_SIZE + 4 + 4;
 }

src/adaptors/http_common.c

@@ -39,7 +39,7 @@ ALLOC_DEFINE(qd_http_adaptor_config_t);
 
 #define CHECK() if (qd_error_code()) goto error
 
-static qd_http_adaptor_config_t *qd_http_adaptor_config()
+static qd_http_adaptor_config_t *qd_http_adaptor_config(void)
 {
     qd_http_adaptor_config_t *http_config = new_qd_http_adaptor_config_t();
     assert(http_config);
@@ -367,7 +367,7 @@ typedef struct {
 
 static http_request_info_records_t* request_info = 0;
 
-static http_request_info_records_t *_get_request_info()
+static http_request_info_records_t *_get_request_info(void)
 {
     if (!request_info) {
         request_info = NEW(http_request_info_records_t);
@@ -677,7 +677,7 @@ static void _add_http_request_info(qdr_core_t *core, qdr_http_request_info_t* re
     qdr_action_enqueue(core, action);
 }
 
-static qdr_http_request_info_t* _new_qdr_http_request_info_t()
+static qdr_http_request_info_t *_new_qdr_http_request_info_t(void)
 {
     qdr_http_request_info_t* record = NEW(qdr_http_request_info_t);
     ZERO(record);

src/adaptors/tcp/tcp_adaptor.c

@@ -837,7 +837,7 @@ static char *get_global_id(char *site_id, char *host_port)
     return result;
 }
 
-static pn_data_t * qdr_tcp_conn_properties()
+static pn_data_t *qdr_tcp_conn_properties(void)
 {
    // Return a new tcp connection properties map.
     pn_data_t *props = pn_data(0);
@@ -1432,7 +1432,7 @@ static qdr_tcp_connection_t *qdr_tcp_create_dispatcher_connection(qd_tcp_connect
     return tc;
 }
 
-static qd_tcp_adaptor_config_t *qd_tcp_adaptor_config()
+static qd_tcp_adaptor_config_t *qd_tcp_adaptor_config(void)
 {
     qd_tcp_adaptor_config_t *tcp_config = new_qd_tcp_adaptor_config_t();
     if (!tcp_config)

src/bitmask.c

@@ -41,8 +41,7 @@ ALLOC_DEFINE(qd_bitmask_t);
 #define FIRST_NONE    -1
 #define FIRST_UNKNOWN -2
 
-
-int qd_bitmask_width()
+int qd_bitmask_width(void)
 {
     return QD_BITMASK_BITS;
 }

src/delivery_state.c

@@ -24,7 +24,7 @@
 ALLOC_DECLARE(qd_delivery_state_t);
 ALLOC_DEFINE(qd_delivery_state_t);
 
-qd_delivery_state_t *qd_delivery_state()
+qd_delivery_state_t *qd_delivery_state(void)
 {
     qd_delivery_state_t *dstate = new_qd_delivery_state_t();
     ZERO(dstate);

src/dispatch.c

@@ -55,7 +55,7 @@ void            qd_policy_free(qd_policy_t *policy);
 qd_router_t    *qd_router(qd_dispatch_t *qd, qd_router_mode_t mode, const char *area, const char *id);
 void            qd_router_setup_late(qd_dispatch_t *qd);
 void            qd_router_free(qd_router_t *router);
-void            qd_error_initialize();
+void            qd_error_initialize(void);
 static void qd_dispatch_set_router_id(qd_dispatch_t *qd, char *_id);
 static void qd_dispatch_set_router_area(qd_dispatch_t *qd, char *_area);
 static void qd_dispatch_policy_c_counts_free(PyObject *capsule);
@@ -69,7 +69,7 @@ sys_atomic_t global_delivery_id;
 
 qd_dispatch_t *qd = 0;
 
-qd_dispatch_t *qd_dispatch_get_dispatch()
+qd_dispatch_t *qd_dispatch_get_dispatch(void)
 {
     return qd;
 }
@@ -265,7 +265,7 @@ QD_EXPORT qd_error_t qd_dispatch_register_display_name_service(qd_dispatch_t *qd
     return qd_register_display_name_service(qd, object);
 }
 
-QD_EXPORT PyObject* qd_dispatch_policy_c_counts_alloc()
+QD_EXPORT PyObject *qd_dispatch_policy_c_counts_alloc(void)
 {
     return PyCapsule_New(qd_policy_c_counts_alloc(), "qd_policy_c_counts", qd_dispatch_policy_c_counts_free);
 }
@@ -389,7 +389,7 @@ qdr_core_t* qd_dispatch_router_core(const qd_dispatch_t *qd)
  *
  * Return 0 if the memory usage cannot be determined.
  */
-uint64_t qd_router_memory_usage()
+uint64_t qd_router_memory_usage(void)
 {
     // @TODO(kgiusti): only works for linux (what? doesn't everyone run linux?)
 

src/dispatch_private.h

@@ -62,9 +62,7 @@ struct qd_dispatch_t {
     char  *metadata;
 };
 
-qd_dispatch_t *qd_dispatch_get_dispatch();
-
-
+qd_dispatch_t *qd_dispatch_get_dispatch(void);
 
 /**
  * Configure the router node from a configuration entity.

src/entity_cache.c

@@ -51,12 +51,14 @@ static entity_event_t *entity_event(action_t action, const char *type, void *obj
 static sys_mutex_t event_lock;
 static entity_event_list_t  event_list;
 
-void qd_entity_cache_initialize() {
+void qd_entity_cache_initialize(void)
+{
     sys_mutex_init(&event_lock);
     DEQ_INIT(event_list);
 }
 
-void qd_entity_cache_free_entries() {
+void qd_entity_cache_free_entries(void)
+{
     sys_mutex_lock(&event_lock);
     entity_event_t *event = DEQ_HEAD(event_list);
     while (event) {
@@ -99,6 +101,7 @@ QD_EXPORT qd_error_t qd_entity_refresh_begin(PyObject *list) {
     return qd_error_code();
 }
 
-QD_EXPORT void qd_entity_refresh_end() {
+QD_EXPORT void qd_entity_refresh_end(void)
+{
     sys_mutex_unlock(&event_lock);
 }

src/entity_cache.h

@@ -32,10 +32,10 @@
  */
 
 /** Initialize the module. */
-void qd_entity_cache_initialize();
+void qd_entity_cache_initialize(void);
 
 /** Free all entries in the cache. Avoids leaks in c_unittests. */
-void qd_entity_cache_free_entries();
+void qd_entity_cache_free_entries(void);
 
 /** Add an entity to the agent cache. */
 void qd_entity_cache_add(const char *type, void *object);

src/error.c

@@ -66,7 +66,8 @@ static __thread struct {
 
 static qd_log_source_t* log_source = 0;
 
-void qd_error_initialize() {
+void qd_error_initialize(void)
+{
     log_source = qd_log_source("ERROR");
 }
 
@@ -99,17 +100,20 @@ qd_error_t qd_error_impl(qd_error_t code, const char *file, int line, const char
     return err;
 }
 
-qd_error_t qd_error_clear() {
+qd_error_t qd_error_clear(void)
+{
     ts.error_code = 0;
     snprintf(ts.error_message, ERROR_MAX, "No Error");
     return QD_ERROR_NONE;
 }
 
-const char* qd_error_message() {
+const char *qd_error_message(void)
+{
     return ts.error_message;
 }
 
-qd_error_t qd_error_code() {
+qd_error_t qd_error_code(void)
+{
     return ts.error_code;
 }
 

src/http-libwebsockets.c

@@ -59,7 +59,8 @@ static void logger(int lll, const char *line)  {
     qd_log(http_log, qd_level(lll), "%.*s", (int)len, line);
 }
 
-static void log_init() {
+static void log_init(void)
+{
     http_log = qd_log_source("HTTP");
     int levels = 0;
     for (int i = 0; i < LLL_COUNT; ++i) {

src/log.c

@@ -46,7 +46,10 @@ const char *QD_LOG_STATS_TYPE = "logStats";
 
 static qd_log_source_t      *default_log_source=0;
 
-int qd_log_max_len() { return TEXT_MAX; }
+int qd_log_max_len(void)
+{
+    return TEXT_MAX;
+}
 
 typedef struct qd_log_entry_t qd_log_entry_t;
 
@@ -464,7 +467,11 @@ void qd_log_impl(qd_log_source_t *source, qd_log_level_t level, const char *file
   va_end(ap);
 }
 
-static PyObject *inc_none() { Py_INCREF(Py_None); return Py_None; }
+static PyObject *inc_none(void)
+{
+    Py_INCREF(Py_None);
+    return Py_None;
+}
 
 /// Return the log buffer up to limit as a python list. Called by management agent.
 QD_EXPORT PyObject *qd_log_recent_py(long limit) {