Hide non-API library symbols

Author: sipa

configure.ac

@@ -14,6 +14,15 @@ AC_LANG([C++])
 
 AC_PATH_PROG(CCACHE,ccache)
 
+saved_CXXFLAGS="$CXXFLAGS"
+CXXFLAGS="-fvisibility=hidden $CXXFLAGS"
+AC_MSG_CHECKING([if ${CXX} supports -fvisibility=hidden])
+AC_COMPILE_IFELSE([AC_LANG_SOURCE([[char foo;]])],
+    [ AC_MSG_RESULT([yes]) ],
+    [ AC_MSG_RESULT([no])
+      CXXFLAGS="$saved_CXXFLAGS"
+    ])
+
 AC_ARG_ENABLE([ccache],
   [AS_HELP_STRING([--disable-ccache],
   [do not use ccache for building (default is to use if found)])],
@@ -100,6 +109,8 @@ case $host in
      ;;
 esac
 
+AX_CHECK_LINK_FLAG([[-Wl,--exclude-libs,ALL]],[LDFLAGS="-Wl,--exclude-libs,ALL $LDFLAGS"])
+
 AX_CHECK_COMPILE_FLAG([-Wall],[WARN_CXXFLAGS="$WARN_CXXFLAGS -Wall"],,[[$CXXFLAG_WERROR]])
 ## Some compilers (gcc) ignore unknown -Wno-* options, but warn about all
 ## unknown options if any other warning is produced. Test the -Wfoo case, and

include/minisketch.h

@@ -10,6 +10,20 @@
 #  include <unistd.h>
 #endif
 
+#ifndef MINISKETCH_API
+# if defined(_WIN32)
+#  ifdef MINISKETCH_BUILD
+#   define MINISKETCH_API __declspec(dllexport)
+#  else
+#   define MINISKETCH_API
+#  endif
+# elif defined(__GNUC__) && (__GNUC__ >= 4) && defined(MINISKETCH_BUILD)
+#  define MINISKETCH_API __attribute__ ((visibility ("default")))
+# else
+#  define MINISKETCH_API
+# endif
+#endif
+
 #ifdef __cplusplus
 #  if __cplusplus >= 201103L
 #    include <memory>
@@ -26,7 +40,7 @@ extern "C" {
 typedef struct minisketch minisketch;
 
 /** Determine whether support for elements of `bits` bits was compiled in. */
-int minisketch_bits_supported(uint32_t bits);
+MINISKETCH_API int minisketch_bits_supported(uint32_t bits);
 
 /** Determine the maximum number of implementations available.
  *
@@ -37,13 +51,13 @@ int minisketch_bits_supported(uint32_t bits);
  * function call, inclusive. Note that not every combination of implementation
  * and element size may exist (see further).
 */
-uint32_t minisketch_implementation_max(void);
+MINISKETCH_API uint32_t minisketch_implementation_max(void);
 
 /** Determine if the a combination of bits and implementation number is available.
  *
  * Returns 1 if it is, 0 otherwise.
  */
-int minisketch_implementation_supported(uint32_t bits, uint32_t implementation);
+MINISKETCH_API int minisketch_implementation_supported(uint32_t bits, uint32_t implementation);
 
 /** Construct a sketch for a given element size, implementation and capacity.
  *
@@ -54,16 +68,16 @@ int minisketch_implementation_supported(uint32_t bits, uint32_t implementation);
  *
  * If the result is not NULL, it must be destroyed using minisketch_destroy.
  */
-minisketch* minisketch_create(uint32_t bits, uint32_t implementation, size_t capacity);
+MINISKETCH_API minisketch* minisketch_create(uint32_t bits, uint32_t implementation, size_t capacity);
 
 /** Get the element size of a sketch in bits. */
-uint32_t minisketch_bits(const minisketch* sketch);
+MINISKETCH_API uint32_t minisketch_bits(const minisketch* sketch);
 
 /** Get the capacity of a sketch. */
-size_t minisketch_capacity(const minisketch* sketch);
+MINISKETCH_API size_t minisketch_capacity(const minisketch* sketch);
 
 /** Get the implementation of a sketch. */
-uint32_t minisketch_implementation(const minisketch* sketch);
+MINISKETCH_API uint32_t minisketch_implementation(const minisketch* sketch);
 
 /** Set the seed for randomizing algorithm choices to a fixed value.
  *
@@ -76,28 +90,28 @@ uint32_t minisketch_implementation(const minisketch* sketch);
  * When seed is -1, a fixed internal value with predictable behavior is
  * used. It is only intended for testing.
  */
-void minisketch_set_seed(minisketch* sketch, uint64_t seed);
+MINISKETCH_API void minisketch_set_seed(minisketch* sketch, uint64_t seed);
 
 /** Clone a sketch.
  *
  * The result must be destroyed using minisketch_destroy.
  */
-minisketch* minisketch_clone(const minisketch* sketch);
+MINISKETCH_API minisketch* minisketch_clone(const minisketch* sketch);
 
 /** Destroy a sketch.
  *
  * The pointer that was passed in may not be used anymore afterwards.
  */
-void minisketch_destroy(minisketch* sketch);
+MINISKETCH_API void minisketch_destroy(minisketch* sketch);
 
 /** Compute the size in bytes for serializing a given sketch. */
-size_t minisketch_serialized_size(const minisketch* sketch);
+MINISKETCH_API size_t minisketch_serialized_size(const minisketch* sketch);
 
 /** Serialize a sketch to bytes. */
-void minisketch_serialize(const minisketch* sketch, unsigned char* output);
+MINISKETCH_API void minisketch_serialize(const minisketch* sketch, unsigned char* output);
 
 /** Deserialize a sketch from bytes. */
-void minisketch_deserialize(minisketch* sketch, const unsigned char* input);
+MINISKETCH_API void minisketch_deserialize(minisketch* sketch, const unsigned char* input);
 
 /** Add an element to a sketch.
  * 
@@ -112,7 +126,7 @@ void minisketch_deserialize(minisketch* sketch, const unsigned char* input);
  *
  * Note that adding the same element a second time removes it again.
  */
-void minisketch_add_uint64(minisketch* sketch, uint64_t element);
+MINISKETCH_API void minisketch_add_uint64(minisketch* sketch, uint64_t element);
 
 /** Merge the elements of another sketch into this sketch.
  *
@@ -130,7 +144,7 @@ void minisketch_add_uint64(minisketch* sketch, uint64_t element);
  * of two sketches with the same element size and capacity by performing a bitwise XOR
  * of the serializations.
  */
-size_t minisketch_merge(minisketch* sketch, const minisketch* other_sketch);
+MINISKETCH_API size_t minisketch_merge(minisketch* sketch, const minisketch* other_sketch);
 
 /** Decode a sketch.
  *
@@ -139,7 +153,7 @@ size_t minisketch_merge(minisketch* sketch, const minisketch* other_sketch);
  *
  * The return value is the number of decoded elements, or -1 if decoding failed.
  */
-ssize_t minisketch_decode(const minisketch* sketch, size_t max_elements, uint64_t* output);
+MINISKETCH_API ssize_t minisketch_decode(const minisketch* sketch, size_t max_elements, uint64_t* output);
 
 /** Compute the capacity needed to achieve a certain rate of false positives.
  *
@@ -153,7 +167,7 @@ ssize_t minisketch_decode(const minisketch* sketch, size_t max_elements, uint64_
  * function computes the necessary capacity. It is only guaranteed to be
  * accurate up to fpbits=256.
  */
-size_t minisketch_compute_capacity(uint32_t bits, size_t max_elements, uint32_t fpbits);
+MINISKETCH_API size_t minisketch_compute_capacity(uint32_t bits, size_t max_elements, uint32_t fpbits);
 
 /** Compute what max_elements can be decoded for a certain rate of false positives.
  *
@@ -171,7 +185,7 @@ size_t minisketch_compute_capacity(uint32_t bits, size_t max_elements, uint32_t
  * chance of 1 in 2^18.5). Therefore, minisketch_compute_max_elements with
  * capacity=9 will return 9.
  */
-size_t minisketch_compute_max_elements(uint32_t bits, size_t capacity, uint32_t fpbits);
+MINISKETCH_API size_t minisketch_compute_max_elements(uint32_t bits, size_t capacity, uint32_t fpbits);
 
 #ifdef __cplusplus
 }

src/minisketch.cpp

@@ -4,8 +4,13 @@
  * file LICENSE or http://www.opensource.org/licenses/mit-license.php.*
  **********************************************************************/
 
+
 #include <new>
 
+#define MINISKETCH_BUILD
+#ifdef _MINISKETCH_H_
+#  error "minisketch.h cannot be included before minisketch.cpp"
+#endif
 #include "../include/minisketch.h"
 
 #include "false_positives.h"