Remove redundant API attributes in implementation files

11 files changed, 65 insertions, 82 deletions

diff --git a/zix/ampatree.c b/zix/ampatree.c
index 55b79c9..bb67d06 100644
--- a/zix/ampatree.c
+++ b/zix/ampatree.c
@@ -82,7 +82,6 @@ zix_ampatree_print_rec(ZixAMPatreeNode* node, FILE* fd)
 	}
 }
 
-ZIX_API
 void
 zix_ampatree_print_dot(const ZixAMPatree* t, FILE* fd)
 {
@@ -103,7 +102,7 @@ realloc_node(ZixAMPatreeNode* n, n_edges_t n_children)
 	return (ZixAMPatreeNode*)realloc(n, zix_ampatree_node_size(n_children));
 }
 
-ZIX_API ZixAMPatree*
+ZixAMPatree*
 zix_ampatree_new(void)
 {
 	ZixAMPatree* t = (ZixAMPatree*)calloc(1, sizeof(ZixAMPatree));
@@ -124,7 +123,7 @@ zix_ampatree_free_rec(ZixAMPatreeNode* n)
 	}
 }
 
-ZIX_API void
+void
 zix_ampatree_free(ZixAMPatree* t)
 {
 	zix_ampatree_free_rec(t->root);
@@ -270,7 +269,7 @@ patree_insert_internal(ZixAMPatreeNode** n_ptr,
 	return ZIX_STATUS_SUCCESS;
 }
 
-ZIX_API ZixStatus
+ZixStatus
 zix_ampatree_insert(ZixAMPatree* t, const char* str, size_t len)
 {
 	assert(strlen(str) == len);
@@ -279,7 +278,7 @@ zix_ampatree_insert(ZixAMPatree* t, const char* str, size_t len)
 	return patree_insert_internal(&t->root, ustr, ustr, len);
 }
 
-ZIX_API ZixStatus
+ZixStatus
 zix_ampatree_find(const ZixAMPatree* t, const char* const str, const char** match)
 {
 	ZixAMPatreeNode* n = t->root;
diff --git a/zix/bitset.c b/zix/bitset.c
index fc1873d..f447b74 100644
--- a/zix/bitset.c
+++ b/zix/bitset.c
@@ -35,14 +35,14 @@ zix_bitset_popcount(const ZixBitset value)
 #endif
 }
 
-ZIX_API void
+void
 zix_bitset_clear(ZixBitset* b, ZixBitsetTally* t, size_t n_bits)
 {
 	memset(b, 0, ZIX_BITSET_ELEMS(n_bits) * sizeof(ZixBitset));
 	memset(t, 0, ZIX_BITSET_ELEMS(n_bits) * sizeof(ZixBitsetTally));
 }
 
-ZIX_API void
+void
 zix_bitset_set(ZixBitset* b, ZixBitsetTally* t, size_t i)
 {
 	const size_t    e    = i / ZIX_BITSET_ELEM_BIT;
@@ -56,7 +56,7 @@ zix_bitset_set(ZixBitset* b, ZixBitsetTally* t, size_t i)
 	b[e] |= mask;
 }
 
-ZIX_API void
+void
 zix_bitset_reset(ZixBitset* b, ZixBitsetTally* t, size_t i)
 {
 	const size_t    e    = i / ZIX_BITSET_ELEM_BIT;
@@ -70,7 +70,7 @@ zix_bitset_reset(ZixBitset* b, ZixBitsetTally* t, size_t i)
 	b[e] &= ~mask;
 }
 
-ZIX_API bool
+bool
 zix_bitset_get(const ZixBitset* b, size_t i)
 {
 	const size_t    e    = i / ZIX_BITSET_ELEM_BIT;
@@ -80,7 +80,7 @@ zix_bitset_get(const ZixBitset* b, size_t i)
 	return b[e] & mask;
 }
 
-ZIX_API size_t
+size_t
 zix_bitset_count_up_to(const ZixBitset* b, const ZixBitsetTally* t, size_t i)
 {
 	const size_t full_elems = i / ZIX_BITSET_ELEM_BIT;
@@ -99,7 +99,7 @@ zix_bitset_count_up_to(const ZixBitset* b, const ZixBitsetTally* t, size_t i)
 	return count;
 }
 
-ZIX_API size_t
+size_t
 zix_bitset_count_up_to_if(const ZixBitset* b, const ZixBitsetTally* t, size_t i)
 {
 	const size_t full_elems = i / ZIX_BITSET_ELEM_BIT;
diff --git a/zix/btree.c b/zix/btree.c
index 0a8010f..c02126a 100644
--- a/zix/btree.c
+++ b/zix/btree.c
@@ -108,7 +108,7 @@ zix_btree_node_new(const bool leaf)
 	return node;
 }
 
-ZIX_API ZixBTree*
+ZixBTree*
 zix_btree_new(const ZixComparator  cmp,
               const void* const    cmp_data,
               const ZixDestroyFunc destroy)
@@ -147,7 +147,7 @@ zix_btree_free_rec(ZixBTree* const t, ZixBTreeNode* const n)
 	}
 }
 
