GitHub/gf-core
1
0
Fork 1
mirror of https://github.com/GrammaticalFramework/gf-core.git synced 2026-04-09 04:59:31 -06:00
Code Issues Packages Projects Releases Wiki Activity

in libgu mark explicitly all functions that belong to the API

Browse Source
This commit is contained in:
krasimir
2017-04-19 12:30:40 +00:00
parent 74ce52d761
commit 5c93f2fba5
35 changed files with 311 additions and 372 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
src/runtime/c/gu/assert.c
View File

@@ -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, ...)
@@ -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;

6
src/runtime/c/gu/assert.h
View File

@@ -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_ */

5
src/runtime/c/gu/bits.c
View File

@@ -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;

3
src/runtime/c/gu/bits.h
View File

@@ -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);

10
src/runtime/c/gu/choice.c
View File

@@ -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));

10
src/runtime/c/gu/choice.h
View File

@@ -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);

2
src/runtime/c/gu/defs.c
View File

@@ -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;

36
src/runtime/c/gu/defs.h
View File

@@ -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_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;

2
src/runtime/c/gu/enum.c
View File

@@ -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);

2
src/runtime/c/gu/enum.h
View File

@@ -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

16
src/runtime/c/gu/exn.c
View File

@@ -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);

16
src/runtime/c/gu/exn.h
View File

@@ -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);
/** @} */

4
src/runtime/c/gu/file.c
View File

@@ -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);

4
src/runtime/c/gu/file.h
View File

@@ -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_

8
src/runtime/c/gu/hash.c
View File

@@ -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

8
src/runtime/c/gu/hash.h
View File

@@ -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_

48
src/runtime/c/gu/in.c
View File

@@ -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);

43
src/runtime/c/gu/in.h
View File

@@ -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);

18
src/runtime/c/gu/map.c
View File

@@ -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,

20
src/runtime/c/gu/map.h
View File

@@ -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;

26
src/runtime/c/gu/mem.c
View File

@@ -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;

37
src/runtime/c/gu/mem.h
View File

@@ -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);

29
src/runtime/c/gu/out.c
View File

@@ -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;

52
src/runtime/c/gu/out.h
View File

@@ -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_

12
src/runtime/c/gu/prime.c
View File

@@ -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) {

12
src/runtime/c/gu/prime.h
View File

@@ -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);
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_

40
src/runtime/c/gu/seq.c
View File

@@ -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;

42
src/runtime/c/gu/string.c
View File

@@ -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

42
src/runtime/c/gu/string.h
View File

@@ -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_)

32
src/runtime/c/gu/ucs.c
View File

@@ -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)
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;
}

34
src/runtime/c/gu/ucs.h
View File

@@ -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_

10
src/runtime/c/gu/utf8.c
View File

@@ -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];

6
src/runtime/c/gu/utf8.h
View File

@@ -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_

37
src/runtime/c/gu/variant.c
View File

@@ -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 };

2
src/runtime/c/gu/variant.h
View File

@@ -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) {