* avahi-utils: replace python avahi-browse with a version written in C.

* remove -Wunused from GCC command line and use "unused" attribute instead
* remove AVAHI_CLIENT_S_FAILURE and AVAHI_CLIENT_S_INVALID since these event's are never forwarded to the client anyway
* make use of AVAHI_GCC_NORETURN
* really send eror code with StateChange DBUS signals
* ignore EINTR in avahi_simple_poll_loop()


git-svn-id: file:///home/lennart/svn/public/avahi/trunk@879 941a03a8-eaeb-0310-b9a0-b1bbd8fe43fe

6 files changed, 402 insertions, 386 deletions

diff --git a/avahi-compat-howl/address-test.c b/avahi-compat-howl/address-test.c
index 73c356d..05276aa 100644
--- a/avahi-compat-howl/address-test.c
+++ b/avahi-compat-howl/address-test.c
@@ -26,12 +26,14 @@
 #include <assert.h>
 #include <stdio.h>
 
+#include <avahi-common/gccmacro.h>
+
 #include "howl.h"
 
 #define ASSERT_SW_OKAY(t) { sw_result r; r = (t); assert(r == SW_OKAY); }
 #define ASSERT_NOT_NULL(t) { const void* r; r = (t); assert(r); }
 
-int main(int argc, char *argv[]) {
+int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char *argv[]) {
     sw_ipv4_address a;
     char t[256];
     uint8_t a1, a2, a3, a4;
diff --git a/avahi-compat-howl/address.c b/avahi-compat-howl/address.c
index c79b34d..1d9fbbe 100644
--- a/avahi-compat-howl/address.c
+++ b/avahi-compat-howl/address.c
@@ -31,6 +31,8 @@
 #include <arpa/inet.h>
 #include <sys/types.h>
 
+#include <avahi-common/gccmacro.h>
+
 #include "howl.h"
 #include "warn.h"
 
@@ -137,7 +139,7 @@ sw_result sw_ipv4_address_init_from_this_host(sw_ipv4_address *self) {
     return SW_OKAY;
 }
 
-sw_result sw_ipv4_address_fina(sw_ipv4_address self) {
+sw_result sw_ipv4_address_fina(AVAHI_GCC_UNUSED sw_ipv4_address self) {
 
     AVAHI_WARN_LINKAGE;
 
diff --git a/avahi-compat-howl/browse-domain-test.c b/avahi-compat-howl/browse-domain-test.c
index 2eedd48..be99d92 100644
--- a/avahi-compat-howl/browse-domain-test.c
+++ b/avahi-compat-howl/browse-domain-test.c
@@ -26,20 +26,21 @@
 #include <assert.h>
 #include <stdio.h>
 
+#include <avahi-common/gccmacro.h>
 #include "howl.h"
 
 #define ASSERT_SW_OKAY(t) { sw_result _r; _r = (t); assert(_r == SW_OKAY); }
 #define ASSERT_NOT_NULL(t) { const void* _r; r = (t); assert(_r); }
 
 static sw_result reply(
-    sw_discovery discovery,
-    sw_discovery_oid oid,
+    AVAHI_GCC_UNUSED sw_discovery discovery,
+    AVAHI_GCC_UNUSED sw_discovery_oid oid,
     sw_discovery_browse_status status,
-    sw_uint32 interface_index,
-    sw_const_string name,
-    sw_const_string type,
+    AVAHI_GCC_UNUSED sw_uint32 interface_index,
+    AVAHI_GCC_UNUSED sw_const_string name,
+    AVAHI_GCC_UNUSED sw_const_string type,
     sw_const_string domain,
-    sw_opaque extra) {
+    AVAHI_GCC_UNUSED sw_opaque extra) {
 
     switch (status) {
         case SW_DISCOVERY_BROWSE_ADD_DOMAIN:
@@ -61,7 +62,7 @@ static sw_result reply(
     return SW_OKAY;
 }
 
-int main(int argc, char *argv[]) {
+int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char *argv[]) {
     sw_discovery discovery;
     sw_discovery_oid oid;
     
diff --git a/avahi-compat-howl/compat.c b/avahi-compat-howl/compat.c
index 8e8dd06..9160fdb 100644
--- a/avahi-compat-howl/compat.c
+++ b/avahi-compat-howl/compat.c
@@ -694,7 +694,6 @@ static void reg_client_callback(oid_data *data, AvahiClientState state) {
         return;
     
     switch (state) {
-        case AVAHI_CLIENT_S_FAILURE:
         case AVAHI_CLIENT_DISCONNECTED:
             reg_report_status(data, SW_DISCOVERY_PUBLISH_INVALID);
             break;
@@ -717,7 +716,6 @@ static void reg_client_callback(oid_data *data, AvahiClientState state) {
             avahi_entry_group_reset(data->object);
             break;
 
-        case AVAHI_CLIENT_S_INVALID:
         case AVAHI_CLIENT_S_REGISTERING:
             /* Ignore */
             break;
@@ -836,10 +834,10 @@ finish:
 static void domain_browser_callback(
     AvahiDomainBrowser *b,
     AvahiIfIndex interface,
-    AvahiProtocol protocol,
+    AVAHI_GCC_UNUSED AvahiProtocol protocol,
     AvahiBrowserEvent event,
     const char *domain,
-    AvahiLookupResultFlags flags,
+    AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
     void *userdata) {
 
     oid_data* data = userdata;
@@ -922,7 +920,7 @@ finish:
 static void service_resolver_callback(
     AvahiServiceResolver *r,
     AvahiIfIndex interface,
-    AvahiProtocol protocol,
+    AVAHI_GCC_UNUSED AvahiProtocol protocol,
     AvahiResolverEvent event,
     const char *name,
     const char *type,
@@ -931,7 +929,7 @@ static void service_resolver_callback(
     const AvahiAddress *a,
     uint16_t port,
     AvahiStringList *txt,
-    AvahiLookupResultFlags flags,
+    AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
     void *userdata) {
 
     oid_data* data = userdata;
@@ -1031,12 +1029,12 @@ finish:
 static void service_browser_callback(
     AvahiServiceBrowser *b,
     AvahiIfIndex interface,
-    AvahiProtocol protocol,
+    AVAHI_GCC_UNUSED AvahiProtocol protocol,
     AvahiBrowserEvent event,
     const char *name,
     const char *type,
     const char *domain,
-    AvahiLookupResultFlags flags,
+    AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
     void *userdata) {
 
     oid_data* data = userdata;
diff --git a/avahi-compat-howl/text-test.c b/avahi-compat-howl/text-test.c
index 995a7f5..fea653c 100644
--- a/avahi-compat-howl/text-test.c
+++ b/avahi-compat-howl/text-test.c
@@ -26,6 +26,7 @@
 #include <assert.h>
 #include <stdio.h>
 
+#include <avahi-common/gccmacro.h>
 #include "howl.h"
 
 #define ASSERT_SW_OKAY(t) { sw_result _r; _r = (t); assert(_r == SW_OKAY); }
@@ -65,7 +66,7 @@ static void hexdump(const void* p, size_t size) {
     }
 }
 
-int main(int argc, char *argv[]) {
+int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char *argv[]) {
     sw_text_record r;
     sw_text_record_iterator it;
     char key[255];
diff --git a/avahi-compat-howl/unsupported.c b/avahi-compat-howl/unsupported.c
index 09baf13..800b3c3 100644
--- a/avahi-compat-howl/unsupported.c
+++ b/avahi-compat-howl/unsupported.c
@@ -23,987 +23,999 @@
 #include <config.h>
 #endif
 
+#include <avahi-common/gccmacro.h>
+
 #include "howl.h"
 #include "warn.h"
 
-sw_string sw_strdup(sw_const_string str) {
+AVAHI_GCC_NORETURN
+sw_string sw_strdup(AVAHI_GCC_UNUSED sw_const_string str) {
     AVAHI_WARN_UNSUPPORTED_ABORT;
-    return NULL;
 }
 
+AVAHI_GCC_NORETURN
 sw_opaque _sw_debug_malloc(
-    sw_size_t size,
-    sw_const_string function,
-    sw_const_string file,
-    sw_uint32 line) {
+    AVAHI_GCC_UNUSED sw_size_t size,
+    AVAHI_GCC_UNUSED sw_const_string function,
+    AVAHI_GCC_UNUSED sw_const_string file,
+    AVAHI_GCC_UNUSED sw_uint32 line) {
     AVAHI_WARN_UNSUPPORTED_ABORT;
-    return NULL;
 }
 
+AVAHI_GCC_NORETURN
 sw_opaque _sw_debug_realloc(
-   sw_opaque_t mem,
-   sw_size_t size,
-   sw_const_string function,
-   sw_const_string file,
-   sw_uint32 line) {
+    AVAHI_GCC_UNUSED sw_opaque_t mem,
+    AVAHI_GCC_UNUSED sw_size_t size,
+    AVAHI_GCC_UNUSED sw_const_string function,
+    AVAHI_GCC_UNUSED sw_const_string file,
+    AVAHI_GCC_UNUSED sw_uint32 line) {
     AVAHI_WARN_UNSUPPORTED_ABORT;
-    return NULL;
 }
 
 void _sw_debug_free(
-    sw_opaque_t mem,
-    sw_const_string function,
-    sw_const_string file,
-    sw_uint32 line) {
+    AVAHI_GCC_UNUSED sw_opaque_t mem,
+    AVAHI_GCC_UNUSED sw_const_string function,
+    AVAHI_GCC_UNUSED sw_const_string file,
+    AVAHI_GCC_UNUSED sw_uint32 line) {
     AVAHI_WARN_UNSUPPORTED;
 }
 
+AVAHI_GCC_NORETURN
 sw_const_string sw_strerror(/* howl sucks */) {
     AVAHI_WARN_UNSUPPORTED_ABORT;
-    return NULL;
 }
 
-sw_result sw_timer_init(sw_timer * self) {
+sw_result sw_timer_init(AVAHI_GCC_UNUSED sw_timer * self) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
-sw_result sw_timer_fina(sw_timer self) {
+sw_result sw_timer_fina(AVAHI_GCC_UNUSED sw_timer self) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
-sw_result sw_time_init(sw_time * self) {
+sw_result sw_time_init(AVAHI_GCC_UNUSED sw_time * self) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
-sw_result sw_time_init_now(sw_time * self) {
+sw_result sw_time_init_now(AVAHI_GCC_UNUSED sw_time * self) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
-sw_result sw_time_fina(sw_time self) {
+sw_result sw_time_fina(AVAHI_GCC_UNUSED sw_time self) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
+AVAHI_GCC_NORETURN
 sw_time sw_time_add(
-    sw_time self,
-    sw_time y) {
+    AVAHI_GCC_UNUSED sw_time self,
+    AVAHI_GCC_UNUSED sw_time y) {
     AVAHI_WARN_UNSUPPORTED_ABORT;
 }
 
+AVAHI_GCC_NORETURN 
 sw_time sw_time_sub(
-  sw_time self,
-  sw_time y) {
+    AVAHI_GCC_UNUSED sw_time self,
+    AVAHI_GCC_UNUSED sw_time y) {
     AVAHI_WARN_UNSUPPORTED_ABORT;
 }
 
+AVAHI_GCC_NORETURN 
 sw_int32 sw_time_cmp(
-  sw_time self,
-  sw_time y) {
+    AVAHI_GCC_UNUSED sw_time self,
+    AVAHI_GCC_UNUSED sw_time y) {
     AVAHI_WARN_UNSUPPORTED_ABORT;
 }
 
 sw_result sw_salt_init(
-    sw_salt * self,
-    int argc,
-    char ** argv) {
+    AVAHI_GCC_UNUSED sw_salt * self,
+    AVAHI_GCC_UNUSED int argc,
+    AVAHI_GCC_UNUSED char ** argv) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
-sw_result sw_salt_fina(sw_salt self) {
+sw_result sw_salt_fina(AVAHI_GCC_UNUSED sw_salt self) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_salt_register_socket(
-    sw_salt self,
-    struct _sw_socket * socket,
-    sw_socket_event events,
-    sw_socket_handler handler,
-    sw_socket_handler_func func,
-    sw_opaque extra) {
+    AVAHI_GCC_UNUSED sw_salt self,
+    AVAHI_GCC_UNUSED struct _sw_socket * _socket,
+    AVAHI_GCC_UNUSED sw_socket_event events,
+    AVAHI_GCC_UNUSED sw_socket_handler handler,
+    AVAHI_GCC_UNUSED sw_socket_handler_func func,
+    AVAHI_GCC_UNUSED sw_opaque extra) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_salt_unregister_socket(
-    sw_salt self,
-    struct _sw_socket * socket) {
+    AVAHI_GCC_UNUSED sw_salt self,
+    AVAHI_GCC_UNUSED struct _sw_socket * _socket) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 
 sw_result sw_salt_register_timer(
-    sw_salt self,
-    struct _sw_timer * timer,
-    sw_time timeout,
-    sw_timer_handler handler,
-    sw_timer_handler_func func,
-    sw_opaque extra) {
+    AVAHI_GCC_UNUSED sw_salt self,
+    AVAHI_GCC_UNUSED struct _sw_timer * timer,
+    AVAHI_GCC_UNUSED sw_time timeout,
+    AVAHI_GCC_UNUSED sw_timer_handler handler,
+    AVAHI_GCC_UNUSED sw_timer_handler_func func,
+    AVAHI_GCC_UNUSED sw_opaque extra) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_salt_unregister_timer(
-    sw_salt self,
-    struct _sw_timer * timer) {
+    AVAHI_GCC_UNUSED sw_salt self,
+    AVAHI_GCC_UNUSED struct _sw_timer * timer) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_salt_register_network_interface(
-    sw_salt self,
-    struct _sw_network_interface * netif,
-    sw_network_interface_handler handler,
-    sw_network_interface_handler_func func,
-    sw_opaque extra) {
+    AVAHI_GCC_UNUSED sw_salt self,
+    AVAHI_GCC_UNUSED struct _sw_network_interface * netif,
+    AVAHI_GCC_UNUSED sw_network_interface_handler handler,
+    AVAHI_GCC_UNUSED sw_network_interface_handler_func func,
+    AVAHI_GCC_UNUSED sw_opaque extra) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
-sw_result sw_salt_unregister_network_interface_handler(sw_salt self) {
+sw_result sw_salt_unregister_network_interface_handler(AVAHI_GCC_UNUSED sw_salt self) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_salt_register_signal(
-    sw_salt self,
-    struct _sw_signal * signal,
-    sw_signal_handler handler,
-    sw_signal_handler_func func,
-    sw_opaque extra) {
+    AVAHI_GCC_UNUSED sw_salt self,
+    AVAHI_GCC_UNUSED struct _sw_signal * _signal,
+    AVAHI_GCC_UNUSED sw_signal_handler handler,
+    AVAHI_GCC_UNUSED sw_signal_handler_func func,
+    AVAHI_GCC_UNUSED sw_opaque extra) {
 
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_salt_unregister_signal(
-    sw_salt self,
-    struct _sw_signal * signal) {
+    AVAHI_GCC_UNUSED sw_salt self,
+    AVAHI_GCC_UNUSED struct _sw_signal * _signal) {
 
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 void sw_print_assert(
-    int code,
-    sw_const_string assert_string,
-    sw_const_string file,
-    sw_const_string func,
-    int line) {
+    AVAHI_GCC_UNUSED int code,
+    AVAHI_GCC_UNUSED sw_const_string assert_string,
+    AVAHI_GCC_UNUSED sw_const_string file,
+    AVAHI_GCC_UNUSED sw_const_string func,
+    AVAHI_GCC_UNUSED int line) {
     AVAHI_WARN_UNSUPPORTED;
 }
 
 void sw_print_debug(
-    int level,
-    sw_const_string format,
+    AVAHI_GCC_UNUSED int level,
+    AVAHI_GCC_UNUSED sw_const_string format,
     ...) {
     AVAHI_WARN_UNSUPPORTED;
 }
 
-sw_result sw_tcp_socket_init(sw_socket * self) {
+sw_result sw_tcp_socket_init(AVAHI_GCC_UNUSED sw_socket * self) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_tcp_socket_init_with_desc(
-    sw_socket * self,
-    sw_sockdesc_t desc) {
+    AVAHI_GCC_UNUSED sw_socket * self,
+    AVAHI_GCC_UNUSED sw_sockdesc_t desc) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
-sw_result sw_udp_socket_init(
-    sw_socket * self) {
+sw_result sw_udp_socket_init(AVAHI_GCC_UNUSED sw_socket * self) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
-sw_result sw_multicast_socket_init(
-    sw_socket * self) {
+sw_result sw_multicast_socket_init(AVAHI_GCC_UNUSED sw_socket * self) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
-sw_result sw_socket_fina(sw_socket self) {
+sw_result sw_socket_fina(AVAHI_GCC_UNUSED sw_socket self) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_socket_bind(
-    sw_socket self,
-    sw_ipv4_address address,
-    sw_port port) {
+    AVAHI_GCC_UNUSED sw_socket self,
+    AVAHI_GCC_UNUSED sw_ipv4_address address,
+    AVAHI_GCC_UNUSED sw_port port) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_socket_join_multicast_group(
-    sw_socket self,
-    sw_ipv4_address local_address,
-    sw_ipv4_address multicast_address,
-    sw_uint32 ttl) {
+    AVAHI_GCC_UNUSED sw_socket self,
+    AVAHI_GCC_UNUSED sw_ipv4_address local_address,
+    AVAHI_GCC_UNUSED sw_ipv4_address multicast_address,
+    AVAHI_GCC_UNUSED sw_uint32 ttl) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
-sw_result sw_socket_leave_multicast_group(sw_socket self) {
+sw_result sw_socket_leave_multicast_group(AVAHI_GCC_UNUSED sw_socket self) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_socket_listen(
-    sw_socket self,
-    int qsize) {
+    AVAHI_GCC_UNUSED sw_socket self,
+    AVAHI_GCC_UNUSED int qsize) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_socket_connect(
-    sw_socket self,
-    sw_ipv4_address address,
-    sw_port port) {
+    AVAHI_GCC_UNUSED sw_socket self,
+    AVAHI_GCC_UNUSED sw_ipv4_address address,
+    AVAHI_GCC_UNUSED sw_port port) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_socket_accept(
-    sw_socket self,
-    sw_socket * socket) {
+    AVAHI_GCC_UNUSED sw_socket self,
+    AVAHI_GCC_UNUSED sw_socket * _socket) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_socket_send(
-    sw_socket self,
-    sw_octets buffer,
-    sw_size_t len,
-    sw_size_t * bytesWritten) {
+    AVAHI_GCC_UNUSED sw_socket self,
+    AVAHI_GCC_UNUSED sw_octets buffer,
+    AVAHI_GCC_UNUSED sw_size_t len,
+    AVAHI_GCC_UNUSED sw_size_t * bytesWritten) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_socket_sendto(
-    sw_socket self,
-    sw_octets buffer,
-    sw_size_t len,
-    sw_size_t * bytesWritten,
-    sw_ipv4_address to,
-    sw_port port) {
+    AVAHI_GCC_UNUSED sw_socket self,
+    AVAHI_GCC_UNUSED sw_octets buffer,
+    AVAHI_GCC_UNUSED sw_size_t len,
+    AVAHI_GCC_UNUSED sw_size_t * bytesWritten,
+    AVAHI_GCC_UNUSED sw_ipv4_address to,
+    AVAHI_GCC_UNUSED sw_port port) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_socket_recv(
-    sw_socket self,
-    sw_octets buffer,
-    sw_size_t max,
-    sw_size_t * len) {
+    AVAHI_GCC_UNUSED sw_socket self,
+    AVAHI_GCC_UNUSED sw_octets buffer,
+    AVAHI_GCC_UNUSED sw_size_t max,
+    AVAHI_GCC_UNUSED sw_size_t * len) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_socket_recvfrom(
-    sw_socket self,
-    sw_octets buffer,
-    sw_size_t max,
-    sw_size_t * len,
-    sw_ipv4_address * from,
-    sw_port * port,
-    sw_ipv4_address * dest,
-    sw_uint32 * interface_index) {
+    AVAHI_GCC_UNUSED sw_socket self,
+    AVAHI_GCC_UNUSED sw_octets buffer,
+    AVAHI_GCC_UNUSED sw_size_t max,
+    AVAHI_GCC_UNUSED sw_size_t * len,
+    AVAHI_GCC_UNUSED sw_ipv4_address * from,
+    AVAHI_GCC_UNUSED sw_port * port,
+    AVAHI_GCC_UNUSED sw_ipv4_address * dest,
+    AVAHI_GCC_UNUSED sw_uint32 * interface_index) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_socket_set_blocking_mode(
-    sw_socket self,
-    sw_bool blocking_mode) {
+    AVAHI_GCC_UNUSED sw_socket self,
+    AVAHI_GCC_UNUSED sw_bool blocking_mode) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_socket_set_options(
-    sw_socket self,
-    sw_socket_options options) {
+    AVAHI_GCC_UNUSED sw_socket self,
+    AVAHI_GCC_UNUSED sw_socket_options options) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
-sw_ipv4_address sw_socket_ipv4_address(sw_socket self) {
+AVAHI_GCC_NORETURN 
+sw_ipv4_address sw_socket_ipv4_address(AVAHI_GCC_UNUSED sw_socket self) {
     AVAHI_WARN_UNSUPPORTED_ABORT;
 }
 
-sw_port sw_socket_port(sw_socket self) {
+AVAHI_GCC_NORETURN 
+sw_port sw_socket_port(AVAHI_GCC_UNUSED sw_socket self) {
     AVAHI_WARN_UNSUPPORTED_ABORT;
 }
 
-sw_sockdesc_t sw_socket_desc(sw_socket self) {
+AVAHI_GCC_NORETURN 
+sw_sockdesc_t sw_socket_desc(AVAHI_GCC_UNUSED sw_socket self) {
     AVAHI_WARN_UNSUPPORTED_ABORT;
 }
 
-sw_result sw_socket_close(sw_socket self) {
+sw_result sw_socket_close(AVAHI_GCC_UNUSED sw_socket self) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
-sw_result sw_socket_options_init(sw_socket_options * self) {
+sw_result sw_socket_options_init(AVAHI_GCC_UNUSED sw_socket_options * self) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
-sw_result sw_socket_options_fina(sw_socket_options self) {
+sw_result sw_socket_options_fina(AVAHI_GCC_UNUSED sw_socket_options self) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_socket_options_set_debug(
-    sw_socket_options self,
-    sw_bool val) {
+    AVAHI_GCC_UNUSED sw_socket_options self,
+    AVAHI_GCC_UNUSED sw_bool val) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_socket_options_set_nodelay(
-    sw_socket_options self,
-    sw_bool val) {
+    AVAHI_GCC_UNUSED sw_socket_options self,
+    AVAHI_GCC_UNUSED sw_bool val) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_socket_options_set_dontroute(
-    sw_socket_options self,
-    sw_bool val) {
+    AVAHI_GCC_UNUSED sw_socket_options self,
+    AVAHI_GCC_UNUSED sw_bool val) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_socket_options_set_keepalive(
-    sw_socket_options self,
-    sw_bool val) {
+    AVAHI_GCC_UNUSED sw_socket_options self,
+    AVAHI_GCC_UNUSED sw_bool val) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_socket_options_set_linger(
-    sw_socket_options self,
-    sw_bool onoff,
-    sw_uint32 linger) {
+    AVAHI_GCC_UNUSED sw_socket_options self,
+    AVAHI_GCC_UNUSED sw_bool onoff,
+    AVAHI_GCC_UNUSED sw_uint32 linger) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_socket_options_set_reuseaddr(
-    sw_socket_options self,
-    sw_bool val) {
+    AVAHI_GCC_UNUSED sw_socket_options self,
+    AVAHI_GCC_UNUSED sw_bool val) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_socket_options_set_rcvbuf(
-    sw_socket_options self,
-    sw_uint32 val) {
+    AVAHI_GCC_UNUSED sw_socket_options self,
+    AVAHI_GCC_UNUSED sw_uint32 val) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_socket_options_set_sndbuf(
-    sw_socket_options self,
-    sw_uint32 val) {
+    AVAHI_GCC_UNUSED sw_socket_options self,
+    AVAHI_GCC_UNUSED sw_uint32 val) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
+AVAHI_GCC_NORETURN 
 int sw_socket_error_code(void) {
     AVAHI_WARN_UNSUPPORTED_ABORT;
 }
 
 sw_result sw_corby_orb_init(
-    sw_corby_orb * self,
-    sw_salt salt,
-    const sw_corby_orb_config * config,
-    sw_corby_orb_observer observer,
-    sw_corby_orb_observer_func func,
-    sw_opaque_t extra) {
+    AVAHI_GCC_UNUSED sw_corby_orb * self,
+    AVAHI_GCC_UNUSED sw_salt salt,
+    AVAHI_GCC_UNUSED const sw_corby_orb_config * config,
+    AVAHI_GCC_UNUSED sw_corby_orb_observer observer,
+    AVAHI_GCC_UNUSED sw_corby_orb_observer_func func,
+    AVAHI_GCC_UNUSED sw_opaque_t extra) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
-sw_result sw_corby_orb_fina(sw_corby_orb self) {
+sw_result sw_corby_orb_fina(AVAHI_GCC_UNUSED sw_corby_orb self) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_orb_register_servant(
-    sw_corby_orb self,
-    sw_corby_servant servant,
-    sw_corby_servant_cb cb,
-    sw_const_string oid,
-    struct _sw_corby_object ** object,
-    sw_const_string protocol_name) {
+    AVAHI_GCC_UNUSED sw_corby_orb self,
+    AVAHI_GCC_UNUSED sw_corby_servant servant,
+    AVAHI_GCC_UNUSED sw_corby_servant_cb cb,
+    AVAHI_GCC_UNUSED sw_const_string oid,
+    AVAHI_GCC_UNUSED struct _sw_corby_object ** object,
+    AVAHI_GCC_UNUSED sw_const_string protocol_name) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_orb_unregister_servant(
-    sw_corby_orb self,
-    sw_const_string oid) {
+    AVAHI_GCC_UNUSED sw_corby_orb self,
+    AVAHI_GCC_UNUSED sw_const_string oid) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_orb_register_bidirectional_object(
-    sw_corby_orb self,
-    struct _sw_corby_object * object) {
+    AVAHI_GCC_UNUSED sw_corby_orb self,
+    AVAHI_GCC_UNUSED struct _sw_corby_object * object) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_orb_register_channel(
-    sw_corby_orb self,
-    struct _sw_corby_channel * channel) {
+    AVAHI_GCC_UNUSED sw_corby_orb self,
+    AVAHI_GCC_UNUSED struct _sw_corby_channel * channel) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
-sw_corby_orb_delegate sw_corby_orb_get_delegate(sw_corby_orb self) {
+AVAHI_GCC_NORETURN 
+sw_corby_orb_delegate sw_corby_orb_get_delegate(AVAHI_GCC_UNUSED sw_corby_orb self) {
     AVAHI_WARN_UNSUPPORTED_ABORT;
 }
 
 sw_result sw_corby_orb_set_delegate(
-    sw_corby_orb self,
-    sw_corby_orb_delegate delegate) {
+    AVAHI_GCC_UNUSED sw_corby_orb self,
+    AVAHI_GCC_UNUSED sw_corby_orb_delegate delegate) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_orb_set_observer(
-    sw_corby_orb self,
-    sw_corby_orb_observer observer,
-    sw_corby_orb_observer_func func,
-    sw_opaque_t extra) {
+    AVAHI_GCC_UNUSED sw_corby_orb self,
+    AVAHI_GCC_UNUSED sw_corby_orb_observer observer,
+    AVAHI_GCC_UNUSED sw_corby_orb_observer_func func,
+    AVAHI_GCC_UNUSED sw_opaque_t extra) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_orb_protocol_to_address(
-    sw_corby_orb self,
-    sw_const_string tag,
-    sw_string addr,
-    sw_port * port) {
+    AVAHI_GCC_UNUSED sw_corby_orb self,
+    AVAHI_GCC_UNUSED sw_const_string tag,
+    AVAHI_GCC_UNUSED sw_string addr,
+    AVAHI_GCC_UNUSED sw_port * port) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_orb_protocol_to_url(
-    sw_corby_orb self,
-    sw_const_string tag,
-    sw_const_string name,
-    sw_string url,
-    sw_size_t url_len) {
+    AVAHI_GCC_UNUSED sw_corby_orb self,
+    AVAHI_GCC_UNUSED sw_const_string tag,
+    AVAHI_GCC_UNUSED sw_const_string name,
+    AVAHI_GCC_UNUSED sw_string url,
+    AVAHI_GCC_UNUSED sw_size_t url_len) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_orb_read_channel(
-    sw_corby_orb self,
-    struct _sw_corby_channel * channel) {
+    AVAHI_GCC_UNUSED sw_corby_orb self,
+    AVAHI_GCC_UNUSED struct _sw_corby_channel * channel) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_orb_dispatch_message(
-    sw_corby_orb self,
-    struct _sw_corby_channel * channel,
-    struct _sw_corby_message * message,
-    struct _sw_corby_buffer * buffer,
-    sw_uint8 endian) {
+    AVAHI_GCC_UNUSED sw_corby_orb self,
+    AVAHI_GCC_UNUSED struct _sw_corby_channel * channel,
+    AVAHI_GCC_UNUSED struct _sw_corby_message * message,
+    AVAHI_GCC_UNUSED struct _sw_corby_buffer * buffer,
+    AVAHI_GCC_UNUSED sw_uint8 endian) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
-sw_result sw_corby_message_init(sw_corby_message * self) {
+sw_result sw_corby_message_init(AVAHI_GCC_UNUSED sw_corby_message * self) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
-sw_result sw_corby_message_fina(sw_corby_message self) {
+sw_result sw_corby_message_fina(AVAHI_GCC_UNUSED sw_corby_message self) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
-sw_result sw_corby_buffer_init(sw_corby_buffer * self) {
+sw_result sw_corby_buffer_init(AVAHI_GCC_UNUSED sw_corby_buffer * self) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_buffer_init_with_size(
-    sw_corby_buffer * self,
-    sw_size_t size) {
+    AVAHI_GCC_UNUSED sw_corby_buffer * self,
+    AVAHI_GCC_UNUSED sw_size_t size) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_buffer_init_with_delegate(
-    sw_corby_buffer * self,
-    sw_corby_buffer_delegate delegate,
-    sw_corby_buffer_overflow_func overflow,
-    sw_corby_buffer_underflow_func underflow,
-    sw_opaque_t extra) {
+    AVAHI_GCC_UNUSED sw_corby_buffer * self,
+    AVAHI_GCC_UNUSED sw_corby_buffer_delegate delegate,
+    AVAHI_GCC_UNUSED sw_corby_buffer_overflow_func overflow,
+    AVAHI_GCC_UNUSED sw_corby_buffer_underflow_func underflow,
+    AVAHI_GCC_UNUSED sw_opaque_t extra) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_buffer_init_with_size_and_delegate(
-    sw_corby_buffer * self,
-    sw_size_t size,
-    sw_corby_buffer_delegate delegate,
-    sw_corby_buffer_overflow_func overflow,
-    sw_corby_buffer_underflow_func underflow,
-    sw_opaque_t extra) {
+    AVAHI_GCC_UNUSED sw_corby_buffer * self,
+    AVAHI_GCC_UNUSED sw_size_t size,
+    AVAHI_GCC_UNUSED sw_corby_buffer_delegate delegate,
+    AVAHI_GCC_UNUSED sw_corby_buffer_overflow_func overflow,
+    AVAHI_GCC_UNUSED sw_corby_buffer_underflow_func underflow,
+    AVAHI_GCC_UNUSED sw_opaque_t extra) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
-sw_result sw_corby_buffer_fina(sw_corby_buffer self) {
+sw_result sw_corby_buffer_fina(AVAHI_GCC_UNUSED sw_corby_buffer self) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }    
 
-void sw_corby_buffer_reset(sw_corby_buffer self) {
+void sw_corby_buffer_reset(AVAHI_GCC_UNUSED sw_corby_buffer self) {
     AVAHI_WARN_UNSUPPORTED;
 }
 
 sw_result sw_corby_buffer_set_octets(
-    sw_corby_buffer self,
-    sw_octets octets,
-    sw_size_t size) {
+    AVAHI_GCC_UNUSED sw_corby_buffer self,
+    AVAHI_GCC_UNUSED sw_octets octets,
+    AVAHI_GCC_UNUSED sw_size_t size) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
-sw_octets sw_corby_buffer_octets(sw_corby_buffer self) {
+sw_octets sw_corby_buffer_octets(AVAHI_GCC_UNUSED sw_corby_buffer self) {
     AVAHI_WARN_UNSUPPORTED;
     return NULL;
 }
 
-sw_size_t sw_corby_buffer_bytes_used(sw_corby_buffer self) {
+sw_size_t sw_corby_buffer_bytes_used(AVAHI_GCC_UNUSED sw_corby_buffer self) {
     AVAHI_WARN_UNSUPPORTED;
     return 0;
 }
 
-sw_size_t sw_corby_buffer_size(sw_corby_buffer self) {
+sw_size_t sw_corby_buffer_size(AVAHI_GCC_UNUSED sw_corby_buffer self) {
     AVAHI_WARN_UNSUPPORTED;
     return 0;
 }
 
-sw_result sw_corby_buffer_put_int8(sw_corby_buffer self, sw_int8 val) {
+sw_result sw_corby_buffer_put_int8(
+    AVAHI_GCC_UNUSED sw_corby_buffer self,
+    AVAHI_GCC_UNUSED sw_int8 val) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_buffer_put_uint8(
-    sw_corby_buffer self,
-    sw_uint8 val) {
+    AVAHI_GCC_UNUSED sw_corby_buffer self,
+    AVAHI_GCC_UNUSED sw_uint8 val) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_buffer_put_int16(
-    sw_corby_buffer self,
-    sw_int16 val) {
+    AVAHI_GCC_UNUSED sw_corby_buffer self,
+    AVAHI_GCC_UNUSED sw_int16 val) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_buffer_put_uint16(
-    sw_corby_buffer self,
-    sw_uint16 val) {
+    AVAHI_GCC_UNUSED sw_corby_buffer self,
+    AVAHI_GCC_UNUSED sw_uint16 val) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_buffer_put_int32(
-    sw_corby_buffer self,
-    sw_int32 val) {
+    AVAHI_GCC_UNUSED sw_corby_buffer self,
+    AVAHI_GCC_UNUSED sw_int32 val) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_buffer_put_uint32(
-    sw_corby_buffer self,
-    sw_uint32 val) {
+    AVAHI_GCC_UNUSED sw_corby_buffer self,
+    AVAHI_GCC_UNUSED sw_uint32 val) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_buffer_put_octets(
-    sw_corby_buffer self,
-    sw_const_octets val,
-    sw_size_t size) {
+    AVAHI_GCC_UNUSED sw_corby_buffer self,
+    AVAHI_GCC_UNUSED sw_const_octets val,
+    AVAHI_GCC_UNUSED sw_size_t size) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_buffer_put_sized_octets(
-    sw_corby_buffer self,
-    sw_const_octets val,
-    sw_uint32 len) {
+    AVAHI_GCC_UNUSED sw_corby_buffer self,
+    AVAHI_GCC_UNUSED sw_const_octets val,
+    AVAHI_GCC_UNUSED sw_uint32 len) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
     
 sw_result sw_corby_buffer_put_cstring(
-    sw_corby_buffer self,
-    sw_const_string val) {
+    AVAHI_GCC_UNUSED sw_corby_buffer self,
+    AVAHI_GCC_UNUSED sw_const_string val) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_buffer_put_object(
-    sw_corby_buffer self,
-    const struct _sw_corby_object * object) {
+    AVAHI_GCC_UNUSED sw_corby_buffer self,
+    AVAHI_GCC_UNUSED const struct _sw_corby_object * object) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_buffer_put_pad(
-    sw_corby_buffer self,
-    sw_corby_buffer_pad pad) {
+    AVAHI_GCC_UNUSED sw_corby_buffer self,
+    AVAHI_GCC_UNUSED sw_corby_buffer_pad pad) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_buffer_get_int8(
-    sw_corby_buffer self,
-    sw_int8 * val) {
+    AVAHI_GCC_UNUSED sw_corby_buffer self,
+    AVAHI_GCC_UNUSED sw_int8 * val) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_buffer_get_uint8(
-    sw_corby_buffer self,
-    sw_uint8 * val) {
+    AVAHI_GCC_UNUSED sw_corby_buffer self,
+    AVAHI_GCC_UNUSED sw_uint8 * val) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_buffer_get_int16(
-    sw_corby_buffer self,
-    sw_int16 * val,
-    sw_uint8 endian) {
+    AVAHI_GCC_UNUSED sw_corby_buffer self,
+    AVAHI_GCC_UNUSED sw_int16 * val,
+    AVAHI_GCC_UNUSED sw_uint8 endian) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
     
 sw_result sw_corby_buffer_get_uint16(
-    sw_corby_buffer self,
-    sw_uint16 * val,
-    sw_uint8 endian) {
+    AVAHI_GCC_UNUSED sw_corby_buffer self,
+    AVAHI_GCC_UNUSED sw_uint16 * val,
+    AVAHI_GCC_UNUSED sw_uint8 endian) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
     
 sw_result sw_corby_buffer_get_int32(
-    sw_corby_buffer self,
-    sw_int32 * val,
-    sw_uint8 endian) {
+    AVAHI_GCC_UNUSED sw_corby_buffer self,
+    AVAHI_GCC_UNUSED sw_int32 * val,
+    AVAHI_GCC_UNUSED sw_uint8 endian) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_buffer_get_uint32(
-    sw_corby_buffer self,
-    sw_uint32 * val,
-    sw_uint8 endian) {
+    AVAHI_GCC_UNUSED sw_corby_buffer self,
+    AVAHI_GCC_UNUSED sw_uint32 * val,
+    AVAHI_GCC_UNUSED sw_uint8 endian) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_buffer_get_octets(
-    sw_corby_buffer self,
-    sw_octets octets,
-    sw_size_t size) {
+    AVAHI_GCC_UNUSED sw_corby_buffer self,
+    AVAHI_GCC_UNUSED sw_octets octets,
+    AVAHI_GCC_UNUSED sw_size_t size) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_buffer_allocate_and_get_sized_octets(
-    sw_corby_buffer self,
-    sw_octets * val,
-    sw_uint32 * size,
-    sw_uint8 endian) {
+    AVAHI_GCC_UNUSED sw_corby_buffer self,
+    AVAHI_GCC_UNUSED sw_octets * val,
+    AVAHI_GCC_UNUSED sw_uint32 * size,
+    AVAHI_GCC_UNUSED sw_uint8 endian) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_buffer_get_zerocopy_sized_octets(
-    sw_corby_buffer self,
-    sw_octets * val,
-    sw_uint32 * size,
-    sw_uint8 endian) {
+    AVAHI_GCC_UNUSED sw_corby_buffer self,
+    AVAHI_GCC_UNUSED sw_octets * val,
+    AVAHI_GCC_UNUSED sw_uint32 * size,
+    AVAHI_GCC_UNUSED sw_uint8 endian) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_buffer_get_sized_octets(
-    sw_corby_buffer self,
-    sw_octets val,
-    sw_uint32 * len,
-    sw_uint8 endian) {
+    AVAHI_GCC_UNUSED sw_corby_buffer self,
+    AVAHI_GCC_UNUSED sw_octets val,
+    AVAHI_GCC_UNUSED sw_uint32 * len,
+    AVAHI_GCC_UNUSED sw_uint8 endian) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_buffer_allocate_and_get_cstring(
-    sw_corby_buffer self,
-    sw_string * val,
-    sw_uint32 * len,
-    sw_uint8 endian) {
+    AVAHI_GCC_UNUSED sw_corby_buffer self,
+    AVAHI_GCC_UNUSED sw_string * val,
+    AVAHI_GCC_UNUSED sw_uint32 * len,
+    AVAHI_GCC_UNUSED sw_uint8 endian) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_buffer_get_zerocopy_cstring(
-    sw_corby_buffer self,
-    sw_string * val,
-    sw_uint32 * len,
-    sw_uint8 endian) {
+    AVAHI_GCC_UNUSED sw_corby_buffer self,
+    AVAHI_GCC_UNUSED sw_string * val,
+    AVAHI_GCC_UNUSED sw_uint32 * len,
+    AVAHI_GCC_UNUSED sw_uint8 endian) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_buffer_get_cstring(
-    sw_corby_buffer self,
-    sw_string val,
-    sw_uint32 * len,
-    sw_uint8 endian) {
+    AVAHI_GCC_UNUSED sw_corby_buffer self,
+    AVAHI_GCC_UNUSED sw_string val,
+    AVAHI_GCC_UNUSED sw_uint32 * len,
+    AVAHI_GCC_UNUSED sw_uint8 endian) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_buffer_get_object(
-    sw_corby_buffer self,
-    struct _sw_corby_object ** object,
-    sw_uint8 endian) {
+    AVAHI_GCC_UNUSED sw_corby_buffer self,
+    AVAHI_GCC_UNUSED struct _sw_corby_object ** object,
+    AVAHI_GCC_UNUSED sw_uint8 endian) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_channel_start_request(
-    sw_corby_channel self,
-    sw_const_corby_profile profile,
-    struct _sw_corby_buffer ** buffer,
-    sw_const_string op,
-    sw_uint32 oplen,
-    sw_bool reply_expected) {
+    AVAHI_GCC_UNUSED sw_corby_channel self,
+    AVAHI_GCC_UNUSED sw_const_corby_profile profile,
+    AVAHI_GCC_UNUSED struct _sw_corby_buffer ** buffer,
+    AVAHI_GCC_UNUSED sw_const_string op,
+    AVAHI_GCC_UNUSED sw_uint32 oplen,
+    AVAHI_GCC_UNUSED sw_bool reply_expected) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
     
 sw_result sw_corby_channel_start_reply(
-    sw_corby_channel self,
-    struct _sw_corby_buffer ** buffer,
-    sw_uint32 request_id,
-    sw_corby_reply_status status) {
+    AVAHI_GCC_UNUSED sw_corby_channel self,
+    AVAHI_GCC_UNUSED struct _sw_corby_buffer ** buffer,
+    AVAHI_GCC_UNUSED sw_uint32 request_id,
+    AVAHI_GCC_UNUSED sw_corby_reply_status status) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_channel_send(
-    sw_corby_channel self,
-    struct _sw_corby_buffer * buffer,
-    sw_corby_buffer_observer observer,
-    sw_corby_buffer_written_func func,
-    sw_opaque_t extra) {
+    AVAHI_GCC_UNUSED sw_corby_channel self,
+    AVAHI_GCC_UNUSED struct _sw_corby_buffer * buffer,
+    AVAHI_GCC_UNUSED sw_corby_buffer_observer observer,
+    AVAHI_GCC_UNUSED sw_corby_buffer_written_func func,
+    AVAHI_GCC_UNUSED sw_opaque_t extra) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_channel_recv(
-    sw_corby_channel self,
-    sw_salt * salt,
-    struct _sw_corby_message ** message,
-    sw_uint32 * request_id,
-    sw_string * op,
-    sw_uint32 * op_len,
-    struct _sw_corby_buffer ** buffer,
-    sw_uint8 * endian,
-    sw_bool block) {
+    AVAHI_GCC_UNUSED sw_corby_channel self,
+    AVAHI_GCC_UNUSED sw_salt * salt,
+    AVAHI_GCC_UNUSED struct _sw_corby_message ** message,
+    AVAHI_GCC_UNUSED sw_uint32 * request_id,
+    AVAHI_GCC_UNUSED sw_string * op,
+    AVAHI_GCC_UNUSED sw_uint32 * op_len,
+    AVAHI_GCC_UNUSED struct _sw_corby_buffer ** buffer,
+    AVAHI_GCC_UNUSED sw_uint8 * endian,
+    AVAHI_GCC_UNUSED sw_bool block) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_channel_last_recv_from(
-    sw_corby_channel self,
-    sw_ipv4_address * from,
-    sw_port * from_port) {
+    AVAHI_GCC_UNUSED sw_corby_channel self,
+    AVAHI_GCC_UNUSED sw_ipv4_address * from,
+    AVAHI_GCC_UNUSED sw_port * from_port) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_channel_ff(
-    sw_corby_channel self,
-    struct _sw_corby_buffer * buffer) {
+    AVAHI_GCC_UNUSED sw_corby_channel self,
+    AVAHI_GCC_UNUSED struct _sw_corby_buffer * buffer) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
-sw_socket sw_corby_channel_socket(sw_corby_channel self) {
-    AVAHI_WARN_UNSUPPORTED;
-    return SW_E_NO_IMPL;
+AVAHI_GCC_NORETURN
+sw_socket sw_corby_channel_socket(AVAHI_GCC_UNUSED sw_corby_channel self) {
+    AVAHI_WARN_UNSUPPORTED_ABORT;
 }
 
-sw_result sw_corby_channel_retain(sw_corby_channel self) {
+sw_result sw_corby_channel_retain(AVAHI_GCC_UNUSED sw_corby_channel self) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_channel_set_delegate(
-    sw_corby_channel self,
-    sw_corby_channel_delegate delegate) {
+    AVAHI_GCC_UNUSED sw_corby_channel self,
+    AVAHI_GCC_UNUSED sw_corby_channel_delegate delegate) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }    
 
+AVAHI_GCC_NORETURN 
 sw_corby_channel_delegate sw_corby_channel_get_delegate(
-    sw_corby_channel self) {
+    AVAHI_GCC_UNUSED sw_corby_channel self) {
     AVAHI_WARN_UNSUPPORTED_ABORT;
 }
 
 void sw_corby_channel_set_app_data(
-    sw_corby_channel self,
-    sw_opaque app_data) {
+    AVAHI_GCC_UNUSED sw_corby_channel self,
+    AVAHI_GCC_UNUSED sw_opaque app_data) {
     AVAHI_WARN_UNSUPPORTED;
 }
 
-sw_opaque sw_corby_channel_get_app_data(sw_corby_channel self) {
+AVAHI_GCC_NORETURN 
+sw_opaque sw_corby_channel_get_app_data(AVAHI_GCC_UNUSED sw_corby_channel self) {
     AVAHI_WARN_UNSUPPORTED_ABORT;
 }
 
-sw_result sw_corby_channel_fina(sw_corby_channel self) {
+sw_result sw_corby_channel_fina(AVAHI_GCC_UNUSED sw_corby_channel self) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_object_init_from_url(
-    sw_corby_object * self,
-    struct _sw_corby_orb * orb,
-    sw_const_string url,
-    sw_socket_options options,
-    sw_uint32 bufsize) {
+    AVAHI_GCC_UNUSED sw_corby_object * self,
+    AVAHI_GCC_UNUSED struct _sw_corby_orb * orb,
+    AVAHI_GCC_UNUSED sw_const_string url,
+    AVAHI_GCC_UNUSED sw_socket_options options,
+    AVAHI_GCC_UNUSED sw_uint32 bufsize) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_object_fina(
-    sw_corby_object self) {
+    AVAHI_GCC_UNUSED sw_corby_object self) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_object_start_request(
-    sw_corby_object self,
-    sw_const_string op,
-    sw_uint32 op_len,
-    sw_bool reply_expected,
-    sw_corby_buffer * buffer) {
+    AVAHI_GCC_UNUSED sw_corby_object self,
+    AVAHI_GCC_UNUSED sw_const_string op,
+    AVAHI_GCC_UNUSED sw_uint32 op_len,
+    AVAHI_GCC_UNUSED sw_bool reply_expected,
+    AVAHI_GCC_UNUSED sw_corby_buffer * buffer) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_object_send(
-    sw_corby_object self,
-    sw_corby_buffer buffer,
-    sw_corby_buffer_observer observer,
-    sw_corby_buffer_written_func func,
-    sw_opaque extra) {
+    AVAHI_GCC_UNUSED sw_corby_object self,
+    AVAHI_GCC_UNUSED sw_corby_buffer buffer,
+    AVAHI_GCC_UNUSED sw_corby_buffer_observer observer,
+    AVAHI_GCC_UNUSED sw_corby_buffer_written_func func,
+    AVAHI_GCC_UNUSED sw_opaque extra) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
     
 sw_result sw_corby_object_recv(
-    sw_corby_object self,
-    sw_corby_message * message,
-    sw_corby_buffer * buffer,
-    sw_uint8 * endian,
-    sw_bool block) {
+    AVAHI_GCC_UNUSED sw_corby_object self,
+    AVAHI_GCC_UNUSED sw_corby_message * message,
+    AVAHI_GCC_UNUSED sw_corby_buffer * buffer,
+    AVAHI_GCC_UNUSED sw_uint8 * endian,
+    AVAHI_GCC_UNUSED sw_bool block) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_object_channel(
-    sw_corby_object self,
-    sw_corby_channel * channel) {
+    AVAHI_GCC_UNUSED sw_corby_object self,
+    AVAHI_GCC_UNUSED sw_corby_channel * channel) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_corby_object_set_channel(
-    sw_corby_object self,
-    sw_corby_channel channel) {
+    AVAHI_GCC_UNUSED sw_corby_object self,
+    AVAHI_GCC_UNUSED sw_corby_channel channel) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_discovery_publish_host(
-    sw_discovery self,
-    sw_uint32 interface_index,
-    sw_const_string name,
-    sw_const_string domain,
-    sw_ipv4_address address,
-    sw_discovery_publish_reply reply,
-    sw_opaque extra,
-    sw_discovery_oid * oid) {
+    AVAHI_GCC_UNUSED sw_discovery self,
+    AVAHI_GCC_UNUSED sw_uint32 interface_index,
+    AVAHI_GCC_UNUSED sw_const_string name,
+    AVAHI_GCC_UNUSED sw_const_string domain,
+    AVAHI_GCC_UNUSED sw_ipv4_address address,
+    AVAHI_GCC_UNUSED sw_discovery_publish_reply reply,
+    AVAHI_GCC_UNUSED sw_opaque extra,
+    AVAHI_GCC_UNUSED sw_discovery_oid * oid) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_discovery_publish_update(
-    sw_discovery self,
-    sw_discovery_oid oid,
-    sw_octets text_record,
-    sw_uint32 text_record_len) {
+    AVAHI_GCC_UNUSED sw_discovery self,
+    AVAHI_GCC_UNUSED sw_discovery_oid oid,
+    AVAHI_GCC_UNUSED sw_octets text_record,
+    AVAHI_GCC_UNUSED sw_uint32 text_record_len) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_discovery_query_record(
-    sw_discovery self,
-    sw_uint32 interface_index,
-    sw_uint32 flags,
-    sw_const_string fullname,
-    sw_uint16 rrtype,
-    sw_uint16 rrclass,
-    sw_discovery_query_record_reply reply,
-    sw_opaque extra,
-    sw_discovery_oid * oid) {
+    AVAHI_GCC_UNUSED sw_discovery self,
+    AVAHI_GCC_UNUSED sw_uint32 interface_index,
+    AVAHI_GCC_UNUSED sw_uint32 flags,
+    AVAHI_GCC_UNUSED sw_const_string fullname,
+    AVAHI_GCC_UNUSED sw_uint16 rrtype,
+    AVAHI_GCC_UNUSED sw_uint16 rrclass,
+    AVAHI_GCC_UNUSED sw_discovery_query_record_reply reply,
+    AVAHI_GCC_UNUSED sw_opaque extra,
+    AVAHI_GCC_UNUSED sw_discovery_oid * oid) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_text_record_string_iterator_init(
-    sw_text_record_string_iterator * self,
-    sw_const_string text_record_string) {
+    AVAHI_GCC_UNUSED sw_text_record_string_iterator * self,
+    AVAHI_GCC_UNUSED sw_const_string text_record_string) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }
 
 sw_result sw_text_record_string_iterator_fina(
-    sw_text_record_string_iterator self) {
+    AVAHI_GCC_UNUSED sw_text_record_string_iterator self) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }    
 
 sw_result sw_text_record_string_iterator_next(
-    sw_text_record_string_iterator self,
-    char key[255],
-    char val[255]) {
+    AVAHI_GCC_UNUSED sw_text_record_string_iterator self,
+    AVAHI_GCC_UNUSED char key[255],
+    AVAHI_GCC_UNUSED char val[255]) {
     AVAHI_WARN_UNSUPPORTED;
     return SW_E_NO_IMPL;
 }