-ZIX_API void
+void
 zix_btree_free(ZixBTree* const t)
 {
 	if (t) {
@@ -156,7 +156,7 @@ zix_btree_free(ZixBTree* const t)
 	}
 }
 
-ZIX_API size_t
+size_t
 zix_btree_size(const ZixBTree* const t)
 {
 	return t->size;
@@ -292,7 +292,7 @@ zix_btree_node_find(const ZixBTree* const     t,
 	return first;
 }
 
-ZIX_API ZixStatus
+ZixStatus
 zix_btree_insert(ZixBTree* const t, void* const e)
 {
 	ZixBTreeNode* parent = NULL;     // Parent of n
@@ -504,7 +504,7 @@ zix_btree_remove_max(ZixBTree* const t, ZixBTreeNode* n)
 	return n->vals[--n->n_vals];
 }
 
-ZIX_API ZixStatus
+ZixStatus
 zix_btree_remove(ZixBTree* const      t,
                  const void* const    e,
                  void** const         out,
@@ -622,7 +622,7 @@ zix_btree_remove(ZixBTree* const      t,
 	return ZIX_STATUS_ERROR;
 }
 
-ZIX_API ZixStatus
+ZixStatus
 zix_btree_find(const ZixBTree* const t,
                const void* const     e,
                ZixBTreeIter** const  ti)
@@ -653,7 +653,7 @@ zix_btree_find(const ZixBTree* const t,
 	return ZIX_STATUS_NOT_FOUND;
 }
 
-ZIX_API ZixStatus
+ZixStatus
 zix_btree_lower_bound(const ZixBTree* const t,
                       const void* const     e,
                       ZixBTreeIter** const  ti)
@@ -709,7 +709,7 @@ zix_btree_lower_bound(const ZixBTree* const t,
 	return ZIX_STATUS_SUCCESS;
 }
 
-ZIX_API void*
+void*
 zix_btree_get(const ZixBTreeIter* const ti)
 {
 	const ZixBTreeIterFrame* const frame = &ti->stack[ti->level];
@@ -718,7 +718,7 @@ zix_btree_get(const ZixBTreeIter* const ti)
 	return frame->node->vals[frame->index];
 }
 
-ZIX_API ZixBTreeIter*
+ZixBTreeIter*
 zix_btree_begin(const ZixBTree* const t)
 {
 	ZixBTreeIter* const i = zix_btree_iter_new(t);
@@ -741,13 +741,13 @@ zix_btree_begin(const ZixBTree* const t)
 	return i;
 }
 
-ZIX_API ZixBTreeIter*
+ZixBTreeIter*
 zix_btree_end(const ZixBTree* const t)
 {
 	return zix_btree_iter_new(t);
 }
 
-ZIX_API ZixBTreeIter*
+ZixBTreeIter*
 zix_btree_iter_copy(const ZixBTreeIter* const i)
 {
 	if (!i) {
@@ -762,13 +762,13 @@ zix_btree_iter_copy(const ZixBTreeIter* const i)
 	return j;
 }
 
-ZIX_API bool
+bool
 zix_btree_iter_is_end(const ZixBTreeIter* const i)
 {
 	return !i || i->stack[0].node == NULL;
 }
 
-ZIX_API bool
+bool
 zix_btree_iter_equals(const ZixBTreeIter* const lhs, const ZixBTreeIter* const rhs)
 {
 	if (zix_btree_iter_is_end(lhs) && zix_btree_iter_is_end(rhs)) {
@@ -785,7 +785,7 @@ zix_btree_iter_equals(const ZixBTreeIter* const lhs, const ZixBTreeIter* const r
 	                   (lhs->level + 1) * sizeof(ZixBTreeIterFrame));
 }
 
-ZIX_API void
+void
 zix_btree_iter_increment(ZixBTreeIter* const i)
 {
 	ZixBTreeIterFrame* f = &i->stack[i->level];
@@ -826,7 +826,7 @@ zix_btree_iter_increment(ZixBTreeIter* const i)
 	}
 }
 
-ZIX_API void
+void
 zix_btree_iter_free(ZixBTreeIter* const i)
 {
 	free(i);
diff --git a/zix/chunk.c b/zix/chunk.c
index d1e7e6c..1254d14 100644
--- a/zix/chunk.c
+++ b/zix/chunk.c
@@ -20,13 +20,13 @@
 
 #include <string.h>
 
-ZIX_API uint32_t
+uint32_t
 zix_chunk_hash(const ZixChunk* const chunk)
 {
 	return zix_digest_add(zix_digest_start(), chunk->buf, chunk->len);
 }
 
-ZIX_API bool
+bool
 zix_chunk_equal(const ZixChunk* a, const ZixChunk* b)
 {
 	return a->len == b->len && !memcmp(a->buf, b->buf, a->len);
diff --git a/zix/digest.c b/zix/digest.c
index 889cfde..2ac1715 100644
--- a/zix/digest.c
+++ b/zix/digest.c
@@ -27,13 +27,13 @@
 
 // SSE 4.2 CRC32
 
-ZIX_API uint32_t
+uint32_t
 zix_digest_start(void)
 {
 	return 1;
 }
 
-ZIX_API uint32_t
+uint32_t
 zix_digest_add(uint32_t hash, const void* const buf, const size_t len)
 {
 	const uint8_t* str = (const uint8_t*)buf;
@@ -57,7 +57,7 @@ zix_digest_add(uint32_t hash, const void* const buf, const size_t len)
 	return hash;
 }
 
-ZIX_API uint32_t
+uint32_t
 zix_digest_add_64(uint32_t hash, const void* const buf, const size_t len)
 {
 	assert((uintptr_t)buf % sizeof(uint64_t) == 0);
@@ -73,7 +73,7 @@ zix_digest_add_64(uint32_t hash, const void* const buf, const size_t len)
 	return hash;
 }
 
-ZIX_API uint32_t
+uint32_t
 zix_digest_add_ptr(const uint32_t hash, const void* const ptr)
 {
 #if UINTPTR_MAX == UINT64_MAX
@@ -87,13 +87,13 @@ zix_digest_add_ptr(const uint32_t hash, const void* const ptr)
 
 // Classic DJB hash
 
-ZIX_API uint32_t
+uint32_t
 zix_digest_start(void)
 {
 	return 5381;
 }
 
-ZIX_API uint32_t
+uint32_t
 zix_digest_add(uint32_t hash, const void* const buf, const size_t len)
 {
 	const uint8_t* str = (const uint8_t*)buf;
@@ -105,7 +105,7 @@ zix_digest_add(uint32_t hash, const void* const buf, const size_t len)
 	return hash;
 }
 
-ZIX_API uint32_t
+uint32_t
 zix_digest_add_64(uint32_t hash, const void* const buf, const size_t len)
 {
 	assert((uintptr_t)buf % sizeof(uint64_t) == 0);
@@ -114,7 +114,7 @@ zix_digest_add_64(uint32_t hash, const void* const buf, const size_t len)
 	return zix_digest_add(hash, buf, len);
 }
 
-ZIX_API uint32_t
+uint32_t
 zix_digest_add_ptr(const uint32_t hash, const void* const ptr)
 {
 	return zix_digest_add(hash, &ptr, sizeof(ptr));
diff --git a/zix/hash.c b/zix/hash.c
index c4a2dba..35eaf24 100644
--- a/zix/hash.c
+++ b/zix/hash.c
@@ -51,7 +51,7 @@ zix_hash_value(ZixHashEntry* entry)
 	return entry + 1;
 }
 
-ZIX_API ZixHash*
+ZixHash*
 zix_hash_new(ZixHashFunc  hash_func,
              ZixEqualFunc equal_func,
              size_t       value_size)
@@ -72,7 +72,7 @@ zix_hash_new(ZixHashFunc  hash_func,
 	return hash;
 }
 
-ZIX_API void
+void
 zix_hash_free(ZixHash* hash)
 {
 	if (!hash) {
@@ -92,7 +92,7 @@ zix_hash_free(ZixHash* hash)
 	free(hash);
 }
 
-ZIX_API size_t
+size_t
 zix_hash_size(const ZixHash* hash)
 {
 	return hash->count;
@@ -144,7 +144,7 @@ find_entry(const ZixHash* hash,
 	return NULL;
 }
 
-ZIX_API void*
+void*
 zix_hash_find(const ZixHash* hash, const void* value)
 {
 	const unsigned h_nomod = hash->hash_func(value);
@@ -153,7 +153,7 @@ zix_hash_find(const ZixHash* hash, const void* value)
 	return entry ? zix_hash_value(entry) : 0;
 }
 
-ZIX_API ZixStatus
+ZixStatus
 zix_hash_insert(ZixHash* hash, const void* value, void** inserted)
 {
 	unsigned h_nomod = hash->hash_func(value);
@@ -191,7 +191,7 @@ zix_hash_insert(ZixHash* hash, const void* value, void** inserted)
 	return ZIX_STATUS_SUCCESS;
 }
 
-ZIX_API ZixStatus
+ZixStatus
 zix_hash_remove(ZixHash* hash, const void* value)
 {
 	const unsigned h_nomod = hash->hash_func(value);
@@ -221,7 +221,7 @@ zix_hash_remove(ZixHash* hash, const void* value)
 	return ZIX_STATUS_NOT_FOUND;
 }
 
-ZIX_API void
+void
 zix_hash_foreach(ZixHash*         hash,
                  ZixHashVisitFunc f,
                  void*            user_data)
diff --git a/zix/patree.c b/zix/patree.c
index 54a5637..a7d7e45 100644
--- a/zix/patree.c
+++ b/zix/patree.c
@@ -117,7 +117,7 @@ realloc_node(ZixPatreeNode* n, n_edges_t n_children)
 	return (ZixPatreeNode*)realloc(n, zix_patree_node_size(n_children));
 }
 
-ZIX_API ZixPatree*
+ZixPatree*
 zix_patree_new(void)
 {
 	ZixPatree* t = (ZixPatree*)calloc(1, sizeof(ZixPatree));
@@ -138,7 +138,7 @@ zix_patree_free_rec(ZixPatreeNode* n)
 	}
 }
 
-ZIX_API void
+void
 zix_patree_free(ZixPatree* t)
 {
 	zix_patree_free_rec(t->root);
@@ -293,7 +293,7 @@ patree_insert_internal(ZixPatreeNode** n_ptr,
 	return ZIX_STATUS_SUCCESS;
 }
 
-ZIX_API ZixStatus
+ZixStatus
 zix_patree_insert(ZixPatree* t, const char* str, size_t len)
 {
 	assert(strlen(str) == len);
@@ -302,7 +302,7 @@ zix_patree_insert(ZixPatree* t, const char* str, size_t len)
 	return patree_insert_internal(&t->root, ustr, ustr, len);
 }
 
-ZIX_API ZixStatus
+ZixStatus
 zix_patree_find(const ZixPatree* t, const char* const str, const char** match)
 {
 	ZixPatreeNode* n = t->root;
diff --git a/zix/sorted_array.c b/zix/sorted_array.c
index 0f08e89..038bc23 100644
--- a/zix/sorted_array.c
+++ b/zix/sorted_array.c
@@ -48,7 +48,6 @@ zix_sorted_array_print(ZixSortedArray* a)
 #    define DUMP(a)
 #endif
 
-ZIX_API
 ZixSortedArray*
 zix_sorted_array_new(bool          allow_duplicates,
                      ZixComparator cmp,
@@ -65,7 +64,6 @@ zix_sorted_array_new(bool          allow_duplicates,
 	return a;
 }
 
-ZIX_API
 void
 zix_sorted_array_free(ZixSortedArray* a)
 {
@@ -73,14 +71,12 @@ zix_sorted_array_free(ZixSortedArray* a)
 	free(a);
 }
 
-ZIX_API
 size_t
 zix_sorted_array_size(ZixSortedArray* a)
 {
 	return a->num_elems;
 }
 
-ZIX_API
 ZixStatus
 zix_sorted_array_insert(ZixSortedArray*     a,
                         const void*         e,
@@ -112,7 +108,6 @@ zix_sorted_array_insert(ZixSortedArray*     a,
 	return ZIX_STATUS_SUCCESS;
 }
 
-ZIX_API
 ZixStatus
 zix_sorted_array_remove(ZixSortedArray* a, ZixSortedArrayIter ai)
 {
@@ -131,7 +126,6 @@ zix_sorted_array_index_unchecked(const ZixSortedArray* a, size_t index)
 	return (char*)a->array + (a->elem_size * index);
 }
 
-ZIX_API
 void*
 zix_sorted_array_index(const ZixSortedArray* a, size_t index)
 {
@@ -142,7 +136,6 @@ zix_sorted_array_index(const ZixSortedArray* a, size_t index)
 	return zix_sorted_array_index_unchecked(a, index);
 }
 
-ZIX_API
 ZixStatus
 zix_sorted_array_find(const ZixSortedArray* a,
                       const void*           e,
@@ -169,35 +162,30 @@ zix_sorted_array_find(const ZixSortedArray* a,
 	return ZIX_STATUS_NOT_FOUND;
 }
 
-ZIX_API
 void*
 zix_sorted_array_get_data(ZixSortedArrayIter ai)
 {
 	return ai;
 }
 
-ZIX_API
 ZixSortedArrayIter
 zix_sorted_array_begin(ZixSortedArray* a)
 {
 	return a->array;
 }
 
-ZIX_API
 ZixSortedArrayIter
 zix_sorted_array_end(ZixSortedArray* a)
 {
 	return (char*)a->array + (a->elem_size * a->num_elems);
 }
 
-ZIX_API
 bool
 zix_sorted_array_iter_is_end(ZixSortedArray* a, ZixSortedArrayIter i)
 {
 	return i != zix_sorted_array_end(a);
 }
 
-ZIX_API
 ZixSortedArrayIter
 zix_sorted_array_iter_next(ZixSortedArray* a, ZixSortedArrayIter i)
 {
diff --git a/zix/strindex.c b/zix/strindex.c
index 103ea50..cbc218d 100644
--- a/zix/strindex.c
+++ b/zix/strindex.c
@@ -44,7 +44,6 @@ strindex_insert(ZixStrindexNode* n,
                 char*            first,
                 char*            last);
 
-ZIX_API
 ZixStrindex*
 zix_strindex_new(const char* s)
 {
@@ -79,7 +78,6 @@ zix_strindex_free_rec(ZixStrindexNode* n)
 	}
 }
 
-ZIX_API
 void
 zix_strindex_free(ZixStrindex* strindex)
 {
@@ -191,7 +189,6 @@ strindex_insert(ZixStrindexNode* n, char* suffix_first, char* first, char* last)
 	return ZIX_STATUS_SUCCESS;
 }
 
-ZIX_API
 ZixStatus
 zix_strindex_find(ZixStrindex* strindex, const char* const str, char** match)
 {
diff --git a/zix/tree.c b/zix/tree.c
index e0576fb..baeb6a3 100644
--- a/zix/tree.c
+++ b/zix/tree.c
@@ -66,7 +66,7 @@ struct ZixTreeNodeImpl {
 #    define DEBUG_PRINTF(fmt, ...)
 #endif
 
-ZIX_API ZixTree*
+ZixTree*
 zix_tree_new(bool           allow_duplicates,
              ZixComparator  cmp,
              void*          cmp_data,
@@ -95,7 +95,7 @@ zix_tree_free_rec(ZixTree* t, ZixTreeNode* n)
 	}
 }
 
-ZIX_API void
+void
 zix_tree_free(ZixTree* t)
 {
 	if (t) {
@@ -104,7 +104,7 @@ zix_tree_free(ZixTree* t)
 	}
 }
 
-ZIX_API size_t
+size_t
 zix_tree_size(const ZixTree* t)
 {
 	return t->size;
@@ -336,7 +336,7 @@ zix_tree_rebalance(ZixTree* t, ZixTreeNode* node, int* height_change)
 	return replacement;
 }
 
-ZIX_API ZixStatus
+ZixStatus
 zix_tree_insert(ZixTree* t, void* e, ZixTreeIter** ti)
 {
 	DEBUG_PRINTF("**** INSERT %ld\n", (intptr_t)e);
@@ -433,7 +433,7 @@ zix_tree_insert(ZixTree* t, void* e, ZixTreeIter** ti)
 	return ZIX_STATUS_SUCCESS;
 }
 
-ZIX_API ZixStatus
+ZixStatus
 zix_tree_remove(ZixTree* t, ZixTreeIter* ti)
 {
 	ZixTreeNode* const n          = ti;
@@ -590,7 +590,7 @@ zix_tree_remove(ZixTree* t, ZixTreeIter* ti)
 	return ZIX_STATUS_SUCCESS;
 }
 
-ZIX_API ZixStatus
+ZixStatus
 zix_tree_find(const ZixTree* t, const void* e, ZixTreeIter** ti)
 {
 	ZixTreeNode* n = t->root;
@@ -609,13 +609,13 @@ zix_tree_find(const ZixTree* t, const void* e, ZixTreeIter** ti)
 	return (n) ? ZIX_STATUS_SUCCESS : ZIX_STATUS_NOT_FOUND;
 }
 
-ZIX_API void*
+void*
 zix_tree_get(const ZixTreeIter* ti)
 {
 	return ti ? ti->data : NULL;
 }
 
-ZIX_API ZixTreeIter*
+ZixTreeIter*
 zix_tree_begin(ZixTree* t)
 {
 	if (!t->root) {
@@ -629,13 +629,13 @@ zix_tree_begin(ZixTree* t)
 	return n;
 }
 
-ZIX_API ZixTreeIter*
+ZixTreeIter*
 zix_tree_end(ZixTree* ZIX_UNUSED(t))
 {
 	return NULL;
 }
 
-ZIX_API ZixTreeIter*
+ZixTreeIter*
 zix_tree_rbegin(ZixTree* t)
 {
 	if (!t->root) {
@@ -649,25 +649,25 @@ zix_tree_rbegin(ZixTree* t)
 	return n;
 }
 
-ZIX_API ZixTreeIter*
+ZixTreeIter*
 zix_tree_rend(ZixTree* ZIX_UNUSED(t))
 {
 	return NULL;
 }
 
-ZIX_API bool
+bool
 zix_tree_iter_is_end(const ZixTreeIter* i)
 {
 	return !i;
 }
 
-ZIX_API bool
+bool
 zix_tree_iter_is_rend(const ZixTreeIter* i)
 {
 	return !i;
 }
 
-ZIX_API ZixTreeIter*
+ZixTreeIter*
 zix_tree_iter_next(ZixTreeIter* i)
 {
 	if (!i) {
@@ -690,7 +690,7 @@ zix_tree_iter_next(ZixTreeIter* i)
 	return i;
 }
 
-ZIX_API ZixTreeIter*
+ZixTreeIter*
 zix_tree_iter_prev(ZixTreeIter* i)
 {
 	if (!i) {
diff --git a/zix/trie.c b/zix/trie.c
index fc16d35..1a2d3f6 100644
--- a/zix/trie.c
+++ b/zix/trie.c
@@ -83,7 +83,6 @@ zix_trie_print_rec(ZixTrieNode* node, FILE* fd)
 	}
 }
 
-ZIX_API
 void
 zix_trie_print_dot(const ZixTrie* t, FILE* fd)
 {
@@ -106,7 +105,7 @@ realloc_node(ZixTrieNode* n, n_edges_t num_children)
 	return (ZixTrieNode*)realloc(n, zix_trie_node_size(num_children));
 }
 
-ZIX_API ZixTrie*
+ZixTrie*
 zix_trie_new(void)
 {
 	ZixTrie* t = (ZixTrie*)calloc(1, sizeof(ZixTrie));
@@ -127,7 +126,7 @@ zix_trie_free_rec(ZixTrieNode* n)
 	}
 }
 
-ZIX_API void
+void
 zix_trie_free(ZixTrie* t)
 {
 	zix_trie_free_rec(t->root);
@@ -306,7 +305,7 @@ trie_insert_internal(ZixTrieNode**  n_ptr,
 	return ZIX_STATUS_SUCCESS;
 }
 
-ZIX_API ZixStatus
+ZixStatus
 zix_trie_insert(ZixTrie* t, const char* str, size_t len)
 {
 	assert(strlen(str) == len);
@@ -315,7 +314,7 @@ zix_trie_insert(ZixTrie* t, const char* str, size_t len)
 	return trie_insert_internal(&t->root, ustr, ustr, len);
 }
 
-ZIX_API ZixStatus
+ZixStatus
 zix_trie_find(const ZixTrie* t, const char* const str, const char** match)
 {
 	ZixTrieNode* n = t->root;