Export symbols in order to support shared libraries (#54)

* Add BAC_ROUTING compile definition

* Reorder cmake

* Fix OpenSSL support: support both 1.0 and 1.1t pus

* Explicitly export symbols, hidden by default

* Build shared libraries on travis using cmake

* Learn Makefile about static library

* Fix build using mingw with cmake

* Do not cleanup twice or after potential free

.appveyor.yml

@@ -1,10 +1,8 @@
-configuration: Release
-
 image:
   - Visual Studio 2019
   - Ubuntu
   - macOS
 
 build_script:
-  - cmake .
+  - cmake . -DBUILD_SHARED_LIBS=ON
-  - cmake --build . --config %CONFIGURATION%
+  - cmake --build . --config Release

.travis.yml

@@ -22,7 +22,7 @@ jobs:
     - stage: demos-build-cmake
       os: linux
       compiler: gcc
-      script: mkdir build && cd build && cmake .. && cmake --build . --clean-first
+      script: mkdir build && cd build && cmake .. -DBUILD_SHARED_LIBS=ON && cmake --build . --clean-first
     - stage: gateway-build
       os: linux
       compiler: gcc

CMakeLists.txt

@@ -76,10 +76,12 @@ message(STATUS "BACNET: BACDL_ETHERNET \"${BACDL_ETHERNET}\"")
 message(STATUS "BACNET: BACDL_NONE \"${BACDL_NONE}\"")
 
 #
-# sources
+# library
 #
 
-set(BACNETSTACK_SRCS
+find_package(Threads)
+
+add_library(${PROJECT_NAME}
     src/bacnet/abort.c
     src/bacnet/abort.h
     src/bacnet/access_rule.c
@@ -417,75 +419,6 @@ set(BACNETSTACK_SRCS
     src/bacnet/wp.h
     src/bacnet/wpm.c
     src/bacnet/wpm.h)
-
-#
-# add ports
-#
-
-set(BACNET_PORT_DIRECTORY_PATH "")
-
-if(${CMAKE_SYSTEM_NAME}
-   STREQUAL
-   "Linux")
-  message(STATUS "BACNET: building for linux")
-  set(BACNET_PORT_DIRECTORY_PATH ${CMAKE_CURRENT_LIST_DIR}/ports/linux)
-
-  list(
-    APPEND BACNETSTACK_SRCS
-           ports/linux/bacport.h
-           ports/linux/datetime-init.c
-           $<$<BOOL:${BACDL_BIP}>:ports/linux/bip-init.c>
-           $<$<BOOL:${BACDL_BIP6}>:ports/linux/bip6.c>
-           $<$<BOOL:${BACDL_ARCNET}>:ports/linux/arcnet.c>
-           $<$<BOOL:${BACDL_MSTP}>:ports/linux/rs485.c>
-           $<$<BOOL:${BACDL_MSTP}>:ports/linux/rs485.h>
-           $<$<BOOL:${BACDL_MSTP}>:ports/linux/dlmstp.c>
-           $<$<BOOL:${BACDL_MSTP}>:ports/linux/dlmstp_linux.c>
-           $<$<BOOL:${BACDL_MSTP}>:ports/linux/dlmstp_linux.h>
-           ports/linux/mstimer-init.c
-           # ports/linux/rx_fsm.c
-           $<$<BOOL:${BACDL_ETHERNET}>:ports/linux/ethernet.c>)
-
-endif()
-
-if(WIN32)
-  message(STATUS "BACNET: building for win32")
-  set(BACNET_PORT_DIRECTORY_PATH ${CMAKE_CURRENT_LIST_DIR}/ports/win32)
-
-  list(
-    APPEND BACNETSTACK_SRCS
-           ports/win32/bacport.h
-           $<$<BOOL:${BACDL_BIP6}>:ports/win32/bip6.c>
-           $<$<BOOL:${BACDL_BIP}>:ports/win32/bip-init.c>
-           # ports/win32/rx_fsm.c
-           ports/win32/datetime-init.c
-           $<$<BOOL:${BACDL_MSTP}>:ports/win32/dlmstp.c>
-           #  ports/win32/dlmstp-mm.c
-           $<$<BOOL:${BACDL_ETHERNET}>:ports/win32/ethernet.c>
-           ports/win32/mstimer-init.c
-           $<$<BOOL:${BACDL_MSTP}>:ports/win32/rs485.c>
-           $<$<BOOL:${BACDL_MSTP}>:ports/win32/rs485.h>)
-endif()
-
-if(APPLE)
-  message(STATUS "BACNET: building for APPLE")
-  set(BACNET_PORT_DIRECTORY_PATH ${CMAKE_CURRENT_LIST_DIR}/ports/bsd)
-  list(
-    APPEND BACNETSTACK_SRCS
-           ports/bsd/bacport.h
-           ports/bsd/bip-init.c
-           ports/bsd/datetime-init.c
-           ports/bsd/mstimer-init.c
-           ports/bsd/stdbool.h)
-endif()
-
-#
-# library
-#
-
-find_package(Threads)
-
-add_library(${PROJECT_NAME})
 target_sources(
   ${PROJECT_NAME}
   PRIVATE
@@ -493,12 +426,17 @@ target_sources(
 target_include_directories(
   ${PROJECT_NAME}
   PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/src/>
-         $<BUILD_INTERFACE:${BACNET_PORT_DIRECTORY_PATH}>
          $<INSTALL_INTERFACE:include/bacnet/>)
+if(BUILD_SHARED_LIBS)
+  set_target_properties(
+    ${PROJECT_NAME}
+    PROPERTIES
+      C_VISIBILITY_PRESET hidden)
+endif()
 target_compile_definitions(
   ${PROJECT_NAME}
   PUBLIC
-  -DBACNET_PROTOCOL_REVISION=${BACNET_PROTOCOL_REVISION}
+  BACNET_PROTOCOL_REVISION=${BACNET_PROTOCOL_REVISION}
   $<$<BOOL:${BACDL_BIP}>:BACDL_BIP>
   $<$<BOOL:${BACDL_BIP6}>:BACDL_BIP6>
   $<$<BOOL:${BACDL_ARCNET}>:BACDL_ARCNET>
@@ -506,15 +444,80 @@ target_compile_definitions(
   $<$<BOOL:${BACDL_ETHERNET}>:BACDL_ETHERNET>
   $<$<BOOL:${BACDL_NONE}>:BACDL_NONE>
   $<$<BOOL:${BACNET_PROPERTY_LISTS}>:BACNET_PROPERTY_LISTS>
+  $<$<BOOL:${BAC_ROUTING}>:BAC_ROUTING>
+  $<$<NOT:$<BOOL:${BUILD_SHARED_LIBS}>>:BACNET_STACK_STATIC_DEFINE>
   PRIVATE
-  -DPRINT_ENABLED=1)
+  PRINT_ENABLED=1)
-target_link_libraries(${PROJECT_NAME} PUBLIC $<$<BOOL:${WIN32}>:wsock32> Threads::Threads)
+target_link_libraries(${PROJECT_NAME} PUBLIC Threads::Threads)
 
 add_library(
   ${PROJECT_NAME}::${PROJECT_NAME}
   ALIAS
   ${PROJECT_NAME})
 
+#
+# add ports
+#
+
+set(BACNET_PORT_DIRECTORY_PATH "")
+
+if(${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
+  message(STATUS "BACNET: building for linux")
+  set(BACNET_PORT_DIRECTORY_PATH ${CMAKE_CURRENT_LIST_DIR}/ports/linux)
+
+  target_sources(${PROJECT_NAME} PRIVATE
+    ports/linux/bacport.h
+    ports/linux/datetime-init.c
+    $<$<BOOL:${BACDL_BIP}>:ports/linux/bip-init.c>
+    $<$<BOOL:${BACDL_BIP6}>:ports/linux/bip6.c>
+    $<$<BOOL:${BACDL_ARCNET}>:ports/linux/arcnet.c>
+    $<$<BOOL:${BACDL_MSTP}>:ports/linux/rs485.c>
+    $<$<BOOL:${BACDL_MSTP}>:ports/linux/rs485.h>
+    $<$<BOOL:${BACDL_MSTP}>:ports/linux/dlmstp.c>
+    $<$<BOOL:${BACDL_MSTP}>:ports/linux/dlmstp_linux.c>
+    $<$<BOOL:${BACDL_MSTP}>:ports/linux/dlmstp_linux.h>
+    # ports/linux/rx_fsm.c
+    $<$<BOOL:${BACDL_ETHERNET}>:ports/linux/ethernet.c>
+    ports/linux/mstimer-init.c)
+
+elseif(WIN32)
+  message(STATUS "BACNET: building for win32")
+  set(BACNET_PORT_DIRECTORY_PATH ${CMAKE_CURRENT_LIST_DIR}/ports/win32)
+
+  target_link_libraries(${PROJECT_NAME} PUBLIC wsock32)
+
+  target_link_libraries(${PROJECT_NAME} PRIVATE
+    winmm
+    $<$<BOOL:${BACDL_BIP}>:ws2_32>
+    $<$<BOOL:${BACDL_BIP}>:iphlpapi>)
+
+  target_sources(${PROJECT_NAME} PRIVATE
+    ports/win32/bacport.h
+    $<$<BOOL:${BACDL_BIP6}>:ports/win32/bip6.c>
+    $<$<BOOL:${BACDL_BIP}>:ports/win32/bip-init.c>
+    # ports/win32/rx_fsm.c
+    ports/win32/datetime-init.c
+    $<$<BOOL:${BACDL_MSTP}>:ports/win32/dlmstp.c>
+    #  ports/win32/dlmstp-mm.c
+    $<$<BOOL:${BACDL_ETHERNET}>:ports/win32/ethernet.c>
+    ports/win32/mstimer-init.c
+    $<$<BOOL:${BACDL_MSTP}>:ports/win32/rs485.c>
+    $<$<BOOL:${BACDL_MSTP}>:ports/win32/rs485.h>)
+elseif(APPLE)
+  message(STATUS "BACNET: building for APPLE")
+  set(BACNET_PORT_DIRECTORY_PATH ${CMAKE_CURRENT_LIST_DIR}/ports/bsd)
+
+  target_sources(${PROJECT_NAME} PRIVATE
+    ports/bsd/bacport.h
+    ports/bsd/bip-init.c
+    ports/bsd/datetime-init.c
+    ports/bsd/mstimer-init.c
+    ports/bsd/stdbool.h)
+endif()
+
+target_include_directories(${PROJECT_NAME} PUBLIC
+  $<BUILD_INTERFACE:${BACNET_PORT_DIRECTORY_PATH}>)
+
 #
 # examples
 #

cmake/Config.cmake.in

@@ -1,4 +1,8 @@
 @PACKAGE_INIT@
 
+if("@CMAKE_SYSTEM_NAME@" STREQUAL "Linux" OR APPLE OR WIN32)
+    find_package(OpenSSL REQUIRED)
+endif()
+
 include("${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@Targets.cmake")
 check_required_components("@PROJECT_NAME@")

ports/linux/bacport.h

@@ -99,10 +99,12 @@
 #include <sys/un.h>
 #include <sys/ioctl.h>
 #include <netdb.h>
+#include "bacnet/bacnet_stack_exports.h"
 
 /** @file linux/net.h  Includes Linux network headers. */
 
 /* Local helper functions for this port */
+BACNET_STACK_EXPORT
 extern int bip_get_local_netmask(
     struct in_addr *netmask);
 

ports/linux/dlmstp_linux.h

@@ -32,6 +32,7 @@
 #include <stdbool.h>
 #include <stdint.h>
 #include <stddef.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/npdu.h"
 #include <termios.h>
@@ -127,15 +128,19 @@ typedef struct shared_mstp_data {
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     bool dlmstp_init(
         void *poShared,
         char *ifname);
+    BACNET_STACK_EXPORT
     void dlmstp_reset(
         void *poShared);
+    BACNET_STACK_EXPORT
     void dlmstp_cleanup(
         void *poShared);
 
     /* returns number of bytes sent on success, negative on failure */
+    BACNET_STACK_EXPORT
     int dlmstp_send_pdu(
         void *poShared,
         BACNET_ADDRESS * dest,  /* destination address */
@@ -143,6 +148,7 @@ extern "C" {
         unsigned pdu_len);      /* number of bytes of data */
 
     /* returns the number of octets in the PDU, or zero on failure */
+    BACNET_STACK_EXPORT
     uint16_t dlmstp_receive(
         void *poShared,
         BACNET_ADDRESS * src,   /* source address */
@@ -157,9 +163,11 @@ extern "C" {
     /* nodes. This may be used to allocate more or less of the available link */
     /* bandwidth to particular nodes. If Max_Info_Frames is not writable in a */
     /* node, its value shall be 1. */
+    BACNET_STACK_EXPORT
     void dlmstp_set_max_info_frames(
         void *poShared,
         uint8_t max_info_frames);
+    BACNET_STACK_EXPORT
     uint8_t dlmstp_max_info_frames(
         void *poShared);
 
@@ -168,36 +176,46 @@ extern "C" {
     /* allowable address for master nodes. The value of Max_Master shall be */
     /* less than or equal to 127. If Max_Master is not writable in a node, */
     /* its value shall be 127. */
+    BACNET_STACK_EXPORT
     void dlmstp_set_max_master(
         void *poShared,
         uint8_t max_master);
+    BACNET_STACK_EXPORT
     uint8_t dlmstp_max_master(
         void *poShared);
 
     /* MAC address 0-127 */
+    BACNET_STACK_EXPORT
     void dlmstp_set_mac_address(
         void *poShared,
         uint8_t my_address);
+    BACNET_STACK_EXPORT
     uint8_t dlmstp_mac_address(
         void *poShared);
 
+    BACNET_STACK_EXPORT
     void dlmstp_get_my_address(
         void *poShared,
         BACNET_ADDRESS * my_address);
+    BACNET_STACK_EXPORT
     void dlmstp_get_broadcast_address(
         BACNET_ADDRESS * dest); /* destination address */
 
     /* RS485 Baud Rate 9600, 19200, 38400, 57600, 115200 */
+    BACNET_STACK_EXPORT
     void dlmstp_set_baud_rate(
         void *poShared,
         uint32_t baud);
+    BACNET_STACK_EXPORT
     uint32_t dlmstp_baud_rate(
         void *poShared);
 
+    BACNET_STACK_EXPORT
     void dlmstp_fill_bacnet_address(
         BACNET_ADDRESS * src,
         uint8_t mstp_address);
 
+    BACNET_STACK_EXPORT
     bool dlmstp_sole_master(
         void);
 

ports/linux/rs485.h

@@ -37,36 +37,47 @@
 #define RS485_H
 
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/datalink/mstp.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void RS485_Set_Interface(
         char *ifname);
+    BACNET_STACK_EXPORT
     const char *RS485_Interface(
         void);
 
+    BACNET_STACK_EXPORT
     void RS485_Initialize(
         void);
 
+    BACNET_STACK_EXPORT
     void RS485_Send_Frame(
         volatile struct mstp_port_struct_t *mstp_port,  /* port specific data */
         uint8_t * buffer,       /* frame to send (up to 501 bytes of data) */
         uint16_t nbytes);       /* number of bytes of data (up to 501) */
 
+    BACNET_STACK_EXPORT
     void RS485_Check_UART_Data(
         volatile struct mstp_port_struct_t *mstp_port); /* port specific data */
+    BACNET_STACK_EXPORT
     uint32_t RS485_Get_Port_Baud_Rate(
         volatile struct mstp_port_struct_t *mstp_port);
+    BACNET_STACK_EXPORT
     uint32_t RS485_Get_Baud_Rate(
         void);
+    BACNET_STACK_EXPORT
     bool RS485_Set_Baud_Rate(
         uint32_t baud);
 
+    BACNET_STACK_EXPORT
     void RS485_Cleanup(
         void);
+    BACNET_STACK_EXPORT
     void RS485_Print_Ports(
         void);
 

ports/win32/bacport.h

@@ -26,6 +26,8 @@
 #ifndef BACPORT_H
 #define BACPORT_H
 
+#include "bacnet/bacnet_stack_exports.h"
+
 #define WIN32_LEAN_AND_MEAN
 #define STRICT 1
 /* Windows XP minimum */
@@ -55,7 +57,7 @@ and globals in favor of more secure versions.  */
 /* add winmm.lib to our build */
 #pragma comment(lib, "winmm.lib")
 #endif
-#include <MMSystem.h>
+#include <mmsystem.h>
 
 #if !defined(_MSC_VER)
 #include <sys/time.h>

ports/win32/rs485.h

@@ -37,6 +37,7 @@
 #define RS485_H
 
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/datalink/mstp.h"
 #include "bacport.h"
 
@@ -44,32 +45,42 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void RS485_Set_Interface(
         char *ifname);
+    BACNET_STACK_EXPORT
     const char *RS485_Interface(
         void);
 
+    BACNET_STACK_EXPORT
     void RS485_Initialize(
         void);
 
+    BACNET_STACK_EXPORT
     void RS485_Send_Frame(
         volatile struct mstp_port_struct_t *mstp_port,  /* port specific data */
         uint8_t * buffer,       /* frame to send (up to 501 bytes of data) */
         uint16_t nbytes);       /* number of bytes of data (up to 501) */
 
+    BACNET_STACK_EXPORT
     void RS485_Check_UART_Data(
         volatile struct mstp_port_struct_t *mstp_port); /* port specific data */
 
+    BACNET_STACK_EXPORT
     uint32_t RS485_Get_Baud_Rate(
         void);
+    BACNET_STACK_EXPORT
     bool RS485_Set_Baud_Rate(
         uint32_t baud);
 
+    BACNET_STACK_EXPORT
     void RS485_Print_Error(
         void);
 
+    BACNET_STACK_EXPORT
     bool RS485_Interface_Valid(
         unsigned port_number);
+    BACNET_STACK_EXPORT
     void RS485_Print_Ports(
         void);
 

src/Makefile

@@ -9,6 +9,12 @@
 #
 # Assumes rm and cp are available
 
+CFLAGS += -Dbacnet_stack_EXPORTS
+
+ifeq ($(STATIC),1)
+  CFLAGS += -DBACNET_STACK_STATIC_DEFINE
+endif
+
 # These might be already defined in an previous Makefile
 BACNET_PORT ?= linux
 BACNET_SRC_DIR ?= $(realpath .)
@@ -22,7 +28,7 @@ BACNET_PORT_SRC ?= \
 BACNET_INCLUDES = -I$(BACNET_SRC_DIR) -I$(BACNET_PORT_DIR)
 CFLAGS += $(BACNET_INCLUDES)
 
-BACNET_SRC ?= main.c \
+BACNET_SRC ?= \
 	$(wildcard $(BACNET_SRC_DIR)/bacnet/*.c) \
 	$(wildcard $(BACNET_SRC_DIR)/bacnet/basic/*.c) \
 	$(wildcard $(BACNET_SRC_DIR)/bacnet/basic/binding/*.c) \
@@ -42,7 +48,7 @@ all: $(OBJS) Makefile
 
 depend:
 	rm -f .depend
-	${CC} -MM ${CFLAGS} *.c >> .depend
+	${CC} -MM ${CFLAGS} $(BACNET_SRC) >> .depend
 
 clean:
 	rm -rf core $(OBJS) $(LIBRARY)

src/bacnet/abort.h

@@ -26,23 +26,28 @@
 
 #include <stdint.h>
 #include <stdbool.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacenum.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     BACNET_ABORT_REASON abort_convert_error_code(
         BACNET_ERROR_CODE error_code);
+    BACNET_STACK_EXPORT
     BACNET_ERROR_CODE abort_convert_to_error_code(
         BACNET_ABORT_REASON abort_code);
 
+    BACNET_STACK_EXPORT
     int abort_encode_apdu(
         uint8_t * apdu,
         uint8_t invoke_id,
         uint8_t abort_reason,
         bool server);
 
+    BACNET_STACK_EXPORT
     int abort_decode_service_request(
         uint8_t * apdu,
         unsigned apdu_len,
@@ -51,6 +56,7 @@ extern "C" {
 
 #ifdef TEST
 #include "ctest.h"
+    BACNET_STACK_EXPORT
     void testAbort(
         Test * pTest);
 #endif

src/bacnet/access_rule.h

@@ -28,6 +28,7 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacapp.h"
 #include "bacnet/bacdevobjpropref.h"
@@ -57,16 +58,20 @@ typedef struct {
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     int bacapp_encode_access_rule(
         uint8_t * apdu,
         BACNET_ACCESS_RULE * rule);
+    BACNET_STACK_EXPORT
     int bacapp_encode_context_access_rule(
         uint8_t * apdu,
         uint8_t tag_number,
         BACNET_ACCESS_RULE * rule);
+    BACNET_STACK_EXPORT
     int bacapp_decode_access_rule(
         uint8_t * apdu,
         BACNET_ACCESS_RULE * rule);
+    BACNET_STACK_EXPORT
     int bacapp_decode_context_access_rule(
         uint8_t * apdu,
         uint8_t tag_number,

src/bacnet/alarm_ack.h

@@ -26,6 +26,7 @@
 
 #include <stdint.h>
 #include <stdbool.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacenum.h"
 #include "bacnet/bacapp.h"
 #include "bacnet/timestamp.h"
@@ -56,6 +57,7 @@ extern "C" {
 ** Creates a Alarm Acknowledge APDU
 **
 ****************************************************/
+    BACNET_STACK_EXPORT
     int alarm_ack_encode_apdu(
         uint8_t * apdu,
         uint8_t invoke_id,
@@ -66,6 +68,7 @@ extern "C" {
 ** Encodes the service data part of Alarm Acknowledge
 **
 ****************************************************/
+    BACNET_STACK_EXPORT
     int alarm_ack_encode_service_request(
         uint8_t * apdu,
         BACNET_ALARM_ACK_DATA * data);
@@ -75,6 +78,7 @@ extern "C" {
 ** Decodes the service data part of Alarm Acknowledge
 **
 ****************************************************/
+    BACNET_STACK_EXPORT
     int alarm_ack_decode_service_request(
         uint8_t * apdu,
         unsigned apdu_len,

src/bacnet/arf.h

@@ -26,6 +26,7 @@
 
 #include <stdint.h>
 #include <stdbool.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdcode.h"
 #include "bacnet/bacstr.h"
 
@@ -59,17 +60,20 @@ extern "C" {
 
 /* Atomic Read File */
 /* encode service */
+    BACNET_STACK_EXPORT
     int arf_encode_apdu(
         uint8_t * apdu,
         uint8_t invoke_id,
         BACNET_ATOMIC_READ_FILE_DATA * data);
 
 /* decode the service request only */
+    BACNET_STACK_EXPORT
     int arf_decode_service_request(
         uint8_t * apdu,
         unsigned apdu_len,
         BACNET_ATOMIC_READ_FILE_DATA * data);
 
+    BACNET_STACK_EXPORT
     int arf_decode_apdu(
         uint8_t * apdu,
         unsigned apdu_len,
@@ -79,17 +83,20 @@ extern "C" {
 /* Atomic Read File Ack */
 
 /* encode service */
+    BACNET_STACK_EXPORT
     int arf_ack_encode_apdu(
         uint8_t * apdu,
         uint8_t invoke_id,
         BACNET_ATOMIC_READ_FILE_DATA * data);
 
 /* decode the service request only */
+    BACNET_STACK_EXPORT
     int arf_ack_decode_service_request(
         uint8_t * apdu,
         unsigned apdu_len,
         BACNET_ATOMIC_READ_FILE_DATA * data);
 
+    BACNET_STACK_EXPORT
     int arf_ack_decode_apdu(
         uint8_t * apdu,
         unsigned apdu_len,
@@ -99,8 +106,10 @@ extern "C" {
 #ifdef TEST
 #include "ctest.h"
 
+    BACNET_STACK_EXPORT
     void test_AtomicReadFile(
         Test * pTest);
+    BACNET_STACK_EXPORT
     void test_AtomicReadFileAck(
         Test * pTest);
 #endif

src/bacnet/assigned_access_rights.h

@@ -28,6 +28,7 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacapp.h"
 #include "bacnet/bacdevobjpropref.h"
@@ -41,16 +42,20 @@ typedef struct {
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     int bacapp_encode_assigned_access_rights(
         uint8_t * apdu,
         BACNET_ASSIGNED_ACCESS_RIGHTS * aar);
+    BACNET_STACK_EXPORT
     int bacapp_encode_context_assigned_access_rights(
         uint8_t * apdu,
         uint8_t tag,
         BACNET_ASSIGNED_ACCESS_RIGHTS * aar);
+    BACNET_STACK_EXPORT
     int bacapp_decode_assigned_access_rights(
         uint8_t * apdu,
         BACNET_ASSIGNED_ACCESS_RIGHTS * aar);
+    BACNET_STACK_EXPORT
     int bacapp_decode_context_assigned_access_rights(
         uint8_t * apdu,
         uint8_t tag,

src/bacnet/authentication_factor.h

@@ -28,6 +28,7 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacapp.h"
 
@@ -42,16 +43,20 @@ typedef struct {
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     int bacapp_encode_authentication_factor(
         uint8_t * apdu,
         BACNET_AUTHENTICATION_FACTOR * af);
+    BACNET_STACK_EXPORT
     int bacapp_encode_context_authentication_factor(
         uint8_t * apdu,
         uint8_t tag,
         BACNET_AUTHENTICATION_FACTOR * af);
+    BACNET_STACK_EXPORT
     int bacapp_decode_authentication_factor(
         uint8_t * apdu,
         BACNET_AUTHENTICATION_FACTOR * af);
+    BACNET_STACK_EXPORT
     int bacapp_decode_context_authentication_factor(
         uint8_t * apdu,
         uint8_t tag,

src/bacnet/authentication_factor_format.h

@@ -28,6 +28,7 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 
 typedef struct {
@@ -39,16 +40,20 @@ typedef struct {
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     int bacapp_encode_authentication_factor_format(
         uint8_t * apdu,
         BACNET_AUTHENTICATION_FACTOR_FORMAT * aff);
+    BACNET_STACK_EXPORT
     int bacapp_encode_context_authentication_factor_format(
         uint8_t * apdu,
         uint8_t tag_number,
         BACNET_AUTHENTICATION_FACTOR_FORMAT * aff);
+    BACNET_STACK_EXPORT
     int bacapp_decode_authentication_factor_format(
         uint8_t * apdu,
         BACNET_AUTHENTICATION_FACTOR_FORMAT * aff);
+    BACNET_STACK_EXPORT
     int bacapp_decode_context_authentication_factor_format(
         uint8_t * apdu,
         uint8_t tag_number,

src/bacnet/awf.h

@@ -26,6 +26,7 @@
 
 #include <stdint.h>
 #include <stdbool.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdcode.h"
 
 #ifndef BACNET_WRITE_FILE_RECORD_COUNT
@@ -54,17 +55,20 @@ extern "C" {
 
 /* Atomic Write File */
 /* encode service */
+    BACNET_STACK_EXPORT
     int awf_encode_apdu(
         uint8_t * apdu,
         uint8_t invoke_id,
         BACNET_ATOMIC_WRITE_FILE_DATA * data);
 
 /* decode the service request only */
+    BACNET_STACK_EXPORT
     int awf_decode_service_request(
         uint8_t * apdu,
         unsigned apdu_len,
         BACNET_ATOMIC_WRITE_FILE_DATA * data);
 
+    BACNET_STACK_EXPORT
     int awf_decode_apdu(
         uint8_t * apdu,
         unsigned apdu_len,
@@ -73,17 +77,20 @@ extern "C" {
 
 /* Atomic Write File Ack */
 /* encode service */
+    BACNET_STACK_EXPORT
     int awf_ack_encode_apdu(
         uint8_t * apdu,
         uint8_t invoke_id,
         BACNET_ATOMIC_WRITE_FILE_DATA * data);
 
 /* decode the service request only */
+    BACNET_STACK_EXPORT
     int awf_ack_decode_service_request(
         uint8_t * apdu,
         unsigned apdu_len,
         BACNET_ATOMIC_WRITE_FILE_DATA * data);
 
+    BACNET_STACK_EXPORT
     int awf_ack_decode_apdu(
         uint8_t * apdu,
         unsigned apdu_len,
@@ -93,8 +100,10 @@ extern "C" {
 #ifdef TEST
 #include "ctest.h"
 
+    BACNET_STACK_EXPORT
     void test_AtomicWriteFile(
         Test * pTest);
+    BACNET_STACK_EXPORT
     void test_AtomicWriteFileAck(
         Test * pTest);
 #endif

src/bacnet/bacaddr.h

@@ -27,15 +27,18 @@
 #include <stddef.h>
 #include <stdint.h>
 #include <stdbool.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void bacnet_address_copy(
         BACNET_ADDRESS * dest,
         BACNET_ADDRESS * src);
+    BACNET_STACK_EXPORT
     bool bacnet_address_same(
         BACNET_ADDRESS * dest,
         BACNET_ADDRESS * src);

src/bacnet/bacapp.h

@@ -27,6 +27,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stdio.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacint.h"
 #include "bacnet/bacstr.h"
@@ -137,56 +138,68 @@ typedef struct BACnet_Object_Property_Value {
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void bacapp_value_list_init(
         BACNET_APPLICATION_DATA_VALUE *value,
         size_t count);
+    BACNET_STACK_EXPORT
     void bacapp_property_value_list_init(
         BACNET_PROPERTY_VALUE *value,
         size_t count);
 
+    BACNET_STACK_EXPORT
     int bacapp_encode_data(
         uint8_t * apdu,
         BACNET_APPLICATION_DATA_VALUE * value);
+    BACNET_STACK_EXPORT
     int bacapp_decode_data(
         uint8_t * apdu,
         uint8_t tag_data_type,
         uint32_t len_value_type,
         BACNET_APPLICATION_DATA_VALUE * value);
 
+    BACNET_STACK_EXPORT
     int bacapp_decode_application_data(
         uint8_t * apdu,
         unsigned max_apdu_len,
         BACNET_APPLICATION_DATA_VALUE * value);
 
+    BACNET_STACK_EXPORT
     bool bacapp_decode_application_data_safe(
         uint8_t * new_apdu,
         uint32_t new_apdu_len,
         BACNET_APPLICATION_DATA_VALUE * value);
 
+    BACNET_STACK_EXPORT
     int bacapp_encode_application_data(
         uint8_t * apdu,
         BACNET_APPLICATION_DATA_VALUE * value);
 
+    BACNET_STACK_EXPORT
     int bacapp_decode_context_data(
         uint8_t * apdu,
         unsigned max_apdu_len,
         BACNET_APPLICATION_DATA_VALUE * value,
         BACNET_PROPERTY_ID property);
 
+    BACNET_STACK_EXPORT
     int bacapp_encode_context_data(
         uint8_t * apdu,
         BACNET_APPLICATION_DATA_VALUE * value,
         BACNET_PROPERTY_ID property);
 
+    BACNET_STACK_EXPORT
     int bacapp_encode_context_data_value(
         uint8_t * apdu,
         uint8_t context_tag_number,
         BACNET_APPLICATION_DATA_VALUE * value);
 
+    BACNET_STACK_EXPORT
     BACNET_APPLICATION_TAG bacapp_context_tag_type(
         BACNET_PROPERTY_ID property,
         uint8_t tag_number);
 
+    BACNET_STACK_EXPORT
     bool bacapp_copy(
         BACNET_APPLICATION_DATA_VALUE * dest_value,
         BACNET_APPLICATION_DATA_VALUE * src_value);
@@ -195,17 +208,21 @@ extern "C" {
        Expects that the first octet contain the opening tag.
        Include a value property identifier for context specific data
        such as the value received in a WriteProperty request */
+    BACNET_STACK_EXPORT
     int bacapp_data_len(
         uint8_t * apdu,
         unsigned max_apdu_len,
         BACNET_PROPERTY_ID property);
+    BACNET_STACK_EXPORT
     int bacapp_decode_data_len(
         uint8_t * apdu,
         uint8_t tag_data_type,
         uint32_t len_value_type);
+    BACNET_STACK_EXPORT
     int bacapp_decode_application_data_len(
         uint8_t * apdu,
         unsigned max_apdu_len);
+    BACNET_STACK_EXPORT
     int bacapp_decode_context_data_len(
         uint8_t * apdu,
         unsigned max_apdu_len,
@@ -219,6 +236,7 @@ extern "C" {
 #endif
 
 #ifdef BACAPP_SNPRINTF_ENABLED
+    BACNET_STACK_EXPORT
     int bacapp_snprintf_value(
         char *str,
         size_t str_len,
@@ -226,10 +244,12 @@ extern "C" {
 #endif
 
 #ifdef BACAPP_PRINT_ENABLED
+    BACNET_STACK_EXPORT
     bool bacapp_parse_application_data(
         BACNET_APPLICATION_TAG tag_number,
         const char *argv,
         BACNET_APPLICATION_DATA_VALUE * value);
+    BACNET_STACK_EXPORT
     bool bacapp_print_value(
         FILE * stream,
         BACNET_OBJECT_PROPERTY_VALUE * value);
@@ -242,12 +262,15 @@ extern "C" {
 #ifdef TEST
 #include "ctest.h"
 #include "bacnet/datetime.h"
+    BACNET_STACK_EXPORT
     bool bacapp_same_value(
         BACNET_APPLICATION_DATA_VALUE * value,
         BACNET_APPLICATION_DATA_VALUE * test_value);
 
+    BACNET_STACK_EXPORT
     void testBACnetApplicationDataLength(
         Test * pTest);
+    BACNET_STACK_EXPORT
     void testBACnetApplicationData(
         Test * pTest);
 #endif

src/bacnet/bacdcode.h

@@ -27,6 +27,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stddef.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/datetime.h"
 #include "bacnet/bacstr.h"
@@ -40,6 +41,7 @@ extern "C" {
 
 /* from clause 20.2.1 General Rules for Encoding BACnet Tags */
 /* returns the number of apdu bytes consumed */
+    BACNET_STACK_EXPORT
     int encode_tag(
         uint8_t * apdu,
         uint8_t tag_number,
@@ -48,74 +50,93 @@ extern "C" {
 
 /* from clause 20.2.1.3.2 Constructed Data */
 /* returns the number of apdu bytes consumed */
+    BACNET_STACK_EXPORT
     int encode_opening_tag(
         uint8_t * apdu,
         uint8_t tag_number);
+    BACNET_STACK_EXPORT
     int encode_closing_tag(
         uint8_t * apdu,
         uint8_t tag_number);
+    BACNET_STACK_EXPORT
     int decode_tag_number(
         uint8_t * apdu,
         uint8_t * tag_number);
 
+    BACNET_STACK_EXPORT
     int bacnet_tag_number_decode(
         uint8_t * apdu,
         uint32_t apdu_len_remaining,
         uint8_t * tag_number);
 
+    BACNET_STACK_EXPORT
     int decode_tag_number_and_value(
         uint8_t * apdu,
         uint8_t * tag_number,
         uint32_t * value);
 
+    BACNET_STACK_EXPORT
     int bacnet_tag_number_and_value_decode(
         uint8_t * apdu,
         uint32_t apdu_len_remaining,
         uint8_t * tag_number,
         uint32_t * value);
 /* returns true if the tag is an opening tag and matches */
+    BACNET_STACK_EXPORT
     bool decode_is_opening_tag_number(
         uint8_t * apdu,
         uint8_t tag_number);
 /* returns true if the tag is a closing tag and matches */
+    BACNET_STACK_EXPORT
     bool decode_is_closing_tag_number(
         uint8_t * apdu,
         uint8_t tag_number);
 /* returns true if the tag is context specific and matches */
+    BACNET_STACK_EXPORT
     bool decode_is_context_tag(
         uint8_t * apdu,
         uint8_t tag_number);
+    BACNET_STACK_EXPORT
     bool decode_is_context_tag_with_length(
         uint8_t * apdu,
         uint8_t tag_number,
         int *tag_length);
     /* returns true if the tag is an opening tag */
+    BACNET_STACK_EXPORT
     bool decode_is_opening_tag(
         uint8_t * apdu);
     /* returns true if the tag is a closing tag */
+    BACNET_STACK_EXPORT
     bool decode_is_closing_tag(
         uint8_t * apdu);
 
 /* from clause 20.2.2 Encoding of a Null Value */
+    BACNET_STACK_EXPORT
     int encode_application_null(
         uint8_t * apdu);
+    BACNET_STACK_EXPORT
     int encode_context_null(
         uint8_t * apdu,
         uint8_t tag_number);
 
 /* from clause 20.2.3 Encoding of a Boolean Value */
+    BACNET_STACK_EXPORT
     int encode_application_boolean(
         uint8_t * apdu,
         bool boolean_value);
+    BACNET_STACK_EXPORT
     bool decode_boolean(
         uint32_t len_value);
+    BACNET_STACK_EXPORT
     int encode_context_boolean(
         uint8_t * apdu,
         uint8_t tag_number,
         bool boolean_value);
+    BACNET_STACK_EXPORT
     bool decode_context_boolean(
         uint8_t * apdu);
 
+    BACNET_STACK_EXPORT
     int decode_context_boolean2(
         uint8_t * apdu,
         uint8_t tag_number,
@@ -123,22 +144,27 @@ extern "C" {
 
 /* from clause 20.2.10 Encoding of a Bit String Value */
 /* returns the number of apdu bytes consumed */
+    BACNET_STACK_EXPORT
     int decode_bitstring(
         uint8_t * apdu,
         uint32_t len_value,
         BACNET_BIT_STRING * bit_string);
 
+    BACNET_STACK_EXPORT
     int decode_context_bitstring(
         uint8_t * apdu,
         uint8_t tag_number,
         BACNET_BIT_STRING * bit_string);
 /* returns the number of apdu bytes consumed */
+    BACNET_STACK_EXPORT
     int encode_bitstring(
         uint8_t * apdu,
         BACNET_BIT_STRING * bit_string);
+    BACNET_STACK_EXPORT
     int encode_application_bitstring(
         uint8_t * apdu,
         BACNET_BIT_STRING * bit_string);
+    BACNET_STACK_EXPORT
     int encode_context_bitstring(
         uint8_t * apdu,
         uint8_t tag_number,
@@ -147,9 +173,11 @@ extern "C" {
 /* from clause 20.2.6 Encoding of a Real Number Value */
 /* and 20.2.1 General Rules for Encoding BACnet Tags */
 /* returns the number of apdu bytes consumed */
+    BACNET_STACK_EXPORT
     int encode_application_real(
         uint8_t * apdu,
         float value);
+    BACNET_STACK_EXPORT
     int encode_context_real(
         uint8_t * apdu,
         uint8_t tag_number,
@@ -158,10 +186,12 @@ extern "C" {
 /* from clause 20.2.7 Encoding of a Double Precision Real Number Value */
 /* and 20.2.1 General Rules for Encoding BACnet Tags */
 /* returns the number of apdu bytes consumed */
+    BACNET_STACK_EXPORT
     int encode_application_double(
         uint8_t * apdu,
         double value);
 
+    BACNET_STACK_EXPORT
     int encode_context_double(
         uint8_t * apdu,
         uint8_t tag_number,
@@ -170,21 +200,25 @@ extern "C" {
 /* from clause 20.2.14 Encoding of an Object Identifier Value */
 /* and 20.2.1 General Rules for Encoding BACnet Tags */
 /* returns the number of apdu bytes consumed */
+    BACNET_STACK_EXPORT
     int decode_object_id(
         uint8_t * apdu,
         BACNET_OBJECT_TYPE * object_type,
         uint32_t * object_instance);
 
+    BACNET_STACK_EXPORT
     int bacnet_object_id_decode(
         uint8_t * apdu,
         uint32_t len_value,
         BACNET_OBJECT_TYPE * object_type,
         uint32_t * instance);
+    BACNET_STACK_EXPORT
     int bacnet_object_id_application_decode(
         uint8_t * apdu,
         uint16_t apdu_len_max,
         BACNET_OBJECT_TYPE * object_type,
         uint32_t * object_instance);
+    BACNET_STACK_EXPORT
     int bacnet_object_id_context_decode(
         uint8_t * apdu,
         uint16_t apdu_len_max,
@@ -192,21 +226,25 @@ extern "C" {
         BACNET_OBJECT_TYPE * object_type,
         uint32_t * instance);
 
+    BACNET_STACK_EXPORT
     int decode_context_object_id(
         uint8_t * apdu,
         uint8_t tag_number,
         BACNET_OBJECT_TYPE * object_type,
         uint32_t * instance);
 
+    BACNET_STACK_EXPORT
     int encode_bacnet_object_id(
         uint8_t * apdu,
         BACNET_OBJECT_TYPE object_type,
         uint32_t instance);
+    BACNET_STACK_EXPORT
     int encode_context_object_id(
         uint8_t * apdu,
         uint8_t tag_number,
         BACNET_OBJECT_TYPE object_type,
         uint32_t instance);
+    BACNET_STACK_EXPORT
     int encode_application_object_id(
         uint8_t * apdu,
         BACNET_OBJECT_TYPE object_type,
@@ -215,30 +253,37 @@ extern "C" {
 /* from clause 20.2.8 Encoding of an Octet String Value */
 /* and 20.2.1 General Rules for Encoding BACnet Tags */
 /* returns the number of apdu bytes consumed */
+    BACNET_STACK_EXPORT
     int encode_octet_string(
         uint8_t * apdu,
         BACNET_OCTET_STRING * octet_string);
+    BACNET_STACK_EXPORT
     int encode_application_octet_string(
         uint8_t * apdu,
         BACNET_OCTET_STRING * octet_string);
+    BACNET_STACK_EXPORT
     int encode_context_octet_string(
         uint8_t * apdu,
         uint8_t tag_number,
         BACNET_OCTET_STRING * octet_string);
+    BACNET_STACK_EXPORT
     int decode_octet_string(
         uint8_t * apdu,
         uint32_t len_value,
         BACNET_OCTET_STRING * octet_string);
+    BACNET_STACK_EXPORT
     int decode_context_octet_string(
         uint8_t * apdu,
         uint8_t tag_number,
         BACNET_OCTET_STRING * octet_string);
 
+    BACNET_STACK_EXPORT
     int bacnet_octet_string_decode(
         uint8_t * apdu,
         uint16_t apdu_len_max,
         uint32_t len_value,
         BACNET_OCTET_STRING * value);
+    BACNET_STACK_EXPORT
     int bacnet_octet_string_application_decode(
         uint8_t * apdu,
         uint16_t apdu_len_max,
@@ -247,35 +292,43 @@ extern "C" {
 /* from clause 20.2.9 Encoding of a Character String Value */
 /* and 20.2.1 General Rules for Encoding BACnet Tags */
 /* returns the number of apdu bytes consumed */
+    BACNET_STACK_EXPORT
     uint32_t encode_bacnet_character_string_safe(
         uint8_t * apdu,
         uint32_t max_apdu,
         uint8_t encoding,
         char *pString,
         uint32_t length);
+    BACNET_STACK_EXPORT
     int encode_bacnet_character_string(
         uint8_t * apdu,
         BACNET_CHARACTER_STRING * char_string);
+    BACNET_STACK_EXPORT
     int encode_application_character_string(
         uint8_t * apdu,
         BACNET_CHARACTER_STRING * char_string);
+    BACNET_STACK_EXPORT
     int encode_context_character_string(
         uint8_t * apdu,
         uint8_t tag_number,
         BACNET_CHARACTER_STRING * char_string);
+    BACNET_STACK_EXPORT
     int decode_character_string(
         uint8_t * apdu,
         uint32_t len_value,
         BACNET_CHARACTER_STRING * char_string);
+    BACNET_STACK_EXPORT
     int decode_context_character_string(
         uint8_t * apdu,
         uint8_t tag_number,
         BACNET_CHARACTER_STRING * char_string);
+    BACNET_STACK_EXPORT
     int bacnet_character_string_decode(
         uint8_t * apdu,
         uint16_t apdu_len_max,
         uint32_t len_value,
         BACNET_CHARACTER_STRING * char_string);
+    BACNET_STACK_EXPORT
     int bacnet_character_string_context_decode(
         uint8_t * apdu,
         uint16_t apdu_len_max,
@@ -286,34 +339,42 @@ extern "C" {
 /* from clause 20.2.4 Encoding of an Unsigned Integer Value */
 /* and 20.2.1 General Rules for Encoding BACnet Tags */
 /* returns the number of apdu bytes consumed */
+    BACNET_STACK_EXPORT
     int encode_bacnet_unsigned(
         uint8_t * apdu,
         BACNET_UNSIGNED_INTEGER value);
+    BACNET_STACK_EXPORT
     int encode_context_unsigned(
         uint8_t * apdu,
         uint8_t tag_number,
         BACNET_UNSIGNED_INTEGER value);
+    BACNET_STACK_EXPORT
     int encode_application_unsigned(
         uint8_t * apdu,
         BACNET_UNSIGNED_INTEGER value);
+    BACNET_STACK_EXPORT
     int decode_unsigned(
         uint8_t * apdu,
         uint32_t len_value,
         BACNET_UNSIGNED_INTEGER * value);
+    BACNET_STACK_EXPORT
     int decode_context_unsigned(
         uint8_t * apdu,
         uint8_t tag_number,
         BACNET_UNSIGNED_INTEGER * value);
 
+    BACNET_STACK_EXPORT
     int bacnet_unsigned_decode(
         uint8_t * apdu,
         uint16_t apdu_max_len,
         uint32_t len_value,
         BACNET_UNSIGNED_INTEGER * value);
+    BACNET_STACK_EXPORT
     int bacnet_unsigned_application_decode(
         uint8_t * apdu,
         uint16_t apdu_len_max,
         BACNET_UNSIGNED_INTEGER * value);
+    BACNET_STACK_EXPORT
     int bacnet_unsigned_context_decode(
         uint8_t * apdu,
         uint16_t apdu_len_max,
@@ -323,35 +384,43 @@ extern "C" {
 /* from clause 20.2.5 Encoding of a Signed Integer Value */
 /* and 20.2.1 General Rules for Encoding BACnet Tags */
 /* returns the number of apdu bytes consumed */
+    BACNET_STACK_EXPORT
     int encode_bacnet_signed(
         uint8_t * apdu,
         int32_t value);
+    BACNET_STACK_EXPORT
     int encode_application_signed(
         uint8_t * apdu,
         int32_t value);
+    BACNET_STACK_EXPORT
     int encode_context_signed(
         uint8_t * apdu,
         uint8_t tag_number,
         int32_t value);
+    BACNET_STACK_EXPORT
     int decode_signed(
         uint8_t * apdu,
         uint32_t len_value,
         int32_t * value);
+    BACNET_STACK_EXPORT
     int decode_context_signed(
         uint8_t * apdu,
         uint8_t tag_number,
         int32_t * value);
 
+    BACNET_STACK_EXPORT
     int bacnet_signed_decode(
         uint8_t * apdu,
         uint16_t apdu_len_max,
         uint32_t len_value,
         int32_t * value);
+    BACNET_STACK_EXPORT
     int bacnet_signed_context_decode(
         uint8_t * apdu,
         uint16_t apdu_len_max,
         uint8_t tag_value,
         int32_t * value);
+    BACNET_STACK_EXPORT
     int bacnet_signed_application_decode(
         uint8_t * apdu,
         uint16_t apdu_len_max,
@@ -360,30 +429,37 @@ extern "C" {
 /* from clause 20.2.11 Encoding of an Enumerated Value */
 /* and 20.2.1 General Rules for Encoding BACnet Tags */
 /* returns the number of apdu bytes consumed */
+    BACNET_STACK_EXPORT
     int bacnet_enumerated_decode(
         uint8_t * apdu,
         uint16_t apdu_max_len,
         uint32_t len_value,
         uint32_t * value);
+    BACNET_STACK_EXPORT
     int bacnet_enumerated_context_decode(
         uint8_t * apdu,
         uint16_t apdu_len_max,
         uint8_t tag_value,
         uint32_t * value);
+    BACNET_STACK_EXPORT
     int decode_enumerated(
         uint8_t * apdu,
         uint32_t len_value,
         uint32_t * value);
+    BACNET_STACK_EXPORT
     int decode_context_enumerated(
         uint8_t * apdu,
         uint8_t tag_value,
         uint32_t * value);
+    BACNET_STACK_EXPORT
     int encode_bacnet_enumerated(
         uint8_t * apdu,
         uint32_t value);
+    BACNET_STACK_EXPORT
     int encode_application_enumerated(
         uint8_t * apdu,
         uint32_t value);
+    BACNET_STACK_EXPORT
     int encode_context_enumerated(
         uint8_t * apdu,
         uint8_t tag_number,
@@ -392,41 +468,51 @@ extern "C" {
 /* from clause 20.2.13 Encoding of a Time Value */
 /* and 20.2.1 General Rules for Encoding BACnet Tags */
 /* returns the number of apdu bytes consumed */
+    BACNET_STACK_EXPORT
     int encode_bacnet_time(
         uint8_t * apdu,
         BACNET_TIME * btime);
+    BACNET_STACK_EXPORT
     int encode_application_time(
         uint8_t * apdu,
         BACNET_TIME * btime);
+    BACNET_STACK_EXPORT
     int decode_bacnet_time(
         uint8_t * apdu,
         BACNET_TIME * btime);
+    BACNET_STACK_EXPORT
     int decode_bacnet_time_safe(
         uint8_t * apdu,
         uint32_t len_value,
         BACNET_TIME * btime);
+    BACNET_STACK_EXPORT
     int encode_context_time(
         uint8_t * apdu,
         uint8_t tag_number,
         BACNET_TIME * btime);
+    BACNET_STACK_EXPORT
     int decode_application_time(
         uint8_t * apdu,
         BACNET_TIME * btime);
+    BACNET_STACK_EXPORT
     int decode_context_bacnet_time(
         uint8_t * apdu,
         uint8_t tag_number,
         BACNET_TIME * btime);
 
+    BACNET_STACK_EXPORT
     int bacnet_time_decode(
         uint8_t * apdu,
         uint16_t apdu_len_max,
         uint32_t len_value,
         BACNET_TIME * value);
+    BACNET_STACK_EXPORT
     int bacnet_time_context_decode(
         uint8_t * apdu,
         uint16_t apdu_len_max,
         uint8_t tag_value,
         BACNET_TIME * value);
+    BACNET_STACK_EXPORT
     int bacnet_time_application_decode(
         uint8_t * apdu,
         uint16_t apdu_len_max,
@@ -441,26 +527,33 @@ extern "C" {
 /* from clause 20.2.12 Encoding of a Date Value */
 /* and 20.2.1 General Rules for Encoding BACnet Tags */
 /* returns the number of apdu bytes consumed */
+    BACNET_STACK_EXPORT
     int encode_bacnet_date(
         uint8_t * apdu,
         BACNET_DATE * bdate);
+    BACNET_STACK_EXPORT
     int encode_application_date(
         uint8_t * apdu,
         BACNET_DATE * bdate);
+    BACNET_STACK_EXPORT
     int encode_context_date(
         uint8_t * apdu,
         uint8_t tag_number,
         BACNET_DATE * bdate);
+    BACNET_STACK_EXPORT
     int decode_date(
         uint8_t * apdu,
         BACNET_DATE * bdate);
+    BACNET_STACK_EXPORT
     int decode_date_safe(
         uint8_t * apdu,
         uint32_t len_value,
         BACNET_DATE * bdate);
+    BACNET_STACK_EXPORT
     int decode_application_date(
         uint8_t * apdu,
         BACNET_DATE * bdate);
+    BACNET_STACK_EXPORT
     int decode_context_date(
         uint8_t * apdu,
         uint8_t tag_number,
@@ -469,30 +562,38 @@ extern "C" {
 /* from clause 20.1.2.4 max-segments-accepted */
 /* and clause 20.1.2.5 max-APDU-length-accepted */
 /* returns the encoded octet */
+    BACNET_STACK_EXPORT
     uint8_t encode_max_segs_max_apdu(
         int max_segs,
         int max_apdu);
+    BACNET_STACK_EXPORT
     int decode_max_segs(
         uint8_t octet);
+    BACNET_STACK_EXPORT
     int decode_max_apdu(
         uint8_t octet);
 
 /* returns the number of apdu bytes consumed */
+    BACNET_STACK_EXPORT
     int encode_simple_ack(
         uint8_t * apdu,
         uint8_t invoke_id,
         uint8_t service_choice);
 
+    BACNET_STACK_EXPORT
     int encode_bacnet_address(
         uint8_t * apdu,
         BACNET_ADDRESS * destination);
+    BACNET_STACK_EXPORT
     int decode_bacnet_address(
         uint8_t * apdu,
         BACNET_ADDRESS * destination);
+    BACNET_STACK_EXPORT
     int encode_context_bacnet_address(
         uint8_t * apdu,
         uint8_t tag_number,
         BACNET_ADDRESS * destination);
+    BACNET_STACK_EXPORT
     int decode_context_bacnet_address(
         uint8_t * apdu,
         uint8_t tag_number,
@@ -520,6 +621,7 @@ extern "C" {
 
 #ifdef TEST
 #include "ctest.h"
+    BACNET_STACK_EXPORT
     void test_BACDCode(
         Test * pTest);
 #endif

src/bacnet/bacdevobjpropref.h

@@ -27,6 +27,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stddef.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacint.h"
 #include "bacnet/bacenum.h"
@@ -54,38 +55,46 @@ typedef struct BACnetDeviceObjectReference {
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     int bacapp_encode_device_obj_property_ref(
         uint8_t * apdu,
         BACNET_DEVICE_OBJECT_PROPERTY_REFERENCE * value);
 
+    BACNET_STACK_EXPORT
     int bacapp_encode_context_device_obj_property_ref(
         uint8_t * apdu,
         uint8_t tag_number,
         BACNET_DEVICE_OBJECT_PROPERTY_REFERENCE * value);
 
+    BACNET_STACK_EXPORT
     int bacapp_decode_device_obj_property_ref(
         uint8_t * apdu,
         BACNET_DEVICE_OBJECT_PROPERTY_REFERENCE * value);
 
+    BACNET_STACK_EXPORT
     int bacapp_decode_context_device_obj_property_ref(
         uint8_t * apdu,
         uint8_t tag_number,
         BACNET_DEVICE_OBJECT_PROPERTY_REFERENCE * value);
 
 
+    BACNET_STACK_EXPORT
     int bacapp_encode_device_obj_ref(
         uint8_t * apdu,
         BACNET_DEVICE_OBJECT_REFERENCE * value);
 
+    BACNET_STACK_EXPORT
     int bacapp_encode_context_device_obj_ref(
         uint8_t * apdu,
         uint8_t tag_number,
         BACNET_DEVICE_OBJECT_REFERENCE * value);
 
+    BACNET_STACK_EXPORT
     int bacapp_decode_device_obj_ref(
         uint8_t * apdu,
         BACNET_DEVICE_OBJECT_REFERENCE * value);
 
+    BACNET_STACK_EXPORT
     int bacapp_decode_context_device_obj_ref(
         uint8_t * apdu,
         uint8_t tag_number,
@@ -93,6 +102,7 @@ extern "C" {
 
 #ifdef TEST
 #include "ctest.h"
+    BACNET_STACK_EXPORT
     void testBACnetDeviceObjectPropertyReference(
         Test * pTest);
 #endif

src/bacnet/bacerror.h

@@ -26,12 +26,14 @@
 
 #include <stdint.h>
 #include <stdbool.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacenum.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     int bacerror_encode_apdu(
         uint8_t * apdu,
         uint8_t invoke_id,
@@ -39,6 +41,7 @@ extern "C" {
         BACNET_ERROR_CLASS error_class,
         BACNET_ERROR_CODE error_code);
 
+    BACNET_STACK_EXPORT
     int bacerror_decode_service_request(
         uint8_t * apdu,
         unsigned apdu_len,
@@ -47,6 +50,7 @@ extern "C" {
         BACNET_ERROR_CLASS * error_class,
         BACNET_ERROR_CODE * error_code);
 
+    BACNET_STACK_EXPORT
     int bacerror_decode_error_class_and_code(
         uint8_t * apdu,
         unsigned apdu_len,
@@ -55,6 +59,7 @@ extern "C" {
 
 #ifdef TEST
 #include "ctest.h"
+    BACNET_STACK_EXPORT
     int bacerror_decode_apdu(
         uint8_t * apdu,
         unsigned apdu_len,
@@ -63,6 +68,7 @@ extern "C" {
         BACNET_ERROR_CLASS * error_class,
         BACNET_ERROR_CODE * error_code);
 
+    BACNET_STACK_EXPORT
     void testBACError(
         Test * pTest);
 #endif

src/bacnet/bacint.h

@@ -27,6 +27,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stddef.h>
+#include "bacnet/bacnet_stack_exports.h"
 
 #ifdef UINT64_MAX
 typedef uint64_t BACNET_UNSIGNED_INTEGER;
@@ -41,80 +42,104 @@ extern "C" {
 #endif /* __cplusplus */
 
     /* unsigned value encoding and decoding */
+    BACNET_STACK_EXPORT
     int encode_unsigned16(
         uint8_t * apdu,
         uint16_t value);
+    BACNET_STACK_EXPORT
     int decode_unsigned16(
         uint8_t * apdu,
         uint16_t * value);
+    BACNET_STACK_EXPORT
     int encode_unsigned24(
         uint8_t * apdu,
         uint32_t value);
+    BACNET_STACK_EXPORT
     int decode_unsigned24(
         uint8_t * apdu,
         uint32_t * value);
+    BACNET_STACK_EXPORT
     int encode_unsigned32(
         uint8_t * apdu,
         uint32_t value);
+    BACNET_STACK_EXPORT
     int decode_unsigned32(
         uint8_t * apdu,
         uint32_t * value);
 #ifdef UINT64_MAX
+    BACNET_STACK_EXPORT
     int encode_unsigned40(
         uint8_t * buffer,
         uint64_t value);
+    BACNET_STACK_EXPORT
     int decode_unsigned40(
         uint8_t * buffer,
         uint64_t * value);
+    BACNET_STACK_EXPORT
     int encode_unsigned48(
         uint8_t * buffer,
         uint64_t value);
+    BACNET_STACK_EXPORT
     int decode_unsigned48(
         uint8_t * buffer,
         uint64_t * value);
+    BACNET_STACK_EXPORT
     int encode_unsigned56(
         uint8_t * buffer,
         uint64_t value);
+    BACNET_STACK_EXPORT
     int decode_unsigned56(
         uint8_t * buffer,
         uint64_t * value);
+    BACNET_STACK_EXPORT
     int encode_unsigned64(
         uint8_t * buffer,
         uint64_t value);
+    BACNET_STACK_EXPORT
     int decode_unsigned64(
         uint8_t * buffer,
         uint64_t * value);
 #endif
+    BACNET_STACK_EXPORT
     int bacnet_unsigned_length(
         BACNET_UNSIGNED_INTEGER value);
     /* signed value encoding and decoding */
+    BACNET_STACK_EXPORT
     int encode_signed8(
         uint8_t * apdu,
         int8_t value);
+    BACNET_STACK_EXPORT
     int decode_signed8(
         uint8_t * apdu,
         int32_t * value);
+    BACNET_STACK_EXPORT
     int encode_signed16(
         uint8_t * apdu,
         int16_t value);
+    BACNET_STACK_EXPORT
     int decode_signed16(
         uint8_t * apdu,
         int32_t * value);
+    BACNET_STACK_EXPORT
     int encode_signed24(
         uint8_t * apdu,
         int32_t value);
+    BACNET_STACK_EXPORT
     int decode_signed24(
         uint8_t * apdu,
         int32_t * value);
+    BACNET_STACK_EXPORT
     int encode_signed32(
         uint8_t * apdu,
         int32_t value);
+    BACNET_STACK_EXPORT
     int decode_signed32(
         uint8_t * apdu,
         int32_t * value);
 
 #ifdef TEST
 #include "ctest.h"
+    BACNET_STACK_EXPORT
     void testBACnetIntegers(
         Test * pTest);
 #endif

src/bacnet/bacnet_stack_exports.h

@@ -0,0 +1,53 @@
+/**************************************************************************
+*
+* Copyright (C) 2020 Steve Karg <skarg@users.sourceforge.net>
+*
+* Permission is hereby granted, free of charge, to any person obtaining
+* a copy of this software and associated documentation files (the
+* "Software"), to deal in the Software without restriction, including
+* without limitation the rights to use, copy, modify, merge, publish,
+* distribute, sublicense, and/or sell copies of the Software, and to
+* permit persons to whom the Software is furnished to do so, subject to
+* the following conditions:
+*
+* The above copyright notice and this permission notice shall be included
+* in all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*********************************************************************/
+#ifndef BACNET_STACK_EXPORTS_H
+#define BACNET_STACK_EXPORTS_H
+
+
+#ifdef BACNET_STACK_STATIC_DEFINE
+    /* We want a static library */
+# define BACNET_STACK_EXPORT
+#else
+    /* We want a shared library */
+# ifdef _MSC_VER
+#   define BACNET_STACK_LIBRARY_IMPORT __declspec(dllimport)
+#   define BACNET_STACK_LIBRARY_EXPORT __declspec(dllexport)
+# else
+#   define BACNET_STACK_LIBRARY_IMPORT
+#   define BACNET_STACK_LIBRARY_EXPORT __attribute__((visibility("default")))
+# endif
+#endif
+
+
+#ifndef BACNET_STACK_EXPORT
+#  ifdef bacnet_stack_EXPORTS
+      /* We are building this library */
+#    define BACNET_STACK_EXPORT BACNET_STACK_LIBRARY_EXPORT
+#  else
+      /* We are using this library */
+#    define BACNET_STACK_EXPORT BACNET_STACK_LIBRARY_IMPORT
+#  endif
+#endif
+
+#endif  // BACNET_STACK_EXPORTS_H

src/bacnet/bacprop.h

@@ -26,6 +26,7 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacenum.h"
 
 typedef struct {
@@ -37,11 +38,13 @@ typedef struct {
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     signed bacprop_tag_by_index_default(
         PROP_TAG_DATA * data_list,
         signed index,
         signed default_ret);
 
+    BACNET_STACK_EXPORT
     signed bacprop_property_tag(
         BACNET_OBJECT_TYPE type,
         signed prop);

src/bacnet/bacpropstates.h

@@ -26,6 +26,7 @@
 
 #include <stdint.h>
 #include <stdbool.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacenum.h"
 #include "bacnet/bacapp.h"
 #include "bacnet/timestamp.h"
@@ -71,15 +72,18 @@ typedef struct {
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     int bacapp_decode_property_state(
         uint8_t * apdu,
         BACNET_PROPERTY_STATE * value);
 
+    BACNET_STACK_EXPORT
     int bacapp_decode_context_property_state(
         uint8_t * apdu,
         uint8_t tag_number,
         BACNET_PROPERTY_STATE * value);
 
+    BACNET_STACK_EXPORT
     int bacapp_encode_property_state(
         uint8_t * apdu,
         BACNET_PROPERTY_STATE * value);

src/bacnet/bacreal.h

@@ -27,39 +27,48 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stddef.h>
+#include "bacnet/bacnet_stack_exports.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     int decode_real_safe(
         uint8_t * apdu,
         uint32_t len_value,
         float *real_value);
 
+    BACNET_STACK_EXPORT
     int decode_real(
         uint8_t * apdu,
         float *real_value);
 
+    BACNET_STACK_EXPORT
     int decode_context_real(
         uint8_t * apdu,
         uint8_t tag_number,
         float *real_value);
+    BACNET_STACK_EXPORT
     int encode_bacnet_real(
         float value,
         uint8_t * apdu);
+    BACNET_STACK_EXPORT
     int decode_double(
         uint8_t * apdu,
         double *real_value);
+    BACNET_STACK_EXPORT
     int decode_context_double(
         uint8_t * apdu,
         uint8_t tag_number,
         double *double_value);
+    BACNET_STACK_EXPORT
     int decode_double_safe(
         uint8_t * apdu,
         uint32_t len_value,
         double *double_value);
 
+    BACNET_STACK_EXPORT
     int encode_bacnet_double(
         double value,
         uint8_t * apdu);
@@ -67,8 +76,10 @@ extern "C" {
 #ifdef TEST
 #include "ctest.h"
 
+    BACNET_STACK_EXPORT
     void testBACreal(
         Test * pTest);
+    BACNET_STACK_EXPORT
     void testBACdouble(
         Test * pTest);
 #endif

src/bacnet/bacstr.h

@@ -27,6 +27,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stddef.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/config.h"
 
@@ -56,70 +57,88 @@ typedef struct BACnet_Octet_String {
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void bitstring_init(
         BACNET_BIT_STRING * bit_string);
+    BACNET_STACK_EXPORT
     void bitstring_set_bit(
         BACNET_BIT_STRING * bit_string,
         uint8_t bit_number,
         bool value);
+    BACNET_STACK_EXPORT
     bool bitstring_bit(
         BACNET_BIT_STRING * bit_string,
         uint8_t bit_number);
+    BACNET_STACK_EXPORT
     uint8_t bitstring_bits_used(
         BACNET_BIT_STRING * bit_string);
 /* returns the number of bytes that a bit string is using */
+    BACNET_STACK_EXPORT
     uint8_t bitstring_bytes_used(
         BACNET_BIT_STRING * bit_string);
+    BACNET_STACK_EXPORT
     uint8_t bitstring_bits_capacity(
         BACNET_BIT_STRING * bit_string);
 /* used for encoding and decoding from the APDU */
+    BACNET_STACK_EXPORT
     uint8_t bitstring_octet(
         BACNET_BIT_STRING * bit_string,
         uint8_t octet_index);
+    BACNET_STACK_EXPORT
     bool bitstring_set_octet(
         BACNET_BIT_STRING * bit_string,
         uint8_t index,
         uint8_t octet);
+    BACNET_STACK_EXPORT
     bool bitstring_set_bits_used(
         BACNET_BIT_STRING * bit_string,
         uint8_t bytes_used,
         uint8_t unused_bits);
+    BACNET_STACK_EXPORT
     bool bitstring_copy(
         BACNET_BIT_STRING * dest,
         BACNET_BIT_STRING * src);
+    BACNET_STACK_EXPORT
     bool bitstring_same(
         BACNET_BIT_STRING * bitstring1,
         BACNET_BIT_STRING * bitstring2);
+    BACNET_STACK_EXPORT
     bool bitstring_init_ascii(
         BACNET_BIT_STRING * bit_string,
         const char *ascii);
 
 /* returns false if the string exceeds capacity
    initialize by using length=0 */
+    BACNET_STACK_EXPORT
     bool characterstring_init(
         BACNET_CHARACTER_STRING * char_string,
         uint8_t encoding,
         const char *value,
         size_t length);
 /* used for ANSI C-Strings */
+    BACNET_STACK_EXPORT
     bool characterstring_init_ansi(
         BACNET_CHARACTER_STRING * char_string,
         const char *value);
     bool characterstring_copy(
         BACNET_CHARACTER_STRING * dest,
         BACNET_CHARACTER_STRING * src);
+    BACNET_STACK_EXPORT
     bool characterstring_ansi_copy(
         char *dest,
         size_t dest_max_len,
         BACNET_CHARACTER_STRING * src);
 /* returns true if the strings are the same length, encoding, value */
+    BACNET_STACK_EXPORT
     bool characterstring_same(
         BACNET_CHARACTER_STRING * dest,
         BACNET_CHARACTER_STRING * src);
+    BACNET_STACK_EXPORT
     bool characterstring_ansi_same(
         BACNET_CHARACTER_STRING * dest,
         const char *src);
 /* returns false if the string exceeds capacity */
+    BACNET_STACK_EXPORT
     bool characterstring_append(
         BACNET_CHARACTER_STRING * char_string,
         const char *value,
@@ -127,32 +146,42 @@ extern "C" {
 /* This function sets a new length without changing the value.
    If length exceeds capacity, no modification happens and
    function returns false.  */
+    BACNET_STACK_EXPORT
     bool characterstring_truncate(
         BACNET_CHARACTER_STRING * char_string,
         size_t length);
+    BACNET_STACK_EXPORT
     bool characterstring_set_encoding(
         BACNET_CHARACTER_STRING * char_string,
         uint8_t encoding);
 /* Returns the value */
+    BACNET_STACK_EXPORT
     char *characterstring_value(
         BACNET_CHARACTER_STRING * char_string);
 /* returns the length */
+    BACNET_STACK_EXPORT
     size_t characterstring_length(
         BACNET_CHARACTER_STRING * char_string);
+    BACNET_STACK_EXPORT
     uint8_t characterstring_encoding(
         BACNET_CHARACTER_STRING * char_string);
+    BACNET_STACK_EXPORT
     size_t characterstring_capacity(
         BACNET_CHARACTER_STRING * char_string);
+    BACNET_STACK_EXPORT
     bool characterstring_printable(
         BACNET_CHARACTER_STRING * char_string);
+    BACNET_STACK_EXPORT
     bool characterstring_valid(
         BACNET_CHARACTER_STRING * char_string);
+    BACNET_STACK_EXPORT
     bool utf8_isvalid(
         const char *str,
         size_t length);
 
     /* returns false if the string exceeds capacity
        initialize by using length=0 */
+    BACNET_STACK_EXPORT
     bool octetstring_init(
         BACNET_OCTET_STRING * octet_string,
         uint8_t * value,
@@ -160,18 +189,22 @@ extern "C" {
 #ifdef PRINT_ENABLED
     /* converts an null terminated ASCII Hex string to an octet string.
        returns true if successfully converted and fits; false if too long */
+    BACNET_STACK_EXPORT
     bool octetstring_init_ascii_hex(
         BACNET_OCTET_STRING * octet_string,
         const char *ascii_hex);
 #endif
+    BACNET_STACK_EXPORT
     bool octetstring_copy(
         BACNET_OCTET_STRING * dest,
         BACNET_OCTET_STRING * src);
+    BACNET_STACK_EXPORT
     size_t octetstring_copy_value(
         uint8_t * dest,
         size_t length,
         BACNET_OCTET_STRING * src);
 /* returns false if the string exceeds capacity */
+    BACNET_STACK_EXPORT
     bool octetstring_append(
         BACNET_OCTET_STRING * octet_string,
         uint8_t * value,
@@ -179,24 +212,30 @@ extern "C" {
 /* This function sets a new length without changing the value.
    If length exceeds capacity, no modification happens and
    function returns false.  */
+    BACNET_STACK_EXPORT
     bool octetstring_truncate(
         BACNET_OCTET_STRING * octet_string,
         size_t length);
 /* Returns the value */
+    BACNET_STACK_EXPORT
     uint8_t *octetstring_value(
         BACNET_OCTET_STRING * octet_string);
 /* Returns the length.*/
+    BACNET_STACK_EXPORT
     size_t octetstring_length(
         BACNET_OCTET_STRING * octet_string);
+    BACNET_STACK_EXPORT
     size_t octetstring_capacity(
         BACNET_OCTET_STRING * octet_string);
     /* returns true if the same length and contents */
+    BACNET_STACK_EXPORT
     bool octetstring_value_same(
         BACNET_OCTET_STRING * octet_string1,
         BACNET_OCTET_STRING * octet_string2);
 
 #ifdef TEST
 #include "ctest.h"
+    BACNET_STACK_EXPORT
     void testBACnetStrings(
         Test * pTest);
 #endif

src/bacnet/bactext.h

@@ -35,114 +35,158 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/indtext.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     const char *bactext_confirmed_service_name(
         unsigned index);
+    BACNET_STACK_EXPORT
     const char *bactext_unconfirmed_service_name(
         unsigned index);
+    BACNET_STACK_EXPORT
     const char *bactext_application_tag_name(
         unsigned index);
+    BACNET_STACK_EXPORT
 	bool bactext_application_tag_index(
 		const char *search_name,
 		unsigned *found_index);
+    BACNET_STACK_EXPORT
     const char *bactext_object_type_name(
         unsigned index);
+    BACNET_STACK_EXPORT
     bool bactext_object_type_index(
         const char *search_name,
         unsigned *found_index);
+    BACNET_STACK_EXPORT
     bool bactext_object_type_strtol(
         const char *search_name,
         unsigned *found_index);
+    BACNET_STACK_EXPORT
     const char *bactext_notify_type_name(
         unsigned index);
+    BACNET_STACK_EXPORT
     const char *bactext_event_type_name(
         unsigned index);
+    BACNET_STACK_EXPORT
     const char *bactext_property_name(
         unsigned index);
+    BACNET_STACK_EXPORT
     const char *bactext_property_name_default(
         unsigned index,
         const char *default_string);
+    BACNET_STACK_EXPORT
     bool bactext_property_index(
         const char *search_name,
         unsigned *found_index);
+    BACNET_STACK_EXPORT
     bool bactext_property_strtol(
         const char *search_name,
         unsigned *found_index);
+    BACNET_STACK_EXPORT
     const char *bactext_engineering_unit_name(
         unsigned index);
+    BACNET_STACK_EXPORT
     bool bactext_engineering_unit_index(
         const char *search_name,
         unsigned *found_index);
+    BACNET_STACK_EXPORT
     const char *bactext_reject_reason_name(
         unsigned index);
+    BACNET_STACK_EXPORT
     const char *bactext_abort_reason_name(
         unsigned index);
+    BACNET_STACK_EXPORT
     const char *bactext_error_class_name(
         unsigned index);
+    BACNET_STACK_EXPORT
     const char *bactext_error_code_name(
         unsigned index);
+    BACNET_STACK_EXPORT
     unsigned bactext_property_id(
         const char *name);
+    BACNET_STACK_EXPORT
     const char *bactext_month_name(
         unsigned index);
+    BACNET_STACK_EXPORT
     const char *bactext_week_of_month_name(
         unsigned index);
+    BACNET_STACK_EXPORT
     const char *bactext_day_of_week_name(
         unsigned index);
+    BACNET_STACK_EXPORT
     const char *bactext_event_state_name(
         unsigned index);
+    BACNET_STACK_EXPORT
     const char *bactext_binary_present_value_name(
         unsigned index);
+    BACNET_STACK_EXPORT
     const char *bactext_binary_polarity_name(
         unsigned index);
+    BACNET_STACK_EXPORT
     bool bactext_binary_present_value_index(
         const char *search_name,
         unsigned *found_index);
+    BACNET_STACK_EXPORT
     const char *bactext_reliability_name(
         unsigned index);
+    BACNET_STACK_EXPORT
     const char *bactext_device_status_name(
         unsigned index);
+    BACNET_STACK_EXPORT
     const char *bactext_segmentation_name(
         unsigned index);
+    BACNET_STACK_EXPORT
 	bool bactext_segmentation_index(
 		const char *search_name,
 		unsigned *found_index);
+    BACNET_STACK_EXPORT
     const char *bactext_node_type_name(
         unsigned index);
+    BACNET_STACK_EXPORT
     const char *bactext_character_string_encoding_name(
         unsigned index);
+    BACNET_STACK_EXPORT
     const char *bactext_event_transition_name(
         unsigned index);
+    BACNET_STACK_EXPORT
     bool bactext_event_transition_index(
         const char *search_name,
         unsigned *found_index);
 
+    BACNET_STACK_EXPORT
     const char *bactext_days_of_week_name(
         unsigned index);
+    BACNET_STACK_EXPORT
     bool bactext_days_of_week_index(
         const char *search_name,
         unsigned *found_index);
 
+    BACNET_STACK_EXPORT
     const char *bactext_network_layer_msg_name(
         unsigned index);
 
+    BACNET_STACK_EXPORT
 	const char *bactext_life_safety_state_name(
         unsigned index);
 
+    BACNET_STACK_EXPORT
     const char *bactext_device_communications_name(
         unsigned index);
 
+    BACNET_STACK_EXPORT
     const char *bactext_lighting_operation_name(
         unsigned index);
 
+    BACNET_STACK_EXPORT
 	const char *bactext_lighting_in_progress(
 		unsigned index);
 
+    BACNET_STACK_EXPORT
 	const char *bactext_lighting_transition(
 		unsigned index);
 #ifdef __cplusplus

src/bacnet/bactimevalue.h

@@ -28,6 +28,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stddef.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacenum.h"
 #include "bacnet/bacapp.h"
@@ -42,16 +43,20 @@ typedef struct {
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     int bacapp_encode_time_value(uint8_t * apdu,
         BACNET_TIME_VALUE * value);
 
+    BACNET_STACK_EXPORT
     int bacapp_encode_context_time_value(uint8_t * apdu,
         uint8_t tag_number,
         BACNET_TIME_VALUE * value);
 
+    BACNET_STACK_EXPORT
     int bacapp_decode_time_value(uint8_t * apdu,
         BACNET_TIME_VALUE * value);
 
+    BACNET_STACK_EXPORT
     int bacapp_decode_context_time_value(uint8_t * apdu,
         uint8_t tag_number,
         BACNET_TIME_VALUE * value);

src/bacnet/basic/bbmd6/h_bbmd6.h

@@ -33,6 +33,7 @@
 #include <stdbool.h>
 #include <stdint.h>
 #include "bacnet/bacdef.h"
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/datalink/bvlc6.h"
 
 #ifdef __cplusplus
@@ -40,19 +41,24 @@ extern "C" {
 #endif /* __cplusplus */
 
     /* user application function prototypes */
+    BACNET_STACK_EXPORT
     int bvlc6_handler(
         BACNET_IP6_ADDRESS *addr,
         BACNET_ADDRESS * src,
         uint8_t * npdu,
         uint16_t npdu_len);
+    BACNET_STACK_EXPORT
     int bvlc6_register_with_bbmd(
         BACNET_IP6_ADDRESS *bbmd_addr,
         uint32_t vmac_src,
         uint16_t time_to_live_seconds);
+    BACNET_STACK_EXPORT
     uint16_t bvlc6_get_last_result(
         void);
+    BACNET_STACK_EXPORT
     uint8_t bvlc6_get_function_code(
         void);
+    BACNET_STACK_EXPORT
     void bvlc6_init(void);
 
 

src/bacnet/basic/bbmd6/vmac.h

@@ -8,6 +8,7 @@
 
 #include <stdint.h>
 #include <stdbool.h>
+#include "bacnet/bacnet_stack_exports.h"
 
 /* define the max MAC as big as IPv6 + port number */
 #define VMAC_MAC_MAX 18
@@ -26,22 +27,32 @@ struct vmac_data {
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     unsigned int VMAC_Count(void);
+    BACNET_STACK_EXPORT
     struct vmac_data *VMAC_Find_By_Key(uint32_t device_id);
+    BACNET_STACK_EXPORT
     bool VMAC_Find_By_Data(struct vmac_data *vmac, uint32_t *device_id);
+    BACNET_STACK_EXPORT
     bool VMAC_Add(uint32_t device_id, struct vmac_data *pVMAC);
+    BACNET_STACK_EXPORT
     bool VMAC_Delete(uint32_t device_id);
+    BACNET_STACK_EXPORT
     bool VMAC_Different(
         struct vmac_data *vmac1,
         struct vmac_data *vmac2);
+    BACNET_STACK_EXPORT
     bool VMAC_Match(
         struct vmac_data *vmac1,
         struct vmac_data *vmac2);
+    BACNET_STACK_EXPORT
     void VMAC_Cleanup(void);
+    BACNET_STACK_EXPORT
     void VMAC_Init(void);
 
 #ifdef TEST
 #include "ctest.h"
+    BACNET_STACK_EXPORT
     void testVMAC(
         Test * pTest);
 #endif

src/bacnet/basic/binding/address.h

@@ -27,6 +27,7 @@
 #include <stddef.h>
 #include <stdint.h>
 #include <stdbool.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/readrange.h"
 
@@ -34,31 +35,38 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void address_init(
         void);
 
+    BACNET_STACK_EXPORT
     void address_init_partial(
         void);
 
+    BACNET_STACK_EXPORT
     void address_add(
         uint32_t device_id,
         unsigned max_apdu,
         BACNET_ADDRESS * src);
 
+    BACNET_STACK_EXPORT
     void address_remove_device(
         uint32_t device_id);
 
+    BACNET_STACK_EXPORT
     bool address_get_by_device(
         uint32_t device_id,
         unsigned *max_apdu,
         BACNET_ADDRESS * src);
 
+    BACNET_STACK_EXPORT
     bool address_get_by_index(
         unsigned index,
         uint32_t * device_id,
         unsigned *max_apdu,
         BACNET_ADDRESS * src);
 
+    BACNET_STACK_EXPORT
     bool address_device_get_by_index(
         unsigned index,
         uint32_t * device_id,
@@ -66,59 +74,73 @@ extern "C" {
         unsigned *max_apdu,
         BACNET_ADDRESS * src);
 
+    BACNET_STACK_EXPORT
     bool address_get_device_id(
         BACNET_ADDRESS * src,
         uint32_t * device_id);
 
+    BACNET_STACK_EXPORT
     unsigned address_count(
         void);
 
+    BACNET_STACK_EXPORT
     bool address_match(
         BACNET_ADDRESS * dest,
         BACNET_ADDRESS * src);
 
+    BACNET_STACK_EXPORT
     bool address_bind_request(
         uint32_t device_id,
         unsigned *max_apdu,
         BACNET_ADDRESS * src);
 
+    BACNET_STACK_EXPORT
     bool address_device_bind_request(
         uint32_t device_id,
         uint32_t * device_ttl,
         unsigned *max_apdu,
         BACNET_ADDRESS * src);
 
+    BACNET_STACK_EXPORT
     void address_add_binding(
         uint32_t device_id,
         unsigned max_apdu,
         BACNET_ADDRESS * src);
 
+    BACNET_STACK_EXPORT
     int address_list_encode(
         uint8_t * apdu,
         unsigned apdu_len);
 
+    BACNET_STACK_EXPORT
     int rr_address_list_encode(
         uint8_t * apdu,
         BACNET_READ_RANGE_DATA * pRequest);
 
+    BACNET_STACK_EXPORT
     void address_set_device_TTL(
         uint32_t device_id,
         uint32_t TimeOut,
         bool StaticFlag);
 
+    BACNET_STACK_EXPORT
     void address_cache_timer(
         uint16_t uSeconds);
 
+    BACNET_STACK_EXPORT
     void address_mac_init(
         BACNET_MAC_ADDRESS *mac,
         uint8_t *adr,
         uint8_t len);
 
+    BACNET_STACK_EXPORT
     bool address_mac_from_ascii(
         BACNET_MAC_ADDRESS *mac,
         char *arg);
 
+    BACNET_STACK_EXPORT
     void address_protected_entry_index_set(uint32_t top_protected_entry_index);
+    BACNET_STACK_EXPORT
     void address_own_device_id_set(uint32_t own_id);
 
 #ifdef __cplusplus

src/bacnet/basic/npdu/h_npdu.h

@@ -32,6 +32,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacenum.h"
 #include "bacnet/apdu.h"
@@ -41,25 +42,31 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void npdu_handler(
         BACNET_ADDRESS * src,
         uint8_t * pdu,
         uint16_t pdu_len);
+    BACNET_STACK_EXPORT
     void npdu_handler_cleanup(void);
+    BACNET_STACK_EXPORT
     void npdu_handler_init(
         uint16_t bip_net,
         uint16_t mstp_net);
+    BACNET_STACK_EXPORT
     void npdu_router_handler(
         uint16_t snet,
         BACNET_ADDRESS * src,
         uint8_t * pdu,
         uint16_t pdu_len);
+    BACNET_STACK_EXPORT
     int npdu_router_send_pdu(
         uint16_t dnet,
         BACNET_ADDRESS * dest,
         BACNET_NPDU_DATA * npdu_data,
         uint8_t * pdu,
         unsigned int pdu_len);
+    BACNET_STACK_EXPORT
     void npdu_router_get_my_address(
         uint16_t dnet,
         BACNET_ADDRESS * my_address);

src/bacnet/basic/npdu/h_routed_npdu.h

@@ -32,6 +32,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacenum.h"
 #include "bacnet/apdu.h"
@@ -40,6 +41,7 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void routing_npdu_handler(
         BACNET_ADDRESS * src,
         int *DNET_list,

src/bacnet/basic/npdu/s_router.h

@@ -32,6 +32,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacapp.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacenum.h"
@@ -41,27 +42,34 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void npdu_encode_npdu_network(
         BACNET_NPDU_DATA *npdu_data,
         BACNET_NETWORK_MESSAGE_TYPE network_message_type,
         bool data_expecting_reply,
         BACNET_MESSAGE_PRIORITY priority);
+    BACNET_STACK_EXPORT
     int Send_Network_Layer_Message(
         BACNET_NETWORK_MESSAGE_TYPE network_message_type,
         BACNET_ADDRESS * dst,
         int *iArgs);
+    BACNET_STACK_EXPORT
     void Send_Who_Is_Router_To_Network(
         BACNET_ADDRESS * dst,
         int dnet);
+    BACNET_STACK_EXPORT
     void Send_I_Am_Router_To_Network(
         const int DNET_list[]);
+    BACNET_STACK_EXPORT
     void Send_Reject_Message_To_Network(
         BACNET_ADDRESS * dst,
         uint8_t reject_reason,
         int dnet);
+    BACNET_STACK_EXPORT
     void Send_Initialize_Routing_Table(
         BACNET_ADDRESS * dst,
         const int DNET_list[]);
+    BACNET_STACK_EXPORT
     void Send_Initialize_Routing_Table_Ack(
         BACNET_ADDRESS * dst,
         const int DNET_list[]);

src/bacnet/basic/object/acc.h

@@ -3,6 +3,7 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacint.h"
 #include "bacnet/rp.h"
@@ -11,64 +12,86 @@
 #ifdef __cplusplus
 extern "C" {
 #endif /* __cplusplus */
+    BACNET_STACK_EXPORT
     void Accumulator_Property_Lists(
         const int **pRequired,
         const int **pOptional,
         const int **pProprietary);
 
+    BACNET_STACK_EXPORT
     bool Accumulator_Valid_Instance(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     unsigned Accumulator_Count(
         void);
+    BACNET_STACK_EXPORT
     uint32_t Accumulator_Index_To_Instance(
         unsigned index);
+    BACNET_STACK_EXPORT
     unsigned Accumulator_Instance_To_Index(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Accumulator_Object_Instance_Add(
         uint32_t instance);
 
+    BACNET_STACK_EXPORT
     char *Accumulator_Name(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Accumulator_Name_Set(
         uint32_t object_instance,
         char *new_name);
 
+    BACNET_STACK_EXPORT
     char *Accumulator_Description(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Accumulator_Description_Set(
         uint32_t instance,
         char *new_name);
 
+    BACNET_STACK_EXPORT
     bool Accumulator_Object_Name(
         uint32_t object_instance,
         BACNET_CHARACTER_STRING * object_name);
 
 
+    BACNET_STACK_EXPORT
     bool Accumulator_Units_Set(
         uint32_t instance,
         uint16_t units);
+    BACNET_STACK_EXPORT
     uint16_t Accumulator_Units(
         uint32_t instance);
 
+    BACNET_STACK_EXPORT
     int Accumulator_Read_Property(
         BACNET_READ_PROPERTY_DATA * rpdata);
+    BACNET_STACK_EXPORT
     bool Accumulator_Write_Property(
         BACNET_WRITE_PROPERTY_DATA * wp_data);
 
+    BACNET_STACK_EXPORT
 	BACNET_UNSIGNED_INTEGER Accumulator_Present_Value(uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Accumulator_Present_Value_Set(
         uint32_t object_instance,
         BACNET_UNSIGNED_INTEGER value);
 
+    BACNET_STACK_EXPORT
     BACNET_UNSIGNED_INTEGER Accumulator_Max_Pres_Value(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Accumulator_Max_Pres_Value_Set(
         uint32_t object_instance,
         BACNET_UNSIGNED_INTEGER value);
 
+    BACNET_STACK_EXPORT
     int32_t Accumulator_Scale_Integer(uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Accumulator_Scale_Integer_Set(uint32_t object_instance, int32_t);
 
+    BACNET_STACK_EXPORT
     void Accumulator_Init(
         void);
 

src/bacnet/basic/object/access_credential.h

@@ -27,6 +27,7 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacerror.h"
 #include "bacnet/datetime.h"
@@ -75,45 +76,60 @@ extern "C" {
             assigned_access_rights[MAX_ASSIGNED_ACCESS_RIGHTS];
     } ACCESS_CREDENTIAL_DESCR;
 
+    BACNET_STACK_EXPORT
     void Access_Credential_Property_Lists(
         const int **pRequired,
         const int **pOptional,
         const int **pProprietary);
+    BACNET_STACK_EXPORT
     bool Access_Credential_Valid_Instance(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     unsigned Access_Credential_Count(
         void);
+    BACNET_STACK_EXPORT
     uint32_t Access_Credential_Index_To_Instance(
         unsigned index);
+    BACNET_STACK_EXPORT
     unsigned Access_Credential_Instance_To_Index(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Access_Credential_Object_Instance_Add(
         uint32_t instance);
 
 
+    BACNET_STACK_EXPORT
     bool Access_Credential_Object_Name(
         uint32_t object_instance,
         BACNET_CHARACTER_STRING * object_name);
+    BACNET_STACK_EXPORT
     bool Access_Credential_Name_Set(
         uint32_t object_instance,
         char *new_name);
 
+    BACNET_STACK_EXPORT
     int Access_Credential_Read_Property(
         BACNET_READ_PROPERTY_DATA * rpdata);
+    BACNET_STACK_EXPORT
     bool Access_Credential_Write_Property(
         BACNET_WRITE_PROPERTY_DATA * wp_data);
 
+    BACNET_STACK_EXPORT
     bool Access_Credential_Create(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Access_Credential_Delete(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     void Access_Credential_Cleanup(
         void);
+    BACNET_STACK_EXPORT
     void Access_Credential_Init(
         void);
 
 #ifdef TEST
 #include "ctest.h"
+    BACNET_STACK_EXPORT
     void testAccessCredential(
         Test * pTest);
 #endif

src/bacnet/basic/object/access_door.h

@@ -27,6 +27,7 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacerror.h"
 #include "bacnet/rp.h"
@@ -57,82 +58,110 @@ extern "C" {
         BACNET_DOOR_ALARM_STATE door_alarm_state;
     } ACCESS_DOOR_DESCR;
 
+    BACNET_STACK_EXPORT
     void Access_Door_Property_Lists(
         const int **pRequired,
         const int **pOptional,
         const int **pProprietary);
+    BACNET_STACK_EXPORT
     bool Access_Door_Valid_Instance(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     unsigned Access_Door_Count(
         void);
+    BACNET_STACK_EXPORT
     uint32_t Access_Door_Index_To_Instance(
         unsigned index);
+    BACNET_STACK_EXPORT
     unsigned Access_Door_Instance_To_Index(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Access_Door_Object_Instance_Add(
         uint32_t instance);
 
+    BACNET_STACK_EXPORT
     BACNET_DOOR_VALUE Access_Door_Present_Value(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     unsigned Access_Door_Present_Value_Priority(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Access_Door_Present_Value_Set(
         uint32_t object_instance,
         BACNET_DOOR_VALUE value,
         unsigned priority);
+    BACNET_STACK_EXPORT
     bool Access_Door_Present_Value_Relinquish(
         uint32_t object_instance,
         unsigned priority);
 
+    BACNET_STACK_EXPORT
     BACNET_DOOR_VALUE Access_Door_Relinquish_Default(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Access_Door_Relinquish_Default_Set(
         uint32_t object_instance,
         float value);
 
+    BACNET_STACK_EXPORT
     bool Access_Door_Change_Of_Value(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     void Access_Door_Change_Of_Value_Clear(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Access_Door_Encode_Value_List(
         uint32_t object_instance,
         BACNET_PROPERTY_VALUE * value_list);
 
+    BACNET_STACK_EXPORT
     bool Access_Door_Object_Name(
         uint32_t object_instance,
         BACNET_CHARACTER_STRING * object_name);
+    BACNET_STACK_EXPORT
     bool Access_Door_Name_Set(
         uint32_t object_instance,
         char *new_name);
 
+    BACNET_STACK_EXPORT
     char *Access_Door_Description(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Access_Door_Description_Set(
         uint32_t instance,
         char *new_name);
 
+    BACNET_STACK_EXPORT
     bool Access_Door_Out_Of_Service(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     void Access_Door_Out_Of_Service_Set(
         uint32_t instance,
         bool oos_flag);
 
+    BACNET_STACK_EXPORT
     int Access_Door_Read_Property(
         BACNET_READ_PROPERTY_DATA * rpdata);
+    BACNET_STACK_EXPORT
     bool Access_Door_Write_Property(
         BACNET_WRITE_PROPERTY_DATA * wp_data);
 
+    BACNET_STACK_EXPORT
     bool Access_Door_Create(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Access_Door_Delete(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     void Access_Door_Cleanup(
         void);
+    BACNET_STACK_EXPORT
     void Access_Door_Init(
         void);
 
 #ifdef TEST
 #include "ctest.h"
+    BACNET_STACK_EXPORT
     void testAccessDoor(
         Test * pTest);
 #endif

src/bacnet/basic/object/access_point.h

@@ -27,6 +27,7 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacerror.h"
 #include "bacnet/timestamp.h"
@@ -64,52 +65,68 @@ extern "C" {
         uint8_t priority_for_writing;
     } ACCESS_POINT_DESCR;
 
+    BACNET_STACK_EXPORT
     void Access_Point_Property_Lists(
         const int **pRequired,
         const int **pOptional,
         const int **pProprietary);
+    BACNET_STACK_EXPORT
     bool Access_Point_Valid_Instance(
         uint32_t object_instance);
     unsigned Access_Point_Count(
         void);
+    BACNET_STACK_EXPORT
     uint32_t Access_Point_Index_To_Instance(
         unsigned index);
+    BACNET_STACK_EXPORT
     unsigned Access_Point_Instance_To_Index(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Access_Point_Object_Instance_Add(
         uint32_t instance);
 
 
+    BACNET_STACK_EXPORT
     bool Access_Point_Object_Name(
         uint32_t object_instance,
         BACNET_CHARACTER_STRING * object_name);
+    BACNET_STACK_EXPORT
     bool Access_Point_Name_Set(
         uint32_t object_instance,
         char *new_name);
 
 
+    BACNET_STACK_EXPORT
     bool Access_Point_Out_Of_Service(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     void Access_Point_Out_Of_Service_Set(
         uint32_t instance,
         bool oos_flag);
 
+    BACNET_STACK_EXPORT
     int Access_Point_Read_Property(
         BACNET_READ_PROPERTY_DATA * rpdata);
+    BACNET_STACK_EXPORT
     bool Access_Point_Write_Property(
         BACNET_WRITE_PROPERTY_DATA * wp_data);
 
+    BACNET_STACK_EXPORT
     bool Access_Point_Create(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Access_Point_Delete(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     void Access_Point_Cleanup(
         void);
+    BACNET_STACK_EXPORT
     void Access_Point_Init(
         void);
 
 #ifdef TEST
 #include "ctest.h"
+    BACNET_STACK_EXPORT
     void testAccessPoint(
         Test * pTest);
 #endif

src/bacnet/basic/object/access_rights.h

@@ -27,6 +27,7 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacerror.h"
 #include "bacnet/bacdevobjpropref.h"
@@ -62,44 +63,58 @@ extern "C" {
             positive_access_rules[MAX_POSITIVE_ACCESS_RIGHTS_RULES];
     } ACCESS_RIGHTS_DESCR;
 
+    BACNET_STACK_EXPORT
     void Access_Rights_Property_Lists(
         const int **pRequired,
         const int **pOptional,
         const int **pProprietary);
+    BACNET_STACK_EXPORT
     bool Access_Rights_Valid_Instance(
         uint32_t object_instance);
     unsigned Access_Rights_Count(
         void);
+    BACNET_STACK_EXPORT
     uint32_t Access_Rights_Index_To_Instance(
         unsigned index);
+    BACNET_STACK_EXPORT
     unsigned Access_Rights_Instance_To_Index(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Access_Rights_Object_Instance_Add(
         uint32_t instance);
 
+    BACNET_STACK_EXPORT
     bool Access_Rights_Object_Name(
         uint32_t object_instance,
         BACNET_CHARACTER_STRING * object_name);
+    BACNET_STACK_EXPORT
     bool Access_Rights_Name_Set(
         uint32_t object_instance,
         char *new_name);
 
+    BACNET_STACK_EXPORT
     int Access_Rights_Read_Property(
         BACNET_READ_PROPERTY_DATA * rpdata);
+    BACNET_STACK_EXPORT
     bool Access_Rights_Write_Property(
         BACNET_WRITE_PROPERTY_DATA * wp_data);
 
+    BACNET_STACK_EXPORT
     bool Access_Rights_Create(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Access_Rights_Delete(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     void Access_Rights_Cleanup(
         void);
+    BACNET_STACK_EXPORT
     void Access_Rights_Init(
         void);
 
 #ifdef TEST
 #include "ctest.h"
+    BACNET_STACK_EXPORT
     void testAccessRights(
         Test * pTest);
 #endif

src/bacnet/basic/object/access_user.h

@@ -27,6 +27,7 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacerror.h"
 #include "bacnet/bacdevobjpropref.h"
@@ -55,44 +56,58 @@ extern "C" {
             credentials[MAX_ACCESS_USER_CREDENTIALS_COUNT];
     } ACCESS_USER_DESCR;
 
+    BACNET_STACK_EXPORT
     void Access_User_Property_Lists(
         const int **pRequired,
         const int **pOptional,
         const int **pProprietary);
+    BACNET_STACK_EXPORT
     bool Access_User_Valid_Instance(
         uint32_t object_instance);
     unsigned Access_User_Count(
         void);
+    BACNET_STACK_EXPORT
     uint32_t Access_User_Index_To_Instance(
         unsigned index);
+    BACNET_STACK_EXPORT
     unsigned Access_User_Instance_To_Index(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Access_User_Object_Instance_Add(
         uint32_t instance);
 
+    BACNET_STACK_EXPORT
     bool Access_User_Object_Name(
         uint32_t object_instance,
         BACNET_CHARACTER_STRING * object_name);
+    BACNET_STACK_EXPORT
     bool Access_User_Name_Set(
         uint32_t object_instance,
         char *new_name);
 
+    BACNET_STACK_EXPORT
     int Access_User_Read_Property(
         BACNET_READ_PROPERTY_DATA * rpdata);
+    BACNET_STACK_EXPORT
     bool Access_User_Write_Property(
         BACNET_WRITE_PROPERTY_DATA * wp_data);
 
+    BACNET_STACK_EXPORT
     bool Access_User_Create(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Access_User_Delete(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     void Access_User_Cleanup(
         void);
+    BACNET_STACK_EXPORT
     void Access_User_Init(
         void);
 
 #ifdef TEST
 #include "ctest.h"
+    BACNET_STACK_EXPORT
     void testAccessUser(
         Test * pTest);
 #endif

src/bacnet/basic/object/access_zone.h

@@ -27,6 +27,7 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacerror.h"
 #include "bacnet/bacdevobjpropref.h"
@@ -63,50 +64,66 @@ extern "C" {
             exit_points[MAX_ACCESS_ZONE_EXIT_POINTS];
     } ACCESS_ZONE_DESCR;
 
+    BACNET_STACK_EXPORT
     void Access_Zone_Property_Lists(
         const int **pRequired,
         const int **pOptional,
         const int **pProprietary);
+    BACNET_STACK_EXPORT
     bool Access_Zone_Valid_Instance(
         uint32_t object_instance);
     unsigned Access_Zone_Count(
         void);
+    BACNET_STACK_EXPORT
     uint32_t Access_Zone_Index_To_Instance(
         unsigned index);
+    BACNET_STACK_EXPORT
     unsigned Access_Zone_Instance_To_Index(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Access_Zone_Object_Instance_Add(
         uint32_t instance);
 
+    BACNET_STACK_EXPORT
     bool Access_Zone_Object_Name(
         uint32_t object_instance,
         BACNET_CHARACTER_STRING * object_name);
+    BACNET_STACK_EXPORT
     bool Access_Zone_Name_Set(
         uint32_t object_instance,
         char *new_name);
 
+    BACNET_STACK_EXPORT
     bool Access_Zone_Out_Of_Service(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     void Access_Zone_Out_Of_Service_Set(
         uint32_t instance,
         bool oos_flag);
 
+    BACNET_STACK_EXPORT
     int Access_Zone_Read_Property(
         BACNET_READ_PROPERTY_DATA * rpdata);
+    BACNET_STACK_EXPORT
     bool Access_Zone_Write_Property(
         BACNET_WRITE_PROPERTY_DATA * wp_data);
 
+    BACNET_STACK_EXPORT
     bool Access_Zone_Create(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Access_Zone_Delete(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     void Access_Zone_Cleanup(
         void);
+    BACNET_STACK_EXPORT
     void Access_Zone_Init(
         void);
 
 #ifdef TEST
 #include "ctest.h"
+    BACNET_STACK_EXPORT
     void testAccessZone(
         Test * pTest);
 #endif

src/bacnet/basic/object/ai.h

@@ -28,6 +28,7 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/rp.h"
 #include "bacnet/wp.h"
@@ -69,101 +70,132 @@ extern "C" {
 #endif
     } ANALOG_INPUT_DESCR;
 
+    BACNET_STACK_EXPORT
     void Analog_Input_Property_Lists(
         const int **pRequired,
         const int **pOptional,
         const int **pProprietary);
 
+    BACNET_STACK_EXPORT
     bool Analog_Input_Valid_Instance(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     unsigned Analog_Input_Count(
         void);
+    BACNET_STACK_EXPORT
     uint32_t Analog_Input_Index_To_Instance(
         unsigned index);
+    BACNET_STACK_EXPORT
     unsigned Analog_Input_Instance_To_Index(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Analog_Input_Object_Instance_Add(
         uint32_t instance);
 
+    BACNET_STACK_EXPORT
     bool Analog_Input_Object_Name(
         uint32_t object_instance,
         BACNET_CHARACTER_STRING * object_name);
+    BACNET_STACK_EXPORT
     bool Analog_Input_Name_Set(
         uint32_t object_instance,
         char *new_name);
 
+    BACNET_STACK_EXPORT
     char *Analog_Input_Description(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Analog_Input_Description_Set(
         uint32_t instance,
         char *new_name);
 
+    BACNET_STACK_EXPORT
     bool Analog_Input_Units_Set(
         uint32_t instance,
         uint16_t units);
+    BACNET_STACK_EXPORT
     uint16_t Analog_Input_Units(
         uint32_t instance);
 
+    BACNET_STACK_EXPORT
     int Analog_Input_Read_Property(
         BACNET_READ_PROPERTY_DATA * rpdata);
+    BACNET_STACK_EXPORT
     bool Analog_Input_Write_Property(
         BACNET_WRITE_PROPERTY_DATA * wp_data);
 
+    BACNET_STACK_EXPORT
     float Analog_Input_Present_Value(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     void Analog_Input_Present_Value_Set(
         uint32_t object_instance,
         float value);
 
+    BACNET_STACK_EXPORT
     bool Analog_Input_Out_Of_Service(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     void Analog_Input_Out_Of_Service_Set(
         uint32_t object_instance,
         bool oos_flag);
 
+    BACNET_STACK_EXPORT
     bool Analog_Input_Change_Of_Value(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     void Analog_Input_Change_Of_Value_Clear(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Analog_Input_Encode_Value_List(
         uint32_t object_instance,
         BACNET_PROPERTY_VALUE * value_list);
     float Analog_Input_COV_Increment(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     void Analog_Input_COV_Increment_Set(
         uint32_t instance,
         float value);
 
     /* note: header of Intrinsic_Reporting function is required
        even when INTRINSIC_REPORTING is not defined */
+    BACNET_STACK_EXPORT
     void Analog_Input_Intrinsic_Reporting(
         uint32_t object_instance);
 
 #if defined(INTRINSIC_REPORTING)
+    BACNET_STACK_EXPORT
     int Analog_Input_Event_Information(
         unsigned index,
         BACNET_GET_EVENT_INFORMATION_DATA * getevent_data);
 
+    BACNET_STACK_EXPORT
     int Analog_Input_Alarm_Ack(
         BACNET_ALARM_ACK_DATA * alarmack_data,
         BACNET_ERROR_CODE * error_code);
 
+    BACNET_STACK_EXPORT
     int Analog_Input_Alarm_Summary(
         unsigned index,
         BACNET_GET_ALARM_SUMMARY_DATA * getalarm_data);
 #endif
 
+    BACNET_STACK_EXPORT
     bool Analog_Input_Create(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Analog_Input_Delete(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     void Analog_Input_Cleanup(
         void);
+    BACNET_STACK_EXPORT
     void Analog_Input_Init(
         void);
 
 #ifdef TEST
 #include "ctest.h"
+    BACNET_STACK_EXPORT
     void testAnalogInput(
         Test * pTest);
 #endif

src/bacnet/basic/object/ao.h

@@ -27,6 +27,7 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacerror.h"
 #include "bacnet/rp.h"
@@ -36,99 +37,133 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void Analog_Output_Property_Lists(
         const int **pRequired,
         const int **pOptional,
         const int **pProprietary);
+    BACNET_STACK_EXPORT
     bool Analog_Output_Valid_Instance(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     unsigned Analog_Output_Count(
         void);
+    BACNET_STACK_EXPORT
     uint32_t Analog_Output_Index_To_Instance(
         unsigned index);
+    BACNET_STACK_EXPORT
     unsigned Analog_Output_Instance_To_Index(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Analog_Output_Object_Instance_Add(
         uint32_t instance);
 
+    BACNET_STACK_EXPORT
     float Analog_Output_Present_Value(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     unsigned Analog_Output_Present_Value_Priority(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Analog_Output_Present_Value_Set(
         uint32_t object_instance,
         float value,
         unsigned priority);
+    BACNET_STACK_EXPORT
     bool Analog_Output_Present_Value_Relinquish(
         uint32_t object_instance,
         unsigned priority);
 
+    BACNET_STACK_EXPORT
     float Analog_Output_Relinquish_Default(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Analog_Output_Relinquish_Default_Set(
         uint32_t object_instance,
         float value);
 
+    BACNET_STACK_EXPORT
     bool Analog_Output_Change_Of_Value(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     void Analog_Output_Change_Of_Value_Clear(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Analog_Output_Encode_Value_List(
         uint32_t object_instance,
         BACNET_PROPERTY_VALUE * value_list);
+    BACNET_STACK_EXPORT
     float Analog_Output_COV_Increment(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     void Analog_Output_COV_Increment_Set(
         uint32_t instance,
         float value);
 
+    BACNET_STACK_EXPORT
     bool Analog_Output_Object_Name(
         uint32_t object_instance,
         BACNET_CHARACTER_STRING * object_name);
+    BACNET_STACK_EXPORT
     bool Analog_Output_Name_Set(
         uint32_t object_instance,
         char *new_name);
 
+    BACNET_STACK_EXPORT
     char *Analog_Output_Description(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Analog_Output_Description_Set(
         uint32_t instance,
         char *new_name);
 
+    BACNET_STACK_EXPORT
     BACNET_RELIABILITY Analog_Output_Reliability(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Analog_Output_Reliability_Set(
         uint32_t object_instance,
         BACNET_RELIABILITY value);
 
+    BACNET_STACK_EXPORT
     bool Analog_Output_Units_Set(
         uint32_t instance,
         uint16_t units);
+    BACNET_STACK_EXPORT
     uint16_t Analog_Output_Units(
         uint32_t instance);
 
+    BACNET_STACK_EXPORT
     bool Analog_Output_Out_Of_Service(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     void Analog_Output_Out_Of_Service_Set(
         uint32_t instance,
         bool oos_flag);
 
+    BACNET_STACK_EXPORT
     int Analog_Output_Read_Property(
         BACNET_READ_PROPERTY_DATA * rpdata);
+    BACNET_STACK_EXPORT
     bool Analog_Output_Write_Property(
         BACNET_WRITE_PROPERTY_DATA * wp_data);
 
+    BACNET_STACK_EXPORT
     bool Analog_Output_Create(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Analog_Output_Delete(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     void Analog_Output_Cleanup(
         void);
+    BACNET_STACK_EXPORT
     void Analog_Output_Init(
         void);
 
 #ifdef TEST
 #include "ctest.h"
+    BACNET_STACK_EXPORT
     void testAnalogOutput(
         Test * pTest);
 #endif

src/bacnet/basic/object/av.h

@@ -28,6 +28,7 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacerror.h"
 #include "bacnet/wp.h"
@@ -70,106 +71,139 @@ extern "C" {
     } ANALOG_VALUE_DESCR;
 
 
+    BACNET_STACK_EXPORT
     void Analog_Value_Property_Lists(
         const int **pRequired,
         const int **pOptional,
         const int **pProprietary);
+    BACNET_STACK_EXPORT
     bool Analog_Value_Valid_Instance(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     unsigned Analog_Value_Count(
         void);
+    BACNET_STACK_EXPORT
     uint32_t Analog_Value_Index_To_Instance(
         unsigned index);
+    BACNET_STACK_EXPORT
     unsigned Analog_Value_Instance_To_Index(
         uint32_t object_instance);
 
+    BACNET_STACK_EXPORT
     bool Analog_Value_Object_Name(
         uint32_t object_instance,
         BACNET_CHARACTER_STRING * object_name);
+    BACNET_STACK_EXPORT
     bool Analog_Value_Name_Set(
         uint32_t object_instance,
         char *new_name);
 
+    BACNET_STACK_EXPORT
     int Analog_Value_Read_Property(
         BACNET_READ_PROPERTY_DATA * rpdata);
 
+    BACNET_STACK_EXPORT
     bool Analog_Value_Write_Property(
         BACNET_WRITE_PROPERTY_DATA * wp_data);
 
+    BACNET_STACK_EXPORT
     bool Analog_Value_Present_Value_Set(
         uint32_t object_instance,
         float value,
         uint8_t priority);
+    BACNET_STACK_EXPORT
     float Analog_Value_Present_Value(
         uint32_t object_instance);
 
+    BACNET_STACK_EXPORT
     bool Analog_Value_Change_Of_Value(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     void Analog_Value_Change_Of_Value_Clear(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Analog_Value_Encode_Value_List(
         uint32_t object_instance,
         BACNET_PROPERTY_VALUE * value_list);
+    BACNET_STACK_EXPORT
     float Analog_Value_COV_Increment(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     void Analog_Value_COV_Increment_Set(
         uint32_t instance,
         float value);
 
+    BACNET_STACK_EXPORT
     char *Analog_Value_Description(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Analog_Value_Description_Set(
         uint32_t instance,
         char *new_name);
 
+    BACNET_STACK_EXPORT
     BACNET_RELIABILITY Analog_Value_Reliability(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Analog_Value_Reliability_Set(
         uint32_t object_instance,
         BACNET_RELIABILITY value);
 
+    BACNET_STACK_EXPORT
     uint16_t Analog_Value_Units(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Analog_Value_Units_Set(
         uint32_t instance,
         uint16_t unit);
 
+    BACNET_STACK_EXPORT
     bool Analog_Value_Out_Of_Service(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     void Analog_Value_Out_Of_Service_Set(
         uint32_t instance,
         bool oos_flag);
 
     /* note: header of Intrinsic_Reporting function is required
        even when INTRINSIC_REPORTING is not defined */
+    BACNET_STACK_EXPORT
     void Analog_Value_Intrinsic_Reporting(
         uint32_t object_instance);
 
 #if defined(INTRINSIC_REPORTING)
+    BACNET_STACK_EXPORT
     int Analog_Value_Event_Information(
         unsigned index,
         BACNET_GET_EVENT_INFORMATION_DATA * getevent_data);
 
+    BACNET_STACK_EXPORT
     int Analog_Value_Alarm_Ack(
         BACNET_ALARM_ACK_DATA * alarmack_data,
         BACNET_ERROR_CODE * error_code);
 
+    BACNET_STACK_EXPORT
     int Analog_Value_Alarm_Summary(
         unsigned index,
         BACNET_GET_ALARM_SUMMARY_DATA * getalarm_data);
 #endif
 
+    BACNET_STACK_EXPORT
     bool Analog_Value_Create(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Analog_Value_Delete(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     void Analog_Value_Cleanup(
         void);
+    BACNET_STACK_EXPORT
     void Analog_Value_Init(
         void);
 
 #ifdef TEST
 #include "ctest.h"
+    BACNET_STACK_EXPORT
     void testAnalog_Value(
         Test * pTest);
 #endif

src/bacnet/basic/object/bacfile.h

@@ -36,6 +36,7 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacenum.h"
 #include "bacnet/apdu.h"
@@ -48,21 +49,28 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void BACfile_Property_Lists(
         const int **pRequired,
         const int **pOptional,
         const int **pProprietary);
+    BACNET_STACK_EXPORT
     bool bacfile_object_name(
         uint32_t object_instance,
         BACNET_CHARACTER_STRING * object_name);
+    BACNET_STACK_EXPORT
     bool bacfile_valid_instance(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     uint32_t bacfile_count(
         void);
+    BACNET_STACK_EXPORT
     uint32_t bacfile_index_to_instance(
         unsigned find_index);
+    BACNET_STACK_EXPORT
     unsigned bacfile_instance_to_index(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     uint32_t bacfile_instance(
         char *filename);
     /* this is one way to match up the invoke ID with */
@@ -70,35 +78,46 @@ extern "C" {
     /* Another way would be to store the */
     /* invokeID and file instance in a list or table */
     /* when the request was sent */
+    BACNET_STACK_EXPORT
     uint32_t bacfile_instance_from_tsm(
         uint8_t invokeID);
 
     /* handler ACK helper */
+    BACNET_STACK_EXPORT
     bool bacfile_read_stream_data(
         BACNET_ATOMIC_READ_FILE_DATA * data);
+    BACNET_STACK_EXPORT
     bool bacfile_read_ack_stream_data(
         uint32_t instance,
         BACNET_ATOMIC_READ_FILE_DATA * data);
+    BACNET_STACK_EXPORT
     bool bacfile_write_stream_data(
         BACNET_ATOMIC_WRITE_FILE_DATA * data);
+    BACNET_STACK_EXPORT
     bool bacfile_read_record_data(
         BACNET_ATOMIC_READ_FILE_DATA * data);
+    BACNET_STACK_EXPORT
     bool bacfile_read_ack_record_data(
         uint32_t instance,
         BACNET_ATOMIC_READ_FILE_DATA * data);
+    BACNET_STACK_EXPORT
     bool bacfile_write_record_data(
         BACNET_ATOMIC_WRITE_FILE_DATA * data);
 
+    BACNET_STACK_EXPORT
     void bacfile_init(
         void);
+    BACNET_STACK_EXPORT
     uint32_t bacfile_file_size(
         uint32_t instance);
 
     /* handling for read property service */
+    BACNET_STACK_EXPORT
     int bacfile_read_property(
         BACNET_READ_PROPERTY_DATA * rpdata);
 
     /* handling for write property service */
+    BACNET_STACK_EXPORT
     bool bacfile_write_property(
         BACNET_WRITE_PROPERTY_DATA * wp_data);
 

src/bacnet/basic/object/bi.h

@@ -27,6 +27,7 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/cov.h"
 #include "bacnet/rp.h"
@@ -36,95 +37,127 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void Binary_Input_Property_Lists(
         const int **pRequired,
         const int **pOptional,
         const int **pProprietary);
 
+    BACNET_STACK_EXPORT
     bool Binary_Input_Valid_Instance(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     unsigned Binary_Input_Count(
         void);
+    BACNET_STACK_EXPORT
     uint32_t Binary_Input_Index_To_Instance(
         unsigned index);
+    BACNET_STACK_EXPORT
     unsigned Binary_Input_Instance_To_Index(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Binary_Input_Object_Instance_Add(
         uint32_t instance);
 
+    BACNET_STACK_EXPORT
     bool Binary_Input_Object_Name(
         uint32_t object_instance,
         BACNET_CHARACTER_STRING * object_name);
+    BACNET_STACK_EXPORT
     bool Binary_Input_Name_Set(
         uint32_t object_instance,
         char *new_name);
 
+    BACNET_STACK_EXPORT
     BACNET_BINARY_PV Binary_Input_Present_Value(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Binary_Input_Present_Value_Set(
         uint32_t object_instance,
         BACNET_BINARY_PV value);
 
+    BACNET_STACK_EXPORT
     char *Binary_Input_Description(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Binary_Input_Description_Set(
         uint32_t instance,
         char *new_name);
 
+    BACNET_STACK_EXPORT
     BACNET_RELIABILITY Binary_Input_Reliability(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Binary_Input_Reliability_Set(
         uint32_t object_instance,
         BACNET_RELIABILITY value);
 
+    BACNET_STACK_EXPORT
     char *Binary_Input_Inactive_Text(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Binary_Input_Inactive_Text_Set(
         uint32_t instance,
         char *new_name);
+    BACNET_STACK_EXPORT
     char *Binary_Input_Active_Text(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Binary_Input_Active_Text_Set(
         uint32_t instance,
         char *new_name);
 
+    BACNET_STACK_EXPORT
     BACNET_POLARITY Binary_Input_Polarity(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Binary_Input_Polarity_Set(
         uint32_t object_instance,
         BACNET_POLARITY polarity);
 
+    BACNET_STACK_EXPORT
     bool Binary_Input_Out_Of_Service(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     void Binary_Input_Out_Of_Service_Set(
         uint32_t object_instance,
         bool value);
 
+    BACNET_STACK_EXPORT
     bool Binary_Input_Encode_Value_List(
         uint32_t object_instance,
         BACNET_PROPERTY_VALUE * value_list);
+    BACNET_STACK_EXPORT
     bool Binary_Input_Change_Of_Value(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     void Binary_Input_Change_Of_Value_Clear(
         uint32_t instance);
 
+    BACNET_STACK_EXPORT
     int Binary_Input_Read_Property(
         BACNET_READ_PROPERTY_DATA * rpdata);
 
+    BACNET_STACK_EXPORT
     bool Binary_Input_Write_Property(
         BACNET_WRITE_PROPERTY_DATA * wp_data);
 
+    BACNET_STACK_EXPORT
     bool Binary_Input_Create(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Binary_Input_Delete(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     void Binary_Input_Cleanup(
         void);
+    BACNET_STACK_EXPORT
     void Binary_Input_Init(
         void);
 
 #ifdef TEST
 #include "ctest.h"
+    BACNET_STACK_EXPORT
     void testBinaryInput(
         Test * pTest);
 #endif

src/bacnet/basic/object/bo.h

@@ -27,6 +27,7 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacerror.h"
 #include "bacnet/rp.h"
@@ -36,101 +37,135 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void Binary_Output_Init(
         void);
 
+    BACNET_STACK_EXPORT
     void Binary_Output_Property_Lists(
         const int **pRequired,
         const int **pOptional,
         const int **pProprietary);
 
+    BACNET_STACK_EXPORT
     bool Binary_Output_Valid_Instance(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     unsigned Binary_Output_Count(
         void);
+    BACNET_STACK_EXPORT
     uint32_t Binary_Output_Index_To_Instance(
         unsigned index);
+    BACNET_STACK_EXPORT
     unsigned Binary_Output_Instance_To_Index(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Binary_Output_Object_Instance_Add(
         uint32_t instance);
 
+    BACNET_STACK_EXPORT
     bool Binary_Output_Object_Name(
         uint32_t object_instance,
         BACNET_CHARACTER_STRING * object_name);
+    BACNET_STACK_EXPORT
     bool Binary_Output_Name_Set(
         uint32_t object_instance,
         char *new_name);
 
+    BACNET_STACK_EXPORT
     char *Binary_Output_Description(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Binary_Output_Description_Set(
         uint32_t instance,
         char *new_name);
 
+    BACNET_STACK_EXPORT
     char *Binary_Output_Inactive_Text(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Binary_Output_Inactive_Text_Set(
         uint32_t instance,
         char *new_name);
+    BACNET_STACK_EXPORT
     char *Binary_Output_Active_Text(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Binary_Output_Active_Text_Set(
         uint32_t instance,
         char *new_name);
 
+    BACNET_STACK_EXPORT
     BACNET_BINARY_PV Binary_Output_Present_Value(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Binary_Output_Present_Value_Set(
         uint32_t instance,
         BACNET_BINARY_PV binary_value,
         unsigned priority);
+    BACNET_STACK_EXPORT
     bool Binary_Output_Present_Value_Relinquish(
         uint32_t instance,
         unsigned priority);
+    BACNET_STACK_EXPORT
     unsigned Binary_Output_Present_Value_Priority(
         uint32_t object_instance);
 
+    BACNET_STACK_EXPORT
     BACNET_POLARITY Binary_Output_Polarity(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Binary_Output_Polarity_Set(
         uint32_t object_instance,
         BACNET_POLARITY polarity);
 
+    BACNET_STACK_EXPORT
     bool Binary_Output_Out_Of_Service(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     void Binary_Output_Out_Of_Service_Set(
         uint32_t object_instance,
         bool value);
 
+    BACNET_STACK_EXPORT
     BACNET_BINARY_PV Binary_Output_Relinquish_Default(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Binary_Output_Relinquish_Default_Set(
         uint32_t object_instance,
         BACNET_BINARY_PV value);
 
+    BACNET_STACK_EXPORT
     bool Binary_Output_Encode_Value_List(
         uint32_t object_instance,
         BACNET_PROPERTY_VALUE * value_list);
+    BACNET_STACK_EXPORT
     bool Binary_Output_Change_Of_Value(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     void Binary_Output_Change_Of_Value_Clear(
         uint32_t instance);
 
+    BACNET_STACK_EXPORT
     int Binary_Output_Read_Property(
         BACNET_READ_PROPERTY_DATA * rpdata);
+    BACNET_STACK_EXPORT
     bool Binary_Output_Write_Property(
         BACNET_WRITE_PROPERTY_DATA * wp_data);
 
+    BACNET_STACK_EXPORT
     bool Binary_Output_Create(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Binary_Output_Delete(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     void Binary_Output_Cleanup(
         void);
 
 #ifdef TEST
 #include "ctest.h"
+    BACNET_STACK_EXPORT
     void testBinaryOutput(
         Test * pTest);
 #endif

src/bacnet/basic/object/bv.h

@@ -27,6 +27,7 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacerror.h"
 #include "bacnet/rp.h"
@@ -36,112 +37,150 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void Binary_Value_Init(
         void);
 
+    BACNET_STACK_EXPORT
     void Binary_Value_Property_Lists(
         const int **pRequired,
         const int **pOptional,
         const int **pProprietary);
 
+    BACNET_STACK_EXPORT
     bool Binary_Value_Valid_Instance(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     unsigned Binary_Value_Count(
         void);
+    BACNET_STACK_EXPORT
     uint32_t Binary_Value_Index_To_Instance(
         unsigned index);
+    BACNET_STACK_EXPORT
     unsigned Binary_Value_Instance_To_Index(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Binary_Value_Object_Instance_Add(
         uint32_t instance);
 
+    BACNET_STACK_EXPORT
     bool Binary_Value_Object_Name(
         uint32_t object_instance,
         BACNET_CHARACTER_STRING * object_name);
+    BACNET_STACK_EXPORT
     bool Binary_Value_Name_Set(
         uint32_t object_instance,
         char *new_name);
 
+    BACNET_STACK_EXPORT
     char *Binary_Value_Description(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Binary_Value_Description_Set(
         uint32_t instance,
         char *new_name);
 
+    BACNET_STACK_EXPORT
     BACNET_RELIABILITY Binary_Value_Reliability(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Binary_Value_Reliability_Set(
         uint32_t object_instance,
         BACNET_RELIABILITY value);
 
+    BACNET_STACK_EXPORT
     char *Binary_Value_Inactive_Text(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Binary_Value_Inactive_Text_Set(
         uint32_t instance,
         char *new_name);
+    BACNET_STACK_EXPORT
     char *Binary_Value_Active_Text(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Binary_Value_Active_Text_Set(
         uint32_t instance,
         char *new_name);
 
+    BACNET_STACK_EXPORT
     int Binary_Value_Read_Property(
         BACNET_READ_PROPERTY_DATA * rpdata);
 
+    BACNET_STACK_EXPORT
     bool Binary_Value_Write_Property(
         BACNET_WRITE_PROPERTY_DATA * wp_data);
 
+    BACNET_STACK_EXPORT
     bool Binary_Value_Encode_Value_List(
         uint32_t object_instance,
         BACNET_PROPERTY_VALUE * value_list);
+    BACNET_STACK_EXPORT
     bool Binary_Value_Change_Of_Value(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     void Binary_Value_Change_Of_Value_Clear(
         uint32_t instance);
 
+    BACNET_STACK_EXPORT
     BACNET_BINARY_PV Binary_Value_Present_Value(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Binary_Value_Present_Value_Set(
         uint32_t instance,
         BACNET_BINARY_PV value);
 
+    BACNET_STACK_EXPORT
     bool Binary_Value_Out_Of_Service(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     void Binary_Value_Out_Of_Service_Set(
         uint32_t instance,
         bool value);
 
+    BACNET_STACK_EXPORT
     char *Binary_Value_Description(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Binary_Value_Description_Set(
         uint32_t object_instance,
         char *text_string);
 
+    BACNET_STACK_EXPORT
     char *Binary_Value_Inactive_Text(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Binary_Value_Inactive_Text_Set(
         uint32_t instance,
         char *new_name);
+    BACNET_STACK_EXPORT
     char *Binary_Value_Active_Text(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Binary_Value_Active_Text_Set(
         uint32_t instance,
         char *new_name);
 
+    BACNET_STACK_EXPORT
     BACNET_POLARITY Binary_Value_Polarity(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Binary_Value_Polarity_Set(
         uint32_t object_instance,
         BACNET_POLARITY polarity);
+    BACNET_STACK_EXPORT
     bool Binary_Value_Create(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Binary_Value_Delete(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     void Binary_Value_Cleanup(
         void);
 
 #ifdef TEST
 #include "ctest.h"
+    BACNET_STACK_EXPORT
     void testBinary_Value(
         Test * pTest);
 #endif

src/bacnet/basic/object/channel.h

@@ -36,6 +36,7 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/rp.h"
 #include "bacnet/wp.h"
@@ -124,76 +125,106 @@ extern "C" {
         struct BACnet_Channel_Value_t *next;
     } BACNET_CHANNEL_VALUE;
 
+    BACNET_STACK_EXPORT
     void Channel_Property_Lists(const int **pRequired,
         const int **pOptional,
         const int **pProprietary);
+    BACNET_STACK_EXPORT
     bool Channel_Valid_Instance(uint32_t object_instance);
+    BACNET_STACK_EXPORT
     unsigned Channel_Count(void);
+    BACNET_STACK_EXPORT
     uint32_t Channel_Index_To_Instance(unsigned index);
+    BACNET_STACK_EXPORT
     unsigned Channel_Instance_To_Index(uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Channel_Object_Instance_Add(uint32_t instance);
 
+    BACNET_STACK_EXPORT
     bool Channel_Object_Name(uint32_t object_instance,
         BACNET_CHARACTER_STRING * object_name);
+    BACNET_STACK_EXPORT
     bool Channel_Name_Set(uint32_t object_instance,
         char *new_name);
 
+    BACNET_STACK_EXPORT
     int Channel_Read_Property(BACNET_READ_PROPERTY_DATA * rpdata);
+    BACNET_STACK_EXPORT
     bool Channel_Write_Property(BACNET_WRITE_PROPERTY_DATA * wp_data);
 
+    BACNET_STACK_EXPORT
     BACNET_CHANNEL_VALUE * Channel_Present_Value(uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Channel_Present_Value_Set(
         BACNET_WRITE_PROPERTY_DATA * wp_data,
         BACNET_APPLICATION_DATA_VALUE * value);
 
+    BACNET_STACK_EXPORT
     bool Channel_Out_Of_Service(uint32_t object_instance);
+    BACNET_STACK_EXPORT
     void Channel_Out_Of_Service_Set(uint32_t object_instance,
         bool oos_flag);
 
+    BACNET_STACK_EXPORT
     unsigned Channel_Last_Priority(uint32_t object_instance);
+    BACNET_STACK_EXPORT
     BACNET_WRITE_STATUS Channel_Write_Status(uint32_t object_instance);
     uint16_t Channel_Number(uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Channel_Number_Set(uint32_t object_instance, uint16_t value);
 
+    BACNET_STACK_EXPORT
     unsigned Channel_Reference_List_Member_Count(uint32_t object_instance);
+    BACNET_STACK_EXPORT
     BACNET_DEVICE_OBJECT_PROPERTY_REFERENCE *
     Channel_Reference_List_Member_Element(uint32_t object_instance,
         unsigned element);
+    BACNET_STACK_EXPORT
     bool Channel_Reference_List_Member_Element_Set(uint32_t object_instance,
         unsigned array_index,
         BACNET_DEVICE_OBJECT_PROPERTY_REFERENCE *pMemberSrc);
+    BACNET_STACK_EXPORT
     unsigned Channel_Reference_List_Member_Element_Add(uint32_t object_instance,
         BACNET_DEVICE_OBJECT_PROPERTY_REFERENCE *pMemberSrc);
+    BACNET_STACK_EXPORT
     unsigned Channel_Reference_List_Member_Local_Add(
         uint32_t object_instance,
         BACNET_OBJECT_TYPE type,
         uint32_t instance,
         BACNET_PROPERTY_ID propertyIdentifier,
         uint32_t arrayIndex);
+    BACNET_STACK_EXPORT
     uint16_t Channel_Control_Groups_Element(
         uint32_t object_instance,
         int32_t array_index);
+    BACNET_STACK_EXPORT
     bool Channel_Control_Groups_Element_Set(
         uint32_t object_instance,
         int32_t array_index,
         uint16_t value);
+    BACNET_STACK_EXPORT
     bool Channel_Value_Copy(BACNET_CHANNEL_VALUE * cvalue,
         BACNET_APPLICATION_DATA_VALUE * value);
+    BACNET_STACK_EXPORT
     int Channel_Value_Encode(uint8_t *apdu, int apdu_max,
         BACNET_CHANNEL_VALUE * value);
+    BACNET_STACK_EXPORT
     int Channel_Coerce_Data_Encode(
         uint8_t * apdu,
         unsigned max_apdu,
         BACNET_APPLICATION_DATA_VALUE * value,
         BACNET_APPLICATION_TAG tag);
+    BACNET_STACK_EXPORT
     bool Channel_Write_Member_Value(
         BACNET_WRITE_PROPERTY_DATA * wp_data,
         BACNET_APPLICATION_DATA_VALUE * value);
 
+    BACNET_STACK_EXPORT
     void Channel_Init(void);
 
 #ifdef TEST
 #include "ctest.h"
+    BACNET_STACK_EXPORT
     void testChannelObject(Test * pTest);
 #endif
 

src/bacnet/basic/object/command.h

@@ -44,6 +44,7 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/rp.h"
 #include "bacnet/wp.h"
@@ -90,81 +91,106 @@ extern "C" {
         BACNET_ACTION_LIST Action[MAX_COMMAND_ACTIONS];
     } COMMAND_DESCR;
 
+    BACNET_STACK_EXPORT
     void Command_Property_Lists(
         const int **pRequired,
         const int **pOptional,
         const int **pProprietary);
 
+    BACNET_STACK_EXPORT
     bool Command_Valid_Instance(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     unsigned Command_Count(
         void);
+    BACNET_STACK_EXPORT
     uint32_t Command_Index_To_Instance(
         unsigned index);
+    BACNET_STACK_EXPORT
     unsigned Command_Instance_To_Index(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Command_Object_Instance_Add(
         uint32_t instance);
 
+    BACNET_STACK_EXPORT
     bool Command_Object_Name(
         uint32_t object_instance,
         BACNET_CHARACTER_STRING * object_name);
+    BACNET_STACK_EXPORT
     bool Command_Name_Set(
         uint32_t object_instance,
         char *new_name);
 
+    BACNET_STACK_EXPORT
     char *Command_Description(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Command_Description_Set(
         uint32_t instance,
         char *new_name);
 
+    BACNET_STACK_EXPORT
     int Command_Read_Property(
         BACNET_READ_PROPERTY_DATA * rpdata);
+    BACNET_STACK_EXPORT
     bool Command_Write_Property(
         BACNET_WRITE_PROPERTY_DATA * wp_data);
 
+    BACNET_STACK_EXPORT
     uint32_t Command_Present_Value(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Command_Present_Value_Set(
         uint32_t object_instance,
         uint32_t value);
 
+    BACNET_STACK_EXPORT
     bool Command_In_Process(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Command_In_Process_Set(
         uint32_t object_instance,
         bool value);
 
+    BACNET_STACK_EXPORT
     bool Command_All_Writes_Successful(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Command_All_Writes_Successful_Set(
         uint32_t object_instance,
         bool value);
 
+    BACNET_STACK_EXPORT
     bool Command_Change_Of_Value(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     void Command_Change_Of_Value_Clear(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Command_Encode_Value_List(
         uint32_t object_instance,
         BACNET_PROPERTY_VALUE * value_list);
     float Command_COV_Increment(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     void Command_COV_Increment_Set(
         uint32_t instance,
         float value);
 
     /* note: header of Intrinsic_Reporting function is required
        even when INTRINSIC_REPORTING is not defined */
+    BACNET_STACK_EXPORT
     void Command_Intrinsic_Reporting(
         uint32_t object_instance);
 
+    BACNET_STACK_EXPORT
     void Command_Init(
         void);
 
 #ifdef TEST
 #include "ctest.h"
+    BACNET_STACK_EXPORT
     void testCommand(
         Test * pTest);
 #endif

src/bacnet/basic/object/credential_data_input.h

@@ -27,6 +27,7 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacerror.h"
 #include "bacnet/timestamp.h"
@@ -60,52 +61,69 @@ extern "C" {
         BACNET_TIMESTAMP timestamp;
     } CREDENTIAL_DATA_INPUT_DESCR;
 
+    BACNET_STACK_EXPORT
     void Credential_Data_Input_Property_Lists(
         const int **pRequired,
         const int **pOptional,
         const int **pProprietary);
+    BACNET_STACK_EXPORT
     bool Credential_Data_Input_Valid_Instance(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     unsigned Credential_Data_Input_Count(
         void);
+    BACNET_STACK_EXPORT
     uint32_t Credential_Data_Input_Index_To_Instance(
         unsigned index);
+    BACNET_STACK_EXPORT
     unsigned Credential_Data_Input_Instance_To_Index(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Credential_Data_Input_Object_Instance_Add(
         uint32_t instance);
 
 
+    BACNET_STACK_EXPORT
     bool Credential_Data_Input_Object_Name(
         uint32_t object_instance,
         BACNET_CHARACTER_STRING * object_name);
+    BACNET_STACK_EXPORT
     bool Credential_Data_Input_Name_Set(
         uint32_t object_instance,
         char *new_name);
 
 
+    BACNET_STACK_EXPORT
     bool Credential_Data_Input_Out_Of_Service(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     void Credential_Data_Input_Out_Of_Service_Set(
         uint32_t instance,
         bool oos_flag);
 
+    BACNET_STACK_EXPORT
     int Credential_Data_Input_Read_Property(
         BACNET_READ_PROPERTY_DATA * rpdata);
+    BACNET_STACK_EXPORT
     bool Credential_Data_Input_Write_Property(
         BACNET_WRITE_PROPERTY_DATA * wp_data);
 
+    BACNET_STACK_EXPORT
     bool Credential_Data_Input_Create(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Credential_Data_Input_Delete(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     void Credential_Data_Input_Cleanup(
         void);
+    BACNET_STACK_EXPORT
     void Credential_Data_Input_Init(
         void);
 
 #ifdef TEST
 #include "ctest.h"
+    BACNET_STACK_EXPORT
     void testCredentialDataInput(
         Test * pTest);
 #endif

src/bacnet/basic/object/csv.h

@@ -27,6 +27,7 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacerror.h"
 #include "bacnet/rp.h"
@@ -36,55 +37,71 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void CharacterString_Value_Property_Lists(
         const int **pRequired,
         const int **pOptional,
         const int **pProprietary);
 
+    BACNET_STACK_EXPORT
     bool CharacterString_Value_Valid_Instance(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     unsigned CharacterString_Value_Count(
         void);
+    BACNET_STACK_EXPORT
     uint32_t CharacterString_Value_Index_To_Instance(
         unsigned index);
+    BACNET_STACK_EXPORT
     unsigned CharacterString_Value_Instance_To_Index(
         uint32_t instance);
 
+    BACNET_STACK_EXPORT
     int CharacterString_Value_Read_Property(
         BACNET_READ_PROPERTY_DATA * rpdata);
 
+    BACNET_STACK_EXPORT
     bool CharacterString_Value_Write_Property(
         BACNET_WRITE_PROPERTY_DATA * wp_data);
 
     /* optional API */
+    BACNET_STACK_EXPORT
     bool CharacterString_Value_Object_Instance_Add(
         uint32_t instance);
 
+    BACNET_STACK_EXPORT
     bool CharacterString_Value_Object_Name(
         uint32_t object_instance,
         BACNET_CHARACTER_STRING * object_name);
+    BACNET_STACK_EXPORT
     bool CharacterString_Value_Name_Set(
         uint32_t object_instance,
         char *new_name);
 
+    BACNET_STACK_EXPORT
     bool CharacterString_Value_Present_Value(
         uint32_t object_instance,
         BACNET_CHARACTER_STRING * value);
+    BACNET_STACK_EXPORT
     bool CharacterString_Value_Present_Value_Set(
         uint32_t object_instance,
         BACNET_CHARACTER_STRING * value);
+    BACNET_STACK_EXPORT
     bool CharacterString_Value_Description_Set(
         uint32_t object_instance,
         char *text_string);
+    BACNET_STACK_EXPORT
     bool CharacterString_Value_Out_Of_Service(
         uint32_t object_instance);
 
+    BACNET_STACK_EXPORT
     void CharacterString_Value_Init(
         void);
 
 
 #ifdef TEST
 #include "ctest.h"
+    BACNET_STACK_EXPORT
     void testCharacterStringValue(
         Test * pTest);
 #endif

src/bacnet/basic/object/device.h

@@ -31,6 +31,7 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacenum.h"
 #include "bacnet/wp.h"
@@ -221,164 +222,223 @@ typedef struct devObj_s {
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void Device_Init(
         object_functions_t * object_table);
 
+    BACNET_STACK_EXPORT
     bool Device_Reinitialize(
         BACNET_REINITIALIZE_DEVICE_DATA * rd_data);
+    BACNET_STACK_EXPORT
     bool Device_Reinitialize_State_Set(BACNET_REINITIALIZED_STATE state);
+    BACNET_STACK_EXPORT
     BACNET_REINITIALIZED_STATE Device_Reinitialized_State(
         void);
 
+    BACNET_STACK_EXPORT
     rr_info_function Device_Objects_RR_Info(
         BACNET_OBJECT_TYPE object_type);
 
+    BACNET_STACK_EXPORT
     void Device_getCurrentDateTime(
         BACNET_DATE_TIME * DateTime);
 
+    BACNET_STACK_EXPORT
     int32_t Device_UTC_Offset(void);
+    BACNET_STACK_EXPORT
     void Device_UTC_Offset_Set(int16_t offset);
 
+    BACNET_STACK_EXPORT
     bool Device_Daylight_Savings_Status(void);
     bool Device_Align_Intervals(void);
+    BACNET_STACK_EXPORT
     bool Device_Align_Intervals_Set(bool flag);
+    BACNET_STACK_EXPORT
     uint32_t Device_Time_Sync_Interval(void);
+    BACNET_STACK_EXPORT
     bool Device_Time_Sync_Interval_Set(uint32_t value);
+    BACNET_STACK_EXPORT
     uint32_t Device_Interval_Offset(void);
+    BACNET_STACK_EXPORT
     bool Device_Interval_Offset_Set(uint32_t value);
 
+    BACNET_STACK_EXPORT
     void Device_Property_Lists(
         const int **pRequired,
         const int **pOptional,
         const int **pProprietary);
+    BACNET_STACK_EXPORT
     void Device_Objects_Property_List(
         BACNET_OBJECT_TYPE object_type,
         uint32_t object_instance,
         struct special_property_list_t *pPropertyList);
     /* functions to support COV */
+    BACNET_STACK_EXPORT
     bool Device_Encode_Value_List(
         BACNET_OBJECT_TYPE object_type,
         uint32_t object_instance,
         BACNET_PROPERTY_VALUE * value_list);
     bool Device_Value_List_Supported(
         BACNET_OBJECT_TYPE object_type);
+    BACNET_STACK_EXPORT
     bool Device_COV(
         BACNET_OBJECT_TYPE object_type,
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     void Device_COV_Clear(
         BACNET_OBJECT_TYPE object_type,
         uint32_t object_instance);
 
+    BACNET_STACK_EXPORT
     uint32_t Device_Object_Instance_Number(
         void);
+    BACNET_STACK_EXPORT
     bool Device_Set_Object_Instance_Number(
         uint32_t object_id);
+    BACNET_STACK_EXPORT
     bool Device_Valid_Object_Instance_Number(
         uint32_t object_id);
+    BACNET_STACK_EXPORT
     unsigned Device_Object_List_Count(
         void);
+    BACNET_STACK_EXPORT
     bool Device_Object_List_Identifier(
         uint32_t array_index,
         BACNET_OBJECT_TYPE *object_type,
         uint32_t * instance);
 
+    BACNET_STACK_EXPORT
     unsigned Device_Count(
         void);
+    BACNET_STACK_EXPORT
     uint32_t Device_Index_To_Instance(
         unsigned index);
 
+    BACNET_STACK_EXPORT
     bool Device_Object_Name(
         uint32_t object_instance,
         BACNET_CHARACTER_STRING * object_name);
+    BACNET_STACK_EXPORT
     bool Device_Set_Object_Name(
         BACNET_CHARACTER_STRING * object_name);
     /* Copy a child object name, given its ID. */
+    BACNET_STACK_EXPORT
     bool Device_Object_Name_Copy(
         BACNET_OBJECT_TYPE object_type,
         uint32_t object_instance,
         BACNET_CHARACTER_STRING * object_name);
+    BACNET_STACK_EXPORT
     bool Device_Object_Name_ANSI_Init(const char * object_name);
+    BACNET_STACK_EXPORT
     char * Device_Object_Name_ANSI(void);
 
+    BACNET_STACK_EXPORT
     BACNET_DEVICE_STATUS Device_System_Status(
         void);
+    BACNET_STACK_EXPORT
     int Device_Set_System_Status(
         BACNET_DEVICE_STATUS status,
         bool local);
 
+    BACNET_STACK_EXPORT
     const char *Device_Vendor_Name(
         void);
 
+    BACNET_STACK_EXPORT
     uint16_t Device_Vendor_Identifier(
         void);
+    BACNET_STACK_EXPORT
     void Device_Set_Vendor_Identifier(
         uint16_t vendor_id);
 
+    BACNET_STACK_EXPORT
     const char *Device_Model_Name(
         void);
+    BACNET_STACK_EXPORT
     bool Device_Set_Model_Name(
         const char *name,
         size_t length);
 
+    BACNET_STACK_EXPORT
     const char *Device_Firmware_Revision(
         void);
 
+    BACNET_STACK_EXPORT
     const char *Device_Application_Software_Version(
         void);
+    BACNET_STACK_EXPORT
     bool Device_Set_Application_Software_Version(
         const char *name,
         size_t length);
 
+    BACNET_STACK_EXPORT
     const char *Device_Description(
         void);
+    BACNET_STACK_EXPORT
     bool Device_Set_Description(
         const char *name,
         size_t length);
 
+    BACNET_STACK_EXPORT
     const char *Device_Location(
         void);
+    BACNET_STACK_EXPORT
     bool Device_Set_Location(
         const char *name,
         size_t length);
 
     /* some stack-centric constant values - no set methods */
+    BACNET_STACK_EXPORT
     uint8_t Device_Protocol_Version(
         void);
+    BACNET_STACK_EXPORT
     uint8_t Device_Protocol_Revision(
         void);
+    BACNET_STACK_EXPORT
     BACNET_SEGMENTATION Device_Segmentation_Supported(
         void);
 
+    BACNET_STACK_EXPORT
     uint32_t Device_Database_Revision(
         void);
+    BACNET_STACK_EXPORT
     void Device_Set_Database_Revision(
         uint32_t revision);
+    BACNET_STACK_EXPORT
     void Device_Inc_Database_Revision(
         void);
 
+    BACNET_STACK_EXPORT
     bool Device_Valid_Object_Name(
         BACNET_CHARACTER_STRING * object_name,
         BACNET_OBJECT_TYPE *object_type,
         uint32_t * object_instance);
+    BACNET_STACK_EXPORT
     bool Device_Valid_Object_Id(
         BACNET_OBJECT_TYPE object_type,
         uint32_t object_instance);
 
+    BACNET_STACK_EXPORT
     int Device_Read_Property(
         BACNET_READ_PROPERTY_DATA * rpdata);
+    BACNET_STACK_EXPORT
     bool Device_Write_Property(
         BACNET_WRITE_PROPERTY_DATA * wp_data);
 
+    BACNET_STACK_EXPORT
     bool DeviceGetRRInfo(
         BACNET_READ_RANGE_DATA * pRequest,      /* Info on the request */
         RR_PROP_INFO * pInfo);  /* Where to put the information */
 
+    BACNET_STACK_EXPORT
     int Device_Read_Property_Local(
         BACNET_READ_PROPERTY_DATA * rpdata);
+    BACNET_STACK_EXPORT
     bool Device_Write_Property_Local(
         BACNET_WRITE_PROPERTY_DATA * wp_data);
 
 #if defined(INTRINSIC_REPORTING)
+    BACNET_STACK_EXPORT
     void Device_local_reporting(
         void);
 #endif
@@ -387,53 +447,70 @@ extern "C" {
  * Enable by defining BAC_ROUTING in config.h and including gw_device.c
  * in the build (lib/Makefile).
  */
+    BACNET_STACK_EXPORT
     void Routing_Device_Init(
         uint32_t first_object_instance);
 
+    BACNET_STACK_EXPORT
     uint16_t Add_Routed_Device(
         uint32_t Object_Instance,
         BACNET_CHARACTER_STRING * Object_Name,
         const char *Description);
+    BACNET_STACK_EXPORT
     DEVICE_OBJECT_DATA *Get_Routed_Device_Object(
         int idx);
+    BACNET_STACK_EXPORT
     BACNET_ADDRESS *Get_Routed_Device_Address(
         int idx);
 
+    BACNET_STACK_EXPORT
     void routed_get_my_address(
         BACNET_ADDRESS * my_address);
 
+    BACNET_STACK_EXPORT
     bool Routed_Device_Address_Lookup(
         int idx,
         uint8_t address_len,
         uint8_t * mac_adress);
+    BACNET_STACK_EXPORT
     bool Routed_Device_GetNext(
         BACNET_ADDRESS * dest,
         int *DNET_list,
         int *cursor);
+    BACNET_STACK_EXPORT
     bool Routed_Device_Is_Valid_Network(
         uint16_t dest_net,
         int *DNET_list);
 
+    BACNET_STACK_EXPORT
     uint32_t Routed_Device_Index_To_Instance(
         unsigned index);
+    BACNET_STACK_EXPORT
     bool Routed_Device_Valid_Object_Instance_Number(
         uint32_t object_id);
+    BACNET_STACK_EXPORT
     bool Routed_Device_Name(
         uint32_t object_instance,
         BACNET_CHARACTER_STRING * object_name);
+    BACNET_STACK_EXPORT
     uint32_t Routed_Device_Object_Instance_Number(
         void);
+    BACNET_STACK_EXPORT
     bool Routed_Device_Set_Object_Instance_Number(
         uint32_t object_id);
+    BACNET_STACK_EXPORT
     bool Routed_Device_Set_Object_Name(
         uint8_t encoding,
         const char *value,
         size_t length);
+    BACNET_STACK_EXPORT
     bool Routed_Device_Set_Description(
         const char *name,
         size_t length);
+    BACNET_STACK_EXPORT
     void Routed_Device_Inc_Database_Revision(
         void);
+    BACNET_STACK_EXPORT
     int Routed_Device_Service_Approval(
         BACNET_CONFIRMED_SERVICE service,
         int service_argument,

src/bacnet/basic/object/iv.h

@@ -35,6 +35,7 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacerror.h"
 #include "bacnet/wp.h"
@@ -44,72 +45,95 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void Integer_Value_Property_Lists(
         const int **pRequired,
         const int **pOptional,
         const int **pProprietary);
+    BACNET_STACK_EXPORT
     bool Integer_Value_Valid_Instance(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     unsigned Integer_Value_Count(
         void);
+    BACNET_STACK_EXPORT
     uint32_t Integer_Value_Index_To_Instance(
         unsigned index);
+    BACNET_STACK_EXPORT
     unsigned Integer_Value_Instance_To_Index(
         uint32_t object_instance);
 
+    BACNET_STACK_EXPORT
     bool Integer_Value_Object_Name(
         uint32_t object_instance,
         BACNET_CHARACTER_STRING * object_name);
 
+    BACNET_STACK_EXPORT
     int Integer_Value_Read_Property(
         BACNET_READ_PROPERTY_DATA * rpdata);
 
+    BACNET_STACK_EXPORT
     bool Integer_Value_Write_Property(
         BACNET_WRITE_PROPERTY_DATA * wp_data);
 
+    BACNET_STACK_EXPORT
     bool Integer_Value_Present_Value_Set(
         uint32_t object_instance,
         int32_t value,
         uint8_t priority);
+    BACNET_STACK_EXPORT
     int32_t Integer_Value_Present_Value(
         uint32_t object_instance);
 
+    BACNET_STACK_EXPORT
     bool Integer_Value_Change_Of_Value(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     void Integer_Value_Change_Of_Value_Clear(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Integer_Value_Encode_Value_List(
         uint32_t object_instance,
         BACNET_PROPERTY_VALUE * value_list);
+    BACNET_STACK_EXPORT
     float Integer_Value_COV_Increment(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     void Integer_Value_COV_Increment_Set(
         uint32_t instance,
         float value);
 
+    BACNET_STACK_EXPORT
     char *Integer_Value_Description(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Integer_Value_Description_Set(
         uint32_t instance,
         char *new_name);
 
+    BACNET_STACK_EXPORT
     uint16_t Integer_Value_Units(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Integer_Value_Units_Set(
         uint32_t instance,
         uint16_t unit);
 
+    BACNET_STACK_EXPORT
     bool Integer_Value_Out_Of_Service(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     void Integer_Value_Out_Of_Service_Set(
         uint32_t instance,
         bool oos_flag);
 
+    BACNET_STACK_EXPORT
     void Integer_Value_Init(
         void);
 
 #ifdef TEST
 #include "ctest.h"
+    BACNET_STACK_EXPORT
     void testInteger_Value(
         Test * pTest);
 #endif

src/bacnet/basic/object/lc.h

@@ -27,6 +27,7 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacerror.h"
 #include "bacnet/rp.h"
@@ -36,39 +37,51 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void Load_Control_Property_Lists(
         const int **pRequired,
         const int **pOptional,
         const int **pProprietary);
+    BACNET_STACK_EXPORT
     void Load_Control_State_Machine_Handler(
         void);
 
+    BACNET_STACK_EXPORT
     bool Load_Control_Valid_Instance(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     unsigned Load_Control_Count(
         void);
+    BACNET_STACK_EXPORT
     uint32_t Load_Control_Index_To_Instance(
         unsigned index);
+    BACNET_STACK_EXPORT
     unsigned Load_Control_Instance_To_Index(
         uint32_t object_instance);
 
+    BACNET_STACK_EXPORT
     bool Load_Control_Object_Name(
         uint32_t object_instance,
         BACNET_CHARACTER_STRING * object_name);
 
+    BACNET_STACK_EXPORT
     void Load_Control_Init(
         void);
+    BACNET_STACK_EXPORT
     void Load_Control_State_Machine(
         int object_index);
 
+    BACNET_STACK_EXPORT
     int Load_Control_Read_Property(
         BACNET_READ_PROPERTY_DATA * rpdata);
 
+    BACNET_STACK_EXPORT
     bool Load_Control_Write_Property(
         BACNET_WRITE_PROPERTY_DATA * wp_data);
 
 #ifdef TEST
 #include "ctest.h"
+    BACNET_STACK_EXPORT
     void testLoadControl(
         Test * pTest);
 #endif

src/bacnet/basic/object/lo.h

@@ -27,6 +27,7 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacerror.h"
 #include "bacnet/rp.h"
@@ -36,141 +37,188 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void Lighting_Output_Property_Lists(
         const int **pRequired,
         const int **pOptional,
         const int **pProprietary);
+    BACNET_STACK_EXPORT
     bool Lighting_Output_Valid_Instance(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     unsigned Lighting_Output_Count(
         void);
+    BACNET_STACK_EXPORT
     uint32_t Lighting_Output_Index_To_Instance(
         unsigned index);
+    BACNET_STACK_EXPORT
     unsigned Lighting_Output_Instance_To_Index(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Lighting_Output_Object_Instance_Add(
         uint32_t instance);
 
+    BACNET_STACK_EXPORT
     float Lighting_Output_Present_Value(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     unsigned Lighting_Output_Present_Value_Priority(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Lighting_Output_Present_Value_Set(
         uint32_t object_instance,
         float value,
         unsigned priority);
+    BACNET_STACK_EXPORT
     bool Lighting_Output_Present_Value_Relinquish(
         uint32_t object_instance,
         unsigned priority);
 
+    BACNET_STACK_EXPORT
     float Lighting_Output_Relinquish_Default(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Lighting_Output_Relinquish_Default_Set(
         uint32_t object_instance,
         float value);
 
+    BACNET_STACK_EXPORT
     bool Lighting_Output_Change_Of_Value(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     void Lighting_Output_Change_Of_Value_Clear(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Lighting_Output_Encode_Value_List(
         uint32_t object_instance,
         BACNET_PROPERTY_VALUE * value_list);
+    BACNET_STACK_EXPORT
     float Lighting_Output_COV_Increment(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     void Lighting_Output_COV_Increment_Set(
         uint32_t instance,
         float value);
 
+    BACNET_STACK_EXPORT
     bool Lighting_Output_Object_Name(
         uint32_t object_instance,
         BACNET_CHARACTER_STRING * object_name);
+    BACNET_STACK_EXPORT
     bool Lighting_Output_Name_Set(
         uint32_t object_instance,
         char *new_name);
 
+    BACNET_STACK_EXPORT
     char *Lighting_Output_Description(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Lighting_Output_Description_Set(
         uint32_t instance,
         char *new_name);
 
+    BACNET_STACK_EXPORT
     bool Lighting_Output_Out_Of_Service(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     void Lighting_Output_Out_Of_Service_Set(
         uint32_t instance,
         bool oos_flag);
 
+    BACNET_STACK_EXPORT
     bool Lighting_Output_Lighting_Command_Set(
         uint32_t object_instance,
         BACNET_LIGHTING_COMMAND *value);
+    BACNET_STACK_EXPORT
     bool Lighting_Output_Lighting_Command(
         uint32_t object_instance,
         BACNET_LIGHTING_COMMAND *value);
 
+    BACNET_STACK_EXPORT
     BACNET_LIGHTING_IN_PROGRESS Lighting_Output_In_Progress(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Lighting_Output_In_Progress_Set(
         uint32_t object_instance,
         BACNET_LIGHTING_IN_PROGRESS in_progress);
 
+    BACNET_STACK_EXPORT
     float Lighting_Output_Tracking_Value(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Lighting_Output_Tracking_Value_Set(
         uint32_t object_instance,
         float value);
 
+    BACNET_STACK_EXPORT
     bool Lighting_Output_Blink_Warn_Enable(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Lighting_Output_Blink_Warn_Enable_Set(
         uint32_t object_instance,
         bool enable);
 
+    BACNET_STACK_EXPORT
     uint32_t Lighting_Output_Egress_Time(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Lighting_Output_Egress_Time_Set(
         uint32_t object_instance,
         uint32_t seconds);
+    BACNET_STACK_EXPORT
     bool Lighting_Output_Egress_Active(
         uint32_t object_instance);
 
+    BACNET_STACK_EXPORT
     uint32_t Lighting_Output_Default_Fade_Time(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Lighting_Output_Default_Fade_Time_Set(
         uint32_t object_instance,
         uint32_t milliseconds);
 
+    BACNET_STACK_EXPORT
     float Lighting_Output_Default_Ramp_Rate(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Lighting_Output_Default_Ramp_Rate_Set(
         uint32_t object_instance,
         float percent_per_second);
 
+    BACNET_STACK_EXPORT
     float Lighting_Output_Default_Step_Increment(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Lighting_Output_Default_Step_Increment_Set(
         uint32_t object_instance,
         float step_increment);
 
+    BACNET_STACK_EXPORT
     unsigned Lighting_Output_Default_Priority(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Lighting_Output_Default_Priority_Set(
         uint32_t object_instance,
         unsigned priority);
 
+    BACNET_STACK_EXPORT
     void Lighting_Output_Timer(
         uint16_t milliseconds);
 
+    BACNET_STACK_EXPORT
     void Lighting_Output_Init(
         void);
 
+    BACNET_STACK_EXPORT
     int Lighting_Output_Read_Property(
         BACNET_READ_PROPERTY_DATA * rpdata);
+    BACNET_STACK_EXPORT
     bool Lighting_Output_Write_Property(
         BACNET_WRITE_PROPERTY_DATA * wp_data);
 
 #ifdef TEST
 #include "ctest.h"
+    BACNET_STACK_EXPORT
     void testLightingOutput(
         Test * pTest);
 #endif

src/bacnet/basic/object/lsp.h

@@ -27,6 +27,7 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacerror.h"
 #include "bacnet/rp.h"
@@ -36,32 +37,42 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void Life_Safety_Point_Property_Lists(
         const int **pRequired,
         const int **pOptional,
         const int **pProprietary);
+    BACNET_STACK_EXPORT
     bool Life_Safety_Point_Valid_Instance(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     unsigned Life_Safety_Point_Count(
         void);
+    BACNET_STACK_EXPORT
     uint32_t Life_Safety_Point_Index_To_Instance(
         unsigned index);
+    BACNET_STACK_EXPORT
     unsigned Life_Safety_Point_Instance_To_Index(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Life_Safety_Point_Object_Name(
         uint32_t object_instance,
         BACNET_CHARACTER_STRING * object_name);
+    BACNET_STACK_EXPORT
     void Life_Safety_Point_Init(
         void);
 
+    BACNET_STACK_EXPORT
     int Life_Safety_Point_Read_Property(
         BACNET_READ_PROPERTY_DATA * rpdata);
 
+    BACNET_STACK_EXPORT
     bool Life_Safety_Point_Write_Property(
         BACNET_WRITE_PROPERTY_DATA * wp_data);
 
 #ifdef TEST
 #include "ctest.h"
+    BACNET_STACK_EXPORT
     void testLifeSafetyPoint(
         Test * pTest);
 #endif

src/bacnet/basic/object/ms-input.h

@@ -27,6 +27,7 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacerror.h"
 #include "bacnet/rp.h"
@@ -36,93 +37,122 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void Multistate_Input_Property_Lists(
         const int **pRequired,
         const int **pOptional,
         const int **pProprietary);
 
+    BACNET_STACK_EXPORT
     bool Multistate_Input_Valid_Instance(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     unsigned Multistate_Input_Count(
         void);
+    BACNET_STACK_EXPORT
     uint32_t Multistate_Input_Index_To_Instance(
         unsigned index);
+    BACNET_STACK_EXPORT
     unsigned Multistate_Input_Instance_To_Index(
         uint32_t instance);
 
+    BACNET_STACK_EXPORT
     int Multistate_Input_Read_Property(
         BACNET_READ_PROPERTY_DATA * rpdata);
 
+    BACNET_STACK_EXPORT
     bool Multistate_Input_Write_Property(
         BACNET_WRITE_PROPERTY_DATA * wp_data);
 
     /* optional API */
+    BACNET_STACK_EXPORT
     bool Multistate_Input_Object_Instance_Add(
         uint32_t instance);
 
+    BACNET_STACK_EXPORT
     bool Multistate_Input_Object_Name(
         uint32_t object_instance,
         BACNET_CHARACTER_STRING * object_name);
+    BACNET_STACK_EXPORT
     bool Multistate_Input_Name_Set(
         uint32_t object_instance,
         char *new_name);
 
+    BACNET_STACK_EXPORT
     uint32_t Multistate_Input_Present_Value(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Multistate_Input_Present_Value_Set(
         uint32_t object_instance,
         uint32_t value);
 
+    BACNET_STACK_EXPORT
     bool Multistate_Input_Change_Of_Value(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     void Multistate_Input_Change_Of_Value_Clear(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Multistate_Input_Encode_Value_List(
         uint32_t object_instance,
         BACNET_PROPERTY_VALUE * value_list);
 
+    BACNET_STACK_EXPORT
     bool Multistate_Input_Out_Of_Service(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     void Multistate_Input_Out_Of_Service_Set(
         uint32_t object_instance,
         bool value);
 
+    BACNET_STACK_EXPORT
     char *Multistate_Input_Description(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Multistate_Input_Description_Set(
         uint32_t object_instance,
         char *text_string);
 
+    BACNET_STACK_EXPORT
     BACNET_RELIABILITY Multistate_Input_Reliability(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Multistate_Input_Reliability_Set(
         uint32_t object_instance,
         BACNET_RELIABILITY value);
 
+    BACNET_STACK_EXPORT
     bool Multistate_Input_State_Text_Set(
         uint32_t object_instance,
         uint32_t state_index,
         char *new_name);
+    BACNET_STACK_EXPORT
     bool Multistate_Input_Max_States_Set(
         uint32_t instance,
         uint32_t max_states_requested);
+    BACNET_STACK_EXPORT
     char *Multistate_Input_State_Text(
         uint32_t object_instance,
         uint32_t state_index);
 
+    BACNET_STACK_EXPORT
     bool Multistate_Input_Create(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Multistate_Input_Delete(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     void Multistate_Input_Cleanup(
         void);
 
+    BACNET_STACK_EXPORT
     void Multistate_Input_Init(
         void);
 
 
 #ifdef TEST
 #include "ctest.h"
+    BACNET_STACK_EXPORT
     void testMultistateInput(
         Test * pTest);
 #endif

src/bacnet/basic/object/mso.h

@@ -27,6 +27,7 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacerror.h"
 #include "bacnet/rp.h"
@@ -36,69 +37,91 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void Multistate_Output_Property_Lists(
         const int **pRequired,
         const int **pOptional,
         const int **pProprietary);
+    BACNET_STACK_EXPORT
     bool Multistate_Output_Valid_Instance(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     unsigned Multistate_Output_Count(
         void);
+    BACNET_STACK_EXPORT
     uint32_t Multistate_Output_Index_To_Instance(
         unsigned index);
+    BACNET_STACK_EXPORT
     unsigned Multistate_Output_Instance_To_Index(
         uint32_t object_instance);
 
+    BACNET_STACK_EXPORT
     bool Multistate_Output_Object_Name(
         uint32_t object_instance,
         BACNET_CHARACTER_STRING * object_name);
 
+    BACNET_STACK_EXPORT
     void Multistate_Output_Init(
         void);
 
+    BACNET_STACK_EXPORT
     int Multistate_Output_Read_Property(
         BACNET_READ_PROPERTY_DATA * rpdata);
 
+    BACNET_STACK_EXPORT
     bool Multistate_Output_Write_Property(
         BACNET_WRITE_PROPERTY_DATA * wp_data);
 
+    BACNET_STACK_EXPORT
     bool Multistate_Output_Change_Of_Value(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     void Multistate_Output_Change_Of_Value_Clear(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Multistate_Output_Encode_Value_List(
         uint32_t object_instance,
         BACNET_PROPERTY_VALUE * value_list);
 
+    BACNET_STACK_EXPORT
     uint32_t Multistate_Output_Present_Value(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Multistate_Output_Present_Value_Set(
         uint32_t instance,
         unsigned value,
         unsigned priority);
+    BACNET_STACK_EXPORT
     bool Multistate_Output_Present_Value_Relinquish(
         uint32_t instance,
         unsigned priority);
 
+    BACNET_STACK_EXPORT
     bool Multistate_Output_Out_Of_Service(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     void Multistate_Output_Out_Of_Service_Set(
         uint32_t instance,
         bool value);
 
+    BACNET_STACK_EXPORT
     char *Multistate_Output_Description(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Multistate_Output_Description_Set(
         uint32_t object_instance,
         char *text_string);
 
+    BACNET_STACK_EXPORT
     bool Multistate_Output_State_Text_Set(
         uint32_t object_instance,
         uint32_t state_index,
         char *new_name);
+    BACNET_STACK_EXPORT
     bool Multistate_Output_Max_States_Set(
         uint32_t instance,
         uint32_t max_states_requested);
+    BACNET_STACK_EXPORT
     char *Multistate_Output_State_Text(
         uint32_t object_instance,
         uint32_t state_index);
@@ -106,6 +129,7 @@ extern "C" {
 
 #ifdef TEST
 #include "ctest.h"
+    BACNET_STACK_EXPORT
     void testMultistateOutput(
         Test * pTest);
 #endif

src/bacnet/basic/object/msv.h

@@ -27,6 +27,7 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacerror.h"
 #include "bacnet/rp.h"
@@ -36,23 +37,30 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void Multistate_Value_Property_Lists(
         const int **pRequired,
         const int **pOptional,
         const int **pProprietary);
 
+    BACNET_STACK_EXPORT
     bool Multistate_Value_Valid_Instance(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     unsigned Multistate_Value_Count(
         void);
+    BACNET_STACK_EXPORT
     uint32_t Multistate_Value_Index_To_Instance(
         unsigned index);
+    BACNET_STACK_EXPORT
     unsigned Multistate_Value_Instance_To_Index(
         uint32_t instance);
 
+    BACNET_STACK_EXPORT
     int Multistate_Value_Read_Property(
         BACNET_READ_PROPERTY_DATA * rpdata);
 
+    BACNET_STACK_EXPORT
     bool Multistate_Value_Write_Property(
         BACNET_WRITE_PROPERTY_DATA * wp_data);
 
@@ -60,56 +68,72 @@ extern "C" {
     bool Multistate_Value_Object_Instance_Add(
         uint32_t instance);
 
+    BACNET_STACK_EXPORT
     bool Multistate_Value_Object_Name(
         uint32_t object_instance,
         BACNET_CHARACTER_STRING * object_name);
+    BACNET_STACK_EXPORT
     bool Multistate_Value_Name_Set(
         uint32_t object_instance,
         char *new_name);
 
+    BACNET_STACK_EXPORT
     uint32_t Multistate_Value_Present_Value(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Multistate_Value_Present_Value_Set(
         uint32_t object_instance,
         uint32_t value);
 
+    BACNET_STACK_EXPORT
     bool Multistate_Value_Change_Of_Value(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     void Multistate_Value_Change_Of_Value_Clear(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Multistate_Value_Encode_Value_List(
         uint32_t object_instance,
         BACNET_PROPERTY_VALUE * value_list);
 
+    BACNET_STACK_EXPORT
     bool Multistate_Value_Out_Of_Service(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     void Multistate_Value_Out_Of_Service_Set(
         uint32_t object_instance,
         bool value);
 
+    BACNET_STACK_EXPORT
     char *Multistate_Value_Description(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Multistate_Value_Description_Set(
         uint32_t object_instance,
         char *text_string);
 
+    BACNET_STACK_EXPORT
     bool Multistate_Value_State_Text_Set(
         uint32_t object_instance,
         uint32_t state_index,
         char *new_name);
+    BACNET_STACK_EXPORT
     bool Multistate_Value_Max_States_Set(
         uint32_t instance,
         uint32_t max_states_requested);
+    BACNET_STACK_EXPORT
     char *Multistate_Value_State_Text(
         uint32_t object_instance,
         uint32_t state_index);
 
+    BACNET_STACK_EXPORT
     void Multistate_Value_Init(
         void);
 
 
 #ifdef TEST
 #include "ctest.h"
+    BACNET_STACK_EXPORT
     void testMultistateValue(
         Test * pTest);
 #endif

src/bacnet/basic/object/nc.h

@@ -25,6 +25,7 @@
 #ifndef NC_H
 #define NC_H
 
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/event.h"
 
 
@@ -97,39 +98,50 @@ BACnetRecipient ::= CHOICE {
 
 
 
+    BACNET_STACK_EXPORT
     void Notification_Class_Property_Lists(
         const int **pRequired,
         const int **pOptional,
         const int **pProprietary);
 
+    BACNET_STACK_EXPORT
     void Notification_Class_Init(
         void);
 
     bool Notification_Class_Valid_Instance(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     unsigned Notification_Class_Count(
         void);
+    BACNET_STACK_EXPORT
     uint32_t Notification_Class_Index_To_Instance(
         unsigned index);
+    BACNET_STACK_EXPORT
     unsigned Notification_Class_Instance_To_Index(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Notification_Class_Object_Name(
         uint32_t object_instance,
         BACNET_CHARACTER_STRING * object_name);
 
+    BACNET_STACK_EXPORT
     int Notification_Class_Read_Property(
         BACNET_READ_PROPERTY_DATA * rpdata);
 
+    BACNET_STACK_EXPORT
     bool Notification_Class_Write_Property(
         BACNET_WRITE_PROPERTY_DATA * wp_data);
 
+    BACNET_STACK_EXPORT
     void Notification_Class_Get_Priorities(
         uint32_t Object_Instance,
         uint32_t * pPriorityArray);
 
+    BACNET_STACK_EXPORT
     void Notification_Class_common_reporting_function(
         BACNET_EVENT_NOTIFICATION_DATA * event_data);
 
+    BACNET_STACK_EXPORT
     void Notification_Class_find_recipient(
         void);
 #endif /* defined(INTRINSIC_REPORTING) */

src/bacnet/basic/object/netport.h

@@ -36,6 +36,7 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacenum.h"
 #include "bacnet/apdu.h"
@@ -46,263 +47,343 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void Network_Port_Property_Lists(
         const int **pRequired,
         const int **pOptional,
         const int **pProprietary);
+    BACNET_STACK_EXPORT
     void Network_Port_Property_List(
         uint32_t object_instance,
         const int **pRequired,
         const int **pOptional,
         const int **pProprietary);
 
+    BACNET_STACK_EXPORT
     bool Network_Port_Object_Name(
         uint32_t object_instance,
         BACNET_CHARACTER_STRING * object_name);
+    BACNET_STACK_EXPORT
     bool Network_Port_Name_Set(
         uint32_t object_instance,
         char *new_name);
 
+    BACNET_STACK_EXPORT
     char *Network_Port_Description(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Network_Port_Description_Set(
         uint32_t instance,
         char *new_name);
 
+    BACNET_STACK_EXPORT
     BACNET_RELIABILITY Network_Port_Reliability(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Network_Port_Reliability_Set(
         uint32_t object_instance,
         BACNET_RELIABILITY value);
 
+    BACNET_STACK_EXPORT
     bool Network_Port_Out_Of_Service(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Network_Port_Out_Of_Service_Set(
         uint32_t instance,
         bool oos_flag);
 
+    BACNET_STACK_EXPORT
     uint8_t Network_Port_Type(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Network_Port_Type_Set(
         uint32_t object_instance,
         uint8_t value);
 
+    BACNET_STACK_EXPORT
     uint16_t Network_Port_Network_Number(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Network_Port_Network_Number_Set(
         uint32_t object_instance,
         uint16_t value);
 
+    BACNET_STACK_EXPORT
     BACNET_PORT_QUALITY Network_Port_Quality(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Network_Port_Quality_Set(
         uint32_t object_instance,
         BACNET_PORT_QUALITY value);
 
+    BACNET_STACK_EXPORT
     bool Network_Port_MAC_Address(
         uint32_t object_instance,
         BACNET_OCTET_STRING *mac_address);
+    BACNET_STACK_EXPORT
     bool Network_Port_MAC_Address_Set(
         uint32_t object_instance,
         uint8_t *mac_src,
         uint8_t mac_len);
 
+    BACNET_STACK_EXPORT
     uint16_t Network_Port_APDU_Length(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Network_Port_APDU_Length_Set(
         uint32_t object_instance,
         uint16_t value);
 
+    BACNET_STACK_EXPORT
     uint8_t Network_Port_MSTP_Max_Master(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Network_Port_MSTP_Max_Master_Set(
         uint32_t object_instance,
         uint8_t value);
 
+    BACNET_STACK_EXPORT
     uint8_t Network_Port_MSTP_Max_Info_Frames(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Network_Port_MSTP_Max_Info_Frames_Set(
         uint32_t object_instance,
         uint8_t value);
 
+    BACNET_STACK_EXPORT
     float Network_Port_Link_Speed(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Network_Port_Link_Speed_Set(
         uint32_t object_instance,
         float value);
 
+    BACNET_STACK_EXPORT
     bool Network_Port_IP_Address(
         uint32_t object_instance,
         BACNET_OCTET_STRING *ip_address);
+    BACNET_STACK_EXPORT
     bool Network_Port_IP_Address_Get(
         uint32_t object_instance,
         uint8_t *a, uint8_t *b, uint8_t *c, uint8_t *d);
+    BACNET_STACK_EXPORT
     bool Network_Port_IP_Address_Set(
         uint32_t object_instance,
         uint8_t a, uint8_t b, uint8_t c, uint8_t d);
 
+    BACNET_STACK_EXPORT
     uint8_t Network_Port_IP_Subnet_Prefix(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Network_Port_IP_Subnet_Prefix_Set(
         uint32_t object_instance,
         uint8_t value);
 
+    BACNET_STACK_EXPORT
     bool Network_Port_IP_Subnet(
         uint32_t object_instance,
         BACNET_OCTET_STRING *subnet_mask);
+    BACNET_STACK_EXPORT
     bool Network_Port_IP_Subnet_Get(
         uint32_t object_instance,
         uint8_t *a, uint8_t *b, uint8_t *c, uint8_t *d);
+    BACNET_STACK_EXPORT
     bool Network_Port_IP_Subnet_Set(
         uint32_t object_instance,
         uint8_t a, uint8_t b, uint8_t c, uint8_t d);
 
+    BACNET_STACK_EXPORT
     bool Network_Port_IP_Gateway(
         uint32_t object_instance,
         BACNET_OCTET_STRING *subnet_mask);
+    BACNET_STACK_EXPORT
     bool Network_Port_IP_Gateway_Get(
         uint32_t object_instance,
         uint8_t *a, uint8_t *b, uint8_t *c, uint8_t *d);
+    BACNET_STACK_EXPORT
     bool Network_Port_IP_Gateway_Set(
         uint32_t object_instance,
         uint8_t a, uint8_t b, uint8_t c, uint8_t d);
 
+    BACNET_STACK_EXPORT
     bool Network_Port_IP_DNS_Server(
         uint32_t object_instance,
         unsigned index,
         BACNET_OCTET_STRING *subnet_mask);
+    BACNET_STACK_EXPORT
     bool Network_Port_IP_DNS_Server_Get(
         uint32_t object_instance,
         unsigned index,
         uint8_t *a, uint8_t *b, uint8_t *c, uint8_t *d);
+    BACNET_STACK_EXPORT
     bool Network_Port_IP_DNS_Server_Set(
         uint32_t object_instance,
         unsigned index,
         uint8_t a, uint8_t b, uint8_t c, uint8_t d);
 
+    BACNET_STACK_EXPORT
     uint16_t Network_Port_BIP_Port(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Network_Port_BIP_Port_Set(
         uint32_t object_instance,
         uint16_t value);
 
+    BACNET_STACK_EXPORT
     BACNET_IP_MODE Network_Port_BIP_Mode(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Network_Port_BIP_Mode_Set(
         uint32_t object_instance,
         BACNET_IP_MODE value);
 
+    BACNET_STACK_EXPORT
     bool Network_Port_BBMD_Accept_FD_Registrations(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Network_Port_BBMD_Accept_FD_Registrations_Set(
         uint32_t object_instance,
         bool value);
 
+    BACNET_STACK_EXPORT
     BACNET_IP_MODE Network_Port_BIP6_Mode(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Network_Port_BIP6_Mode_Set(
         uint32_t object_instance,
         BACNET_IP_MODE value);
 
+    BACNET_STACK_EXPORT
     bool Network_Port_IPv6_Address(
         uint32_t object_instance,
         BACNET_OCTET_STRING *ip_address);
+    BACNET_STACK_EXPORT
     bool Network_Port_IPv6_Address_Set(
         uint32_t object_instance,
         uint8_t *ip_address);
 
+    BACNET_STACK_EXPORT
     bool Network_Port_IPv6_Multicast_Address(
         uint32_t object_instance,
         BACNET_OCTET_STRING *ip_address);
+    BACNET_STACK_EXPORT
     bool Network_Port_IPv6_Multicast_Address_Set(
         uint32_t object_instance,
         uint8_t *ip_address);
 
+    BACNET_STACK_EXPORT
     uint8_t Network_Port_IPv6_Subnet_Prefix(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Network_Port_IPv6_Subnet_Prefix_Set(
         uint32_t object_instance,
         uint8_t value);
 
+    BACNET_STACK_EXPORT
     bool Network_Port_IPv6_Gateway(
         uint32_t object_instance,
         BACNET_OCTET_STRING *ip_address);
+    BACNET_STACK_EXPORT
     bool Network_Port_IPv6_Gateway_Set(
         uint32_t object_instance,
         uint8_t *ip_address);
 
+    BACNET_STACK_EXPORT
     bool Network_Port_IPv6_DNS_Server(
         uint32_t object_instance,
         unsigned dns_index,
         BACNET_OCTET_STRING *ip_address);
+    BACNET_STACK_EXPORT
     bool Network_Port_IPv6_DNS_Server_Set(
         uint32_t object_instance,
         unsigned dns_index,
         uint8_t *ip_address);
 
+    BACNET_STACK_EXPORT
     bool Network_Port_IPv6_DHCP_Server(
         uint32_t object_instance,
         BACNET_OCTET_STRING *ip_address);
+    BACNET_STACK_EXPORT
     bool Network_Port_IPv6_DHCP_Server_Set(
         uint32_t object_instance,
         uint8_t *ip_address);
 
+    BACNET_STACK_EXPORT
     bool Network_Port_IPv6_Zone_Index(
         uint32_t object_instance,
         BACNET_CHARACTER_STRING *zone_index);
+    BACNET_STACK_EXPORT
     bool Network_Port_IPv6_Gateway_Zone_Index_Set(
         uint32_t object_instance,
         char *zone_index);
 
+    BACNET_STACK_EXPORT
     uint16_t Network_Port_BIP6_Port(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Network_Port_BIP6_Port_Set(
         uint32_t object_instance,
         uint16_t value);
 
+    BACNET_STACK_EXPORT
     bool Network_Port_Changes_Pending(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Network_Port_Changes_Pending_Set(
         uint32_t instance,
         bool flag);
 
+    BACNET_STACK_EXPORT
     bool Network_Port_Valid_Instance(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     unsigned Network_Port_Count(
         void);
+    BACNET_STACK_EXPORT
     uint32_t Network_Port_Index_To_Instance(
         unsigned find_index);
+    BACNET_STACK_EXPORT
     unsigned Network_Port_Instance_To_Index(
         uint32_t object_instance);
 
+    BACNET_STACK_EXPORT
     bool Network_Port_Object_Instance_Number_Set(
         unsigned index,
         uint32_t object_instance);
 
+    BACNET_STACK_EXPORT
     int Network_Port_Read_Range_BDT(
         uint8_t * apdu,
         BACNET_READ_RANGE_DATA * pRequest);
+    BACNET_STACK_EXPORT
     int Network_Port_Read_Range_FDT(
         uint8_t * apdu,
         BACNET_READ_RANGE_DATA * pRequest);
+    BACNET_STACK_EXPORT
     bool Network_Port_Read_Range(
         BACNET_READ_RANGE_DATA * pRequest,
         RR_PROP_INFO * pInfo);
 
+    BACNET_STACK_EXPORT
     bool Network_Port_Create(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     bool Network_Port_Delete(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     void Network_Port_Cleanup(
         void);
+    BACNET_STACK_EXPORT
     void Network_Port_Init(
         void);
 
     /* handling for read property service */
+    BACNET_STACK_EXPORT
     int Network_Port_Read_Property(
         BACNET_READ_PROPERTY_DATA * rpdata);
 
     /* handling for write property service */
+    BACNET_STACK_EXPORT
     bool Network_Port_Write_Property(
         BACNET_WRITE_PROPERTY_DATA * wp_data);
 

src/bacnet/basic/object/osv.h

@@ -27,6 +27,7 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacerror.h"
 #include "bacnet/wp.h"
@@ -43,49 +44,69 @@ extern "C" {
     } OCTETSTRING_VALUE_DESCR;
 
 
+    BACNET_STACK_EXPORT
     void OctetString_Value_Property_Lists(const int **pRequired,
         const int **pOptional,
         const int **pProprietary);
+    BACNET_STACK_EXPORT
     bool OctetString_Value_Valid_Instance(uint32_t object_instance);
+    BACNET_STACK_EXPORT
     unsigned OctetString_Value_Count(void);
+    BACNET_STACK_EXPORT
     uint32_t OctetString_Value_Index_To_Instance(unsigned index);
+    BACNET_STACK_EXPORT
     unsigned OctetString_Value_Instance_To_Index(uint32_t object_instance);
 
+    BACNET_STACK_EXPORT
     bool OctetString_Value_Object_Name(uint32_t object_instance,
         BACNET_CHARACTER_STRING * object_name);
 
+    BACNET_STACK_EXPORT
     int OctetString_Value_Read_Property(BACNET_READ_PROPERTY_DATA * rpdata);
 
+    BACNET_STACK_EXPORT
     bool OctetString_Value_Write_Property(BACNET_WRITE_PROPERTY_DATA *
         wp_data);
 
+    BACNET_STACK_EXPORT
     bool OctetString_Value_Present_Value_Set(uint32_t object_instance,
         BACNET_OCTET_STRING * value,
         uint8_t priority);
+    BACNET_STACK_EXPORT
     BACNET_OCTET_STRING *OctetString_Value_Present_Value(uint32_t
         object_instance);
 
+    BACNET_STACK_EXPORT
     bool OctetString_Value_Change_Of_Value(uint32_t instance);
+    BACNET_STACK_EXPORT
     void OctetString_Value_Change_Of_Value_Clear(uint32_t instance);
+    BACNET_STACK_EXPORT
     bool OctetString_Value_Encode_Value_List(uint32_t object_instance,
         BACNET_PROPERTY_VALUE * value_list);
 
+    BACNET_STACK_EXPORT
     char *OctetString_Value_Description(uint32_t instance);
+    BACNET_STACK_EXPORT
     bool OctetString_Value_Description_Set(uint32_t instance,
         char *new_name);
 
+    BACNET_STACK_EXPORT
     bool OctetString_Value_Out_Of_Service(uint32_t instance);
+    BACNET_STACK_EXPORT
     void OctetString_Value_Out_Of_Service_Set(uint32_t instance,
         bool oos_flag);
 
     /* note: header of Intrinsic_Reporting function is required
        even when INTRINSIC_REPORTING is not defined */
+    BACNET_STACK_EXPORT
     void OctetString_Value_Intrinsic_Reporting(uint32_t object_instance);
 
+    BACNET_STACK_EXPORT
     void OctetString_Value_Init(void);
 
 #ifdef TEST
 #include "ctest.h"
+    BACNET_STACK_EXPORT
     void testOctetString_Value(Test * pTest);
 #endif
 

src/bacnet/basic/object/piv.h

@@ -27,6 +27,7 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacerror.h"
 #include "bacnet/wp.h"
@@ -43,49 +44,68 @@ extern "C" {
     } POSITIVEINTEGER_VALUE_DESCR;
 
 
+    BACNET_STACK_EXPORT
     void PositiveInteger_Value_Property_Lists(const int **pRequired,
         const int **pOptional,
         const int **pProprietary);
+    BACNET_STACK_EXPORT
     bool PositiveInteger_Value_Valid_Instance(uint32_t object_instance);
     unsigned PositiveInteger_Value_Count(void);
+    BACNET_STACK_EXPORT
     uint32_t PositiveInteger_Value_Index_To_Instance(unsigned index);
+    BACNET_STACK_EXPORT
     unsigned PositiveInteger_Value_Instance_To_Index(uint32_t object_instance);
 
+    BACNET_STACK_EXPORT
     bool PositiveInteger_Value_Object_Name(uint32_t object_instance,
         BACNET_CHARACTER_STRING * object_name);
 
+    BACNET_STACK_EXPORT
     int PositiveInteger_Value_Read_Property(BACNET_READ_PROPERTY_DATA *
         rpdata);
 
+    BACNET_STACK_EXPORT
     bool PositiveInteger_Value_Write_Property(BACNET_WRITE_PROPERTY_DATA *
         wp_data);
 
+    BACNET_STACK_EXPORT
     bool PositiveInteger_Value_Present_Value_Set(uint32_t object_instance,
         uint32_t value,
         uint8_t priority);
+    BACNET_STACK_EXPORT
     uint32_t PositiveInteger_Value_Present_Value(uint32_t object_instance);
 
+    BACNET_STACK_EXPORT
     bool PositiveInteger_Value_Change_Of_Value(uint32_t instance);
+    BACNET_STACK_EXPORT
     void PositiveInteger_Value_Change_Of_Value_Clear(uint32_t instance);
+    BACNET_STACK_EXPORT
     bool PositiveInteger_Value_Encode_Value_List(uint32_t object_instance,
         BACNET_PROPERTY_VALUE * value_list);
 
+    BACNET_STACK_EXPORT
     char *PositiveInteger_Value_Description(uint32_t instance);
+    BACNET_STACK_EXPORT
     bool PositiveInteger_Value_Description_Set(uint32_t instance,
         char *new_name);
 
+    BACNET_STACK_EXPORT
     bool PositiveInteger_Value_Out_Of_Service(uint32_t instance);
+    BACNET_STACK_EXPORT
     void PositiveInteger_Value_Out_Of_Service_Set(uint32_t instance,
         bool oos_flag);
 
     /* note: header of Intrinsic_Reporting function is required
        even when INTRINSIC_REPORTING is not defined */
+    BACNET_STACK_EXPORT
     void PositiveInteger_Value_Intrinsic_Reporting(uint32_t object_instance);
 
+    BACNET_STACK_EXPORT
     void PositiveInteger_Value_Init(void);
 
 #ifdef TEST
 #include "ctest.h"
+    BACNET_STACK_EXPORT
     void testPositiveInteger_Value(Test * pTest);
 #endif
 

src/bacnet/basic/object/schedule.h

@@ -28,6 +28,7 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacapp.h"
 #include "bacnet/datetime.h"
@@ -71,33 +72,46 @@ extern "C" {
         bool Out_Of_Service;
     } SCHEDULE_DESCR;
 
+    BACNET_STACK_EXPORT
     void Schedule_Property_Lists(const int **pRequired,
         const int **pOptional,
         const int **pProprietary);
 
+    BACNET_STACK_EXPORT
     bool Schedule_Valid_Instance(uint32_t object_instance);
+    BACNET_STACK_EXPORT
     unsigned Schedule_Count(void);
+    BACNET_STACK_EXPORT
     uint32_t Schedule_Index_To_Instance(unsigned index);
+    BACNET_STACK_EXPORT
     unsigned Schedule_Instance_To_Index(uint32_t instance);
+    BACNET_STACK_EXPORT
     void Schedule_Init(void);
 
+    BACNET_STACK_EXPORT
     void Schedule_Out_Of_Service_Set(
         uint32_t object_instance,
         bool value);
+    BACNET_STACK_EXPORT
     bool Schedule_Out_Of_Service(
         uint32_t object_instance);
 
 
+    BACNET_STACK_EXPORT
     bool Schedule_Object_Name(uint32_t object_instance,
         BACNET_CHARACTER_STRING * object_name);
 
+    BACNET_STACK_EXPORT
     int Schedule_Read_Property(BACNET_READ_PROPERTY_DATA * rpdata);
+    BACNET_STACK_EXPORT
     bool Schedule_Write_Property(BACNET_WRITE_PROPERTY_DATA * wp_data);
 
     /* utility functions for calculating current Present Value
      * if Exception Schedule is to be added, these functions must take that into account */
+    BACNET_STACK_EXPORT
     bool Schedule_In_Effective_Period(SCHEDULE_DESCR * desc,
         BACNET_DATE * date);
+    BACNET_STACK_EXPORT
     void Schedule_Recalculate_PV(SCHEDULE_DESCR * desc,
         BACNET_WEEKDAY wday,
         BACNET_TIME * time);

src/bacnet/basic/object/trendlog.h

@@ -28,6 +28,7 @@
 #include <stdbool.h>
 #include <stdint.h>
 #include <time.h>       /* for time_t */
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/cov.h"
 #include "bacnet/rp.h"
@@ -123,74 +124,95 @@ extern "C" {
 #define TL_TYPE_ANY     10      /* We don't support this particular can of worms! */
 
 
+    BACNET_STACK_EXPORT
     void Trend_Log_Property_Lists(
         const int **pRequired,
         const int **pOptional,
         const int **pProprietary);
 
+    BACNET_STACK_EXPORT
     bool Trend_Log_Valid_Instance(
         uint32_t object_instance);
+    BACNET_STACK_EXPORT
     unsigned Trend_Log_Count(
         void);
+    BACNET_STACK_EXPORT
     uint32_t Trend_Log_Index_To_Instance(
         unsigned index);
+    BACNET_STACK_EXPORT
     unsigned Trend_Log_Instance_To_Index(
         uint32_t instance);
+    BACNET_STACK_EXPORT
     bool Trend_Log_Object_Instance_Add(
         uint32_t instance);
 
+    BACNET_STACK_EXPORT
     bool Trend_Log_Object_Name(
         uint32_t object_instance,
         BACNET_CHARACTER_STRING * object_name);
 
+    BACNET_STACK_EXPORT
     int Trend_Log_Read_Property(
         BACNET_READ_PROPERTY_DATA * rpdata);
 
+    BACNET_STACK_EXPORT
     bool Trend_Log_Write_Property(
         BACNET_WRITE_PROPERTY_DATA * wp_data);
+    BACNET_STACK_EXPORT
     void Trend_Log_Init(
         void);
 
+    BACNET_STACK_EXPORT
     void TL_Insert_Status_Rec(
         int iLog,
         BACNET_LOG_STATUS eStatus,
         bool bState);
 
+    BACNET_STACK_EXPORT
     bool TL_Is_Enabled(
         int iLog);
 
+    BACNET_STACK_EXPORT
     time_t TL_BAC_Time_To_Local(
         BACNET_DATE_TIME * SourceTime);
 
+    BACNET_STACK_EXPORT
     void TL_Local_Time_To_BAC(
         BACNET_DATE_TIME * DestTime,
         time_t SourceTime);
 
+    BACNET_STACK_EXPORT
     int TL_encode_entry(
         uint8_t * apdu,
         int iLog,
         int iEntry);
 
+    BACNET_STACK_EXPORT
     int TL_encode_by_position(
         uint8_t * apdu,
         BACNET_READ_RANGE_DATA * pRequest);
 
+    BACNET_STACK_EXPORT
     int TL_encode_by_sequence(
         uint8_t * apdu,
         BACNET_READ_RANGE_DATA * pRequest);
 
+    BACNET_STACK_EXPORT
     int TL_encode_by_time(
         uint8_t * apdu,
         BACNET_READ_RANGE_DATA * pRequest);
 
+    BACNET_STACK_EXPORT
     bool TrendLogGetRRInfo(
         BACNET_READ_RANGE_DATA * pRequest,      /* Info on the request */
         RR_PROP_INFO * pInfo);  /* Where to put the information */
 
+    BACNET_STACK_EXPORT
     int rr_trend_log_encode(
         uint8_t * apdu,
         BACNET_READ_RANGE_DATA * pRequest);
 
+    BACNET_STACK_EXPORT
     void trend_log_timer(
         uint16_t uSeconds);
 

src/bacnet/basic/service/h_alarm_ack.h

@@ -30,6 +30,7 @@
 
 #include <stdint.h>
 #include <stdbool.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacenum.h"
 #include "bacnet/apdu.h"
@@ -39,12 +40,14 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void handler_alarm_ack(
         uint8_t * service_request,
         uint16_t service_len,
         BACNET_ADDRESS * src,
         BACNET_CONFIRMED_SERVICE_DATA * service_data);
 
+    BACNET_STACK_EXPORT
     void handler_alarm_ack_set(
         BACNET_OBJECT_TYPE object_type,
         alarm_ack_function pFunction);

src/bacnet/basic/service/h_apdu.h

@@ -30,6 +30,7 @@
 
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacenum.h"
 #include "bacnet/apdu.h"
@@ -110,49 +111,60 @@ extern "C" {
         uint8_t invoke_id,
         uint8_t reject_reason);
 
+    BACNET_STACK_EXPORT
     void apdu_set_confirmed_ack_handler(
         BACNET_CONFIRMED_SERVICE service_choice,
         confirmed_ack_function pFunction);
 
+    BACNET_STACK_EXPORT
     void apdu_set_confirmed_simple_ack_handler(
         BACNET_CONFIRMED_SERVICE service_choice,
         confirmed_simple_ack_function pFunction);
 
 /* configure reject for confirmed services that are not supported */
+    BACNET_STACK_EXPORT
     void apdu_set_unrecognized_service_handler_handler(
         confirmed_function pFunction);
 
+    BACNET_STACK_EXPORT
     void apdu_set_confirmed_handler(
         BACNET_CONFIRMED_SERVICE service_choice,
         confirmed_function pFunction);
 
+    BACNET_STACK_EXPORT
     void apdu_set_unconfirmed_handler(
         BACNET_UNCONFIRMED_SERVICE service_choice,
         unconfirmed_function pFunction);
 
 /* returns true if the service is supported by a handler */
+    BACNET_STACK_EXPORT
     bool apdu_service_supported(
         BACNET_SERVICES_SUPPORTED service_supported);
 
 /* Function to translate a SERVICE_SUPPORTED_ enum to its SERVICE_CONFIRMED_
  *  or SERVICE_UNCONFIRMED_ index.
  */
+    BACNET_STACK_EXPORT
     bool apdu_service_supported_to_index(
         BACNET_SERVICES_SUPPORTED service_supported,
         size_t * index,
         bool * bIsConfirmed);
 
 
+    BACNET_STACK_EXPORT
     void apdu_set_error_handler(
         BACNET_CONFIRMED_SERVICE service_choice,
         error_function pFunction);
 
+    BACNET_STACK_EXPORT
     void apdu_set_abort_handler(
         abort_function pFunction);
 
+    BACNET_STACK_EXPORT
     void apdu_set_reject_handler(
         reject_function pFunction);
 
+    BACNET_STACK_EXPORT
     uint16_t apdu_decode_confirmed_service_request(
         uint8_t * apdu, /* APDU data */
         uint16_t apdu_len,
@@ -161,15 +173,20 @@ extern "C" {
         uint8_t ** service_request,
         uint16_t * service_request_len);
 
+    BACNET_STACK_EXPORT
     uint16_t apdu_timeout(
         void);
+    BACNET_STACK_EXPORT
     void apdu_timeout_set(
         uint16_t value);
+    BACNET_STACK_EXPORT
     uint8_t apdu_retries(
         void);
+    BACNET_STACK_EXPORT
     void apdu_retries_set(
         uint8_t value);
 
+    BACNET_STACK_EXPORT
     void apdu_handler(
         BACNET_ADDRESS * src,   /* source address */
         uint8_t * apdu, /* APDU data */

src/bacnet/basic/service/h_arf.h

@@ -32,6 +32,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacenum.h"
 #include "bacnet/apdu.h"
@@ -40,6 +41,7 @@
 extern "C" {
 #endif /* __cplusplus */
 
+BACNET_STACK_EXPORT
 void handler_atomic_read_file(uint8_t* service_request, uint16_t service_len,
                               BACNET_ADDRESS* src,
                               BACNET_CONFIRMED_SERVICE_DATA* service_data);

src/bacnet/basic/service/h_arf_a.h

@@ -32,6 +32,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacenum.h"
 #include "bacnet/apdu.h"
@@ -40,6 +41,7 @@
 extern "C" {
 #endif /* __cplusplus */
 
+BACNET_STACK_EXPORT
 void handler_atomic_read_file_ack(
     uint8_t* service_request, uint16_t service_len, BACNET_ADDRESS* src,
     BACNET_CONFIRMED_SERVICE_ACK_DATA* service_data);

src/bacnet/basic/service/h_awf.h

@@ -32,6 +32,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacenum.h"
 #include "bacnet/apdu.h"
@@ -40,6 +41,7 @@
 extern "C" {
 #endif /* __cplusplus */
 
+BACNET_STACK_EXPORT
 void handler_atomic_write_file(uint8_t* service_request, uint16_t service_len,
                                BACNET_ADDRESS* src,
                                BACNET_CONFIRMED_SERVICE_DATA* service_data);

src/bacnet/basic/service/h_ccov.h

@@ -32,6 +32,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacenum.h"
 #include "bacnet/apdu.h"
@@ -40,6 +41,7 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void handler_ccov_notification(
         uint8_t * service_request,
         uint16_t service_len,

src/bacnet/basic/service/h_cov.h

@@ -32,6 +32,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacenum.h"
 #include "bacnet/apdu.h"
@@ -40,19 +41,25 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void handler_cov_subscribe(
         uint8_t * service_request,
         uint16_t service_len,
         BACNET_ADDRESS * src,
         BACNET_CONFIRMED_SERVICE_DATA * service_data);
+    BACNET_STACK_EXPORT
     bool handler_cov_fsm(
         void);
+    BACNET_STACK_EXPORT
     void handler_cov_task(
         void);
+    BACNET_STACK_EXPORT
     void handler_cov_timer_seconds(
         uint32_t elapsed_seconds);
+    BACNET_STACK_EXPORT
     void handler_cov_init(
         void);
+    BACNET_STACK_EXPORT
     int handler_cov_encode_subscriptions(
         uint8_t * apdu,
         int max_apdu);

src/bacnet/basic/service/h_dcc.h

@@ -32,6 +32,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacenum.h"
 #include "bacnet/apdu.h"
@@ -40,13 +41,16 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void handler_device_communication_control(
         uint8_t * service_request,
         uint16_t service_len,
         BACNET_ADDRESS * src,
         BACNET_CONFIRMED_SERVICE_DATA * service_data);
+    BACNET_STACK_EXPORT
     void handler_dcc_password_set(
         char *new_password);
+    BACNET_STACK_EXPORT
     char *handler_dcc_password(void);
 
 #ifdef __cplusplus

src/bacnet/basic/service/h_gas_a.h

@@ -32,6 +32,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacenum.h"
 #include "bacnet/apdu.h"
@@ -40,6 +41,7 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void get_alarm_summary_ack_handler(
         uint8_t * service_request,
         uint16_t service_len,

src/bacnet/basic/service/h_get_alarm_sum.h

@@ -32,6 +32,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacenum.h"
 #include "bacnet/apdu.h"
@@ -41,10 +42,12 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void handler_get_alarm_summary_set(
         BACNET_OBJECT_TYPE object_type,
         get_alarm_summary_function pFunction);
 
+    BACNET_STACK_EXPORT
     void handler_get_alarm_summary(
         uint8_t * service_request,
         uint16_t service_len,

src/bacnet/basic/service/h_getevent.h

@@ -32,6 +32,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacenum.h"
 #include "bacnet/apdu.h"
@@ -42,16 +43,19 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void handler_get_event_information_set(
         BACNET_OBJECT_TYPE object_type,
         get_event_info_function pFunction);
 
+    BACNET_STACK_EXPORT
     void handler_get_event_information(
         uint8_t * service_request,
         uint16_t service_len,
         BACNET_ADDRESS * src,
         BACNET_CONFIRMED_SERVICE_DATA * service_data);
 
+    BACNET_STACK_EXPORT
     void ge_ack_print_data(BACNET_GET_EVENT_INFORMATION_DATA* data,
                            uint32_t device_id);
 

src/bacnet/basic/service/h_getevent_a.h

@@ -32,6 +32,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacenum.h"
 #include "bacnet/apdu.h"
@@ -40,6 +41,7 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void get_event_ack_handler(
         uint8_t *service_request,
         uint16_t service_len,

src/bacnet/basic/service/h_iam.h

@@ -32,6 +32,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacenum.h"
 #include "bacnet/apdu.h"
@@ -40,11 +41,13 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void handler_i_am_add(
         uint8_t * service_request,
         uint16_t service_len,
         BACNET_ADDRESS * src);
 
+    BACNET_STACK_EXPORT
     void handler_i_am_bind(
         uint8_t * service_request,
         uint16_t service_len,

src/bacnet/basic/service/h_ihave.h

@@ -32,6 +32,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacenum.h"
 #include "bacnet/apdu.h"
@@ -40,6 +41,7 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void handler_i_have(
         uint8_t * service_request,
         uint16_t service_len,

src/bacnet/basic/service/h_lso.h

@@ -32,6 +32,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacenum.h"
 #include "bacnet/apdu.h"
@@ -40,6 +41,7 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void handler_lso(
         uint8_t * service_request,
         uint16_t service_len,

src/bacnet/basic/service/h_noserv.h

@@ -32,6 +32,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacenum.h"
 #include "bacnet/apdu.h"
@@ -40,6 +41,7 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void handler_unrecognized_service(
         uint8_t * service_request,
         uint16_t service_len,

src/bacnet/basic/service/h_rd.h

@@ -32,6 +32,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacenum.h"
 #include "bacnet/apdu.h"
@@ -40,6 +41,7 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void handler_reinitialize_device(
         uint8_t * service_request,
         uint16_t service_len,

src/bacnet/basic/service/h_rp.h

@@ -32,6 +32,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacenum.h"
 #include "bacnet/apdu.h"
@@ -40,6 +41,7 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void handler_read_property(
         uint8_t * service_request,
         uint16_t service_len,

src/bacnet/basic/service/h_rp_a.h

@@ -32,6 +32,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacenum.h"
 #include "bacnet/apdu.h"
@@ -41,11 +42,13 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void handler_read_property_ack(
         uint8_t * service_request,
         uint16_t service_len,
         BACNET_ADDRESS * src,
         BACNET_CONFIRMED_SERVICE_ACK_DATA * service_data);
+    BACNET_STACK_EXPORT
     void rp_ack_print_data(
         BACNET_READ_PROPERTY_DATA * data);
 

src/bacnet/basic/service/h_rpm.h

@@ -32,6 +32,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacenum.h"
 #include "bacnet/apdu.h"
@@ -40,6 +41,7 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void handler_read_property_multiple(
         uint8_t * service_request,
         uint16_t service_len,

src/bacnet/basic/service/h_rpm_a.h

@@ -32,6 +32,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacenum.h"
 #include "bacnet/apdu.h"
@@ -41,15 +42,18 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void handler_read_property_multiple_ack(
         uint8_t * service_request,
         uint16_t service_len,
         BACNET_ADDRESS * src,
         BACNET_CONFIRMED_SERVICE_ACK_DATA * service_data);
+    BACNET_STACK_EXPORT
     int rpm_ack_decode_service_request(
         uint8_t * apdu,
         int apdu_len,
         BACNET_READ_ACCESS_DATA * read_access_data);
+    BACNET_STACK_EXPORT
     void rpm_ack_print_data(
         BACNET_READ_ACCESS_DATA * rpm_data);
 

src/bacnet/basic/service/h_rr.h

@@ -32,6 +32,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacenum.h"
 #include "bacnet/apdu.h"
@@ -40,6 +41,7 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void handler_read_range(
         uint8_t * service_request,
         uint16_t service_len,

src/bacnet/basic/service/h_rr_a.h

@@ -32,6 +32,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacenum.h"
 #include "bacnet/apdu.h"
@@ -40,6 +41,7 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void handler_read_range_ack(
         uint8_t * service_request,
         uint16_t service_len,

src/bacnet/basic/service/h_ts.h

@@ -32,6 +32,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacenum.h"
 #include "bacnet/apdu.h"
@@ -43,28 +44,40 @@ extern "C" {
 #endif /* __cplusplus */
 
     /* time synchronization handlers */
+    BACNET_STACK_EXPORT
     void handler_timesync(
         uint8_t * service_request,
         uint16_t service_len,
         BACNET_ADDRESS * src);
+    BACNET_STACK_EXPORT
     void handler_timesync_utc(
         uint8_t * service_request,
         uint16_t service_len,
         BACNET_ADDRESS * src);
     /* time sync master features */
+    BACNET_STACK_EXPORT
     int handler_timesync_encode_recipients(
         uint8_t * apdu,
         int max_apdu);
+    BACNET_STACK_EXPORT
     void handler_timesync_task(BACNET_DATE_TIME *bdatetime);
+    BACNET_STACK_EXPORT
     void handler_timesync_init(void);
+    BACNET_STACK_EXPORT
     bool handler_timesync_recipient_write(
         BACNET_WRITE_PROPERTY_DATA * wp_data);
+    BACNET_STACK_EXPORT
     uint32_t handler_timesync_interval(void);
+    BACNET_STACK_EXPORT
     bool handler_timesync_interval_set(uint32_t minutes);
+    BACNET_STACK_EXPORT
     uint32_t handler_timesync_interval_offset(void);
+    BACNET_STACK_EXPORT
     bool handler_timesync_interval_offset_set(uint32_t minutes);
     bool handler_timesync_interval_align(void);
+    BACNET_STACK_EXPORT
     bool handler_timesync_interval_align_set(bool flag);
+    BACNET_STACK_EXPORT
     bool handler_timesync_recipient_address_set(
         unsigned index,
         BACNET_ADDRESS * address);

src/bacnet/basic/service/h_ucov.h

@@ -32,6 +32,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacenum.h"
 #include "bacnet/apdu.h"
@@ -40,6 +41,7 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void handler_ucov_notification(
         uint8_t * service_request,
         uint16_t service_len,

src/bacnet/basic/service/h_upt.h

@@ -32,6 +32,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacenum.h"
 #include "bacnet/apdu.h"
@@ -41,10 +42,12 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void handler_unconfirmed_private_transfer(
         uint8_t * service_request,
         uint16_t service_len,
         BACNET_ADDRESS * src);
+    BACNET_STACK_EXPORT
     void private_transfer_print_data(
         BACNET_PRIVATE_TRANSFER_DATA *private_data);
 

src/bacnet/basic/service/h_whohas.h

@@ -32,6 +32,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacenum.h"
 #include "bacnet/apdu.h"
@@ -40,11 +41,13 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void handler_who_has(
         uint8_t * service_request,
         uint16_t service_len,
         BACNET_ADDRESS * src);
 
+    BACNET_STACK_EXPORT
     void handler_who_has_for_routing(
         uint8_t * service_request,
         uint16_t service_len,

src/bacnet/basic/service/h_whois.h

@@ -32,6 +32,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacenum.h"
 #include "bacnet/apdu.h"
@@ -40,21 +41,25 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void handler_who_is(
         uint8_t * service_request,
         uint16_t service_len,
         BACNET_ADDRESS * src);
 
+    BACNET_STACK_EXPORT
     void handler_who_is_unicast(
         uint8_t * service_request,
         uint16_t service_len,
         BACNET_ADDRESS * src);
 
+    BACNET_STACK_EXPORT
     void handler_who_is_bcast_for_routing(
         uint8_t * service_request,
         uint16_t service_len,
         BACNET_ADDRESS * src);
 
+    BACNET_STACK_EXPORT
     void handler_who_is_unicast_for_routing(
         uint8_t * service_request,
         uint16_t service_len,

src/bacnet/basic/service/h_wp.h

@@ -32,6 +32,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacapp.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacenum.h"
@@ -41,12 +42,14 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void handler_write_property(
         uint8_t * service_request,
         uint16_t service_len,
         BACNET_ADDRESS * src,
         BACNET_CONFIRMED_SERVICE_DATA * service_data);
 
+    BACNET_STACK_EXPORT
     bool WPValidateString(
         BACNET_APPLICATION_DATA_VALUE * pValue,
         int iMaxLen,
@@ -54,6 +57,7 @@ extern "C" {
         BACNET_ERROR_CLASS * pErrorClass,
         BACNET_ERROR_CODE * pErrorCode);
 
+    BACNET_STACK_EXPORT
     bool WPValidateArgType(
         BACNET_APPLICATION_DATA_VALUE * pValue,
         uint8_t ucExpectedType,

src/bacnet/basic/service/h_wpm.h

@@ -32,6 +32,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacapp.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacenum.h"
@@ -41,6 +42,7 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     void handler_write_property_multiple(
         uint8_t * service_request,
         uint16_t service_len,

src/bacnet/basic/service/s_abort.h

@@ -32,6 +32,7 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include "bacnet/bacnet_stack_exports.h"
 #include "bacnet/bacapp.h"
 #include "bacnet/bacdef.h"
 #include "bacnet/bacenum.h"
@@ -42,6 +43,7 @@
 extern "C" {
 #endif /* __cplusplus */
 
+    BACNET_STACK_EXPORT
     int Send_Abort_To_Network(
         uint8_t * buffer,
         BACNET_ADDRESS *dest,
@@ -49,6 +51,7 @@ extern "C" {
         BACNET_ABORT_REASON reason,
         bool server);
 
+    BACNET_STACK_EXPORT
     int abort_encode_pdu(
         uint8_t * buffer,
         BACNET_ADDRESS * dest,