commit 5fad11708288d6d17a9b531233301e2f6e3ddca8
parent ba27b26c1041d0203d927a690b0416b97dc5fddb
Author: vaplv <vaplv@free.fr>
Date: Fri, 3 Oct 2014 15:32:51 +0200
Rename the R_<OK|BAD_ARG|IO_ERR|MEM_ERR|UNKNOWN_ERR> macros to RES_<XXX>
Diffstat:
13 files changed, 125 insertions(+), 125 deletions(-)
diff --git a/src/binary_heap.h b/src/binary_heap.h
@@ -148,7 +148,7 @@ BHEAP_FUNC__(insert)(struct BHEAP_TYPE__* heap, const BHEAP_DATA* value)
inode = BHEAP_NODES_FUNC__(size_get)(&heap->nodes);
res = BHEAP_NODES_FUNC__(push_back)(&heap->nodes, value);
- if(res != R_OK)
+ if(res != RES_OK)
return res;
nodes = BHEAP_NODES_FUNC__(data_get)(&heap->nodes);
@@ -164,7 +164,7 @@ BHEAP_FUNC__(insert)(struct BHEAP_TYPE__* heap, const BHEAP_DATA* value)
inode = iparent;
}
BHEAP_FUNCTOR_RELEASE(&tmp);
- return R_OK;
+ return RES_OK;
}
static INLINE char
diff --git a/src/dynamic_array.h b/src/dynamic_array.h
@@ -81,7 +81,7 @@ DARRAY_FUNC__(functor_release__)(DARRAY_DATA* data)
#ifndef DARRAY_FUNCTOR_COPY
static FINLINE res_T
DARRAY_FUNC__(functor_cp__)(DARRAY_DATA* dst, DARRAY_DATA const* src)
-{ ASSERT(dst && src); *dst = *src; return R_OK; }
+{ ASSERT(dst && src); *dst = *src; return RES_OK; }
#define DARRAY_FUNCTOR_COPY DARRAY_FUNC__(functor_cp__)
#endif
@@ -141,7 +141,7 @@ DARRAY_FUNC__(reserve)(struct DARRAY_TYPE__* darray, const size_t sz)
ASSERT(darray);
if(sz <= darray->capacity)
- return R_OK;
+ return RES_OK;
sz_adjusted = round_up_pow2(sz);
data = MEM_ALLOC_ALIGNED
@@ -149,7 +149,7 @@ DARRAY_FUNC__(reserve)(struct DARRAY_TYPE__* darray, const size_t sz)
sz_adjusted * sizeof(DARRAY_DATA),
ALIGNOF(DARRAY_DATA));
if(!data)
- return R_MEM_ERR;
+ return RES_MEM_ERR;
if(darray->size) {
size_t i = 0;
@@ -157,7 +157,7 @@ DARRAY_FUNC__(reserve)(struct DARRAY_TYPE__* darray, const size_t sz)
res_T res = 0;
DARRAY_FUNCTOR_INIT(darray->allocator, data+i);
res = DARRAY_FUNCTOR_COPY_AND_RELEASE(data+i, darray->data+i);
- if(res != R_OK) {
+ if(res != RES_OK) {
MEM_FREE(darray->allocator, data);
return res;
}
@@ -168,7 +168,7 @@ DARRAY_FUNC__(reserve)(struct DARRAY_TYPE__* darray, const size_t sz)
darray->data = data;
darray->capacity = sz_adjusted;
- return R_OK;
+ return RES_OK;
}
static INLINE res_T
@@ -179,7 +179,7 @@ DARRAY_FUNC__(resize)(struct DARRAY_TYPE__* darray, const size_t sz)
ASSERT(darray);
res = DARRAY_FUNC__(reserve)(darray, sz);
- if(res != R_OK)
+ if(res != RES_OK)
return res;
FOR_EACH(i, sz, darray->size)
@@ -187,7 +187,7 @@ DARRAY_FUNC__(resize)(struct DARRAY_TYPE__* darray, const size_t sz)
FOR_EACH(i, darray->size, sz)
DARRAY_FUNCTOR_INIT(darray->allocator, darray->data+i);
darray->size = sz;
- return R_OK;
+ return RES_OK;
}
static INLINE res_T
@@ -200,10 +200,10 @@ DARRAY_FUNC__(push_back)
ASSERT(darray && data);
sz = darray->size;
res = DARRAY_FUNC__(resize)(darray, sz+1);
- if(res != R_OK)
+ if(res != RES_OK)
return res;
DARRAY_FUNCTOR_COPY(darray->data+sz, data);
- return R_OK;
+ return RES_OK;
}
static INLINE void
@@ -212,7 +212,7 @@ DARRAY_FUNC__(pop_back)(struct DARRAY_TYPE__* darray)
ASSERT(darray);
if(darray->size > 0) {
const res_T res = DARRAY_FUNC__(resize)(darray, darray->size - 1);
- ASSERT(res == R_OK); (void)res;
+ ASSERT(res == RES_OK); (void)res;
}
}
@@ -246,17 +246,17 @@ DARRAY_FUNC__(copy)(struct DARRAY_TYPE__* dst, const struct DARRAY_TYPE__* src)
ASSERT(dst && src);
if(dst == src)
- return R_OK;
+ return RES_OK;
DARRAY_FUNC__(clear)(dst);
src_sz = DARRAY_FUNC__(size_get)(src);
res = DARRAY_FUNC__(reserve)(dst, src_sz);
- if(res != R_OK) return res;
+ if(res != RES_OK) return res;
src_data = DARRAY_FUNC__(cdata_get)(src);
FOR_EACH(i, 0, src_sz)
DARRAY_FUNC__(push_back)(dst, src_data+i);
- return R_OK;
+ return RES_OK;
}
static INLINE res_T
@@ -264,11 +264,11 @@ DARRAY_FUNC__(copy_and_clear)
(struct DARRAY_TYPE__* dst,
struct DARRAY_TYPE__* src)
{
- res_T res = R_OK;
+ res_T res = RES_OK;
ASSERT(dst && src);
if(dst == src) {
DARRAY_FUNC__(clear)(dst);
- return R_OK;
+ return RES_OK;
}
if(src->data != (DARRAY_DATA*)src->buf && src->allocator == dst->allocator) {
@@ -289,13 +289,13 @@ DARRAY_FUNC__(copy_and_clear)
DARRAY_FUNC__(clear)(dst);
res = DARRAY_FUNC__(resize)(dst, src_sz);
- if(res != R_OK) return res;
+ if(res != RES_OK) return res;
src_data = DARRAY_FUNC__(data_get)(src);
dst_data = DARRAY_FUNC__(data_get)(dst);
FOR_EACH(i, 0, src_sz) {
res = DARRAY_FUNCTOR_COPY_AND_RELEASE(dst_data+i, src_data+i);
- if(res != R_OK) return res;
+ if(res != RES_OK) return res;
}
src->size = 0;
}
@@ -307,13 +307,13 @@ DARRAY_FUNC__(copy_and_release)
(struct DARRAY_TYPE__* dst,
struct DARRAY_TYPE__* src)
{
- res_T res = R_OK;
+ res_T res = RES_OK;
ASSERT(dst && src);
if(dst == src) {
DARRAY_FUNC__(release)(dst);
} else {
res = DARRAY_FUNC__(copy_and_clear)(dst, src);
- if(res == R_OK)
+ if(res == RES_OK)
DARRAY_FUNC__(release)(src);
}
return res;
diff --git a/src/hash_table.h b/src/hash_table.h
@@ -112,14 +112,14 @@ HTABLE_FUNC__(key_functor_release__)(HTABLE_KEY* key)
#ifndef HTABLE_DATA_FUNCTOR_COPY
static FINLINE res_T
HTABLE_FUNC__(data_functor_cp__)(HTABLE_DATA* dst, HTABLE_DATA const* src)
-{ ASSERT(dst && src); *dst = *src; return R_OK; }
+{ ASSERT(dst && src); *dst = *src; return RES_OK; }
#define HTABLE_DATA_FUNCTOR_COPY HTABLE_FUNC__(data_functor_cp__)
#endif
#ifndef HTABLE_KEY_FUNCTOR_COPY
static FINLINE res_T
HTABLE_FUNC__(key_functor_cp__)(HTABLE_KEY* dst, HTABLE_KEY const* src)
-{ ASSERT(dst && src); *dst = *src; return R_OK; }
+{ ASSERT(dst && src); *dst = *src; return RES_OK; }
#define HTABLE_KEY_FUNCTOR_COPY HTABLE_FUNC__(key_functor_cp__)
#endif
@@ -198,7 +198,7 @@ HTABLE_FUNC__(pair_copy__)
{
res_T res;
ASSERT(dst && src);
- if(R_OK != (res = HTABLE_KEY_FUNCTOR_COPY(&dst->key, &src->key)))
+ if(RES_OK != (res = HTABLE_KEY_FUNCTOR_COPY(&dst->key, &src->key)))
return res;
res = HTABLE_DATA_FUNCTOR_COPY(&dst->data, &src->data);
return res;
@@ -210,7 +210,7 @@ HTABLE_FUNC__(pair_copy_and_release__)
{
res_T res;
ASSERT(dst && src);
- if(R_OK != (res = HTABLE_KEY_FUNCTOR_COPY_AND_RELEASE(&dst->key, &src->key)))
+ if(RES_OK != (res = HTABLE_KEY_FUNCTOR_COPY_AND_RELEASE(&dst->key, &src->key)))
return res;
res = HTABLE_DATA_FUNCTOR_COPY_AND_RELEASE(&dst->data, &src->data);
return res;
@@ -332,7 +332,7 @@ HTABLE_FUNC__(reserve)(struct HTABLE__* htbl, const size_t size_submitted)
size_t islot = 0;
size_t in_use = 0;
size_t size = 0;
- res_T res = R_OK;
+ res_T res = RES_OK;
ASSERT(htbl);
size = round_up_pow2(size_submitted);
@@ -340,11 +340,11 @@ HTABLE_FUNC__(reserve)(struct HTABLE__* htbl, const size_t size_submitted)
goto exit;
HTABLE_DATA_FUNC__(init)(htbl->allocator, &tbl);
- if(R_OK != (res = HTABLE_DATA_FUNC__(resize)(&tbl, size)))
+ if(RES_OK != (res = HTABLE_DATA_FUNC__(resize)(&tbl, size)))
goto error;
darray_char_init(htbl->allocator, &tbl_slot_is_used);
- if(R_OK != (res = darray_char_resize(&tbl_slot_is_used, size)))
+ if(RES_OK != (res = darray_char_resize(&tbl_slot_is_used, size)))
goto error;
memset(darray_char_data_get(&tbl_slot_is_used), 0, size*sizeof(char));
@@ -400,7 +400,7 @@ HTABLE_FUNC__(set)
struct HTABLE_PAIR__* pair = NULL;
size_t tbl_size = 0;
size_t i = 0;
- res_T res = R_OK;
+ res_T res = RES_OK;
ASSERT(htbl && key && data);
/* Increase hash table size when the load factor is too high */
@@ -411,7 +411,7 @@ HTABLE_FUNC__(set)
} else {
res = HTABLE_FUNC__(reserve)(htbl, tbl_size * 2 );
}
- if(res != R_OK)
+ if(res != RES_OK)
return res;
}
@@ -419,21 +419,21 @@ HTABLE_FUNC__(set)
pair = HTABLE_DATA_FUNC__(data_get)(&htbl->table) + i;
if(darray_char_cdata_get(&htbl->table_slot_is_used)[i]) {
res = HTABLE_DATA_FUNCTOR_COPY(&pair->data, data);
- if(res != R_OK) {
+ if(res != RES_OK) {
darray_char_data_get(&htbl->table_slot_is_used)[i] = 0;
--htbl->table_size_in_use;
}
} else {
res = HTABLE_KEY_FUNCTOR_COPY(&pair->key, key);
- if(res == R_OK) {
+ if(res == RES_OK) {
res = HTABLE_DATA_FUNCTOR_COPY(&pair->data, data);
- if(res == R_OK) {
+ if(res == RES_OK) {
darray_char_data_get(&htbl->table_slot_is_used)[i] = 1;
++htbl->table_size_in_use;
}
}
}
- return R_OK;
+ return RES_OK;
}
/* Return the number of erased elements, i.e. 0 or 1 */
diff --git a/src/image.c b/src/image.c
@@ -28,26 +28,26 @@ image_ppm_write
{
char buf[BUFSIZ];
FILE* fp = NULL;
- res_T res = R_OK;
+ res_T res = RES_OK;
if(width && height && Bpp && !buffer) {
goto error;
}
fp = fopen(path, "w");
if(NULL == fp) {
- res = R_IO_ERR;
+ res = RES_IO_ERR;
goto error;
}
#define FWRITE(Fp, String) \
{ \
const size_t i = fwrite(String, sizeof(char), strlen(String), Fp); \
- if(i != strlen(String) * sizeof(char)) { res = R_MEM_ERR; goto error; } \
+ if(i != strlen(String) * sizeof(char)) { res = RES_MEM_ERR; goto error; } \
} (void)0
#define SNPRINTF(Buf, Sz, Str, Arg0, Arg1, Arg2) \
{ \
const int i = snprintf(Buf, Sz, Str, Arg0, Arg1, Arg2); \
- if( i >= BUFSIZ ) { res = R_MEM_ERR; goto error; } \
+ if( i >= BUFSIZ ) { res = RES_MEM_ERR; goto error; } \
} (void)0
SNPRINTF(buf, BUFSIZ, "P3\n\n%i %i\n%i\n", width, height, 255);
diff --git a/src/library.c b/src/library.c
@@ -30,13 +30,13 @@ library_close(void* lib)
{
BOOL b;
if(!lib)
- return R_BAD_ARG;
+ return RES_BAD_ARG;
b = FreeLibrary((HMODULE)lib);
if(!b)
- return R_UNKNOWN_ERR;
+ return RES_UNKNOWN_ERR;
- return R_OK;
+ return RES_OK;
}
void*
@@ -90,15 +90,15 @@ library_close(void* handle)
{
int err = 0;
if(!handle)
- return R_BAD_ARG;
+ return RES_BAD_ARG;
err = dlclose(handle);
if(err) {
fprintf(stderr, "%s\n", dlerror());
- return R_UNKNOWN_ERR;
+ return RES_UNKNOWN_ERR;
}
- return R_OK;
+ return RES_OK;
}
#endif /* OS_<XXX> */
diff --git a/src/logger.c b/src/logger.c
@@ -29,11 +29,11 @@ logger_print
va_start(vargs_list, log);
vfprintf(type == LOG_OUTPUT ? stdout : stderr, log, vargs_list);
va_end(vargs_list);
- return R_OK;
+ return RES_OK;
}
if(is_list_empty(logger->streams + type))
- return R_OK;
+ return RES_OK;
va_start(vargs_list, log);
sz = vsnprintf
@@ -46,7 +46,7 @@ logger_print
/* If there is not sufficient space in the logger buffer, resize it */
if((size_t)sz >= darray_char_size_get(&logger->buffer)) {
res_T res = darray_char_resize(&logger->buffer, (size_t)sz+1/*+1<=>'\0'*/);
- if(res != R_OK)
+ if(res != RES_OK)
return res;
va_start(vargs_list, log);
@@ -64,6 +64,6 @@ logger_print
(node, struct log_stream, attachments[type]);
stream->writer(darray_char_cdata_get(&logger->buffer), stream->ctx);
}
- return R_OK;
+ return RES_OK;
}
diff --git a/src/rsys.h b/src/rsys.h
@@ -201,11 +201,11 @@
* Result constants
******************************************************************************/
typedef int res_T;
-#define R_OK 0
-#define R_BAD_ARG 1
-#define R_MEM_ERR 2
-#define R_IO_ERR 3
-#define R_UNKNOWN_ERR 4
+#define RES_OK 0
+#define RES_BAD_ARG 1
+#define RES_MEM_ERR 2
+#define RES_IO_ERR 3
+#define RES_UNKNOWN_ERR 4
/*******************************************************************************
* Miscellaneous
diff --git a/src/str.c b/src/str.c
@@ -30,14 +30,14 @@ ensure_allocated(struct str* str, const size_t len, const char keep_old)
ASSERT( str );
if(len * sizeof(char) <= str->allocated)
- return R_OK;
+ return RES_OK;
mod = len % alloc_granularity;
new_len = !mod ? len : len - mod + alloc_granularity;
new_size = new_len * sizeof(char);
buf = MEM_ALLOC(str->allocator, new_size);
if(!buf)
- return R_MEM_ERR;
+ return RES_MEM_ERR;
if(keep_old) {
strncpy( buf, str->cstr, new_len - 1);
@@ -49,7 +49,7 @@ ensure_allocated(struct str* str, const size_t len, const char keep_old)
MEM_FREE(str->allocator, str->cstr);
str->cstr = buf;
- return R_OK;
+ return RES_OK;
}
/*******************************************************************************
@@ -64,10 +64,10 @@ str_set(struct str* str, const char* cstr)
cstr_len = strlen(cstr);
res = ensure_allocated(str, cstr_len + 1, 0);
- if(res != R_OK) return res;
+ if(res != RES_OK) return res;
strncpy(str->cstr, cstr, cstr_len + 1);
str->len = cstr_len;
- return R_OK;
+ return RES_OK;
}
res_T
@@ -77,7 +77,7 @@ str_insert(struct str* str, const size_t i, const char* cstr)
ASSERT(str);
if(i > str->len)
- return R_BAD_ARG;
+ return RES_BAD_ARG;
cstr_len = strlen(cstr);
ASSERT(!MEM_AREA_OVERLAP
@@ -87,7 +87,7 @@ str_insert(struct str* str, const size_t i, const char* cstr)
return str_append(str, cstr);
} else {
const res_T res = ensure_allocated(str, cstr_len + str->len + 1, 1);
- if(res != R_OK)
+ if(res != RES_OK)
return res;
memmove
(str->cstr + i + cstr_len,
@@ -97,14 +97,14 @@ str_insert(struct str* str, const size_t i, const char* cstr)
str->len = str->len + cstr_len;
str->cstr[str->len] = '\0';
}
- return R_OK;
+ return RES_OK;
}
res_T
str_insert_char(struct str* str, const size_t i, const char ch)
{
if(i > str->len)
- return R_BAD_ARG;
+ return RES_BAD_ARG;
if(i == str->len) {
return str_append_char(str, ch);
@@ -113,7 +113,7 @@ str_insert_char(struct str* str, const size_t i, const char ch)
str->len = i;
} else {
const res_T res = ensure_allocated(str, str->len + 2, 1);
- if(res != R_OK)
+ if(res != RES_OK)
return res;
memmove
(str->cstr + i + 1,
@@ -123,14 +123,14 @@ str_insert_char(struct str* str, const size_t i, const char ch)
++str->len;
str->cstr[str->len] = '\0';
}
- return R_OK;
+ return RES_OK;
}
res_T
str_append(struct str* str, const char* cstr)
{
size_t cstr_len = 0;
- res_T res = R_OK;
+ res_T res = RES_OK;
ASSERT(str && cstr);
cstr_len = strlen(cstr);
@@ -138,31 +138,31 @@ str_append(struct str* str, const char* cstr)
(str->cstr, str->allocated, cstr, (cstr_len + 1) * sizeof(char)));
res = ensure_allocated(str, cstr_len + str->len + 1, 1);
- if(res != R_OK)
+ if(res != RES_OK)
return res;
memcpy(str->cstr + str->len, cstr, cstr_len * sizeof(char));
str->len += cstr_len;
str->cstr[str->len] = '\0';
- return R_OK;
+ return RES_OK;
}
res_T
str_append_char(struct str* str, const char ch)
{
- res_T res = R_OK;
+ res_T res = RES_OK;
ASSERT( str );
if(ch == '\0')
- return R_OK;
+ return RES_OK;
res = ensure_allocated(str, str->len + 2, 1);
- if(res != R_OK) return res;
+ if(res != RES_OK) return res;
str->cstr[str->len] = ch;
++str->len;
str->cstr[str->len] = '\0';
- return R_OK;
+ return RES_OK;
}
res_T
diff --git a/src/str.h b/src/str.h
@@ -91,18 +91,18 @@ str_copy(struct str* dst, const struct str* src)
{
ASSERT(dst && src);
if(dst == src)
- return R_OK;
+ return RES_OK;
return str_set(dst, str_cget(src));
}
static INLINE res_T
str_copy_and_clear( struct str* dst, struct str* src )
{
- res_T res = R_OK;
+ res_T res = RES_OK;
ASSERT(dst && src);
if(dst == src) {
str_clear(dst);
- return R_OK;
+ return RES_OK;
}
if(src->cstr != src->buffer && src->allocator == dst->allocator) {
@@ -116,7 +116,7 @@ str_copy_and_clear( struct str* dst, struct str* src )
str_init(src->allocator, src);
} else {
res = str_copy(dst, src);
- if(res == R_OK)
+ if(res == RES_OK)
str_clear(src);
}
return res;
@@ -125,13 +125,13 @@ str_copy_and_clear( struct str* dst, struct str* src )
static INLINE res_T
str_copy_and_release(struct str* dst, struct str* src)
{
- res_T res = R_OK;
+ res_T res = RES_OK;
ASSERT( dst && src );
if(dst == src) {
str_release(dst);
} else {
res = str_copy_and_clear(dst, src);
- if(res == R_OK)
+ if(res == RES_OK)
str_release(src);
}
return res;
diff --git a/src/test_binary_heap.c b/src/test_binary_heap.c
@@ -38,14 +38,14 @@ test_primitive_type(void)
CHECK(bheap_u64_is_empty(&heap), 1);
CHECK(bheap_u64_top(&heap, &i), 0);
CHECK(bheap_u64_pop(&heap, &i), 0);
- i = 48; CHECK(bheap_u64_insert(&heap, &i), R_OK);
- i = 51; CHECK(bheap_u64_insert(&heap, &i), R_OK);
- i = 1; CHECK(bheap_u64_insert(&heap, &i), R_OK);
- i = 7; CHECK(bheap_u64_insert(&heap, &i), R_OK);
- i = 78; CHECK(bheap_u64_insert(&heap, &i), R_OK);
- i = 4; CHECK(bheap_u64_insert(&heap, &i), R_OK);
- i = 61; CHECK(bheap_u64_insert(&heap, &i), R_OK);
- i = 72; CHECK(bheap_u64_insert(&heap, &i), R_OK);
+ i = 48; CHECK(bheap_u64_insert(&heap, &i), RES_OK);
+ i = 51; CHECK(bheap_u64_insert(&heap, &i), RES_OK);
+ i = 1; CHECK(bheap_u64_insert(&heap, &i), RES_OK);
+ i = 7; CHECK(bheap_u64_insert(&heap, &i), RES_OK);
+ i = 78; CHECK(bheap_u64_insert(&heap, &i), RES_OK);
+ i = 4; CHECK(bheap_u64_insert(&heap, &i), RES_OK);
+ i = 61; CHECK(bheap_u64_insert(&heap, &i), RES_OK);
+ i = 72; CHECK(bheap_u64_insert(&heap, &i), RES_OK);
CHECK(bheap_u64_is_empty(&heap), 0);
NCHECK(bheap_u64_top(&heap, &i), 0);
@@ -61,9 +61,9 @@ test_primitive_type(void)
NCHECK(bheap_u64_pop(&heap, &i), 0);
CHECK(i, 48);
- i = 5; CHECK(bheap_u64_insert(&heap, &i), R_OK);
- i = 50; CHECK(bheap_u64_insert(&heap, &i), R_OK);
- i = 51; CHECK(bheap_u64_insert(&heap, &i), R_OK);
+ i = 5; CHECK(bheap_u64_insert(&heap, &i), RES_OK);
+ i = 50; CHECK(bheap_u64_insert(&heap, &i), RES_OK);
+ i = 51; CHECK(bheap_u64_insert(&heap, &i), RES_OK);
NCHECK(bheap_u64_top(&heap, &i), 0);
CHECK(i, 5);
NCHECK(bheap_u64_pop(&heap, &i), 0);
@@ -86,7 +86,7 @@ test_primitive_type(void)
FOR_EACH(i, 0, 17689) {
const uint64_t j = (uint64_t)rand();
- CHECK(bheap_u64_insert(&heap, &j), R_OK);
+ CHECK(bheap_u64_insert(&heap, &j), RES_OK);
}
CHECK(bheap_u64_is_empty(&heap), 0);
NCHECK(bheap_u64_pop(&heap, &i), 0);
diff --git a/src/test_hash_table.c b/src/test_hash_table.c
@@ -39,11 +39,11 @@ test_htbl_int_float(void)
mem_init_proxy_allocator(&allocator_proxy, &mem_default_allocator);
htable_int_float_init(&allocator_proxy, &htbl);
- CHECK(htable_int_float_reserve(&htbl, 30), R_OK);
+ CHECK(htable_int_float_reserve(&htbl, 30), RES_OK);
FOR_EACH(i, 0, n) {
float f = (float)i;
- CHECK(htable_int_float_set(&htbl, &i, &f), R_OK);
+ CHECK(htable_int_float_set(&htbl, &i, &f), RES_OK);
}
FOR_EACH(i, 0, n) {
@@ -159,13 +159,13 @@ test_htbl_str_int(void)
CHECK(htable_str_int_size_get(&htbl), 0);
i = 0;
str_set(&tmp, str[i]);
- CHECK(htable_str_int_set(&htbl, &tmp, &i), R_OK);
+ CHECK(htable_str_int_set(&htbl, &tmp, &i), RES_OK);
CHECK(htable_str_int_is_empty(&htbl), 0);
CHECK(htable_str_int_size_get(&htbl), 1);
FOR_EACH(i, 1, str_size) {
str_set(&tmp, str[i]);
- CHECK(htable_str_int_set(&htbl, &tmp, &i), R_OK);
+ CHECK(htable_str_int_set(&htbl, &tmp, &i), RES_OK);
}
CHECK(htable_str_int_size_get(&htbl), (size_t)str_size);
@@ -205,7 +205,7 @@ test_htbl_str_int(void)
}
FOR_EACH(i, 0, array_size) {
str_set(&tmp, str[array[i]]);
- CHECK(htable_str_int_set(&htbl, &tmp, array + i), R_OK);
+ CHECK(htable_str_int_set(&htbl, &tmp, array + i), RES_OK);
}
CHECK(htable_str_int_size_get(&htbl), (size_t)str_size);
CHECK(htable_str_int_is_empty(&htbl), 0);
@@ -241,18 +241,18 @@ test_htbl_str_int(void)
htable_str_int_init(&allocator_proxy, &htbl);
htable_str_int_reserve(&htbl, 3);
str_set(&tmp, "Zero"), i = 0;
- CHECK(htable_str_int_set(&htbl, &tmp, &i), R_OK);
+ CHECK(htable_str_int_set(&htbl, &tmp, &i), RES_OK);
str_set(&tmp, "One"), i = 1;
- CHECK(htable_str_int_set(&htbl, &tmp, &i), R_OK);
+ CHECK(htable_str_int_set(&htbl, &tmp, &i), RES_OK);
str_set(&tmp, "Two"), i = 2;
- CHECK(htable_str_int_set(&htbl, &tmp, &i), R_OK);
+ CHECK(htable_str_int_set(&htbl, &tmp, &i), RES_OK);
str_set(&tmp, "Three"), i = 3;
- CHECK(htable_str_int_set(&htbl, &tmp, &i), R_OK);
+ CHECK(htable_str_int_set(&htbl, &tmp, &i), RES_OK);
str_set(&tmp, "Four"), i = 4;
- CHECK(htable_str_int_set(&htbl, &tmp, &i), R_OK);
+ CHECK(htable_str_int_set(&htbl, &tmp, &i), RES_OK);
CHECK(htable_str_int_size_get(&htbl), 5);
str_set(&tmp, "Zero"), i = 'a';
- CHECK(htable_str_int_set(&htbl, &tmp, &i), R_OK);
+ CHECK(htable_str_int_set(&htbl, &tmp, &i), RES_OK);
CHECK(htable_str_int_size_get(&htbl), 5);
data = htable_str_int_find(&htbl, &tmp);
@@ -361,10 +361,10 @@ ANGVBA BS QRZBAF EHA NZBX VA BHE PVGVRF.",
FOR_EACH(i, 0, nstrs) {
darray_char_clear(&darray);
FOR_EACH(j, 0, strlen(str[i]) + 1) {
- CHECK(darray_char_push_back(&darray, str[i] + j), R_OK);
+ CHECK(darray_char_push_back(&darray, str[i] + j), RES_OK);
}
str_set(&tmp, str[i]);
- CHECK(htable_str_darray_set(&htbl, &tmp, &darray), R_OK);
+ CHECK(htable_str_darray_set(&htbl, &tmp, &darray), RES_OK);
}
FOR_EACH(j, 0, nerase) {
@@ -395,7 +395,7 @@ ANGVBA BS QRZBAF EHA NZBX VA BHE PVGVRF.",
htable_str_darray_iterator_next(&it0);
}
- CHECK(htable_str_darray_reserve(&htbl, 2891), R_OK);
+ CHECK(htable_str_darray_reserve(&htbl, 2891), RES_OK);
FOR_EACH(j, 0, 5) {
for(;;) {
diff --git a/src/test_library.c b/src/test_library.c
@@ -44,8 +44,8 @@ main(int argc, char** argv)
CHECK(library_get_symbol(lib, "exported_func_BAD"), NULL);
NCHECK(library_get_symbol(lib, "exported_func"), NULL);
- CHECK(library_close(NULL), R_BAD_ARG);
- CHECK(library_close(lib), R_OK);
+ CHECK(library_close(NULL), RES_BAD_ARG);
+ CHECK(library_close(lib), RES_OK);
CHECK(MEM_ALLOCATED_SIZE(&mem_default_allocator), 0);
diff --git a/src/test_str.c b/src/test_str.c
@@ -30,7 +30,7 @@ main(int argc, char** argv)
CHECK(strcmp(str_get(&str), ""), 0);
CHECK(str_len(&str), 0);
- CHECK(str_set(&str, "Foo"), R_OK);
+ CHECK(str_set(&str, "Foo"), RES_OK);
CHECK(strcmp(str_get(&str), "Foo"), 0);
CHECK(str_len(&str), strlen("Foo"));
@@ -38,7 +38,7 @@ main(int argc, char** argv)
CHECK(strcmp(str_get(&str), ""), 0);
CHECK(str_len(&str), 0);
- CHECK(str_set(&str, __FILE__), R_OK);
+ CHECK(str_set(&str, __FILE__), RES_OK);
CHECK(strcmp(str_get(&str), __FILE__), 0);
str_release(&str);
@@ -46,48 +46,48 @@ main(int argc, char** argv)
CHECK(strcmp(str_get(&str), ""), 0);
CHECK(str_len(&str), 0);
- CHECK(str_set(&str, "Hello world!"), R_OK);
+ CHECK(str_set(&str, "Hello world!"), RES_OK);
CHECK(strcmp(str_get(&str), "Hello world!"), 0);
- NCHECK(str_insert(&str, 13, " insert"), R_OK);
- CHECK(str_insert(&str, 12, " insert"), R_OK);
+ NCHECK(str_insert(&str, 13, " insert"), RES_OK);
+ CHECK(str_insert(&str, 12, " insert"), RES_OK);
CHECK(strcmp(str_get(&str), "Hello world! insert"), 0);
- CHECK(str_insert(&str, 6, "abcdefgh "), R_OK);
+ CHECK(str_insert(&str, 6, "abcdefgh "), RES_OK);
CHECK(strcmp(str_get(&str), "Hello abcdefgh world! insert"), 0);
- CHECK(str_insert(&str, 0, "ABC "), R_OK);
+ CHECK(str_insert(&str, 0, "ABC "), RES_OK);
CHECK(strcmp(str_get(&str), "ABC Hello abcdefgh world! insert"), 0);
- CHECK(str_insert(&str, 11, "0123456789ABCDEF"), R_OK);
+ CHECK(str_insert(&str, 11, "0123456789ABCDEF"), RES_OK);
CHECK(strcmp(str_get(&str),
"ABC Hello a0123456789ABCDEFbcdefgh world! insert"), 0);
CHECK(str_len(&str),
strlen("ABC Hello a0123456789ABCDEFbcdefgh world! insert"));
- CHECK(str_set(&str, "Hello world!"), R_OK);
- CHECK(str_append(&str, " Append"), R_OK);
+ CHECK(str_set(&str, "Hello world!"), RES_OK);
+ CHECK(str_append(&str, " Append"), RES_OK);
CHECK(strcmp(str_get(&str), "Hello world! Append"), 0);
- CHECK(str_append(&str, "!"), R_OK);
+ CHECK(str_append(&str, "!"), RES_OK);
CHECK(strcmp(str_get(&str), "Hello world! Append!"), 0);
- NCHECK(str_insert_char(&str, 21, 'a'), R_OK);
+ NCHECK(str_insert_char(&str, 21, 'a'), RES_OK);
CHECK(strcmp(str_get(&str), "Hello world! Append!"), 0);
- CHECK(str_insert_char(&str, 20, 'a'), R_OK);
+ CHECK(str_insert_char(&str, 20, 'a'), RES_OK);
CHECK(strcmp(str_get(&str), "Hello world! Append!a"), 0);
- CHECK(str_insert_char(&str, 0, '0'), R_OK);
+ CHECK(str_insert_char(&str, 0, '0'), RES_OK);
CHECK(strcmp(str_get(&str), "0Hello world! Append!a"), 0);
- CHECK(str_insert_char(&str, 13, 'A'), R_OK);
+ CHECK(str_insert_char(&str, 13, 'A'), RES_OK);
CHECK(strcmp(str_get(&str), "0Hello world!A Append!a"), 0);
- CHECK(str_append_char(&str, 'z'), R_OK);
+ CHECK(str_append_char(&str, 'z'), RES_OK);
CHECK(strcmp(str_get(&str), "0Hello world!A Append!az"), 0);
- CHECK(str_reserve(&str, 128), R_OK);
- CHECK(str_reserve(&str, 0), R_OK);
+ CHECK(str_reserve(&str, 128), RES_OK);
+ CHECK(str_reserve(&str, 0), RES_OK);
CHECK(strcmp(str_get(&str), "0Hello world!A Append!az"), 0);
- CHECK(str_insert_char(&str, 13, '\0'), R_OK);
+ CHECK(str_insert_char(&str, 13, '\0'), RES_OK);
CHECK(strcmp(str_get(&str), "0Hello world!"), 0);
CHECK(str_len(&str), strlen("0Hello world!"));
- CHECK(str_append_char(&str, '\0'), R_OK);
+ CHECK(str_append_char(&str, '\0'), RES_OK);
CHECK(strcmp(str_get(&str), "0Hello world!"), 0);
CHECK(str_len(&str), strlen("0Hello world!"));
