From 5c93f2fba5eadaa1e516106c08d495c14a0eb647 Mon Sep 17 00:00:00 2001 From: krasimir Date: Wed, 19 Apr 2017 12:30:40 +0000 Subject: [PATCH] in libgu mark explicitly all functions that belong to the API --- src/runtime/c/gu/assert.c | 9 +++---- src/runtime/c/gu/assert.h | 6 ++--- src/runtime/c/gu/bits.c | 5 ++-- src/runtime/c/gu/bits.h | 3 ++- src/runtime/c/gu/choice.c | 10 ++++---- src/runtime/c/gu/choice.h | 10 ++++---- src/runtime/c/gu/defs.c | 2 +- src/runtime/c/gu/defs.h | 36 ++++++++------------------ src/runtime/c/gu/enum.c | 2 +- src/runtime/c/gu/enum.h | 2 +- src/runtime/c/gu/exn.c | 16 ++++++------ src/runtime/c/gu/exn.h | 16 ++++++------ src/runtime/c/gu/file.c | 4 +-- src/runtime/c/gu/file.h | 4 +-- src/runtime/c/gu/hash.c | 8 +++--- src/runtime/c/gu/hash.h | 8 +++--- src/runtime/c/gu/in.c | 48 +++++++++++++++++------------------ src/runtime/c/gu/in.h | 43 +++++++++++++++---------------- src/runtime/c/gu/map.c | 18 ++++++------- src/runtime/c/gu/map.h | 20 +++++++-------- src/runtime/c/gu/mem.c | 26 +++++++++---------- src/runtime/c/gu/mem.h | 37 +++++++-------------------- src/runtime/c/gu/out.c | 29 +++++++++------------ src/runtime/c/gu/out.h | 52 ++++++++++++++++++-------------------- src/runtime/c/gu/prime.c | 12 ++++----- src/runtime/c/gu/prime.h | 12 ++++----- src/runtime/c/gu/seq.c | 40 ++++++++++++++--------------- src/runtime/c/gu/string.c | 42 +++++++++++++++--------------- src/runtime/c/gu/string.h | 42 +++++++++++++++--------------- src/runtime/c/gu/ucs.c | 32 +++++++++++------------ src/runtime/c/gu/ucs.h | 34 ++++++++++++------------- src/runtime/c/gu/utf8.c | 10 ++++---- src/runtime/c/gu/utf8.h | 6 ++--- src/runtime/c/gu/variant.c | 37 ++++++++------------------- src/runtime/c/gu/variant.h | 2 +- 35 files changed, 311 insertions(+), 372 deletions(-) diff --git a/src/runtime/c/gu/assert.c b/src/runtime/c/gu/assert.c index e111912d3..ff2ab1355 100644 --- a/src/runtime/c/gu/assert.c +++ b/src/runtime/c/gu/assert.c @@ -3,7 +3,7 @@ #include #include -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, ...) @@ -36,9 +36,8 @@ gu_abort_(GuAssertMode mode, gu_abort_v_(mode, file, func, line, msg_fmt, args); va_end(args); } - -void +GU_API void gu_fatal(const char* fmt, ...) { va_list args; diff --git a/src/runtime/c/gu/assert.h b/src/runtime/c/gu/assert.h index 9d7ecc15f..a49d64748 100644 --- a/src/runtime/c/gu/assert.h +++ b/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_ */ diff --git a/src/runtime/c/gu/bits.c b/src/runtime/c/gu/bits.c index 6197983cc..8c43b8477 100644 --- a/src/runtime/c/gu/bits.c +++ b/src/runtime/c/gu/bits.c @@ -7,7 +7,8 @@ #include #include -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; diff --git a/src/runtime/c/gu/bits.h b/src/runtime/c/gu/bits.h index be8457b0a..edf6a0049 100644 --- a/src/runtime/c/gu/bits.h +++ b/src/runtime/c/gu/bits.h @@ -13,6 +13,7 @@ * */ +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); diff --git a/src/runtime/c/gu/choice.c b/src/runtime/c/gu/choice.c index ed1e02a51..5102e15e9 100644 --- a/src/runtime/c/gu/choice.c +++ b/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)); diff --git a/src/runtime/c/gu/choice.h b/src/runtime/c/gu/choice.h index aea76dde8..976bdce47 100644 --- a/src/runtime/c/gu/choice.h +++ b/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); diff --git a/src/runtime/c/gu/defs.c b/src/runtime/c/gu/defs.c index 5e78e797b..ec1098433 100644 --- a/src/runtime/c/gu/defs.c +++ b/src/runtime/c/gu/defs.c @@ -1,4 +1,4 @@ #include void* const gu_null = NULL; -GU_API_DATA GuStruct* const gu_null_struct = NULL; +GU_API GuStruct* const gu_null_struct = NULL; diff --git a/src/runtime/c/gu/defs.h b/src/runtime/c/gu/defs.h index f302481d6..9c19978f4 100644 --- a/src/runtime/c/gu/defs.h +++ b/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 . - */ - /** @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_DATA __declspec(dllexport) +#define GU_API_DECL __declspec(dllexport) +#define GU_API __declspec(dllexport) #else -#define GU_API_DATA_DECL __declspec(dllimport) -#define GU_API_DATA ERROR_NOT_COMPILING_LIBGU +#define GU_API_DECL __declspec(dllimport) +#define GU_API ERROR_NOT_COMPILING_LIBGU #endif #else -#define GU_API_DATA_DECL extern -#define GU_API_DATA +#define GU_API_DECL +#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; diff --git a/src/runtime/c/gu/enum.c b/src/runtime/c/gu/enum.c index fa8595a55..538ef0dbc 100644 --- a/src/runtime/c/gu/enum.c +++ b/src/runtime/c/gu/enum.c @@ -1,6 +1,6 @@ #include -void +GU_API void gu_enum_next(GuEnum* en, void* to, GuPool* pool) { en->next(en, to, pool); diff --git a/src/runtime/c/gu/enum.h b/src/runtime/c/gu/enum.h index 88cd5ba6a..92f5d69f6 100644 --- a/src/runtime/c/gu/enum.h +++ b/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 diff --git a/src/runtime/c/gu/exn.c b/src/runtime/c/gu/exn.c index 1b8b4f4a5..c6c7652d6 100644 --- a/src/runtime/c/gu/exn.c +++ b/src/runtime/c/gu/exn.c @@ -2,7 +2,7 @@ #include -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); diff --git a/src/runtime/c/gu/exn.h b/src/runtime/c/gu/exn.h index 14f77dbcf..6f5d0ff38 100644 --- a/src/runtime/c/gu/exn.h +++ b/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); /** @} */ diff --git a/src/runtime/c/gu/file.c b/src/runtime/c/gu/file.c index f51eb1ca1..c5a9f6912 100644 --- a/src/runtime/c/gu/file.c +++ b/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); diff --git a/src/runtime/c/gu/file.h b/src/runtime/c/gu/file.h index 1bb3fb00a..9636b8383 100644 --- a/src/runtime/c/gu/file.h +++ b/src/runtime/c/gu/file.h @@ -5,10 +5,10 @@ #include #include -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_ diff --git a/src/runtime/c/gu/hash.c b/src/runtime/c/gu/hash.c index 0057d0f42..9813471d7 100644 --- a/src/runtime/c/gu/hash.c +++ b/src/runtime/c/gu/hash.c @@ -1,6 +1,6 @@ #include -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 diff --git a/src/runtime/c/gu/hash.h b/src/runtime/c/gu/hash.h index fb688af01..c222e26b3 100644 --- a/src/runtime/c/gu/hash.h +++ b/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_ diff --git a/src/runtime/c/gu/in.c b/src/runtime/c/gu/in.c index 3f28d9ba1..b36df7924 100644 --- a/src/runtime/c/gu/in.c +++ b/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); } - -uint32_t +GU_API 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); } - -uint64_t +GU_API 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); diff --git a/src/runtime/c/gu/in.h b/src/runtime/c/gu/in.h index 91c40a42a..64d8ef2cd 100644 --- a/src/runtime/c/gu/in.h +++ b/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); diff --git a/src/runtime/c/gu/map.c b/src/runtime/c/gu/map.c index 477bcef08..9abebbe6e 100644 --- a/src/runtime/c/gu/map.c +++ b/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, diff --git a/src/runtime/c/gu/map.h b/src/runtime/c/gu/map.h index 50af70572..ffd937a01 100644 --- a/src/runtime/c/gu/map.h +++ b/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; diff --git a/src/runtime/c/gu/mem.c b/src/runtime/c/gu/mem.c index 325eaea77..3e5bd57a2 100644 --- a/src/runtime/c/gu/mem.c +++ b/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); } - -void +GU_API 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; diff --git a/src/runtime/c/gu/mem.h b/src/runtime/c/gu/mem.h index bec8ffa44..04fd0ede5 100644 --- a/src/runtime/c/gu/mem.h +++ b/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 . - */ - /** @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); diff --git a/src/runtime/c/gu/out.c b/src/runtime/c/gu/out.c index d08b192dc..7a287cadb 100644 --- a/src/runtime/c/gu/out.c +++ b/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); } - - - -void +GU_API 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); } - -void gu_out_u8_(GuOut* restrict out, uint8_t u, GuExn* err) +GU_API void +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; diff --git a/src/runtime/c/gu/out.h b/src/runtime/c/gu/out.h index 103eb95a2..3435d3e34 100644 --- a/src/runtime/c/gu/out.h +++ b/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); } - - -void +GU_API_DECL 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_ diff --git a/src/runtime/c/gu/prime.c b/src/runtime/c/gu/prime.c index 6452f8777..195215bee 100644 --- a/src/runtime/c/gu/prime.c +++ b/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) { diff --git a/src/runtime/c/gu/prime.h b/src/runtime/c/gu/prime.h index 2ae0617f8..1118878a8 100644 --- a/src/runtime/c/gu/prime.h +++ b/src/runtime/c/gu/prime.h @@ -3,14 +3,14 @@ #include -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); -int gu_twin_prime_inf(int i); +GU_INTERNAL_DECL int gu_prime_inf(int i); +GU_INTERNAL_DECL int gu_twin_prime_inf(int i); -int gu_prime_sup(int i); -int gu_twin_prime_sup(int i); +GU_INTERNAL_DECL int gu_prime_sup(int i); +GU_INTERNAL_DECL int gu_twin_prime_sup(int i); #endif // GU_PRIME_H_ diff --git a/src/runtime/c/gu/seq.c b/src/runtime/c/gu/seq.c index 8cf55929b..72ccc3fae 100644 --- a/src/runtime/c/gu/seq.c +++ b/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; diff --git a/src/runtime/c/gu/string.c b/src/runtime/c/gu/string.c index 118e0cb0b..2b83e2a86 100644 --- a/src/runtime/c/gu/string.c +++ b/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 diff --git a/src/runtime/c/gu/string.h b/src/runtime/c/gu/string.h index 5136b0189..e8b49a1de 100644 --- a/src/runtime/c/gu/string.h +++ b/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_) diff --git a/src/runtime/c/gu/ucs.c b/src/runtime/c/gu/ucs.c index 2dda303c3..38423f738 100644 --- a/src/runtime/c/gu/ucs.c +++ b/src/runtime/c/gu/ucs.c @@ -2,7 +2,7 @@ #include #include -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) -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)) -unipred(gu_ucs_is_lower,GENCAT_LL) -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_cntrl,GENCAT_CC) +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)) +GU_API unipred(gu_ucs_is_upper,(GENCAT_LU|GENCAT_LT)) +GU_API unipred(gu_ucs_is_lower,GENCAT_LL) +GU_API unipred(gu_ucs_is_alpha,(GENCAT_LL|GENCAT_LU|GENCAT_LT|GENCAT_LM|GENCAT_LO)) +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) -caseconv(gu_ucs_to_lower,lowdist) -caseconv(gu_ucs_to_title,titledist) +GU_API caseconv(gu_ucs_to_upper,updist) +GU_API caseconv(gu_ucs_to_lower,lowdist) +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; } diff --git a/src/runtime/c/gu/ucs.h b/src/runtime/c/gu/ucs.h index c976df67f..1af74d27e 100644 --- a/src/runtime/c/gu/ucs.h +++ b/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); -bool gu_ucs_is_digit(GuUCS c); -bool gu_ucs_is_alpha(GuUCS c); -bool gu_ucs_is_cntrl(GuUCS c); -bool gu_ucs_is_space(GuUCS c); -bool gu_ucs_is_print(GuUCS c); -bool gu_ucs_is_lower(GuUCS c); +GU_API_DECL bool gu_ucs_is_upper(GuUCS c); +GU_API_DECL bool gu_ucs_is_digit(GuUCS c); +GU_API_DECL bool gu_ucs_is_alpha(GuUCS c); +GU_API_DECL bool gu_ucs_is_cntrl(GuUCS c); +GU_API_DECL bool gu_ucs_is_space(GuUCS c); +GU_API_DECL bool gu_ucs_is_print(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); -GuUCS gu_ucs_to_upper(GuUCS c); -GuUCS gu_ucs_to_title(GuUCS c); +GU_API_DECL GuUCS gu_ucs_to_lower(GuUCS c); +GU_API_DECL GuUCS gu_ucs_to_upper(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_ diff --git a/src/runtime/c/gu/utf8.c b/src/runtime/c/gu/utf8.c index cd198a83d..29869fd7f 100644 --- a/src/runtime/c/gu/utf8.c +++ b/src/runtime/c/gu/utf8.c @@ -1,7 +1,7 @@ #include #include -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]; diff --git a/src/runtime/c/gu/utf8.h b/src/runtime/c/gu/utf8.h index be3ab0412..6b4932b8e 100644 --- a/src/runtime/c/gu/utf8.h +++ b/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_ diff --git a/src/runtime/c/gu/variant.c b/src/runtime/c/gu/variant.c index 75b75c086..5508c0ce4 100644 --- a/src/runtime/c/gu/variant.c +++ b/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 . - */ - #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 }; diff --git a/src/runtime/c/gu/variant.h b/src/runtime/c/gu/variant.h index ec057faa4..76d7b25b3 100644 --- a/src/runtime/c/gu/variant.h +++ b/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) {