add macros for api visibility to openzap

git-svn-id: http://svn.openzap.org/svn/openzap/trunk@688 a93c3328-9c30-0410-af19-c9cd2b2d52af
2025-08-13 09:36:46 +00:00 · 2009-03-10 15:49:27 +00:00
parent 36d330d39f
commit 6c1e0688c3
15 changed files with 328 additions and 246 deletions
--- a/libs/freetdm/src/include/libteletone.h
+++ b/libs/freetdm/src/include/libteletone.h
@@ -110,6 +110,32 @@ typedef __int16 int16_t;
 #define teletone_assert(expr) assert(expr)
 #endif

+#ifdef _MSC_VER
+#if defined(TT_DECLARE_STATIC)
+#define TELETONE_API(type)			type __stdcall
+#define TELETONE_API_NONSTD(type)		type __cdecl
+#define TELETONE_API_DATA
+#elif defined(TELETONE_EXPORTS)
+#define TELETONE_API(type)			__declspec(dllexport) type __stdcall
+#define TELETONE_API_NONSTD(type)		__declspec(dllexport) type __cdecl
+#define TELETONE_API_DATA				__declspec(dllexport)
+#else
+#define TELETONE_API(type)			__declspec(dllimport) type __stdcall
+#define TELETONE_API_NONSTD(type)		__declspec(dllimport) type __cdecl
+#define TELETONE_API_DATA				__declspec(dllimport)
+#endif
+#else
+#if (defined(__GNUC__) || defined(__SUNPRO_CC) || defined (__SUNPRO_C)) && defined(HAVE_VISIBILITY)
+#define TELETONE_API(type)		__attribute__((visibility("default"))) type
+#define TELETONE_API_NONSTD(type)	__attribute__((visibility("default"))) type
+#define TELETONE_API_DATA		__attribute__((visibility("default")))
+#else
+#define TELETONE_API(type)		type
+#define TELETONE_API_NONSTD(type)	type
+#define TELETONE_API_DATA
+#endif
+#endif
+
 #include <libteletone_generate.h>
 #include <libteletone_detect.h>

@@ -131,5 +157,5 @@ typedef __int16 int16_t;
 * c-basic-offset:4
 * End:
 * For VIM:
- * vim:set softtabstop=4 shiftwidth=4 tabstop=4 expandtab:
+ * vim:set softtabstop=4 shiftwidth=4 tabstop=4:
 */
