in libgu mark explicitly all functions that belong to the API

src/runtime/c/gu/assert.c

@@ -3,7 +3,7 @@
 #include <stdio.h>
 #include <stdarg.h>
 
-const char*
+static const char*
 gu_assert_mode_descs[] = {
 	[GU_ASSERT_PRECOND] = "precondition failed",
 	[GU_ASSERT_POSTCOND] = "postcondition failed",
@@ -11,7 +11,7 @@ gu_assert_mode_descs[] = {
 	[GU_ASSERT_NEVER] = "control should not reach here",
 };
 
-void
+GU_API void
 gu_abort_v_(GuAssertMode mode,
 	    const char* file, const char* func, int line,
 	    const char* msg_fmt, va_list args)
@@ -26,7 +26,7 @@ gu_abort_v_(GuAssertMode mode,
 	abort();
 }
 
-void
+GU_API void
 gu_abort_(GuAssertMode mode,
 	  const char* file, const char* func, int line,
 	  const char* msg_fmt, ...)
@@ -37,8 +37,7 @@ gu_abort_(GuAssertMode mode,
 	va_end(args);
 }
 
-
+GU_API void 
-void 
 gu_fatal(const char* fmt, ...)
 {
 	va_list args;

src/runtime/c/gu/assert.h

@@ -10,12 +10,12 @@ typedef enum {
 	GU_ASSERT_NEVER
 } GuAssertMode;
 
-void
+GU_API_DECL void
 gu_abort_v_(GuAssertMode mode, 
 	    const char* file, const char* func, int line,
 	    const char* msg_fmt, va_list args);
 
-void
+GU_API_DECL void
 gu_abort_(GuAssertMode mode, 
 	  const char* file, const char* func, int line,
 	  const char* msg_fmt, ...);
@@ -55,7 +55,7 @@ gu_abort_(GuAssertMode mode,
 #define gu_impossible()				\
 	gu_impossible_msg(NULL)
 
-void 
+GU_API_DECL void
 gu_fatal(const char* fmt, ...);
 
 #endif /* GU_ASSERT_H_ */

src/runtime/c/gu/bits.c

@@ -7,7 +7,8 @@
 #include <stdlib.h>
 #include <math.h>
 
-unsigned gu_ceil2e(unsigned u)  
+GU_INTERNAL unsigned
+gu_ceil2e(unsigned u)  
 {
 	u--;
 	u |= u >> 1;
@@ -24,7 +25,7 @@ unsigned gu_ceil2e(unsigned u)
 	return u;
 }
 
-double 
+GU_INTERNAL double
 gu_decode_double(uint64_t u)
 {
 	bool sign = u >> 63;

src/runtime/c/gu/bits.h

@@ -13,6 +13,7 @@
  * <http://graphics.stanford.edu/~seander/bithacks.html>
  */
 
+GU_INTERNAL_DECL
 unsigned gu_ceil2e(unsigned i);
 
 static inline int
@@ -140,7 +141,7 @@ gu_decode_2c64(uint64_t u, GuExn* err)
 			     UINT64_C(0x7fffffffffffffff), INT64_MIN, err);
 }
 
-double
+GU_INTERNAL_DECL double
 gu_decode_double(uint64_t u);
 
 

src/runtime/c/gu/choice.c

@@ -7,7 +7,7 @@ struct GuChoice {
 	size_t path_idx;
 };
 
-GuChoice*
+GU_API GuChoice*
 gu_new_choice(GuPool* pool)
 {
 	GuChoice* ch = gu_new(GuChoice, pool);
@@ -16,14 +16,14 @@ gu_new_choice(GuPool* pool)
 	return ch;
 }
 
-GuChoiceMark
+GU_API GuChoiceMark
 gu_choice_mark(GuChoice* ch)
 {
 	gu_assert(ch->path_idx <= gu_buf_length(ch->path));
 	return (GuChoiceMark){ch->path_idx};
 }
 
-void
+GU_API void
 gu_choice_reset(GuChoice* ch, GuChoiceMark mark)
 {
 	gu_assert(ch->path_idx <= gu_buf_length(ch->path));
@@ -31,7 +31,7 @@ gu_choice_reset(GuChoice* ch, GuChoiceMark mark)
 	ch->path_idx = mark.path_idx;
 }
 
-int
+GU_API int
 gu_choice_next(GuChoice* ch, int n_choices)
 {
 	gu_assert(n_choices >= 0);
@@ -52,7 +52,7 @@ gu_choice_next(GuChoice* ch, int n_choices)
 	return ret;
 }
 
-bool
+GU_API bool
 gu_choice_advance(GuChoice* ch)
 {
 	gu_assert(ch->path_idx <= gu_buf_length(ch->path));

src/runtime/c/gu/choice.h

@@ -7,19 +7,19 @@ typedef struct GuChoice GuChoice;
 
 typedef struct GuChoiceMark GuChoiceMark;
 
-GuChoice*
+GU_API_DECL GuChoice*
 gu_new_choice(GuPool* pool);
 
-int
+GU_API_DECL int
 gu_choice_next(GuChoice* ch, int n_choices);
 
-GuChoiceMark
+GU_API_DECL GuChoiceMark
 gu_choice_mark(GuChoice* ch);
 
-void
+GU_API_DECL void
 gu_choice_reset(GuChoice* ch, GuChoiceMark mark);
 
-bool
+GU_API_DECL bool
 gu_choice_advance(GuChoice* ch);
 
 

src/runtime/c/gu/defs.c

@@ -1,4 +1,4 @@
 #include <gu/defs.h>
 
 void* const gu_null = NULL;
-GU_API_DATA GuStruct* const gu_null_struct = NULL;
+GU_API GuStruct* const gu_null_struct = NULL;

src/runtime/c/gu/defs.h

@@ -1,22 +1,3 @@
-/* 
- * Copyright 2010 University of Helsinki.
- *   
- * This file is part of libgu.
- * 
- * Libgu is free software: you can redistribute it and/or modify it under
- * the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or (at your
- * option) any later version.
- * 
- * Libgu is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with libgu. If not, see <http://www.gnu.org/licenses/>.
- */
-
 /** @file
  *
  * Miscellaneous macros.
@@ -30,16 +11,19 @@
 // for functions, but not for data/variables.
 #if defined(_MSC_VER)
 #if defined(COMPILING_GU)
-#define GU_API_DATA_DECL __declspec(dllexport)
+#define GU_API_DECL __declspec(dllexport)
-#define GU_API_DATA __declspec(dllexport)
+#define GU_API __declspec(dllexport)
 #else
-#define GU_API_DATA_DECL __declspec(dllimport)
+#define GU_API_DECL __declspec(dllimport)
-#define GU_API_DATA ERROR_NOT_COMPILING_LIBGU
+#define GU_API ERROR_NOT_COMPILING_LIBGU
 #endif
 
 #else
-#define GU_API_DATA_DECL extern
+#define GU_API_DECL
-#define GU_API_DATA
+#define GU_API
+
+#define GU_INTERNAL_DECL  __attribute__ ((visibility ("hidden")))
+#define GU_INTERNAL       __attribute__ ((visibility ("hidden")))
 #endif
 // end MSVC workaround
 
@@ -172,7 +156,7 @@ extern void* const gu_null;
 // Dummy struct used for generic struct pointers
 typedef struct GuStruct GuStruct;
 
-GU_API_DATA_DECL GuStruct* const gu_null_struct;
+GU_API_DECL extern GuStruct* const gu_null_struct;
 
 typedef uintptr_t GuWord;
 

src/runtime/c/gu/enum.c

@@ -1,6 +1,6 @@
 #include <gu/enum.h>
 
-void
+GU_API void
 gu_enum_next(GuEnum* en, void* to, GuPool* pool)
 {
 	en->next(en, to, pool);

src/runtime/c/gu/enum.h

@@ -9,7 +9,7 @@ struct GuEnum {
 	void (*next)(GuEnum* self, void* to, GuPool* pool);
 };
 
-void
+GU_API_DECL void
 gu_enum_next(GuEnum* en, void* to, GuPool* pool);
 
 #ifdef GU_GNUC

src/runtime/c/gu/exn.c

@@ -2,7 +2,7 @@
 #include <gu/assert.h>
 
 
-GuExn*
+GU_API GuExn*
 gu_new_exn(GuPool* pool)
 {
 	GuExn* exn = gu_new(GuExn, pool);
@@ -13,18 +13,18 @@ gu_new_exn(GuPool* pool)
 	return exn;
 }
 
-bool
+GU_API bool
 gu_exn_is_raised(GuExn* err) {
 	return err && (err->state == GU_EXN_RAISED);
 }
 
-bool
+GU_API bool
 gu_exn_caught_(GuExn* err, const char* type)
 {
 	return (err->caught && strcmp(err->caught, type) == 0);
 }
 
-void
+GU_API void
 gu_exn_block(GuExn* err)
 {
 	if (err && err->state == GU_EXN_RAISED) {
@@ -32,7 +32,7 @@ gu_exn_block(GuExn* err)
 	}
 }
 
-void
+GU_API void
 gu_exn_unblock(GuExn* err)
 {
 	if (err && err->state == GU_EXN_BLOCKED) {
@@ -40,7 +40,7 @@ gu_exn_unblock(GuExn* err)
 	}
 }
 
-GuExnData*
+GU_API GuExnData*
 gu_exn_raise_debug_(GuExn* err, const char* type, 
 		            const char* filename, const char* func, int lineno)
 {
@@ -60,13 +60,13 @@ gu_exn_raise_debug_(GuExn* err, const char* type,
 	return NULL;
 }
 
-GuExnData*
+GU_API GuExnData*
 gu_exn_raise_(GuExn* base, const char* type)
 {
 	return gu_exn_raise_debug_(base, type, NULL, NULL, -1);
 }
 
-void
+GU_API void
 gu_raise_errno(GuExn* err)
 {
 	GuExnData* err_data = gu_raise(err, GuErrno);

src/runtime/c/gu/exn.h

@@ -64,11 +64,11 @@ struct GuExn {
 
 
 /// Allocate a new exception frame.
-GuExn*
+GU_API_DECL GuExn*
 gu_new_exn(GuPool* pool);
 
 
-bool
+GU_API_DECL bool
 gu_exn_is_raised(GuExn* err);
 
 static inline void
@@ -80,7 +80,7 @@ gu_exn_clear(GuExn* err) {
 #define gu_exn_caught(err, type) \
 	(err->caught && strcmp(err->caught, #type) == 0)
 	
-bool
+GU_API_DECL bool
 gu_exn_caught_(GuExn* err, const char* type);
 
 static inline const void*
@@ -90,19 +90,19 @@ gu_exn_caught_data(GuExn* err)
 }
 
 /// Temporarily block a raised exception.
-void
+GU_API_DECL void
 gu_exn_block(GuExn* err);
 
 /// Show again a blocked exception.
-void
+GU_API_DECL void
 gu_exn_unblock(GuExn* err);
 
 //@private
-GuExnData*
+GU_API_DECL GuExnData*
 gu_exn_raise_(GuExn* err, const char* type);
 
 //@private
-GuExnData*
+GU_API_DECL GuExnData*
 gu_exn_raise_debug_(GuExn* err, const char* type,
 		      const char* filename, const char* func, int lineno);
 
@@ -163,7 +163,7 @@ gu_ok(GuExn* exn) {
 
 typedef int GuErrno;
 
-void
+GU_API_DECL void
 gu_raise_errno(GuExn* err);
 
 /** @} */

src/runtime/c/gu/file.c

@@ -31,7 +31,7 @@ gu_file_flush(GuOutStream* stream, GuExn* err)
 	}
 }
 
-GuOut*
+GU_API GuOut*
 gu_file_out(FILE* file, GuPool* pool)
 {
 	GuFileOutStream* fos = gu_new(GuFileOutStream, pool);
@@ -65,7 +65,7 @@ gu_file_input(GuInStream* stream, uint8_t* buf, size_t sz, GuExn* err)
 	return got;
 }
 
-GuIn*
+GU_API GuIn*
 gu_file_in(FILE* file, GuPool* pool)
 {
 	GuFileInStream* fis = gu_new(GuFileInStream, pool);

src/runtime/c/gu/file.h

@@ -5,10 +5,10 @@
 #include <gu/out.h>
 #include <stdio.h>
 
-GuOut*
+GU_API_DECL GuOut*
 gu_file_out(FILE* file, GuPool* pool);
 
-GuIn* 
+GU_API_DECL GuIn* 
 gu_file_in(FILE* file, GuPool* pool);
 
 #endif // GU_FILE_H_

src/runtime/c/gu/hash.c

@@ -1,6 +1,6 @@
 #include <gu/hash.h>
 
-GuHash
+GU_API GuHash
 gu_hash_bytes(GuHash h, const uint8_t* buf, size_t len)
 {
 	for (size_t n = 0; n < len; n++) {
@@ -25,7 +25,7 @@ gu_int_hash_fn(GuHasher* self, const void* p)
 	return (GuHash) *(const int*) p;
 }
 
-GU_API_DATA GuHasher gu_int_hasher[1] = {
+GU_API GuHasher gu_int_hasher[1] = {
 	{
 		{ gu_int_eq_fn },
 		gu_int_hash_fn
@@ -46,7 +46,7 @@ gu_addr_hash_fn(GuHasher* self, const void* p)
 	return (GuHash) (uintptr_t) p;
 }
 
-GU_API_DATA GuHasher gu_addr_hasher[1] = {
+GU_API GuHasher gu_addr_hasher[1] = {
 	{
 		{ gu_addr_eq_fn },
 		gu_addr_hash_fn
@@ -69,7 +69,7 @@ gu_word_hash_fn(GuHasher* self, const void* p)
 	return (GuHash) (uintptr_t) p;
 }
 
-GU_API_DATA GuHasher gu_word_hasher[1] = {
+GU_API GuHasher gu_word_hasher[1] = {
 	{
 		{ gu_word_eq_fn },
 		gu_word_hash_fn

src/runtime/c/gu/hash.h

@@ -20,7 +20,7 @@ gu_hash_byte(GuHash h, uint8_t u)
 }
 
 
-GuHash
+GU_API GuHash
 gu_hash_bytes(GuHash h, const uint8_t* buf, size_t len);
 
 typedef const struct GuHasher GuHasher;
@@ -31,10 +31,10 @@ struct GuHasher {
 };
 
 
-GU_API_DATA_DECL GuHasher gu_int_hasher[1];
+GU_API_DECL extern GuHasher gu_int_hasher[1];
 
-GU_API_DATA_DECL GuHasher gu_addr_hasher[1];
+GU_API_DECL extern GuHasher gu_addr_hasher[1];
 
-GU_API_DATA_DECL GuHasher gu_word_hasher[1];
+GU_API_DECL extern GuHasher gu_word_hasher[1];
 
 #endif // GU_HASH_H_

src/runtime/c/gu/in.c

@@ -68,7 +68,7 @@ gu_in_input(GuIn* in, uint8_t* dst, size_t sz, GuExn* err)
 	return 0;
 }
 
-size_t
+GU_API size_t
 gu_in_some(GuIn* in, uint8_t* dst, size_t sz, GuExn* err)
 {
 	gu_require(sz <= PTRDIFF_MAX);
@@ -82,7 +82,7 @@ gu_in_some(GuIn* in, uint8_t* dst, size_t sz, GuExn* err)
 	return real_sz;
 }
 
-void
+GU_API void
 gu_in_bytes_(GuIn* in, uint8_t* dst, size_t sz, GuExn* err)
 {
 	for (;;) {
@@ -102,7 +102,7 @@ gu_in_bytes_(GuIn* in, uint8_t* dst, size_t sz, GuExn* err)
 	}
 }
 
-const uint8_t*
+GU_API const uint8_t*
 gu_in_begin_span(GuIn* in, size_t *sz_out, GuExn* err)
 {
 	if (!gu_in_begin_buffering(in, err)) {
@@ -112,14 +112,14 @@ gu_in_begin_span(GuIn* in, size_t *sz_out, GuExn* err)
 	return &in->buf_end[in->buf_curr];
 }
 
-void
+GU_API void
 gu_in_end_span(GuIn* in, size_t consumed)
 {
 	gu_require(consumed <= (size_t) -in->buf_curr);
 	in->buf_curr += (ptrdiff_t) consumed;
 }
 
-uint8_t 
+GU_API uint8_t 
 gu_in_u8_(GuIn* in, GuExn* err)
 {
 	if (gu_in_begin_buffering(in, err) && in->buf_curr < 0) {
@@ -158,94 +158,92 @@ gu_in_le(GuIn* in, GuExn* err, int n)
 	return u;
 }
 
-int8_t 
+GU_API int8_t 
 gu_in_s8(GuIn* in, GuExn* err)
 {
 	return gu_decode_2c8(gu_in_u8(in, err), err);
 }
 
 
-uint16_t
+GU_API uint16_t
 gu_in_u16le(GuIn* in, GuExn* err)
 {
 	return gu_in_le(in, err, 2);
 }
 
-int16_t 
+GU_API int16_t 
 gu_in_s16le(GuIn* in, GuExn* err)
 {
 	return gu_decode_2c16(gu_in_u16le(in, err), err);
 }
 
-uint16_t
+GU_API uint16_t
 gu_in_u16be(GuIn* in, GuExn* err)
 {
 	return gu_in_be(in, err, 2);
 }
 
-int16_t 
+GU_API int16_t 
 gu_in_s16be(GuIn* in, GuExn* err)
 {
 	return gu_decode_2c16(gu_in_u16be(in, err), err);
 }
 
-
+GU_API uint32_t
-uint32_t
 gu_in_u32le(GuIn* in, GuExn* err)
 {
 	return gu_in_le(in, err, 4);
 }
 
-int32_t 
+GU_API int32_t 
 gu_in_s32le(GuIn* in, GuExn* err)
 {
 	return gu_decode_2c32(gu_in_u32le(in, err), err);
 }
 
-uint32_t
+GU_API uint32_t
 gu_in_u32be(GuIn* in, GuExn* err)
 {
 	return gu_in_be(in, err, 4);
 }
 
-int32_t 
+GU_API int32_t 
 gu_in_s32be(GuIn* in, GuExn* err)
 {
 	return gu_decode_2c32(gu_in_u32be(in, err), err);
 }
 
-
+GU_API uint64_t
-uint64_t
 gu_in_u64le(GuIn* in, GuExn* err)
 {
 	return gu_in_le(in, err, 8);
 }
 
-int64_t 
+GU_API int64_t 
 gu_in_s64le(GuIn* in, GuExn* err)
 {
 	return gu_decode_2c64(gu_in_u64le(in, err), err);
 }
 
-uint64_t
+GU_API uint64_t
 gu_in_u64be(GuIn* in, GuExn* err)
 {
 	return gu_in_be(in, err, 8);
 }
 
-int64_t 
+GU_API int64_t 
 gu_in_s64be(GuIn* in, GuExn* err)
 {
 	return gu_decode_2c64(gu_in_u64be(in, err), err);
 }
 
-double
+GU_API double
 gu_in_f64le(GuIn* in, GuExn* err)
 {
 	return gu_decode_double(gu_in_u64le(in, err));
 }
 
-double
+GU_API double
 gu_in_f64be(GuIn* in, GuExn* err)
 {
 	return gu_decode_double(gu_in_u64le(in, err));
@@ -261,7 +259,7 @@ gu_in_fini(GuFinalizer* fin)
 	gu_pool_free(pool);
 }
 
-GuIn*
+GU_API GuIn*
 gu_new_in(GuInStream* stream, GuPool* pool)
 {
 	gu_require(stream != NULL);
@@ -317,7 +315,7 @@ gu_buffered_in_input(GuInStream* self, uint8_t* dst, size_t sz, GuExn* err)
 	return gu_in_some(bis->in, dst, sz, err);
 }
 
-GuIn*
+GU_API GuIn*
 gu_buffered_in(GuIn* in, size_t buf_sz, GuPool* pool)
 {
 	GuBufferedInStream* bis = gu_new_flex(pool, GuBufferedInStream,
@@ -355,7 +353,7 @@ gu_data_in_begin_buffer(GuInStream* self, size_t* sz_out, GuExn* err)
 	return buf;
 }
 
-GuIn*
+GU_API GuIn*
 gu_data_in(const uint8_t* data, size_t sz, GuPool* pool)
 {
 	GuDataIn* di = gu_new(GuDataIn, pool);

src/runtime/c/gu/in.h

@@ -25,16 +25,16 @@ struct GuIn {
 	GuFinalizer fini;
 };
 
-GuIn*
+GU_API_DECL GuIn*
 gu_new_in(GuInStream* stream, GuPool* pool);
 
-const uint8_t*
+GU_API_DECL const uint8_t*
 gu_in_begin_span(GuIn* in, size_t *sz_out, GuExn* err);
 
-void
+GU_API_DECL void
 gu_in_end_span(GuIn* in, size_t consumed);
 
-size_t
+GU_API_DECL size_t
 gu_in_some(GuIn* in, uint8_t* buf, size_t max_len, GuExn* err);
 
 inline void
@@ -69,7 +69,6 @@ gu_in_consume(GuIn* restrict in, size_t sz)
 	in->buf_curr += sz;
 }
 
-
 inline uint8_t 
 gu_in_u8(GuIn* restrict in, GuExn* err)
 {
@@ -80,55 +79,55 @@ gu_in_u8(GuIn* restrict in, GuExn* err)
 	return in->buf_end[in->buf_curr++];
 }
 
-int8_t 
+GU_API_DECL int8_t 
 gu_in_s8(GuIn* in, GuExn* err);
 
-uint16_t
+GU_API_DECL uint16_t
 gu_in_u16le(GuIn* in, GuExn* err);
 
-uint16_t
+GU_API_DECL uint16_t
 gu_in_u16be(GuIn* in, GuExn* err);
 
-int16_t
+GU_API_DECL int16_t
 gu_in_s16le(GuIn* in, GuExn* err);
 
-int16_t
+GU_API_DECL int16_t
 gu_in_s16be(GuIn* in, GuExn* err);
 
-uint32_t
+GU_API_DECL uint32_t
 gu_in_u32le(GuIn* in, GuExn* err);
 
-uint32_t
+GU_API_DECL uint32_t
 gu_in_u32be(GuIn* in, GuExn* err);
 
-int32_t
+GU_API_DECL int32_t
 gu_in_s32le(GuIn* in, GuExn* err);
 
-int32_t
+GU_API_DECL int32_t
 gu_in_s32be(GuIn* in, GuExn* err);
 
-uint64_t
+GU_API_DECL uint64_t
 gu_in_u64le(GuIn* in, GuExn* err);
 
-uint64_t
+GU_API_DECL uint64_t
 gu_in_u64be(GuIn* in, GuExn* err);
 
-int64_t
+GU_API_DECL int64_t
 gu_in_s64le(GuIn* in, GuExn* err);
 
-int64_t
+GU_API_DECL int64_t
 gu_in_s64be(GuIn* in, GuExn* err);
 
-double
+GU_API_DECL double
 gu_in_f64le(GuIn* in, GuExn* err);
 
-double
+GU_API_DECL double
 gu_in_f64be(GuIn* in, GuExn* err);
 
-GuIn*
+GU_API_DECL GuIn*
 gu_buffered_in(GuIn* in, size_t sz, GuPool* pool);
 
-GuIn*
+GU_API_DECL GuIn*
 gu_data_in(const uint8_t* buf, size_t size, GuPool* pool);
 
 

src/runtime/c/gu/map.c

@@ -222,7 +222,7 @@ gu_map_maybe_resize(GuMap* map)
 	return false;
 }
 
-void*
+GU_API void*
 gu_map_find(GuMap* map, const void* key)
 {
 	size_t idx;
@@ -233,14 +233,14 @@ gu_map_find(GuMap* map, const void* key)
 	return NULL;
 }
 
-const void*
+GU_API const void*
 gu_map_find_default(GuMap* map, const void* key)
 {
 	void* p = gu_map_find(map, key);
 	return p ? p : map->default_value;
 }
 
-const void*
+GU_API const void*
 gu_map_find_key(GuMap* map, const void* key)
 {
 	size_t idx;
@@ -251,14 +251,14 @@ gu_map_find_key(GuMap* map, const void* key)
 	return NULL;
 }
 
-bool
+GU_API bool
 gu_map_has(GuMap* ht, const void* key)
 {
 	size_t idx;
 	return gu_map_lookup(ht, key, &idx);
 }
 
-void*
+GU_API void*
 gu_map_insert(GuMap* map, const void* key)
 {
 	size_t idx;
@@ -289,7 +289,7 @@ gu_map_insert(GuMap* map, const void* key)
 	return &map->data.values[idx * map->value_size];
 }
 
-void
+GU_API void
 gu_map_iter(GuMap* map, GuMapItor* itor, GuExn* err)
 {
 	for (size_t i = 0; i < map->data.n_entries && gu_ok(err); i++) {
@@ -340,7 +340,7 @@ gu_map_enum_next(GuEnum* self, void* to, GuPool* pool)
 	en->i = i+1;
 }
 
-GuEnum*
+GU_API GuEnum*
 gu_map_enum(GuMap* ht, GuPool* pool)
 {
 	GuMapEnum* en = gu_new(GuMapEnum, pool);
@@ -350,7 +350,7 @@ gu_map_enum(GuMap* ht, GuPool* pool)
 	return &en->en;
 }
 
-size_t
+GU_API size_t
 gu_map_count(GuMap* map)
 {
 	size_t count = 0;
@@ -365,7 +365,7 @@ gu_map_count(GuMap* map)
 
 static const uint8_t gu_map_no_values[1] = { 0 };
 
-GuMap*
+GU_API GuMap*
 gu_make_map(size_t key_size, GuHasher* hasher,
 	    size_t value_size, const void* default_value,
 	    size_t init_size,

src/runtime/c/gu/map.h

@@ -15,7 +15,7 @@ struct GuMapItor {
 
 typedef struct GuMap GuMap;
 
-GuMap*
+GU_API_DECL GuMap*
 gu_make_map(size_t key_size, GuHasher* hasher,
 	    size_t value_size, const void* default_value,
 	    size_t init_size,
@@ -32,19 +32,19 @@ gu_make_map(size_t key_size, GuHasher* hasher,
 #define gu_new_addr_map(K, V, DV, POOL)				\
 	(gu_make_map(sizeof(K), gu_addr_hasher, sizeof(V), (DV), GU_MAP_DEFAULT_INIT_SIZE, (POOL)))
 
-size_t
+GU_API_DECL size_t
 gu_map_count(GuMap* map);
 
-void*
+GU_API_DECL void*
 gu_map_find_full(GuMap* ht, void* key_inout);
 
-const void*
+GU_API_DECL const void*
 gu_map_find_default(GuMap* ht, const void* key);
 
 #define gu_map_get(MAP, KEYP, V)		\
 	(*(V*)gu_map_find_default((MAP), (KEYP)))
 
-void*
+GU_API_DECL void*
 gu_map_find(GuMap* ht, const void* key);
 
 #define gu_map_set(MAP, KEYP, V, VAL)				\
@@ -53,13 +53,13 @@ gu_map_find(GuMap* ht, const void* key);
 	*gu_map_set_p_ = (VAL);					\
 	GU_END
 
-const void*
+GU_API_DECL const void*
 gu_map_find_key(GuMap* ht, const void* key);
 
-bool
+GU_API_DECL bool
 gu_map_has(GuMap* ht, const void* key);
 
-void*
+GU_API_DECL void*
 gu_map_insert(GuMap* ht, const void* key);
 
 #define gu_map_put(MAP, KEYP, V, VAL)				\
@@ -68,7 +68,7 @@ gu_map_insert(GuMap* ht, const void* key);
 	*gu_map_put_p_ = (VAL);					\
 	GU_END
 
-void
+GU_API_DECL void
 gu_map_iter(GuMap* ht, GuMapItor* itor, GuExn* err);
 
 typedef struct {
@@ -76,7 +76,7 @@ typedef struct {
 	void* value;
 } GuMapKeyValue;
 
-GuEnum*
+GU_API_DECL GuEnum*
 gu_map_enum(GuMap* ht, GuPool* pool);
 
 typedef GuMap GuIntMap;

src/runtime/c/gu/mem.c

@@ -23,7 +23,7 @@
 static const size_t
 // Maximum request size for a chunk. The actual maximum chunk size
 // may be somewhat larger.
-gu_mem_chunk_max_size = 1024 * sizeof(void*),
+    gu_mem_chunk_max_size = 1024 * sizeof(void*),
 
 // number of bytes to allocate in the pool when it is created
 	gu_mem_pool_initial_size = 24 * sizeof(void*),
@@ -90,7 +90,7 @@ gu_mem_padovan(size_t min)
 	return a;
 }
 
-void*
+GU_API void*
 gu_mem_buf_realloc(void* old_buf, size_t min_size, size_t* real_size_out)
 {
 	size_t min_blocks = ((min_size + gu_malloc_overhead - 1) /
@@ -101,13 +101,14 @@ gu_mem_buf_realloc(void* old_buf, size_t min_size, size_t* real_size_out)
 	*real_size_out = buf ? size : 0;
 	return buf;
 }
-void*
+
+GU_API void*
 gu_mem_buf_alloc(size_t min_size, size_t* real_size_out)
 {
 	return gu_mem_buf_realloc(NULL, min_size, real_size_out);
 }
 
-void
+GU_API void
 gu_mem_buf_free(void* buf)
 {
 	gu_mem_free(buf);
@@ -162,7 +163,7 @@ gu_init_pool(uint8_t* buf, size_t sz)
 	return pool;
 }
 
-GuPool*
+GU_API GuPool*
 gu_local_pool_(uint8_t* buf, size_t sz)
 {
 	GuPool* pool = gu_init_pool(buf, sz);
@@ -170,7 +171,7 @@ gu_local_pool_(uint8_t* buf, size_t sz)
 	return pool;
 }
 
-GuPool* 
+GU_API GuPool* 
 gu_new_pool(void)
 {
 	size_t sz = GU_FLEX_SIZE(GuPool, init_buf, gu_mem_pool_initial_size);
@@ -179,7 +180,7 @@ gu_new_pool(void)
 	return pool;
 }
 
-GuPool* 
+GU_API GuPool* 
 gu_mmap_pool(char* fpath, void* addr, size_t size, void**pptr)
 {
 #if !defined(_WIN32) && !defined(_WIN64)
@@ -281,7 +282,7 @@ gu_pool_avail(GuPool* pool)
 	return (size_t) pool->right_edge - (size_t) pool->left_edge;
 }
 
-void*
+GU_API void*
 gu_pool_malloc_unaligned(GuPool* pool, size_t size)
 {
 	if (size > gu_pool_avail(pool)) {
@@ -294,7 +295,7 @@ gu_pool_malloc_unaligned(GuPool* pool, size_t size)
 	return addr;
 }
 
-void*
+GU_API void*
 gu_malloc_prefixed(GuPool* pool, size_t pre_align, size_t pre_size,
 		   size_t align, size_t size)
 {
@@ -327,14 +328,13 @@ gu_malloc_prefixed(GuPool* pool, size_t pre_align, size_t pre_size,
 	return ret;
 }
 
-void*
+GU_API void*
 gu_malloc_aligned(GuPool* pool, size_t size, size_t align)
 {
 	return gu_malloc_prefixed(pool, 1, 0, align, size);
 }
 
-
+GU_API void 
-void 
 gu_pool_finally(GuPool* pool, GuFinalizer* finalizer)
 {
 	gu_require(pool->type != GU_POOL_MMAP);
@@ -344,7 +344,7 @@ gu_pool_finally(GuPool* pool, GuFinalizer* finalizer)
 	pool->finalizers = node;
 }
 
-void
+GU_API void
 gu_pool_free(GuPool* pool)
 {
 	GuFinalizerNode* node = pool->finalizers;

src/runtime/c/gu/mem.h

@@ -1,22 +1,3 @@
-/* 
- * Copyright 2010 University of Helsinki.
- *   
- * This file is part of libgu.
- * 
- * Libgu is free software: you can redistribute it and/or modify it under
- * the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or (at your
- * option) any later version.
- * 
- * Libgu is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with libgu. If not, see <http://www.gnu.org/licenses/>.
- */
-
 /** @file
  *
  * Memory allocation tools.
@@ -49,7 +30,7 @@ gu_new_pool(void);
 
 
 //@private
-GuPool*
+GU_API_DECL GuPool*
 gu_local_pool_(uint8_t* init_buf, size_t sz);
 
 //@private
@@ -75,7 +56,7 @@ gu_local_pool_(uint8_t* init_buf, size_t sz);
  */
 
 /// Create a pool stored in a memory mapped file.
-GuPool* 
+GU_API_DECL GuPool* 
 gu_mmap_pool(char* fpath, void* addr, size_t size, void**pptr);
 
 //@}
@@ -84,7 +65,7 @@ gu_mmap_pool(char* fpath, void* addr, size_t size, void**pptr);
 
 
 /// Free a memory pool and all objects allocated from it.
-void
+GU_API_DECL void
 gu_pool_free(GU_ONLY GuPool* pool);
 /**<
  * When the pool is freed, all finalizers registered by
@@ -100,10 +81,10 @@ gu_pool_free(GU_ONLY GuPool* pool);
  
 
 /// Allocate memory with a specified alignment.
-void* 
+GU_API_DECL void* 
 gu_malloc_aligned(GuPool* pool, size_t size, size_t alignment); 
 
-void*
+GU_API_DECL void*
 gu_malloc_prefixed(GuPool* pool, size_t pre_align, size_t pre_size,
 		   size_t align, size_t size);
 
@@ -173,7 +154,7 @@ struct GuFinalizer {
 };
 
 /// Register a finalizer.
-void gu_pool_finally(GuPool* pool, GuFinalizer* fini);
+GU_API_DECL void gu_pool_finally(GuPool* pool, GuFinalizer* fini);
 
 /**< Register \p fini to be called when \p pool is destroyed. The
  * finalizers are called in reverse order of registration.
@@ -197,7 +178,7 @@ void gu_pool_finally(GuPool* pool, GuFinalizer* fini);
 
 
 /// Allocate a new memory buffer.
-GU_ONLY void*
+GU_API_DECL void*
 gu_mem_buf_alloc(size_t min_size, size_t* real_size);
 /**<
  * @param min_size The minimum acceptable size for a returned memory block.
@@ -210,7 +191,7 @@ gu_mem_buf_alloc(size_t min_size, size_t* real_size);
 
 
 /// Allocate a new memory buffer to replace an old one.
-GU_ONLY void*
+GU_API_DECL void*
 gu_mem_buf_realloc(
 	GU_NULL GU_ONLY GU_RETURNED
 	void* buf,
@@ -219,7 +200,7 @@ gu_mem_buf_realloc(
 
 
 /// Free a memory buffer.
-void
+GU_API_DECL void
 gu_mem_buf_free(GU_ONLY void* buf);
 
 

src/runtime/c/gu/out.c

@@ -65,7 +65,7 @@ gu_out_fini(GuFinalizer* self)
 	}
 }
 
-GuOut*
+GU_API GuOut*
 gu_new_out(GuOutStream* stream, GuPool* pool)
 {
 	gu_require(stream != NULL);
@@ -82,7 +82,6 @@ gu_new_out(GuOutStream* stream, GuPool* pool)
 extern inline bool
 gu_out_try_buf_(GuOut* out, const uint8_t* src, size_t len);
 
-
 extern inline size_t
 gu_out_bytes(GuOut* out, const uint8_t* buf, size_t len, GuExn* err);
 
@@ -96,10 +95,7 @@ gu_out_output(GuOut* out, const uint8_t* src, size_t len, GuExn* err)
 	return out->stream->output(out->stream, src, len, err);
 }
 
-
+GU_API void 
-
-
-void 
 gu_out_flush(GuOut* out, GuExn* err)
 {
 	GuOutStream* stream = out->stream;
@@ -114,7 +110,7 @@ gu_out_flush(GuOut* out, GuExn* err)
 	}
 }
 
-uint8_t*
+GU_API uint8_t*
 gu_out_begin_span(GuOut* out, size_t req, size_t* sz_out, GuExn* err)
 {
 	if (!out->buf_end && !gu_out_begin_buf(out, req, err)) {
@@ -124,7 +120,7 @@ gu_out_begin_span(GuOut* out, size_t req, size_t* sz_out, GuExn* err)
 	return &out->buf_end[out->buf_curr];
 }
 
-void
+GU_API void
 gu_out_end_span(GuOut* out, size_t sz)
 {
 	ptrdiff_t new_curr = (ptrdiff_t) sz + out->buf_curr;
@@ -132,7 +128,7 @@ gu_out_end_span(GuOut* out, size_t sz)
 	out->buf_curr = new_curr;
 }
 
-size_t
+GU_API size_t
 gu_out_bytes_(GuOut* restrict out, const uint8_t* restrict src, size_t len, 
 	      GuExn* err)
 {
@@ -149,8 +145,8 @@ gu_out_bytes_(GuOut* restrict out, const uint8_t* restrict src, size_t len,
 	return gu_out_output(out, src, len, err);
 }
 
-
+GU_API void
-void gu_out_u8_(GuOut* restrict out, uint8_t u, GuExn* err)
+gu_out_u8_(GuOut* restrict out, uint8_t u, GuExn* err)
 {
 	if (gu_out_begin_buf(out, 1, err)) {
 		if (gu_out_try_u8_(out, u)) {
@@ -160,7 +156,6 @@ void gu_out_u8_(GuOut* restrict out, uint8_t u, GuExn* err)
 	gu_out_output(out, &u, 1, err);
 }
 
-
 extern inline void
 gu_out_u8(GuOut* restrict out, uint8_t u, GuExn* err);
 
@@ -222,7 +217,7 @@ gu_buffered_out_flush(GuOutStream* self, GuExn* err)
 	gu_out_flush(bos->real_out, err);
 }
 
-GuOut*
+GU_API GuOut*
 gu_new_buffered_out(GuOut* out, size_t sz, GuPool* pool)
 {
 	GuBufferedOutStream* b =
@@ -238,7 +233,7 @@ gu_new_buffered_out(GuOut* out, size_t sz, GuPool* pool)
 	return gu_new_out(&b->stream, pool);
 }
 
-GuOut*
+GU_API GuOut*
 gu_out_buffered(GuOut* out, GuPool* pool)
 {
 	if (gu_out_is_buffered(out)) {
@@ -251,13 +246,13 @@ gu_out_buffered(GuOut* out, GuPool* pool)
 extern inline void
 gu_putc(char c, GuOut* out, GuExn* err);
 
-void
+GU_API void
 gu_puts(const char* str, GuOut* out, GuExn* err)
 {
 	gu_out_bytes(out, (const uint8_t*) str, strlen(str), err);
 }
 
-void
+GU_API void
 gu_vprintf(const char* fmt, va_list args, GuOut* out, GuExn* err)
 {
 	GuPool* tmp_pool = gu_local_pool();
@@ -274,7 +269,7 @@ gu_vprintf(const char* fmt, va_list args, GuOut* out, GuExn* err)
 	gu_pool_free(tmp_pool);
 }
 
-void
+GU_API void
 gu_printf(GuOut* out, GuExn* err, const char* fmt, ...)
 {
 	va_list args;

src/runtime/c/gu/out.h

@@ -28,7 +28,7 @@ struct GuOut {
 	GuFinalizer fini;
 };
 
-GuOut*
+GU_API_DECL GuOut*
 gu_new_out(GuOutStream* stream, GuPool* pool);
 
 inline bool
@@ -37,23 +37,23 @@ gu_out_is_buffered(GuOut* out)
 	return !!out->stream->begin_buf;
 }
 
-GuOut*
+GU_API_DECL GuOut*
 gu_new_buffered_out(GuOut* out, size_t buf_sz, GuPool* pool);
 
-GuOut*
+GU_API_DECL GuOut*
 gu_out_buffered(GuOut* out, GuPool* pool);
 
-uint8_t*
+GU_API_DECL uint8_t*
 gu_out_begin_span(GuOut* out, size_t req, size_t* sz_out, GuExn* err);
 
-uint8_t*
+GU_API_DECL uint8_t*
 gu_out_force_span(GuOut* out, size_t min, size_t max, size_t* sz_out,
 		  GuExn* err);
 
-void
+GU_API_DECL void
 gu_out_end_span(GuOut* out, size_t sz);
 
-size_t
+GU_API_DECL size_t
 gu_out_bytes_(GuOut* restrict out, const uint8_t* restrict src, 
 	      size_t len, GuExn* err);
 
@@ -81,7 +81,7 @@ gu_out_bytes(GuOut* restrict out, const uint8_t* restrict src, size_t len,
 	return gu_out_bytes_(out, src, len, err);
 }
 
-void
+GU_API_DECL void
 gu_out_flush(GuOut* out, GuExn* err);
 
 inline bool
@@ -113,48 +113,46 @@ gu_out_s8(GuOut* restrict out, int8_t i, GuExn* err)
 	gu_out_u8(out, (uint8_t) i, err);
 }
 
-
+GU_API_DECL void
-
-void
 gu_out_u16le(GuOut* out, uint16_t u, GuExn* err);
 
-void
+GU_API_DECL void
 gu_out_u16be(GuOut* out, uint16_t u, GuExn* err);
 
-void
+GU_API_DECL void
 gu_out_s16le(GuOut* out, int16_t u, GuExn* err);
 
-void
+GU_API_DECL void
 gu_out_s16be(GuOut* out, int16_t u, GuExn* err);
 
-void
+GU_API_DECL void
 gu_out_u32le(GuOut* out, uint32_t u, GuExn* err);
 
-void
+GU_API_DECL void
 gu_out_u32be(GuOut* out, uint32_t u, GuExn* err);
 
-void
+GU_API_DECL void
 gu_out_s32le(GuOut* out, int32_t u, GuExn* err);
 
-void
+GU_API_DECL void
 gu_out_s32be(GuOut* out, int32_t u, GuExn* err);
 
-void
+GU_API_DECL void
 gu_out_u64le(GuOut* out, uint64_t u, GuExn* err);
 
-void
+GU_API_DECL void
 gu_out_u64be(GuOut* out, uint64_t u, GuExn* err);
 
-void
+GU_API_DECL void
 gu_out_s64le(GuOut* out, int64_t u, GuExn* err);
 
-void
+GU_API_DECL void
 gu_out_s64be(GuOut* out, int64_t u, GuExn* err);
 
-void
+GU_API_DECL void
 gu_out_f64le(GuOut* out, double d, GuExn* err);
 
-void
+GU_API_DECL void
 gu_out_f64be(GuOut* out, double d, GuExn* err);
 
 inline void
@@ -164,13 +162,13 @@ gu_putc(char c, GuOut* out, GuExn* err)
 	gu_out_u8(out, (uint8_t) ucs, err);
 }
 
-void
+GU_API_DECL void
 gu_puts(const char* str, GuOut* out, GuExn* err);
 
-void
+GU_API_DECL void
 gu_vprintf(const char* fmt, va_list args, GuOut* out, GuExn* err);
 
-void
+GU_API_DECL void
 gu_printf(GuOut* out, GuExn* err, const char* fmt, ...);
 
 #endif // GU_OUT_H_

src/runtime/c/gu/prime.c

@@ -50,7 +50,7 @@ gu_is_wheel_prime(int u)
 	return true;
 }
 
-int
+GU_INTERNAL int
 gu_prime_inf(int i)
 {
 	if (i < 2) {
@@ -75,7 +75,7 @@ gu_prime_inf(int i)
 	return d;
 }
 
-int
+GU_INTERNAL int
 gu_prime_sup(int i)
 {
 	if (i <= 2) {
@@ -100,7 +100,7 @@ gu_prime_sup(int i)
 	return d;
 }
 
-bool
+GU_INTERNAL bool
 gu_is_prime(int i)
 {
 	if (i < 2) {
@@ -114,13 +114,13 @@ gu_is_prime(int i)
 	}
 }
 
-bool
+GU_INTERNAL bool
 gu_is_twin_prime(int i)
 {
 	return gu_is_prime(i) && gu_is_prime(i - 2);
 }
 
-int
+GU_INTERNAL int
 gu_twin_prime_inf(int i)
 {
 	while (true) {
@@ -135,7 +135,7 @@ gu_twin_prime_inf(int i)
 	return i;
 }
 
-int
+GU_INTERNAL int
 gu_twin_prime_sup(int i)
 {
 	if (i <= 5) {

src/runtime/c/gu/prime.h

@@ -3,14 +3,14 @@
 
 #include <gu/defs.h>
 
-bool gu_is_prime(int i);
+GU_INTERNAL_DECL bool gu_is_prime(int i);
 
-bool gu_is_twin_prime(int i);
+GU_INTERNAL_DECL bool gu_is_twin_prime(int i);
 
-int gu_prime_inf(int i);
+GU_INTERNAL_DECL int gu_prime_inf(int i);
-int gu_twin_prime_inf(int i);
+GU_INTERNAL_DECL int gu_twin_prime_inf(int i);
 
-int gu_prime_sup(int i);
+GU_INTERNAL_DECL int gu_prime_sup(int i);
-int gu_twin_prime_sup(int i);
+GU_INTERNAL_DECL int gu_twin_prime_sup(int i);
 
 #endif // GU_PRIME_H_

src/runtime/c/gu/seq.c

@@ -15,7 +15,7 @@ gu_buf_fini(GuFinalizer* fin)
 		gu_mem_buf_free(buf->seq);
 }
 
-GuBuf*
+GU_API GuBuf*
 gu_make_buf(size_t elem_size, GuPool* pool)
 {
 	GuBuf* buf = gu_new(GuBuf, pool);
@@ -50,12 +50,12 @@ gu_buf_flush(GuBuf* buf);
 
 static GuSeq gu_empty_seq_ = {0};
 
-GuSeq*
+GU_API GuSeq*
 gu_empty_seq() {
 	return &gu_empty_seq_;
 }
 
-GuSeq*
+GU_API GuSeq*
 gu_make_seq(size_t elem_size, size_t length, GuPool* pool)
 {
 	GuSeq* seq = gu_malloc(pool, sizeof(GuSeq) + elem_size * length);
@@ -69,7 +69,7 @@ gu_seq_length(GuSeq* seq);
 extern void*
 gu_seq_data(GuSeq* seq);
 
-GuSeq*
+GU_API GuSeq*
 gu_alloc_seq_(size_t elem_size, size_t length)
 {
 	if (length == 0)
@@ -81,7 +81,7 @@ gu_alloc_seq_(size_t elem_size, size_t length)
 	return seq;
 }
 
-GuSeq*
+GU_API GuSeq*
 gu_realloc_seq_(GuSeq* seq, size_t elem_size, size_t length)
 {
 	size_t real_size;
@@ -92,7 +92,7 @@ gu_realloc_seq_(GuSeq* seq, size_t elem_size, size_t length)
 	return new_seq;
 }
 
-void
+GU_API void
 gu_seq_free(GuSeq* seq)
 {
 	if (seq == NULL || seq == gu_empty_seq())
@@ -100,7 +100,7 @@ gu_seq_free(GuSeq* seq)
 	gu_mem_buf_free(seq);
 }
 
-void
+GU_API void
 gu_buf_require(GuBuf* buf, size_t req_len)
 {
 	if (req_len <= buf->avail_len) {
@@ -120,7 +120,7 @@ gu_buf_require(GuBuf* buf, size_t req_len)
 	buf->avail_len = (real_size - sizeof(GuSeq)) / buf->elem_size;
 }
 
-void*
+GU_API void*
 gu_buf_extend_n(GuBuf* buf, size_t n_elems)
 {
 	size_t len = gu_buf_length(buf);
@@ -130,14 +130,14 @@ gu_buf_extend_n(GuBuf* buf, size_t n_elems)
 	return &buf->seq->data[buf->elem_size * len];
 }
 
-void
+GU_API void
 gu_buf_push_n(GuBuf* buf, const void* data, size_t n_elems)
 {
 	void* p = gu_buf_extend_n(buf, n_elems);
 	memcpy(p, data, buf->elem_size * n_elems);
 }
 
-const void*
+GU_API const void*
 gu_buf_trim_n(GuBuf* buf, size_t n_elems)
 {
 	gu_require(n_elems <= gu_buf_length(buf));
@@ -146,14 +146,14 @@ gu_buf_trim_n(GuBuf* buf, size_t n_elems)
 	return &buf->seq->data[buf->elem_size * new_len];
 }
 
-void
+GU_API void
 gu_buf_pop_n(GuBuf* buf, size_t n_elems, void* data_out)
 {
 	const void* p = gu_buf_trim_n(buf, n_elems);
 	memcpy(data_out, p, buf->elem_size * n_elems);
 }
 
-GuSeq*
+GU_API GuSeq*
 gu_buf_freeze(GuBuf* buf, GuPool* pool)
 {
 	size_t len = gu_buf_length(buf);
@@ -164,7 +164,7 @@ gu_buf_freeze(GuBuf* buf, GuPool* pool)
 	return seq;
 }
 
-void*
+GU_API void*
 gu_buf_insert(GuBuf* buf, size_t index)
 {
 	size_t len = buf->seq->len;
@@ -225,13 +225,13 @@ gu_quick_sort(GuBuf *buf, GuOrder *order, int left, int right)
 		gu_quick_sort(buf, order, index+1, right);
 }
 
-void
+GU_API void
 gu_buf_sort(GuBuf *buf, GuOrder *order)
 {
 	gu_quick_sort(buf, order, 0, gu_buf_length(buf) - 1);
 }
 
-void*
+GU_API void*
 gu_seq_binsearch_(GuSeq *seq, GuOrder *order, size_t elem_size, const void *key)
 {
 	int i = 0;
@@ -254,7 +254,7 @@ gu_seq_binsearch_(GuSeq *seq, GuOrder *order, size_t elem_size, const void *key)
 	return NULL;
 }
 
-bool
+GU_API bool
 gu_seq_binsearch_index_(GuSeq *seq, GuOrder *order, size_t elem_size,
                         const void *key, size_t *pindex)
 {
@@ -324,14 +324,14 @@ gu_heap_siftup(GuBuf *buf, GuOrder *order,
    gu_heap_siftdown(buf, order, value, startpos, pos);
 }
 
-void
+GU_API void
 gu_buf_heap_push(GuBuf *buf, GuOrder *order, void *value)
 {
 	gu_buf_extend(buf);
 	gu_heap_siftdown(buf, order, value, 0, gu_buf_length(buf)-1);
 }
 
-void
+GU_API void
 gu_buf_heap_pop(GuBuf *buf, GuOrder *order, void* data_out)
 {
 	const void* last = gu_buf_trim(buf); // raises an error if empty
@@ -344,7 +344,7 @@ gu_buf_heap_pop(GuBuf *buf, GuOrder *order, void* data_out)
 	}
 }
 
-void
+GU_API void
 gu_buf_heap_replace(GuBuf *buf, GuOrder *order, void *value, void *data_out)
 {
 	gu_require(gu_buf_length(buf) > 0);
@@ -353,7 +353,7 @@ gu_buf_heap_replace(GuBuf *buf, GuOrder *order, void *value, void *data_out)
 	gu_heap_siftup(buf, order, value, 0);
 }
 
-void
+GU_API void
 gu_buf_heapify(GuBuf *buf, GuOrder *order)
 {
 	size_t middle = gu_buf_length(buf) / 2;

src/runtime/c/gu/string.c

@@ -49,7 +49,7 @@ gu_string_buf_end(GuOutStream* stream, size_t sz, GuExn* err)
 	sbuf->buf->seq->len = len + sz;
 }
 
-GuStringBuf*
+GU_API GuStringBuf*
 gu_new_string_buf(GuPool* pool)
 {
 	GuStringBuf* sbuf = gu_new(GuStringBuf, pool);
@@ -62,13 +62,13 @@ gu_new_string_buf(GuPool* pool)
 	return sbuf;
 }
 
-GuOut*
+GU_API GuOut*
 gu_string_buf_out(GuStringBuf* sb)
 {
 	return sb->out;
 }
 
-GuString
+GU_API GuString
 gu_string_buf_freeze(GuStringBuf* sb, GuPool* pool)
 {
 	gu_out_flush(sb->out, NULL);
@@ -82,33 +82,33 @@ gu_string_buf_freeze(GuStringBuf* sb, GuPool* pool)
 	return p;
 }
 
-char*
+GU_API char*
 gu_string_buf_data(GuStringBuf* sb)
 {
 	gu_out_flush(sb->out, NULL);
 	return gu_buf_data(sb->buf);
 }
 
-size_t
+GU_API size_t
 gu_string_buf_length(GuStringBuf* sb)
 {
 	gu_out_flush(sb->out, NULL);
 	return gu_buf_length(sb->buf);
 }
 
-void
+GU_API void
 gu_string_buf_flush(GuStringBuf* sb)
 {
 	gu_buf_flush(sb->buf);
 }
 
-GuIn*
+GU_API GuIn*
 gu_string_in(GuString s, GuPool* pool)
 {
 	return gu_data_in((uint8_t*) s, strlen(s), pool);
 }
 
-GuString
+GU_API GuString
 gu_string_copy(GuString string, GuPool* pool)
 {
 	size_t len = strlen(string);
@@ -117,13 +117,13 @@ gu_string_copy(GuString string, GuPool* pool)
 	return p;
 }
 
-void
+GU_API void
 gu_string_write(GuString s, GuOut* out, GuExn* err)
 {
 	gu_out_bytes(out, (uint8_t*) s, strlen(s), err);
 }
 
-GuString
+GU_API GuString
 gu_string_read(size_t len, GuPool* pool, GuIn* in, GuExn* err)
 {
 	char* buf = alloca(len*6+1);
@@ -139,7 +139,7 @@ gu_string_read(size_t len, GuPool* pool, GuIn* in, GuExn* err)
 	return p;
 }
 
-GuString
+GU_API GuString
 gu_string_read_latin1(size_t len, GuPool* pool, GuIn* in, GuExn* err)
 {
 	char* p = gu_malloc_aligned(pool, len+1, 2);
@@ -148,7 +148,7 @@ gu_string_read_latin1(size_t len, GuPool* pool, GuIn* in, GuExn* err)
 	return p;
 }
 
-GuString
+GU_API GuString
 gu_format_string_v(const char* fmt, va_list args, GuPool* pool)
 {
 	GuPool* tmp_pool = gu_local_pool();
@@ -161,7 +161,7 @@ gu_format_string_v(const char* fmt, va_list args, GuPool* pool)
 	return s;
 }
 
-GuString
+GU_API GuString
 gu_format_string(GuPool* pool, const char* fmt, ...)
 {
 	va_list args;
@@ -171,7 +171,7 @@ gu_format_string(GuPool* pool, const char* fmt, ...)
 	return s;
 }
 
-bool
+GU_API bool
 gu_string_to_int(GuString s, int *res)
 {
 	bool neg = false;
@@ -195,7 +195,7 @@ gu_string_to_int(GuString s, int *res)
 	return true;
 }
 
-bool
+GU_API bool
 gu_string_to_double(GuString s, double *res)
 {
 	bool neg = false;
@@ -231,7 +231,7 @@ gu_string_to_double(GuString s, double *res)
 	return true;
 }
 
-void
+GU_API void
 gu_double_to_string(double val, GuOut* out, GuExn* err)
 {
 	int ival = (int) val;
@@ -254,7 +254,7 @@ gu_double_to_string(double val, GuOut* out, GuExn* err)
 	}
 }
 
-bool
+GU_API bool
 gu_string_is_prefix(GuString s1, GuString s2)
 {
 	size_t len1 = strlen(s1);
@@ -274,7 +274,7 @@ gu_string_is_prefix(GuString s1, GuString s2)
 	return true;
 }
 
-GuHash
+GU_API GuHash
 gu_string_hash(GuHash h, GuString s)
 {
 	return gu_hash_bytes(h, (uint8_t*)s, strlen(s));
@@ -287,7 +287,7 @@ gu_string_eq_fn(GuEquality* self, const void* p1, const void* p2)
 	return strcmp((GuString) p1, (GuString) p2) == 0;
 }
 
-GU_API_DATA GuEquality gu_string_equality[1] = { { gu_string_eq_fn } };
+GU_API GuEquality gu_string_equality[1] = { { gu_string_eq_fn } };
 
 static int
 gu_string_cmp_fn(GuOrder* self, const void* p1, const void* p2)
@@ -296,7 +296,7 @@ gu_string_cmp_fn(GuOrder* self, const void* p1, const void* p2)
 	return strcmp((GuString) p1, (GuString) p2);
 }
 
-GU_API_DATA GuOrder gu_string_order[1] = { { gu_string_cmp_fn } };
+GU_API GuOrder gu_string_order[1] = { { gu_string_cmp_fn } };
 
 static GuHash
 gu_string_hasher_hash(GuHasher* self, const void* p)
@@ -305,7 +305,7 @@ gu_string_hasher_hash(GuHasher* self, const void* p)
 	return gu_string_hash(0, (GuString) p);
 }
 
-GU_API_DATA GuHasher gu_string_hasher[1] = {
+GU_API GuHasher gu_string_hasher[1] = {
 	{
 		.eq = { gu_string_eq_fn },
 		.hash = gu_string_hasher_hash

src/runtime/c/gu/string.h

@@ -7,75 +7,75 @@
 
 typedef const char* GuString;
 
-GuString
+GU_API_DECL GuString
 gu_string_copy(GuString string, GuPool* pool);
 
-void
+GU_API_DECL void
 gu_string_write(GuString string, GuOut* out, GuExn* err);
 
-GuString
+GU_API_DECL GuString
 gu_string_read(size_t len, GuPool* pool, GuIn* in, GuExn* err);
 
-GuString
+GU_API_DECL GuString
 gu_string_read_latin1(size_t len, GuPool* pool, GuIn* in, GuExn* err);
 
-GuIn*
+GU_API_DECL GuIn*
 gu_string_in(GuString string, GuPool* pool);
 
 typedef struct GuStringBuf GuStringBuf;
 
-GuStringBuf*
+GU_API_DECL GuStringBuf*
 gu_new_string_buf(GuPool* pool);
 
-GuOut*
+GU_API_DECL GuOut*
 gu_string_buf_out(GuStringBuf* sb);
 
-GuString
+GU_API_DECL GuString
 gu_string_buf_freeze(GuStringBuf* sb, GuPool* pool);
 
-char*
+GU_API_DECL char*
 gu_string_buf_data(GuStringBuf* sb);
 
-size_t
+GU_API_DECL size_t
 gu_string_buf_length(GuStringBuf* sb);
 
-void
+GU_API_DECL void
 gu_string_buf_flush(GuStringBuf* sb);
 
-GuString
+GU_API_DECL GuString
 gu_format_string_v(const char* fmt, va_list args, GuPool* pool);
 
-GuString
+GU_API_DECL GuString
 gu_format_string(GuPool* pool, const char* fmt, ...);
 
-bool
+GU_API_DECL bool
 gu_string_to_int(GuString s, int *res);
 
-bool
+GU_API_DECL bool
 gu_string_to_double(GuString s, double *res);
 
-void
+GU_API_DECL void
 gu_double_to_string(double val, GuOut* out, GuExn* err);
 
-bool
+GU_API_DECL bool
 gu_string_is_prefix(GuString s1, GuString s2);
 
 #endif // GU_STRING_H_
 
 #if defined(GU_FUN_H_) && !defined(GU_STRING_H_FUN_)
 #define GU_STRING_H_FUN_
-GU_API_DATA_DECL GuEquality gu_string_equality[1];
+GU_API_DECL extern GuEquality gu_string_equality[1];
 
-GU_API_DATA_DECL GuOrder gu_string_order[1];
+GU_API_DECL extern GuOrder gu_string_order[1];
 #endif
 
 #if defined(GU_HASH_H_) && !defined(GU_STRING_H_HASH_)
 #define GU_STRING_H_HASH_
 
-GuHash
+GU_API_DECL GuHash
 gu_string_hash(GuHash h, GuString s);
 
-GU_API_DATA GuHasher gu_string_hasher[1];
+GU_API_DECL extern GuHasher gu_string_hasher[1];
 #endif
 
 #if defined(GU_SEQ_H_) && !defined(GU_STRING_H_SEQ_)

src/runtime/c/gu/ucs.c

@@ -2,7 +2,7 @@
 #include <gu/assert.h>
 #include <stdlib.h>
 
-bool
+GU_API bool
 gu_char_is_valid(char c)
 {
 	if (c < 0) {
@@ -18,7 +18,7 @@ gu_char_is_valid(char c)
 	return UINT64_C(0x7ffffffefffffffe) & (UINT64_C(1) << (c - 64));
 }
 
-char
+GU_API char
 gu_ucs_char(GuUCS uc, GuExn* err)
 {
 	if (0 <= uc && uc <= 127) {
@@ -31,7 +31,7 @@ gu_ucs_char(GuUCS uc, GuExn* err)
 	return 0;
 }
 
-size_t
+GU_API size_t
 gu_str_to_ucs(const char* cbuf, size_t len, GuUCS* ubuf, GuExn* err)
 {
 	size_t n = 0;
@@ -47,7 +47,7 @@ gu_str_to_ucs(const char* cbuf, size_t len, GuUCS* ubuf, GuExn* err)
 	return n;
 }
 
-size_t
+GU_API size_t
 gu_ucs_to_str(const GuUCS* ubuf, size_t len, char* cbuf, GuExn* err)
 {
 	size_t n = 0;
@@ -66,7 +66,7 @@ gu_ucs_to_str(const GuUCS* ubuf, size_t len, char* cbuf, GuExn* err)
 extern inline bool
 gu_ucs_valid(GuUCS ucs);
 
-GuUCS
+GU_API GuUCS
 gu_char_ucs(char c)
 {
 	gu_require(gu_char_is_valid(c));
@@ -4789,14 +4789,14 @@ bool gu_ucs_is_space(GuUCS c)
 }
 
 
-unipred(gu_ucs_is_cntrl,GENCAT_CC)
+GU_API unipred(gu_ucs_is_cntrl,GENCAT_CC)
-unipred(gu_ucs_is_print, (GENCAT_MC | GENCAT_NO | GENCAT_SK | GENCAT_ME | GENCAT_ND |   GENCAT_PO | GENCAT_LT | GENCAT_PC | GENCAT_SM | GENCAT_ZS |   GENCAT_LU | GENCAT_PD | GENCAT_SO | GENCAT_PE | GENCAT_PF |   GENCAT_PS | GENCAT_SC | GENCAT_LL | GENCAT_LM | GENCAT_PI |   GENCAT_NL | GENCAT_MN | GENCAT_LO))
+GU_API unipred(gu_ucs_is_print, (GENCAT_MC | GENCAT_NO | GENCAT_SK | GENCAT_ME | GENCAT_ND |   GENCAT_PO | GENCAT_LT | GENCAT_PC | GENCAT_SM | GENCAT_ZS |   GENCAT_LU | GENCAT_PD | GENCAT_SO | GENCAT_PE | GENCAT_PF |   GENCAT_PS | GENCAT_SC | GENCAT_LL | GENCAT_LM | GENCAT_PI |   GENCAT_NL | GENCAT_MN | GENCAT_LO))
-unipred(gu_ucs_is_upper,(GENCAT_LU|GENCAT_LT))
+GU_API unipred(gu_ucs_is_upper,(GENCAT_LU|GENCAT_LT))
-unipred(gu_ucs_is_lower,GENCAT_LL)
+GU_API unipred(gu_ucs_is_lower,GENCAT_LL)
-unipred(gu_ucs_is_alpha,(GENCAT_LL|GENCAT_LU|GENCAT_LT|GENCAT_LM|GENCAT_LO))
+GU_API unipred(gu_ucs_is_alpha,(GENCAT_LL|GENCAT_LU|GENCAT_LT|GENCAT_LM|GENCAT_LO))
-unipred(gu_ucs_is_digit,GENCAT_ND)
+GU_API unipred(gu_ucs_is_digit,GENCAT_ND)
 
-unipred(gu_ucs_is_alnum,(GENCAT_LT|GENCAT_LU|GENCAT_LL|GENCAT_LM|GENCAT_LO|
+GU_API unipred(gu_ucs_is_alnum,(GENCAT_LT|GENCAT_LU|GENCAT_LL|GENCAT_LM|GENCAT_LO|
 		    GENCAT_MC|GENCAT_ME|GENCAT_MN|
 		    GENCAT_NO|GENCAT_ND|GENCAT_NL))
 
@@ -4808,11 +4808,11 @@ GuUCS p(GuUCS c) \
 	return c+rule->to;\
 }
 
-caseconv(gu_ucs_to_upper,updist)
+GU_API caseconv(gu_ucs_to_upper,updist)
-caseconv(gu_ucs_to_lower,lowdist)
+GU_API caseconv(gu_ucs_to_lower,lowdist)
-caseconv(gu_ucs_to_title,titledist)
+GU_API caseconv(gu_ucs_to_title,titledist)
 
-int gu_ucs_gen_cat(GuUCS c)
+GU_API int gu_ucs_gen_cat(GuUCS c)
 {
 	return getrule(allchars,NUM_BLOCKS,c)->catnumber;
 }

src/runtime/c/gu/ucs.h

@@ -15,7 +15,7 @@ typedef int32_t GuUCS;
 
 #define GU_UCS_MAX ((GuUCS)(0x10FFFF))
 
-bool
+GU_API_DECL bool
 gu_char_is_valid(char c);
 
 inline bool
@@ -24,32 +24,32 @@ gu_ucs_valid(GuUCS ucs)
 	return ucs >= 0 && ucs <= GU_UCS_MAX;
 }
 
-GuUCS
+GU_API_DECL GuUCS
 gu_char_ucs(char c);
 
-char
+GU_API_DECL char
 gu_ucs_char(GuUCS uc, GuExn* err);
 
-size_t
+GU_API_DECL size_t
 gu_str_to_ucs(const char* cbuf, size_t len, GuUCS* ubuf, GuExn* err);
 
-size_t
+GU_API_DECL size_t
 gu_ucs_to_str(const GuUCS* ubuf, size_t len, char* cbuf, GuExn* err);
 
-bool gu_ucs_is_upper(GuUCS c);
+GU_API_DECL bool gu_ucs_is_upper(GuUCS c);
-bool gu_ucs_is_digit(GuUCS c);
+GU_API_DECL bool gu_ucs_is_digit(GuUCS c);
-bool gu_ucs_is_alpha(GuUCS c);
+GU_API_DECL bool gu_ucs_is_alpha(GuUCS c);
-bool gu_ucs_is_cntrl(GuUCS c);
+GU_API_DECL bool gu_ucs_is_cntrl(GuUCS c);
-bool gu_ucs_is_space(GuUCS c);
+GU_API_DECL bool gu_ucs_is_space(GuUCS c);
-bool gu_ucs_is_print(GuUCS c);
+GU_API_DECL bool gu_ucs_is_print(GuUCS c);
-bool gu_ucs_is_lower(GuUCS c);
+GU_API_DECL bool gu_ucs_is_lower(GuUCS c);
 
-bool gu_ucs_is_alnum(GuUCS c);
+GU_API_DECL bool gu_ucs_is_alnum(GuUCS c);
 
-GuUCS gu_ucs_to_lower(GuUCS c);
+GU_API_DECL GuUCS gu_ucs_to_lower(GuUCS c);
-GuUCS gu_ucs_to_upper(GuUCS c);
+GU_API_DECL GuUCS gu_ucs_to_upper(GuUCS c);
-GuUCS gu_ucs_to_title(GuUCS c);
+GU_API_DECL GuUCS gu_ucs_to_title(GuUCS c);
 
-int gu_ucs_is_gencat(GuUCS wc);
+GU_API_DECL int gu_ucs_is_gencat(GuUCS wc);
 
 #endif // GU_ISO10646_H_

src/runtime/c/gu/utf8.c

@@ -1,7 +1,7 @@
 #include <gu/assert.h>
 #include <gu/utf8.h>
 
-GuUCS
+GU_API GuUCS
 gu_utf8_decode(const uint8_t** src_inout)
 {
 	const uint8_t* src = *src_inout;
@@ -26,7 +26,7 @@ gu_utf8_decode(const uint8_t** src_inout)
 	return (GuUCS) u;
 }
 
-GuUCS
+GU_API GuUCS
 gu_in_utf8_(GuIn* in, GuExn* err)
 {
 	uint8_t c = gu_in_u8(in, err);
@@ -79,7 +79,7 @@ fail:
 extern inline GuUCS
 gu_in_utf8(GuIn* in, GuExn* err);
 
-void
+GU_API void
 gu_in_utf8_buf(uint8_t** buf, GuIn* in, GuExn* err)
 {
 	uint8_t* p = *buf;
@@ -122,7 +122,7 @@ fail:
 	return;
 }
 
-void
+GU_API void
 gu_utf8_encode(GuUCS ucs, uint8_t** buf)
 {
 	gu_require(gu_ucs_valid(ucs));
@@ -163,7 +163,7 @@ gu_utf8_encode(GuUCS ucs, uint8_t** buf)
 	}
 }
 
-void
+GU_API void
 gu_out_utf8_(GuUCS ucs, GuOut* out, GuExn* err)
 {
 	uint8_t buf[6];

src/runtime/c/gu/utf8.h

@@ -31,13 +31,13 @@ gu_out_utf8(GuUCS ucs, GuOut* out, GuExn* err)
 
 // Helper functions used in other modules
 
-GuUCS
+GU_API_DECL GuUCS
 gu_utf8_decode(const uint8_t** buf);
 
-void
+GU_API_DECL void
 gu_utf8_encode(GuUCS ucs, uint8_t** buf);
 
-void
+GU_API_DECL void
 gu_in_utf8_buf(uint8_t** buf, GuIn* in, GuExn* err);
 
 #endif // GU_UTF8_H_

src/runtime/c/gu/variant.c

@@ -1,22 +1,3 @@
-/* 
- * Copyright 2010 University of Helsinki.
- *   
- * This file is part of libgu.
- * 
- * Libgu is free software: you can redistribute it and/or modify it under
- * the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or (at your
- * option) any later version.
- * 
- * Libgu is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- * License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with libgu. If not, see <http://www.gnu.org/licenses/>.
- */
-
 #include "variant.h"
 #include "bits.h"
 
@@ -24,7 +5,7 @@ enum {
 	GU_VARIANT_ALIGNMENT = sizeof(uintptr_t)
 };
 
-void* 
+GU_API void*
 gu_alloc_variant(uint8_t tag, size_t size, 
 		 size_t align, GuVariant* variant_out, GuPool* pool)
 {
@@ -41,7 +22,7 @@ gu_alloc_variant(uint8_t tag, size_t size,
 	return p;
 }
 
-GuVariant 
+GU_API GuVariant 
 gu_make_variant(uint8_t tag, size_t size, size_t align, const void* init,
 		GuPool* pool)
 {
@@ -51,7 +32,7 @@ gu_make_variant(uint8_t tag, size_t size, size_t align, const void* init,
 	return v;
 }
 
-int
+GU_API int
 gu_variant_tag(GuVariant variant)
 {
 	if (gu_variant_is_null(variant)) {
@@ -65,7 +46,7 @@ gu_variant_tag(GuVariant variant)
 	return u - 1;
 }
 
-void*
+GU_API void*
 gu_variant_data(GuVariant variant)
 {
 	if (gu_variant_is_null(variant)) {
@@ -74,7 +55,8 @@ gu_variant_data(GuVariant variant)
 	return (void*)gu_align_backward(variant, GU_VARIANT_ALIGNMENT);
 }
 
-GuVariantInfo gu_variant_open(GuVariant variant)
+GU_API GuVariantInfo
+gu_variant_open(GuVariant variant)
 {
 	GuVariantInfo info = {
 		.tag = gu_variant_tag(variant),
@@ -83,7 +65,8 @@ GuVariantInfo gu_variant_open(GuVariant variant)
 	return info;
 }
 
-GuVariant gu_variant_close(GuVariantInfo info)
+GU_API GuVariant
+gu_variant_close(GuVariantInfo info)
 {
 	GuVariant variant;
 
@@ -97,7 +80,7 @@ GuVariant gu_variant_close(GuVariantInfo info)
 	return variant;
 }
 
-int 
+GU_API int 
 gu_variant_intval(GuVariant variant)
 {
 	int u = variant % GU_VARIANT_ALIGNMENT;
@@ -108,4 +91,4 @@ gu_variant_intval(GuVariant variant)
 	return (variant / GU_VARIANT_ALIGNMENT);
 }
 
-GU_API_DATA const GuVariant gu_null_variant = { (GuWord) NULL };
+GU_API const GuVariant gu_null_variant = { (GuWord) NULL };

src/runtime/c/gu/variant.h

@@ -97,7 +97,7 @@ gu_variant_from_ptr(const void* p)
 	return (uintptr_t) p;
 }
 
-GU_API_DATA_DECL const GuVariant gu_null_variant;
+GU_API_DECL extern const GuVariant gu_null_variant;
 
 static inline bool
 gu_variant_is_null(GuVariant v) {