--- a/libs/freetdm/src/include/libteletone_detect.h
+++ b/libs/freetdm/src/include/libteletone_detect.h
@@ -169,7 +169,7 @@ extern "C" {
 	  \param mt the multi-frequency tone descriptor
 	  \param map a representation of the multi-frequency tone
 	*/
-	void teletone_multi_tone_init(teletone_multi_tone_t *mt, teletone_tone_map_t *map);
+TELETONE_API(void) teletone_multi_tone_init(teletone_multi_tone_t *mt, teletone_tone_map_t *map);

 	/*! 
 	  \brief Check a sample buffer for the presence of the mulit-frequency tone described by mt
@@ -178,7 +178,7 @@ extern "C" {
 	  \param samples the number of samples present in sample_buffer
 	  \return true when the tone was detected or false when it is not
 	*/
-	int teletone_multi_tone_detect (teletone_multi_tone_t *mt,
+TELETONE_API(int) teletone_multi_tone_detect (teletone_multi_tone_t *mt,
 									int16_t sample_buffer[],
 									int samples);

@@ -187,7 +187,7 @@ extern "C" {
 	  \param dtmf_detect_state the DTMF detection state to initilize
 	  \param sample_rate the desired sample rate
 	*/
-	void teletone_dtmf_detect_init (teletone_dtmf_detect_state_t *dtmf_detect_state, int sample_rate);
+TELETONE_API(void) teletone_dtmf_detect_init (teletone_dtmf_detect_state_t *dtmf_detect_state, int sample_rate);

 	/*! 
 	  \brief Check a sample buffer for the presence of DTMF digits
@@ -196,7 +196,7 @@ extern "C" {
 	  \param samples the number of samples present in sample_buffer
 	  \return true when DTMF was detected or false when it is not
 	*/
-	int teletone_dtmf_detect (teletone_dtmf_detect_state_t *dtmf_detect_state,
+TELETONE_API(int) teletone_dtmf_detect (teletone_dtmf_detect_state_t *dtmf_detect_state,
 							  int16_t sample_buffer[],
 							  int samples);
 	/*! 
@@ -206,7 +206,7 @@ extern "C" {
 	  \param max the maximum length of buf
 	  \return the number of characters written to buf
 	*/
-	int teletone_dtmf_get (teletone_dtmf_detect_state_t *dtmf_detect_state,
+TELETONE_API(int) teletone_dtmf_get (teletone_dtmf_detect_state_t *dtmf_detect_state,
 						   char *buf,
 						   int max);

@@ -216,7 +216,7 @@ extern "C" {
 	  \param sample_buffer an array aof 16 bit signed linear samples
 	  \param samples the number of samples present in sample_buffer
 	*/
-	void teletone_goertzel_update(teletone_goertzel_state_t *goertzel_state,
+TELETONE_API(void) teletone_goertzel_update(teletone_goertzel_state_t *goertzel_state,
 								  int16_t sample_buffer[],
 								  int samples);

@@ -236,5 +236,5 @@ extern "C" {
 * c-basic-offset:4
 * End:
 * For VIM:
- * vim:set softtabstop=4 shiftwidth=4 tabstop=4 expandtab:
+ * vim:set softtabstop=4 shiftwidth=4 tabstop=4:
 */
--- a/libs/freetdm/src/include/libteletone_generate.h
+++ b/libs/freetdm/src/include/libteletone_generate.h
@@ -71,7 +71,7 @@ typedef __int8 int8_t;
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <math.h>
-#if !defined(powf)
+#if !defined(powf) && !defined(_WIN64)
 extern float powf (float, float);
 #endif
 #include <string.h>
@@ -102,7 +102,7 @@ typedef struct teletone_dds_state teletone_dds_state_t;
 /* 3.02 represents twice the power */
 #define DBM0_MAX_POWER (3.14f + 3.02f)

-extern int16_t TELETONE_SINES[SINE_TABLE_MAX];
+TELETONE_API_DATA extern int16_t TELETONE_SINES[SINE_TABLE_MAX];

 static __inline__ int32_t teletone_dds_phase_rate(teletone_process_t tone, uint32_t rate)
 {
@@ -220,7 +220,7 @@ typedef struct teletone_generation_session teletone_generation_session_t;
  \param ... up to TELETONE_MAX_TONES frequencies terminated by 0.0
  \return 0
 */
-int teletone_set_tone(teletone_generation_session_t *ts, int index, ...);
+TELETONE_API(int) teletone_set_tone(teletone_generation_session_t *ts, int index, ...);

 /*! 
  \brief Assign a set of tones to a single tone map
@@ -228,7 +228,7 @@ int teletone_set_tone(teletone_generation_session_t *ts, int index, ...);
  \param ... up to TELETONE_MAX_TONES frequencies terminated by 0.0
  \return 0
 */
-int teletone_set_map(teletone_tone_map_t *map, ...);
+TELETONE_API(int) teletone_set_map(teletone_tone_map_t *map, ...);

 /*! 
  \brief Initilize a tone generation session
@@ -238,14 +238,14 @@ int teletone_set_map(teletone_tone_map_t *map, ...);
  \param user_data optional user data to send
  \return 0
 */
-int teletone_init_session(teletone_generation_session_t *ts, int buflen, tone_handler handler, void *user_data);
+TELETONE_API(int) teletone_init_session(teletone_generation_session_t *ts, int buflen, tone_handler handler, void *user_data);

 /*! 
  \brief Free the buffer allocated by a tone generation session
  \param ts the tone generation session to destroy
  \return 0
 */
-int teletone_destroy_session(teletone_generation_session_t *ts);
+TELETONE_API(int) teletone_destroy_session(teletone_generation_session_t *ts);

 /*! 
  \brief Execute a single tone generation instruction
@@ -253,7 +253,7 @@ int teletone_destroy_session(teletone_generation_session_t *ts);
  \param map the tone mapping to use for the frequencies
  \return 0
 */
-int teletone_mux_tones(teletone_generation_session_t *ts, teletone_tone_map_t *map);
+TELETONE_API(int) teletone_mux_tones(teletone_generation_session_t *ts, teletone_tone_map_t *map);

 /*! 
  \brief Execute a tone generation script and call callbacks after each instruction
@@ -261,7 +261,7 @@ int teletone_mux_tones(teletone_generation_session_t *ts, teletone_tone_map_t *m
  \param cmd the script to execute
  \return 0
 */
-int teletone_run(teletone_generation_session_t *ts, const char *cmd);
+TELETONE_API(int) teletone_run(teletone_generation_session_t *ts, const char *cmd);

 #ifdef __cplusplus
 }
@@ -277,5 +277,5 @@ int teletone_run(teletone_generation_session_t *ts, const char *cmd);
 * c-basic-offset:4
 * End:
 * For VIM:
- * vim:set softtabstop=4 shiftwidth=4 tabstop=4 expandtab:
+ * vim:set softtabstop=4 shiftwidth=4 tabstop=4:
 */
--- a/libs/freetdm/src/include/openzap.h
+++ b/libs/freetdm/src/include/openzap.h
@@ -47,11 +47,37 @@
 #endif

 #ifndef __WINDOWS__
-#if defined(WIN32) || defined(WIN64) || defined(_MSC_VER) || defined(_WIN32)
+#if defined(WIN32) || defined(WIN64) || defined(_MSC_VER) || defined(_WIN32) || defined(_WIN64)
 #define __WINDOWS__
 #endif
 #endif

+#ifdef _MSC_VER
+#if defined(OZ_DECLARE_STATIC)
+#define OZ_DECLARE(type)			type __stdcall
+#define OZ_DECLARE_NONSTD(type)		type __cdecl
+#define OZ_DECLARE_DATA
+#elif defined(OPENZAP_EXPORTS)
+#define OZ_DECLARE(type)			__declspec(dllexport) type __stdcall
+#define OZ_DECLARE_NONSTD(type)		__declspec(dllexport) type __cdecl
+#define OZ_DECLARE_DATA				__declspec(dllexport)
+#else
+#define OZ_DECLARE(type)			__declspec(dllimport) type __stdcall
+#define OZ_DECLARE_NONSTD(type)		__declspec(dllimport) type __cdecl
+#define OZ_DECLARE_DATA				__declspec(dllimport)
+#endif
+#else
+#if (defined(__GNUC__) || defined(__SUNPRO_CC) || defined (__SUNPRO_C)) && defined(HAVE_VISIBILITY)
+#define OZ_DECLARE(type)		__attribute__((visibility("default"))) type
+#define OZ_DECLARE_NONSTD(type)	__attribute__((visibility("default"))) type
+#define OZ_DECLARE_DATA		__attribute__((visibility("default")))
+#else
+#define OZ_DECLARE(type)		type
+#define OZ_DECLARE_NONSTD(type)	type
+#define OZ_DECLARE_DATA
+#endif
+#endif
+
 #ifdef _MSC_VER
 #ifndef __inline__
 #define __inline__ __inline
@@ -89,9 +115,9 @@

 #define ZAP_THREAD_STACKSIZE 240 * 1024
 #define ZAP_ENUM_NAMES(_NAME, _STRINGS) static const char * _NAME [] = { _STRINGS , NULL };
-#define ZAP_STR2ENUM_P(_FUNC1, _FUNC2, _TYPE) _TYPE _FUNC1 (const char *name); const char * _FUNC2 (_TYPE type);
+#define ZAP_STR2ENUM_P(_FUNC1, _FUNC2, _TYPE) OZ_DECLARE(_TYPE) _FUNC1 (const char *name); OZ_DECLARE(const char *) _FUNC2 (_TYPE type);
 #define ZAP_STR2ENUM(_FUNC1, _FUNC2, _TYPE, _STRINGS, _MAX)	\
-	_TYPE _FUNC1 (const char *name)							\
+	OZ_DECLARE(_TYPE) _FUNC1 (const char *name)							\
 	{														\
 		int i;												\
 		_TYPE t = _MAX ;									\
@@ -105,7 +131,7 @@
 															\
 		return t;											\
 	}														\
-	const char * _FUNC2 (_TYPE type)						\
+	OZ_DECLARE(const char *) _FUNC2 (_TYPE type)						\
 	{														\
 		if (type > _MAX) {									\
 			type = _MAX;									\
@@ -123,7 +149,7 @@


 #include <time.h>
-#ifndef WIN32
+#ifndef __WINDOWS__
 #include <sys/time.h>
 #endif

@@ -146,7 +172,7 @@

 #define XX if (0)

-#ifdef WIN32
+#ifdef __WINDOWS__
 #define zap_sleep(x) Sleep(x)
 #else
 #define zap_sleep(x) usleep(x * 1000)
@@ -304,8 +330,8 @@ struct zap_stream_handle {
 };


-zap_status_t zap_console_stream_raw_write(zap_stream_handle_t *handle, uint8_t *data, zap_size_t datalen);
-zap_status_t zap_console_stream_write(zap_stream_handle_t *handle, const char *fmt, ...);
+OZ_DECLARE_NONSTD(zap_status_t) zap_console_stream_raw_write(zap_stream_handle_t *handle, uint8_t *data, zap_size_t datalen);
+OZ_DECLARE_NONSTD(zap_status_t) zap_console_stream_write(zap_stream_handle_t *handle, const char *fmt, ...);

 #define ZAP_CMD_CHUNK_LEN 1024
 #define ZAP_STANDARD_STREAM(s) memset(&s, 0, sizeof(s)); s.data = malloc(ZAP_CMD_CHUNK_LEN); \
@@ -526,7 +552,7 @@ struct zap_span {
 };


-extern zap_logger_t zap_log;
+OZ_DECLARE_DATA extern zap_logger_t zap_log;

 struct zap_io_interface {
 	const char *name;
@@ -547,16 +573,16 @@ struct zap_io_interface {
 };


-zap_size_t zap_fsk_modulator_generate_bit(zap_fsk_modulator_t *fsk_trans, int8_t bit, int16_t *buf, zap_size_t buflen);
-int32_t zap_fsk_modulator_generate_carrier_bits(zap_fsk_modulator_t *fsk_trans, uint32_t bits);
-void zap_fsk_modulator_generate_chan_sieze(zap_fsk_modulator_t *fsk_trans);
-void zap_fsk_modulator_send_data(zap_fsk_modulator_t *fsk_trans);
+OZ_DECLARE(zap_size_t) zap_fsk_modulator_generate_bit(zap_fsk_modulator_t *fsk_trans, int8_t bit, int16_t *buf, zap_size_t buflen);
+OZ_DECLARE(int32_t) zap_fsk_modulator_generate_carrier_bits(zap_fsk_modulator_t *fsk_trans, uint32_t bits);
+OZ_DECLARE(void) zap_fsk_modulator_generate_chan_sieze(zap_fsk_modulator_t *fsk_trans);
+OZ_DECLARE(void) zap_fsk_modulator_send_data(zap_fsk_modulator_t *fsk_trans);
 #define zap_fsk_modulator_send_all(_it) zap_fsk_modulator_generate_chan_sieze(_it); \
 	zap_fsk_modulator_generate_carrier_bits(_it, _it->carrier_bits_start); \
 	zap_fsk_modulator_send_data(_it); \
 	zap_fsk_modulator_generate_carrier_bits(_it, _it->carrier_bits_stop)

-zap_status_t zap_fsk_modulator_init(zap_fsk_modulator_t *fsk_trans,
+OZ_DECLARE(zap_status_t) zap_fsk_modulator_init(zap_fsk_modulator_t *fsk_trans,
 									fsk_modem_types_t modem_type,
 									uint32_t sample_rate,
 									zap_fsk_data_state_t *fsk_data,
@@ -566,72 +592,72 @@ zap_status_t zap_fsk_modulator_init(zap_fsk_modulator_t *fsk_trans,
 									uint32_t chan_sieze_bits,
 									zap_fsk_write_sample_t write_sample_callback,
 									void *user_data);
-int8_t zap_bitstream_get_bit(zap_bitstream_t *bsp);
-void zap_bitstream_init(zap_bitstream_t *bsp, uint8_t *data, uint32_t datalen, zap_endian_t endian, uint8_t ss);
-zap_status_t zap_fsk_data_parse(zap_fsk_data_state_t *state, zap_size_t *type, char **data, zap_size_t *len);
-zap_status_t zap_fsk_demod_feed(zap_fsk_data_state_t *state, int16_t *data, size_t samples);
-zap_status_t zap_fsk_demod_destroy(zap_fsk_data_state_t *state);
-int zap_fsk_demod_init(zap_fsk_data_state_t *state, int rate, uint8_t *buf, size_t bufsize);
-zap_status_t zap_fsk_data_init(zap_fsk_data_state_t *state, uint8_t *data, uint32_t datalen);
-zap_status_t zap_fsk_data_add_mdmf(zap_fsk_data_state_t *state, zap_mdmf_type_t type, const uint8_t *data, uint32_t datalen);
-zap_status_t zap_fsk_data_add_checksum(zap_fsk_data_state_t *state);
-zap_status_t zap_fsk_data_add_sdmf(zap_fsk_data_state_t *state, const char *date, char *number);
-zap_status_t zap_channel_outgoing_call(zap_channel_t *zchan);
-void zap_channel_rotate_tokens(zap_channel_t *zchan);
-void zap_channel_clear_detected_tones(zap_channel_t *zchan);
-void zap_channel_clear_needed_tones(zap_channel_t *zchan);
-zap_status_t zap_channel_get_alarms(zap_channel_t *zchan);
-zap_status_t zap_channel_send_fsk_data(zap_channel_t *zchan, zap_fsk_data_state_t *fsk_data, float db_level);
-zap_status_t zap_channel_clear_token(zap_channel_t *zchan, const char *token);
-zap_status_t zap_channel_add_token(zap_channel_t *zchan, char *token, int end);
-zap_status_t zap_channel_set_state(zap_channel_t *zchan, zap_channel_state_t state, int lock);
-zap_status_t zap_span_load_tones(zap_span_t *span, const char *mapname);
-zap_size_t zap_channel_dequeue_dtmf(zap_channel_t *zchan, char *dtmf, zap_size_t len);
-zap_status_t zap_channel_queue_dtmf(zap_channel_t *zchan, const char *dtmf);
-void zap_channel_flush_dtmf(zap_channel_t *zchan);
-zap_time_t zap_current_time_in_ms(void);
-zap_status_t zap_span_poll_event(zap_span_t *span, uint32_t ms);
-zap_status_t zap_span_next_event(zap_span_t *span, zap_event_t **event);
-zap_status_t zap_span_find(uint32_t id, zap_span_t **span);
-zap_status_t zap_span_create(zap_io_interface_t *zio, zap_span_t **span);
-zap_status_t zap_span_close_all(void);
-zap_status_t zap_span_add_channel(zap_span_t *span, zap_socket_t sockfd, zap_chan_type_t type, zap_channel_t **chan);
-zap_status_t zap_span_set_event_callback(zap_span_t *span, zio_event_cb_t event_callback);
-zap_status_t zap_channel_set_event_callback(zap_channel_t *zchan, zio_event_cb_t event_callback);
-zap_status_t zap_channel_open(uint32_t span_id, uint32_t chan_id, zap_channel_t **zchan);
-zap_status_t zap_channel_open_chan(zap_channel_t *zchan);
-zap_status_t zap_channel_open_any(uint32_t span_id, zap_direction_t direction, zap_caller_data_t *caller_data, zap_channel_t **zchan);
-zap_status_t zap_channel_close(zap_channel_t **zchan);
-zap_status_t zap_channel_done(zap_channel_t *zchan);
-zap_status_t zap_channel_use(zap_channel_t *zchan);
-zap_status_t zap_channel_command(zap_channel_t *zchan, zap_command_t command, void *obj);
-zap_status_t zap_channel_wait(zap_channel_t *zchan, zap_wait_flag_t *flags, int32_t to);
-zap_status_t zap_channel_read(zap_channel_t *zchan, void *data, zap_size_t *datalen);
-zap_status_t zap_channel_write(zap_channel_t *zchan, void *data, zap_size_t datasize, zap_size_t *datalen);
-zap_status_t zap_channel_add_var(zap_channel_t *zchan, const char *var_name, const char *value);
-const char * zap_channel_get_var(zap_channel_t *zchan, const char *var_name);
-zap_status_t zap_channel_clear_vars(zap_channel_t *zchan);
-zap_status_t zap_global_init(void);
-zap_status_t zap_global_destroy(void);
-void zap_global_set_logger(zap_logger_t logger);
-void zap_global_set_default_logger(int level);
-uint32_t zap_separate_string(char *buf, char delim, char **array, int arraylen);
-void print_bits(uint8_t *b, int bl, char *buf, int blen, int e, uint8_t ss);
-void print_hex_bytes(uint8_t *data, zap_size_t dlen, char *buf, zap_size_t blen);
-int zap_hash_equalkeys(void *k1, void *k2);
-uint32_t zap_hash_hashfromstring(void *ky);
-uint32_t zap_running(void);
-zap_status_t zap_channel_complete_state(zap_channel_t *zchan);
-zap_status_t zap_channel_init(zap_channel_t *zchan);
-int zap_load_modules(void);
-zap_status_t zap_unload_modules(void);
-zap_status_t zap_configure_span(const char *type, zap_span_t *span, zio_signal_cb_t sig_cb, ...);
-zap_status_t zap_span_start(zap_span_t *span);
-int zap_load_module(const char *name);
-int zap_load_module_assume(const char *name);
-zap_status_t zap_span_find_by_name(const char *name, zap_span_t **span);
-char *zap_api_execute(const char *type, const char *cmd);
-int zap_vasprintf(char **ret, const char *fmt, va_list ap);
+OZ_DECLARE(int8_t) zap_bitstream_get_bit(zap_bitstream_t *bsp);
+OZ_DECLARE(void) zap_bitstream_init(zap_bitstream_t *bsp, uint8_t *data, uint32_t datalen, zap_endian_t endian, uint8_t ss);
+OZ_DECLARE(zap_status_t) zap_fsk_data_parse(zap_fsk_data_state_t *state, zap_size_t *type, char **data, zap_size_t *len);
+OZ_DECLARE(zap_status_t) zap_fsk_demod_feed(zap_fsk_data_state_t *state, int16_t *data, size_t samples);
+OZ_DECLARE(zap_status_t) zap_fsk_demod_destroy(zap_fsk_data_state_t *state);
+OZ_DECLARE(int) zap_fsk_demod_init(zap_fsk_data_state_t *state, int rate, uint8_t *buf, size_t bufsize);
+OZ_DECLARE(zap_status_t) zap_fsk_data_init(zap_fsk_data_state_t *state, uint8_t *data, uint32_t datalen);
+OZ_DECLARE(zap_status_t) zap_fsk_data_add_mdmf(zap_fsk_data_state_t *state, zap_mdmf_type_t type, const uint8_t *data, uint32_t datalen);
+OZ_DECLARE(zap_status_t) zap_fsk_data_add_checksum(zap_fsk_data_state_t *state);
+OZ_DECLARE(zap_status_t) zap_fsk_data_add_sdmf(zap_fsk_data_state_t *state, const char *date, char *number);
+OZ_DECLARE(zap_status_t) zap_channel_outgoing_call(zap_channel_t *zchan);
+OZ_DECLARE(void) zap_channel_rotate_tokens(zap_channel_t *zchan);
+OZ_DECLARE(void) zap_channel_clear_detected_tones(zap_channel_t *zchan);
+OZ_DECLARE(void) zap_channel_clear_needed_tones(zap_channel_t *zchan);
+OZ_DECLARE(zap_status_t) zap_channel_get_alarms(zap_channel_t *zchan);
+OZ_DECLARE(zap_status_t) zap_channel_send_fsk_data(zap_channel_t *zchan, zap_fsk_data_state_t *fsk_data, float db_level);
+OZ_DECLARE(zap_status_t) zap_channel_clear_token(zap_channel_t *zchan, const char *token);
+OZ_DECLARE(zap_status_t) zap_channel_add_token(zap_channel_t *zchan, char *token, int end);
+OZ_DECLARE(zap_status_t) zap_channel_set_state(zap_channel_t *zchan, zap_channel_state_t state, int lock);
+OZ_DECLARE(zap_status_t) zap_span_load_tones(zap_span_t *span, const char *mapname);
+OZ_DECLARE(zap_size_t) zap_channel_dequeue_dtmf(zap_channel_t *zchan, char *dtmf, zap_size_t len);
+OZ_DECLARE(zap_status_t) zap_channel_queue_dtmf(zap_channel_t *zchan, const char *dtmf);
+OZ_DECLARE(void) zap_channel_flush_dtmf(zap_channel_t *zchan);
+OZ_DECLARE(zap_time_t) zap_current_time_in_ms(void);
+OZ_DECLARE(zap_status_t) zap_span_poll_event(zap_span_t *span, uint32_t ms);
+OZ_DECLARE(zap_status_t) zap_span_next_event(zap_span_t *span, zap_event_t **event);
+OZ_DECLARE(zap_status_t) zap_span_find(uint32_t id, zap_span_t **span);
+OZ_DECLARE(zap_status_t) zap_span_create(zap_io_interface_t *zio, zap_span_t **span);
+OZ_DECLARE(zap_status_t) zap_span_close_all(void);
+OZ_DECLARE(zap_status_t) zap_span_add_channel(zap_span_t *span, zap_socket_t sockfd, zap_chan_type_t type, zap_channel_t **chan);
+OZ_DECLARE(zap_status_t) zap_span_set_event_callback(zap_span_t *span, zio_event_cb_t event_callback);
+OZ_DECLARE(zap_status_t) zap_channel_set_event_callback(zap_channel_t *zchan, zio_event_cb_t event_callback);
+OZ_DECLARE(zap_status_t) zap_channel_open(uint32_t span_id, uint32_t chan_id, zap_channel_t **zchan);
+OZ_DECLARE(zap_status_t) zap_channel_open_chan(zap_channel_t *zchan);
+OZ_DECLARE(zap_status_t) zap_channel_open_any(uint32_t span_id, zap_direction_t direction, zap_caller_data_t *caller_data, zap_channel_t **zchan);
+OZ_DECLARE(zap_status_t) zap_channel_close(zap_channel_t **zchan);
+OZ_DECLARE(zap_status_t) zap_channel_done(zap_channel_t *zchan);
+OZ_DECLARE(zap_status_t) zap_channel_use(zap_channel_t *zchan);
+OZ_DECLARE(zap_status_t) zap_channel_command(zap_channel_t *zchan, zap_command_t command, void *obj);
+OZ_DECLARE(zap_status_t) zap_channel_wait(zap_channel_t *zchan, zap_wait_flag_t *flags, int32_t to);
+OZ_DECLARE(zap_status_t) zap_channel_read(zap_channel_t *zchan, void *data, zap_size_t *datalen);
+OZ_DECLARE(zap_status_t) zap_channel_write(zap_channel_t *zchan, void *data, zap_size_t datasize, zap_size_t *datalen);
+OZ_DECLARE(zap_status_t) zap_channel_add_var(zap_channel_t *zchan, const char *var_name, const char *value);
+OZ_DECLARE(const char *) zap_channel_get_var(zap_channel_t *zchan, const char *var_name);
+OZ_DECLARE(zap_status_t) zap_channel_clear_vars(zap_channel_t *zchan);
+OZ_DECLARE(zap_status_t) zap_global_init(void);
+OZ_DECLARE(zap_status_t) zap_global_destroy(void);
+OZ_DECLARE(void) zap_global_set_logger(zap_logger_t logger);
+OZ_DECLARE(void) zap_global_set_default_logger(int level);
+OZ_DECLARE(uint32_t) zap_separate_string(char *buf, char delim, char **array, int arraylen);
+OZ_DECLARE(void) print_bits(uint8_t *b, int bl, char *buf, int blen, int e, uint8_t ss);
+OZ_DECLARE(void) print_hex_bytes(uint8_t *data, zap_size_t dlen, char *buf, zap_size_t blen);
+OZ_DECLARE_NONSTD(int) zap_hash_equalkeys(void *k1, void *k2);
+OZ_DECLARE_NONSTD(uint32_t) zap_hash_hashfromstring(void *ky);
+OZ_DECLARE(uint32_t) zap_running(void);
+OZ_DECLARE(zap_status_t) zap_channel_complete_state(zap_channel_t *zchan);
+OZ_DECLARE(zap_status_t) zap_channel_init(zap_channel_t *zchan);
+OZ_DECLARE(int) zap_load_modules(void);
+OZ_DECLARE(zap_status_t) zap_unload_modules(void);
+OZ_DECLARE(zap_status_t) zap_configure_span(const char *type, zap_span_t *span, zio_signal_cb_t sig_cb, ...);
+OZ_DECLARE(zap_status_t) zap_span_start(zap_span_t *span);
+OZ_DECLARE(int) zap_load_module(const char *name);
+OZ_DECLARE(int) zap_load_module_assume(const char *name);
+OZ_DECLARE(zap_status_t) zap_span_find_by_name(const char *name, zap_span_t **span);
+OZ_DECLARE(char *) zap_api_execute(const char *type, const char *cmd);
+OZ_DECLARE(int) zap_vasprintf(char **ret, const char *fmt, va_list ap);

 ZIO_CODEC_FUNCTION(zio_slin2ulaw);
 ZIO_CODEC_FUNCTION(zio_ulaw2slin);
--- a/libs/freetdm/src/include/zap_buffer.h
+++ b/libs/freetdm/src/include/zap_buffer.h
@@ -53,25 +53,25 @@ typedef struct zap_buffer zap_buffer_t;
 * \param max_len length the buffer is allowed to grow to
 * \return status
 */
-zap_status_t zap_buffer_create(zap_buffer_t **buffer, zap_size_t blocksize, zap_size_t start_len, zap_size_t max_len);
+OZ_DECLARE(zap_status_t) zap_buffer_create(zap_buffer_t **buffer, zap_size_t blocksize, zap_size_t start_len, zap_size_t max_len);

 /*! \brief Get the length of a zap_buffer_t 
 * \param buffer any buffer of type zap_buffer_t
 * \return int size of the buffer.
 */
-zap_size_t zap_buffer_len(zap_buffer_t *buffer);
+OZ_DECLARE(zap_size_t) zap_buffer_len(zap_buffer_t *buffer);

 /*! \brief Get the freespace of a zap_buffer_t 
 * \param buffer any buffer of type zap_buffer_t
 * \return int freespace in the buffer.
 */
-zap_size_t zap_buffer_freespace(zap_buffer_t *buffer);
+OZ_DECLARE(zap_size_t) zap_buffer_freespace(zap_buffer_t *buffer);

 /*! \brief Get the in use amount of a zap_buffer_t 
 * \param buffer any buffer of type zap_buffer_t
 * \return int ammount of buffer curently in use
 */
-zap_size_t zap_buffer_inuse(zap_buffer_t *buffer);
+OZ_DECLARE(zap_size_t) zap_buffer_inuse(zap_buffer_t *buffer);

 /*! \brief Read data from a zap_buffer_t up to the ammount of datalen if it is available.  Remove read data from buffer. 
 * \param buffer any buffer of type zap_buffer_t
@@ -79,7 +79,7 @@ zap_size_t zap_buffer_inuse(zap_buffer_t *buffer);
 * \param datalen amount of data to be returned
 * \return int ammount of data actually read
 */
-zap_size_t zap_buffer_read(zap_buffer_t *buffer, void *data, zap_size_t datalen);
+OZ_DECLARE(zap_size_t) zap_buffer_read(zap_buffer_t *buffer, void *data, zap_size_t datalen);

 /*! \brief Read data endlessly from a zap_buffer_t 
 * \param buffer any buffer of type zap_buffer_t
@@ -88,13 +88,13 @@ zap_size_t zap_buffer_read(zap_buffer_t *buffer, void *data, zap_size_t datalen)
 * \return int ammount of data actually read
 * \note Once you have read all the data from the buffer it will loop around.
 */
-zap_size_t zap_buffer_read_loop(zap_buffer_t *buffer, void *data, zap_size_t datalen);
+OZ_DECLARE(zap_size_t) zap_buffer_read_loop(zap_buffer_t *buffer, void *data, zap_size_t datalen);

 /*! \brief Assign a number of loops to read
 * \param buffer any buffer of type zap_buffer_t
 * \param loops the number of loops (-1 for infinite)
 */
-void zap_buffer_set_loops(zap_buffer_t *buffer, int32_t loops);
+OZ_DECLARE(void) zap_buffer_set_loops(zap_buffer_t *buffer, int32_t loops);

 /*! \brief Write data into a zap_buffer_t up to the length of datalen
 * \param buffer any buffer of type zap_buffer_t
@@ -102,36 +102,36 @@ void zap_buffer_set_loops(zap_buffer_t *buffer, int32_t loops);
 * \param datalen amount of data to be written
 * \return int amount of buffer used after the write, or 0 if no space available
 */
-zap_size_t zap_buffer_write(zap_buffer_t *buffer, const void *data, zap_size_t datalen);
+OZ_DECLARE(zap_size_t) zap_buffer_write(zap_buffer_t *buffer, const void *data, zap_size_t datalen);

 /*! \brief Remove data from the buffer
 * \param buffer any buffer of type zap_buffer_t
 * \param datalen amount of data to be removed
 * \return int size of buffer, or 0 if unable to toss that much data
 */
-zap_size_t zap_buffer_toss(zap_buffer_t *buffer, zap_size_t datalen);
+OZ_DECLARE(zap_size_t) zap_buffer_toss(zap_buffer_t *buffer, zap_size_t datalen);

 /*! \brief Remove all data from the buffer
 * \param buffer any buffer of type zap_buffer_t
 */
-void zap_buffer_zero(zap_buffer_t *buffer);
+OZ_DECLARE(void) zap_buffer_zero(zap_buffer_t *buffer);

 /*! \brief Destroy the buffer
 * \param buffer buffer to destroy
 * \note only neccessary on dynamic buffers (noop on pooled ones)
 */
-void zap_buffer_destroy(zap_buffer_t **buffer);
+OZ_DECLARE(void) zap_buffer_destroy(zap_buffer_t **buffer);

 /*! \brief Seek to offset from the beginning of the buffer
 * \param buffer buffer to seek
 * \param datalen offset in bytes
 * \return new position
 */
-zap_size_t zap_buffer_seek(zap_buffer_t *buffer, zap_size_t datalen);
+OZ_DECLARE(zap_size_t) zap_buffer_seek(zap_buffer_t *buffer, zap_size_t datalen);

 /** @} */

-zap_size_t zap_buffer_zwrite(zap_buffer_t *buffer, const void *data, zap_size_t datalen);
+OZ_DECLARE(zap_size_t) zap_buffer_zwrite(zap_buffer_t *buffer, const void *data, zap_size_t datalen);

 #endif
 /* For Emacs:
--- a/libs/freetdm/src/include/zap_threadmutex.h
+++ b/libs/freetdm/src/include/zap_threadmutex.h
@@ -27,14 +27,14 @@ typedef struct zap_mutex zap_mutex_t;
 typedef struct zap_thread zap_thread_t;
 typedef void *(*zap_thread_function_t) (zap_thread_t *, void *);

-zap_status_t zap_thread_create_detached(zap_thread_function_t func, void *data);
-zap_status_t zap_thread_create_detached_ex(zap_thread_function_t func, void *data, zap_size_t stack_size);
-void zap_thread_override_default_stacksize(zap_size_t size);
-zap_status_t zap_mutex_create(zap_mutex_t **mutex);
-zap_status_t zap_mutex_destroy(zap_mutex_t **mutex);
-zap_status_t _zap_mutex_lock(zap_mutex_t *mutex);
-zap_status_t _zap_mutex_trylock(zap_mutex_t *mutex);
-zap_status_t _zap_mutex_unlock(zap_mutex_t *mutex);
+OZ_DECLARE(zap_status_t) zap_thread_create_detached(zap_thread_function_t func, void *data);
+OZ_DECLARE(zap_status_t) zap_thread_create_detached_ex(zap_thread_function_t func, void *data, zap_size_t stack_size);
+OZ_DECLARE(void) zap_thread_override_default_stacksize(zap_size_t size);
+OZ_DECLARE(zap_status_t) zap_mutex_create(zap_mutex_t **mutex);
+OZ_DECLARE(zap_status_t) zap_mutex_destroy(zap_mutex_t **mutex);
+OZ_DECLARE(zap_status_t) _zap_mutex_lock(zap_mutex_t *mutex);
+OZ_DECLARE(zap_status_t) _zap_mutex_trylock(zap_mutex_t *mutex);
+OZ_DECLARE(zap_status_t) _zap_mutex_unlock(zap_mutex_t *mutex);

 #endif

--- a/libs/freetdm/src/include/zap_types.h
+++ b/libs/freetdm/src/include/zap_types.h
@@ -461,7 +461,7 @@ typedef zap_status_t (*zio_api_t) ZIO_API_ARGS ;
 #define ZIO_SPAN_NEXT_EVENT_FUNCTION(name) zap_status_t name ZIO_SPAN_NEXT_EVENT_ARGS
 #define ZIO_SIGNAL_CB_FUNCTION(name) zap_status_t name ZIO_SIGNAL_CB_ARGS
 #define ZIO_EVENT_CB_FUNCTION(name) zap_status_t name ZIO_EVENT_CB_ARGS
-#define ZIO_CODEC_FUNCTION(name) zap_status_t name ZIO_CODEC_ARGS
+#define ZIO_CODEC_FUNCTION(name) OZ_DECLARE_NONSTD(zap_status_t) name ZIO_CODEC_ARGS
 #define ZIO_CONFIGURE_SPAN_FUNCTION(name) zap_status_t name ZIO_CONFIGURE_SPAN_ARGS
 #define ZIO_CONFIGURE_FUNCTION(name) zap_status_t name ZIO_CONFIGURE_ARGS
 #define ZIO_OPEN_FUNCTION(name) zap_status_t name ZIO_OPEN_ARGS