kimcinoo
/
efl
forked from enlightenment/efl
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Patch from quarium. 

Add magic to array and list.

Need to patch autotools to generate something like eina_config.h.



SVN revision: 36256
This commit is contained in:
Cedric BAIL 2008-09-25 14:46:16 +00:00
parent e8b25fb405
commit 8b85ce70d4
10 changed files with 284 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
legacy/eina/src/include/eina_array.h
View File

@ -25,6 +25,7 @@
#include "eina_error.h"
#include "eina_iterator.h"
#include "eina_accessor.h"
#include "eina_magic.h"
/**
* @addtogroup Eina_Data_Types_Group Data Types
@ -62,6 +63,8 @@ typedef void **Eina_Array_Iterator;
*/
struct _Eina_Array
{
EINA_MAGIC;
void **data; /**< Pointer to a vector of pointer to payload */
unsigned int total; /**< Total number of slot in the vector */
unsigned int count; /**< Number of activ slot in the vector */

2
legacy/eina/src/include/eina_inline_list.x
View File

@ -49,7 +49,7 @@ eina_list_prev(const Eina_List *list)
}
static inline void *
eina_list_data(const Eina_List *list)
eina_list_data_get(const Eina_List *list)
{
if (!list) return NULL;
return list->data;

13
legacy/eina/src/include/eina_list.h
View File

@ -24,6 +24,7 @@
#include "eina_types.h"
#include "eina_iterator.h"
#include "eina_accessor.h"
#include "eina_magic.h"
/**
* @addtogroup Eina_Data_Types_Group Data Types
@ -57,6 +58,8 @@ typedef struct _Eina_List_Accounting Eina_List_Accounting;
*/
struct _Eina_List /** A linked list node */
{
EINA_MAGIC;
void *data; /**< Pointer to list element payload */
Eina_List *next; /**< Next member in the list */
Eina_List *prev; /**< Previous member in the list */
@ -65,6 +68,8 @@ struct _Eina_List /** A linked list node */
struct _Eina_List_Accounting
{
EINA_MAGIC;
Eina_List *last;
unsigned int count;
};
@ -82,8 +87,8 @@ EAPI Eina_List *eina_list_prepend_relative_list (Eina_List *list, const void *da
EAPI Eina_List *eina_list_remove (Eina_List *list, const void *data);
EAPI Eina_List *eina_list_remove_list (Eina_List *list, Eina_List *remove_list);
EAPI Eina_List *eina_list_promote_list (Eina_List *list, Eina_List *move_list);
EAPI void *eina_list_find(const Eina_List *list, const void *data);
EAPI Eina_List *eina_list_find_list (const Eina_List *list, const void *data);
EAPI void *eina_list_data_find(const Eina_List *list, const void *data);
EAPI Eina_List *eina_list_data_find_list (const Eina_List *list, const void *data);
EAPI Eina_List *eina_list_free (Eina_List *list);
EAPI void *eina_list_nth(const Eina_List *list, unsigned int n);
EAPI Eina_List *eina_list_nth_list (const Eina_List *list, unsigned int n);
@ -93,7 +98,7 @@ EAPI Eina_List *eina_list_sort (Eina_List *list, unsigned int size, Eina_Compare
static inline Eina_List *eina_list_last (const Eina_List *list);
static inline Eina_List *eina_list_next (const Eina_List *list);
static inline Eina_List *eina_list_prev (const Eina_List *list);
static inline void *eina_list_data(const Eina_List *list);
static inline void *eina_list_data_get(const Eina_List *list);
static inline unsigned int eina_list_count(const Eina_List *list);
EAPI Eina_Iterator *eina_list_iterator_new(const Eina_List *list);
@ -128,7 +133,7 @@ EAPI Eina_Accessor *eina_list_accessor_new(const Eina_List *list);
* free(data);
* @endcode
*/
#define EINA_LIST_ITER_NEXT(list, l, data) for (l = list, data = eina_list_data(l); l; l = eina_list_next(l), data = eina_list_data(l))
#define EINA_LIST_ITER_NEXT(list, l, data) for (l = list, data = eina_list_data_get(l); l; l = eina_list_next(l), data = eina_list_data_get(l))
#include "eina_inline_list.x"

88
legacy/eina/src/lib/eina_array.c
View File

@ -48,11 +48,32 @@
* @cond LOCAL
*/
#define EINA_MAGIC_CHECK_ARRAY(d) \
do { \
if (!EINA_MAGIC_CHECK(d, EINA_MAGIC_ARRAY)) \
EINA_MAGIC_FAIL(d, EINA_MAGIC_ARRAY); \
} while (0);
#define EINA_MAGIC_CHECK_ARRAY_ITERATOR(d) \
do { \
if (!EINA_MAGIC_CHECK(d, EINA_MAGIC_ARRAY_ITERATOR)) \
EINA_MAGIC_FAIL(d, EINA_MAGIC_ARRAY_ITERATOR); \
} while (0);
#define EINA_MAGIC_CHECK_ARRAY_ACCESSOR(d) \
do { \
if (!EINA_MAGIC_CHECK(d, EINA_MAGIC_ARRAY_ACCESSOR)) \
EINA_MAGIC_FAIL(d, EINA_MAGIC_ACCESSOR); \
} while (0);
typedef struct _Eina_Iterator_Array Eina_Iterator_Array;
struct _Eina_Iterator_Array
{
Eina_Iterator iterator;
EINA_MAGIC;
const Eina_Array *array;
unsigned int index;
};
@ -62,12 +83,18 @@ struct _Eina_Accessor_Array
{
Eina_Accessor accessor;
EINA_MAGIC;
const Eina_Array *array;
};
static int _eina_array_init_count = 0;
static Eina_Bool
eina_array_iterator_next(Eina_Iterator_Array *it, void **data)
{
EINA_MAGIC_CHECK_ARRAY_ITERATOR(it);
if (!(it->index < eina_array_count_get(it->array)))
return EINA_FALSE;
if (data)
@ -79,18 +106,22 @@ eina_array_iterator_next(Eina_Iterator_Array *it, void **data)
static Eina_Array *
eina_array_iterator_get_container(Eina_Iterator_Array *it)
{
EINA_MAGIC_CHECK_ARRAY_ITERATOR(it);
return (Eina_Array *) it->array;
}
static void
eina_array_iterator_free(Eina_Iterator_Array *it)
{
free(it);
EINA_MAGIC_CHECK_ARRAY_ITERATOR(it);
MAGIC_FREE(it);
}
static Eina_Bool
eina_array_accessor_get_at(Eina_Accessor_Array *it, unsigned int index, void **data)
{
EINA_MAGIC_CHECK_ARRAY_ACCESSOR(it);
if (!(index < eina_array_count_get(it->array)))
return EINA_FALSE;
if (data)
@ -101,13 +132,15 @@ eina_array_accessor_get_at(Eina_Accessor_Array *it, unsigned int index, void **d
static Eina_Array *
eina_array_accessor_get_container(Eina_Accessor_Array *it)
{
EINA_MAGIC_CHECK_ARRAY_ACCESSOR(it);
return (Eina_Array *) it->array;
}
static void
eina_array_accessor_free(Eina_Accessor_Array *it)
{
free(it);
EINA_MAGIC_CHECK_ARRAY_ACCESSOR(it);
MAGIC_FREE(it);
}
EAPI Eina_Bool
@ -116,6 +149,8 @@ eina_array_grow(Eina_Array *array)
void **tmp;
unsigned int total;
EINA_MAGIC_CHECK_ARRAY(array);
total = array->total + array->step;
eina_error_set(0);
tmp = realloc(array->data, sizeof (void*) * total);
@ -188,7 +223,24 @@ eina_array_grow(Eina_Array *array)
EAPI int
eina_array_init(void)
{
return eina_error_init();
if (!_eina_array_init_count)
{
eina_error_init();
eina_magic_string_init();
eina_magic_string_set(EINA_MAGIC_ITERATOR,
"Eina Iterator");
eina_magic_string_set(EINA_MAGIC_ACCESSOR,
"Eina Accessor");
eina_magic_string_set(EINA_MAGIC_ARRAY,
"Eina Array");
eina_magic_string_set(EINA_MAGIC_ARRAY_ITERATOR,
"Eina Array Iterator");
eina_magic_string_set(EINA_MAGIC_ARRAY_ACCESSOR,
"Eina Array Accessor");
}
return ++_eina_array_init_count;
}
/**
@ -205,7 +257,14 @@ eina_array_init(void)
EAPI int
eina_array_shutdown(void)
{
return eina_error_shutdown();
--_eina_array_init_count;
if (!_eina_array_init_count)
{
eina_magic_string_shutdown();
eina_error_shutdown();
}
return _eina_array_init_count;
}
/**
@ -234,6 +293,8 @@ eina_array_new(unsigned int step)
return NULL;
}
EINA_MAGIC_SET(array, EINA_MAGIC_ARRAY);
array->data = NULL;
array->total = 0;
array->count = 0;
@ -257,7 +318,9 @@ EAPI void
eina_array_free(Eina_Array *array)
{
eina_array_flush(array);
free(array);
EINA_MAGIC_CHECK_ARRAY(array);
MAGIC_FREE(array);
}
/**
@ -273,7 +336,11 @@ eina_array_free(Eina_Array *array)
EAPI void
eina_array_step_set(Eina_Array *array, unsigned int step)
{
array->step = step;
array->data = NULL;
array->total = 0;
array->count = 0;
array->step = step;
EINA_MAGIC_SET(array, EINA_MAGIC_ARRAY);
}
/**
@ -288,6 +355,7 @@ eina_array_step_set(Eina_Array *array, unsigned int step)
EAPI void
eina_array_clean(Eina_Array *array)
{
EINA_MAGIC_CHECK_ARRAY(array);
array->count = 0;
}
@ -304,6 +372,7 @@ eina_array_clean(Eina_Array *array)
EAPI void
eina_array_flush(Eina_Array *array)
{
EINA_MAGIC_CHECK_ARRAY(array);
array->count = 0;
array->total = 0;
@ -337,6 +406,7 @@ eina_array_remove(Eina_Array *array, Eina_Bool (*keep)(void *data, void *gdata),
unsigned int limit;
unsigned int i;
EINA_MAGIC_CHECK_ARRAY(array);
if (array->total == 0) return EINA_TRUE;
for (i = 0; i < array->count; ++i)
@ -434,6 +504,9 @@ eina_array_iterator_new(const Eina_Array *array)
return NULL;
}
EINA_MAGIC_SET(it, EINA_MAGIC_ARRAY_ITERATOR);
EINA_MAGIC_SET(&it->iterator, EINA_MAGIC_ITERATOR);
it->array = array;
it->iterator.next = FUNC_ITERATOR_NEXT(eina_array_iterator_next);
@ -469,6 +542,9 @@ eina_array_accessor_new(const Eina_Array *array)
return NULL;
}
EINA_MAGIC_SET(it, EINA_MAGIC_ARRAY_ACCESSOR);
EINA_MAGIC_SET(&it->accessor, EINA_MAGIC_ACCESSOR);
it->array = array;
it->accessor.get_at = FUNC_ACCESSOR_GET_AT(eina_array_accessor_get_at);

14
legacy/eina/src/lib/eina_error.c
View File

@ -374,7 +374,7 @@
* @cond LOCAL
*/
static int _init_count = 0;
static int _eina_error_init_count = 0;
static Eina_List *_error_list;
static Eina_Error _err;
static Eina_Error_Print_Cb _print_cb = eina_error_print_cb_stdout;
@ -519,7 +519,7 @@ EAPI Eina_Error EINA_ERROR_OUT_OF_MEMORY = 0;
*/
EAPI int eina_error_init(void)
{
if (!_init_count)
if (!_eina_error_init_count)
{
char *level;
/* TODO register the eina's basic errors */
@ -531,7 +531,7 @@ EAPI int eina_error_init(void)
EINA_ERROR_OUT_OF_MEMORY = eina_error_msg_register("Out of memory");
}
/* get all the modules */
return ++_init_count;
return ++_eina_error_init_count;
}
/**
@ -548,17 +548,17 @@ EAPI int eina_error_init(void)
*/
EAPI int eina_error_shutdown(void)
{
_init_count--;
if (!_init_count)
_eina_error_init_count--;
if (!_eina_error_init_count)
{
/* remove the error strings */
while (_error_list)
{
free(eina_list_data(_error_list));
free(eina_list_data_get(_error_list));
_error_list = eina_list_free(_error_list);
}
}
return _init_count;
return _eina_error_init_count;
}
/**

188
legacy/eina/src/lib/eina_list.c
View File

@ -64,7 +64,7 @@
# include "config.h"
#endif
#include <assert.h>
#include <stdio.h>
#include "eina_error.h"
#include "eina_list.h"
@ -78,6 +78,30 @@
* @cond LOCAL
*/
#define EINA_MAGIC_CHECK_LIST(d) \
do { \
if (!EINA_MAGIC_CHECK(d, EINA_MAGIC_LIST)) \
EINA_MAGIC_FAIL(d, EINA_MAGIC_LIST); \
} while(0);
#define EINA_MAGIC_CHECK_LIST_ITERATOR(d) \
do { \
if (!EINA_MAGIC_CHECK(d, EINA_MAGIC_LIST_ITERATOR)) \
EINA_MAGIC_FAIL(d, EINA_MAGIC_LIST_ITERATOR); \
} while(0);
#define EINA_MAGIC_CHECK_LIST_ACCESSOR(d) \
do { \
if (!EINA_MAGIC_CHECK(d, EINA_MAGIC_LIST_ACCESSOR)) \
EINA_MAGIC_FAIL(d, EINA_MAGIC_LIST_ACCESSOR); \
} while(0);
#define EINA_MAGIC_CHECK_LIST_ACCOUNTING(d) \
do { \
if (!EINA_MAGIC_CHECK(d, EINA_MAGIC_LIST_ACCOUNTING)) \
EINA_MAGIC_FAIL(d, EINA_MAGIC_LIST_ACCOUNTING); \
} while(0);
typedef struct _Eina_Iterator_List Eina_Iterator_List;
typedef struct _Eina_Accessor_List Eina_Accessor_List;
@ -85,6 +109,8 @@ struct _Eina_Iterator_List
{
Eina_Iterator iterator;
EINA_MAGIC;
const Eina_List *head;
const Eina_List *current;
};
@ -93,12 +119,16 @@ struct _Eina_Accessor_List
{
Eina_Accessor accessor;
EINA_MAGIC;
const Eina_List *head;
const Eina_List *current;
unsigned int index;
};
static int _eina_list_init_count = 0;
static inline Eina_List_Accounting*
_eina_list_mempool_accounting_new(__UNUSED__ Eina_List *list)
{
@ -107,12 +137,16 @@ _eina_list_mempool_accounting_new(__UNUSED__ Eina_List *list)
tmp = malloc(sizeof (Eina_List_Accounting));
if (!tmp) eina_error_set(EINA_ERROR_OUT_OF_MEMORY);
EINA_MAGIC_SET(tmp, EINA_MAGIC_LIST_ACCOUNTING);
return tmp;
}
static inline void
_eina_list_mempool_accounting_free(Eina_List_Accounting *accounting)
{
free(accounting);
EINA_MAGIC_CHECK_LIST_ACCOUNTING(accounting);
MAGIC_FREE(accounting);
}
static inline Eina_List*
@ -123,21 +157,27 @@ _eina_list_mempool_list_new(__UNUSED__ Eina_List *list)
tmp = malloc(sizeof (Eina_List));
if (!tmp) eina_error_set(EINA_ERROR_OUT_OF_MEMORY);
EINA_MAGIC_SET(tmp, EINA_MAGIC_LIST);
return tmp;
}
static inline void
_eina_list_mempool_list_free(Eina_List *list)
{
EINA_MAGIC_CHECK_LIST(list);
list->accounting->count--;
if (list->accounting->count == 0)
_eina_list_mempool_accounting_free(list->accounting);
free(list);
MAGIC_FREE(list);
}
static Eina_List *
_eina_list_setup_accounting(Eina_List *list)
{
EINA_MAGIC_CHECK_LIST(list);
list->accounting = _eina_list_mempool_accounting_new(list);
if (!list->accounting) goto on_error;
@ -154,6 +194,9 @@ _eina_list_setup_accounting(Eina_List *list)
static inline void
_eina_list_update_accounting(Eina_List *list, Eina_List *new_list)
{
EINA_MAGIC_CHECK_LIST(list);
EINA_MAGIC_CHECK_LIST(new_list);
list->accounting->count++;
new_list->accounting = list->accounting;
}
@ -176,8 +219,10 @@ static Eina_Mempool2 _eina_list_accounting_mempool =
static Eina_Bool
eina_list_iterator_next(Eina_Iterator_List *it, void **data)
{
EINA_MAGIC_CHECK_LIST_ITERATOR(it);
if (it->current == NULL) return EINA_FALSE;
if (data) *data = eina_list_data(it->current);
if (data) *data = eina_list_data_get(it->current);
it->current = eina_list_next(it->current);
@ -187,13 +232,17 @@ eina_list_iterator_next(Eina_Iterator_List *it, void **data)
static Eina_List *
eina_list_iterator_get_container(Eina_Iterator_List *it)
{
EINA_MAGIC_CHECK_LIST_ITERATOR(it);
return (Eina_List *) it->head;
}
static void
eina_list_iterator_free(Eina_Iterator_List *it)
{
free(it);
EINA_MAGIC_CHECK_LIST_ITERATOR(it);
MAGIC_FREE(it);
}
static Eina_Bool
@ -203,6 +252,8 @@ eina_list_accessor_get_at(Eina_Accessor_List *it, unsigned int index, void **dat
unsigned int middle;
unsigned int i;
EINA_MAGIC_CHECK_LIST_ACCESSOR(it);
if (index > eina_list_count(it->head)) return EINA_FALSE;
if (it->index == index)
@ -259,20 +310,24 @@ eina_list_accessor_get_at(Eina_Accessor_List *it, unsigned int index, void **dat
it->current = over;
it->index = index;
if (data) *data = eina_list_data(it->current);
if (data) *data = eina_list_data_get(it->current);
return EINA_TRUE;
}
static Eina_List *
eina_list_accessor_get_container(Eina_Accessor_List *it)
{
EINA_MAGIC_CHECK_LIST_ACCESSOR(it);
return (Eina_List *) it->head;
}
static void
eina_list_accessor_free(Eina_Accessor_List *it)
{
free(it);
EINA_MAGIC_CHECK_LIST_ACCESSOR(it);
MAGIC_FREE(it);
}
/**
@ -310,7 +365,26 @@ eina_list_accessor_free(Eina_Accessor_List *it)
EAPI int
eina_list_init(void)
{
return eina_error_init();
if (!_eina_list_init_count)
{
eina_error_init();
eina_magic_string_init();
eina_magic_string_set(EINA_MAGIC_ITERATOR,
"Eina Iterator");
eina_magic_string_set(EINA_MAGIC_ACCESSOR,
"Eina Accessor");
eina_magic_string_set(EINA_MAGIC_LIST,
"Eina List");
eina_magic_string_set(EINA_MAGIC_LIST_ITERATOR,
"Eina List Iterator");
eina_magic_string_set(EINA_MAGIC_LIST_ACCESSOR,
"Eina List Accessor");
eina_magic_string_set(EINA_MAGIC_LIST_ACCOUNTING,
"Eina List Accounting");
}
return ++_eina_list_init_count;
}
/**
@ -327,7 +401,15 @@ eina_list_init(void)
EAPI int
eina_list_shutdown(void)
{
return eina_error_shutdown();
--_eina_list_init_count;
if (!_eina_list_init_count)
{
eina_magic_string_shutdown();
eina_error_shutdown();
}
return _eina_list_init_count;
}
/**
@ -373,6 +455,8 @@ eina_list_append(Eina_List *list, const void *data)
return _eina_list_setup_accounting(new_l);
}
EINA_MAGIC_CHECK_LIST(list);
l = list->accounting->last;
list->accounting->last = new_l;
@ -426,6 +510,8 @@ eina_list_prepend(Eina_List *list, const void *data)
if (!list) return _eina_list_setup_accounting(new_l);
EINA_MAGIC_CHECK_LIST(list);
list->prev = new_l;
_eina_list_update_accounting(list, new_l);
@ -475,12 +561,16 @@ EAPI Eina_List *
eina_list_append_relative(Eina_List *list, const void *data, const void *relative)
{
Eina_List *l;
void *list_data;
for (l = list; l; l = l->next)
if (list) EINA_MAGIC_CHECK_LIST(list);
EINA_LIST_ITER_NEXT(list, l, list_data)
{
if (l->data == relative)
if (list_data == relative)
return eina_list_append_relative_list(list, data, l);
}
return eina_list_append(list, data);
}
@ -511,6 +601,7 @@ eina_list_append_relative_list(Eina_List *list, const void *data, Eina_List *rel
new_l = _eina_list_mempool_list_new(list);
if (!new_l) return list;
EINA_MAGIC_CHECK_LIST(relative);
new_l->next = relative->next;
new_l->data = (void *)data;
@ -570,10 +661,13 @@ EAPI Eina_List *
eina_list_prepend_relative(Eina_List *list, const void *data, const void *relative)
{
Eina_List *l;
void *list_data;
for (l = list; l; l = l->next)
if (list) EINA_MAGIC_CHECK_LIST(list);
EINA_LIST_ITER_NEXT(list, l, list_data)
{
if (l->data == relative)
if (list_data == relative)
return eina_list_prepend_relative_list(list, data, l);
}
return eina_list_prepend(list, data);
@ -606,6 +700,8 @@ eina_list_prepend_relative_list(Eina_List *list, const void *data, Eina_List *re
new_l = _eina_list_mempool_list_new(list);
if (!new_l) return list;
EINA_MAGIC_CHECK_LIST(relative);
new_l->prev = relative->prev;
new_l->next = relative;
new_l->data = (void *)data;
@ -639,12 +735,16 @@ EAPI Eina_List *
eina_list_remove(Eina_List *list, const void *data)
{
Eina_List *l;
void *list_data;
for (l = list; l; l = l->next)
if (list) EINA_MAGIC_CHECK_LIST(list);
EINA_LIST_ITER_NEXT(list, l, list_data)
{
if (l->data == data)
if (list_data == data)
return eina_list_remove_list(list, l);
}
return list;
}
@ -667,10 +767,11 @@ eina_list_remove(Eina_List *list, const void *data)
* extern Eina_List *list;
* Eina_List *l;
* extern void *my_data;
* void *data
*
* for (l = list; l; l= l->next)
* EINA_LIST_ITER_NEXT(list, l, data)
* {
* if (l->data == my_data)
* if (data == my_data)
* {
* list = eina_list_remove_list(list, l);
* break;
@ -685,6 +786,9 @@ eina_list_remove_list(Eina_List *list, Eina_List *remove_list)
if (!list) return NULL;
if (!remove_list) return list;
EINA_MAGIC_CHECK_LIST(remove_list);
if (remove_list->next) remove_list->next->prev = remove_list->prev;
if (remove_list->prev)
{
@ -694,7 +798,10 @@ eina_list_remove_list(Eina_List *list, Eina_List *remove_list)
else
return_l = remove_list->next;
if (remove_list == list->accounting->last)
list->accounting->last = remove_list->prev;
{
EINA_MAGIC_CHECK_LIST(list);
list->accounting->last = remove_list->prev;
}
_eina_list_mempool_list_free(remove_list);
return return_l;
@ -715,6 +822,9 @@ eina_list_free(Eina_List *list)
Eina_List *l, *free_l;
if (!list) return NULL;
EINA_MAGIC_CHECK_LIST(list);
for (l = list; l;)
{
free_l = l;
@ -722,6 +832,7 @@ eina_list_free(Eina_List *list)
_eina_list_mempool_list_free(free_l);
}
return NULL;
}
@ -742,10 +853,11 @@ eina_list_free(Eina_List *list)
* extern Eina_List *list;
* Eina_List *l;
* extern void *my_data;
* void *data;
*
* for (l = list; l; l= l->next)
* EINA_LIST_ITER_NEXT(list, l, data)
* {
* if (l->data == my_data)
* if (data == my_data)
* {
* list = eina_list_promote_list(list, l);
* break;
@ -761,6 +873,9 @@ eina_list_promote_list(Eina_List *list, Eina_List *move_list)
/* Promoting head to be head. */
if (move_list == list) return list;
EINA_MAGIC_CHECK_LIST(list);
EINA_MAGIC_CHECK_LIST(move_list);
/* Update pointer to the last entry if necessary. */
if (move_list == list->accounting->last)
list->accounting->last = move_list->prev;
@ -770,8 +885,6 @@ eina_list_promote_list(Eina_List *list, Eina_List *move_list)
if (move_list->prev) move_list->prev->next = move_list->next;
else list = move_list->next;
assert(list);
move_list->prev = list->prev;
if (list->prev)
list->prev->next = move_list;
@ -796,16 +909,16 @@ eina_list_promote_list(Eina_List *list, Eina_List *move_list)
* extern Eina_List *list;
* extern void *my_data;
*
* if (eina_list_find(list, my_data) == my_data)
* if (eina_list_data_find(list, my_data) == my_data)
* {
* printf("Found member %p\n", my_data);
* }
* @endcode
*/
EAPI void *
eina_list_find(const Eina_List *list, const void *data)
eina_list_data_find(const Eina_List *list, const void *data)
{
if (eina_list_find_list(list, data)) return (void*) data;
if (eina_list_data_find_list(list, data)) return (void*) data;
return NULL;
}
@ -822,14 +935,18 @@ eina_list_find(const Eina_List *list, const void *data)
* @c NULL is returned.
*/
EAPI Eina_List *
eina_list_find_list(const Eina_List *list, const void *data)
eina_list_data_find_list(const Eina_List *list, const void *data)
{
const Eina_List *l;
void *list_data;
for (l = list; l; l = l->next)
if (list) EINA_MAGIC_CHECK_LIST(list);
EINA_LIST_ITER_NEXT(list, l, list_data)
{
if (l->data == data) return (Eina_List *)l;
if (list_data == data) return (Eina_List *)l;
}
return NULL;
}
@ -874,6 +991,8 @@ eina_list_nth_list(const Eina_List *list, unsigned int n)
const Eina_List *l;
unsigned int i;
if (list) EINA_MAGIC_CHECK_LIST(list);
/* check for non-existing nodes */
if ((!list) || (n > (list->accounting->count - 1)))
return NULL;
@ -950,7 +1069,7 @@ static inline Eina_List *eina_list_prev(const Eina_List *list);
* list. It is equivalent to list->data. If @p list is @c NULL, this
* function returns @c NULL.
*/
static inline void *eina_list_data(const Eina_List *list);
static inline void *eina_list_data_get(const Eina_List *list);
/**
* @brief Get the count of the number of items in a list.
@ -982,6 +1101,9 @@ eina_list_reverse(Eina_List *list)
Eina_List *l1, *l2;
if (!list) return NULL;
EINA_MAGIC_CHECK_LIST(list);
l1 = list;
l2 = list->accounting->last;
while (l1 != l2)
@ -1047,6 +1169,8 @@ eina_list_sort(Eina_List *list, unsigned int size, Eina_Compare_Cb func)
if (!list || !func) return NULL;
EINA_MAGIC_CHECK_LIST(list);
/* if the caller specified an invalid size, sort the whole list */
if ((size == 0) ||
(size > list->accounting->count))
@ -1165,6 +1289,9 @@ eina_list_iterator_new(const Eina_List *list)
return NULL;
}
EINA_MAGIC_SET(it, EINA_MAGIC_LIST_ITERATOR);
EINA_MAGIC_SET(&it->iterator, EINA_MAGIC_ITERATOR);
it->head = list;
it->current = list;
@ -1201,6 +1328,9 @@ eina_list_accessor_new(const Eina_List *list)
return NULL;
}
EINA_MAGIC_SET(it, EINA_MAGIC_LIST_ACCESSOR);
EINA_MAGIC_SET(&it->accessor, EINA_MAGIC_ACCESSOR);
it->head = list;
it->current = list;
it->index = 0;

6
legacy/eina/src/lib/eina_module.c
View File

@ -290,7 +290,7 @@ EAPI void eina_module_list_load(Eina_List *list)
{
Eina_Module *m;
m = eina_list_data(l);
m = eina_list_data_get(l);
eina_module_load(m);
}
}
@ -306,7 +306,7 @@ EAPI void eina_module_list_unload(Eina_List *list)
{
Eina_Module *m;
m = eina_list_data(l);
m = eina_list_data_get(l);
eina_module_unload(m);
}
}
@ -323,7 +323,7 @@ EAPI void eina_module_list_delete(Eina_List *list)
{
Eina_Module *m;
m = eina_list_data(l);
m = eina_list_data_get(l);
eina_module_delete(m);
}
}

14
legacy/eina/src/tests/eina_bench_array.c
View File

@ -204,7 +204,7 @@ eina_bench_list_4evas_render(int request)
{
while (list)
{
free(eina_list_data(list));
free(eina_list_data_get(list));
list = eina_list_remove_list(list, list);
}
}
@ -217,7 +217,7 @@ eina_bench_list_4evas_render(int request)
{
Eina_List *reminder = tmp;
ebo = eina_list_data(reminder);
ebo = eina_list_data_get(reminder);
tmp = eina_list_next(tmp);
if (ebo->keep == EINA_FALSE)
@ -231,7 +231,7 @@ eina_bench_list_4evas_render(int request)
for (tmp = list; tmp; tmp = eina_list_next(tmp))
{
ebo = eina_list_data(tmp);
ebo = eina_list_data_get(tmp);
ebo->keep = rand() < (RAND_MAX / 2) ? ebo->keep : EINA_FALSE;
}
@ -239,7 +239,7 @@ eina_bench_list_4evas_render(int request)
while (list)
{
free(eina_list_data(list));
free(eina_list_data_get(list));
list = eina_list_remove_list(list, list);
}
@ -274,7 +274,7 @@ eina_bench_list_4evas_render_iterator(int request)
{
while (list)
{
free(eina_list_data(list));
free(eina_list_data_get(list));
list = eina_list_remove_list(list, list);
}
}
@ -287,7 +287,7 @@ eina_bench_list_4evas_render_iterator(int request)
{
Eina_List *reminder = tmp;
ebo = eina_list_data(reminder);
ebo = eina_list_data_get(reminder);
tmp = eina_list_next(tmp);
if (ebo->keep == EINA_FALSE)
@ -306,7 +306,7 @@ eina_bench_list_4evas_render_iterator(int request)
while (list)
{
free(eina_list_data(list));
free(eina_list_data_get(list));
list = eina_list_remove_list(list, list);
}

2
legacy/eina/src/tests/eina_bench_sort.c
View File

@ -69,7 +69,7 @@ eina_bench_sort_eina(int request)
while (list)
{
free(eina_list_data(list));
free(eina_list_data_get(list));
list = eina_list_remove_list(list, list);
}

24
legacy/eina/src/tests/eina_test_list.c
View File

@ -21,10 +21,10 @@
#include "eina_list.h"
#include "eina_suite.h"
static int eina_int_cmp(void *a, void *b)
static int eina_int_cmp(const void *a, const void *b)
{
int *ia = a;
int *ib = b;
const int *ia = a;
const int *ib = b;
return *ia - *ib;
}
@ -57,7 +57,7 @@ START_TEST(eina_test_simple)
list = eina_list_remove(list, &data[0]);
fail_if(list == NULL);
tmp = eina_list_find_list(list, &data[2]);
tmp = eina_list_data_find_list(list, &data[2]);
fail_if(tmp == NULL);
list = eina_list_append_relative_list(list, &data[3], tmp);
@ -78,9 +78,9 @@ START_TEST(eina_test_simple)
list = eina_list_remove_list(list, tmp);
fail_if(list == NULL);
fail_if(eina_list_find_list(list, &data[2]) != NULL);
fail_if(eina_list_find(list, &data[2]) != NULL);
fail_if(eina_list_find(list, &data[5]) != &data[5]);
fail_if(eina_list_data_find_list(list, &data[2]) != NULL);
fail_if(eina_list_data_find(list, &data[2]) != NULL);
fail_if(eina_list_data_find(list, &data[5]) != &data[5]);
fail_if(eina_list_count(list) != 5);
fail_if(eina_list_nth(list, 4) != &data[3]);
@ -91,7 +91,7 @@ START_TEST(eina_test_simple)
{
int *data;
data = eina_list_data(tmp);
data = eina_list_data_get(tmp);
fail_if(data == NULL);
fail_if(*data != result[i]);
}
@ -102,7 +102,7 @@ START_TEST(eina_test_simple)
{
int *data;
data = eina_list_data(tmp);
data = eina_list_data_get(tmp);
fail_if(data == NULL);
fail_if(*data != result[i - 1]);
}
@ -136,7 +136,7 @@ START_TEST(eina_test_simple)
{
int *data;
data = eina_list_data(tmp);
data = eina_list_data_get(tmp);
fail_if(*test1 > *data);
test1 = data;
@ -156,8 +156,8 @@ START_TEST(eina_test_simple)
list = eina_list_promote_list(eina_list_next(list), list);
fail_if(list == NULL);
fail_if(eina_list_data(list) != test1);
fail_if(eina_list_data(eina_list_next(list)) != test2);
fail_if(eina_list_data_get(list) != test1);
fail_if(eina_list_data_get(eina_list_next(list)) != test2);
list = eina_list_remove_list(list, list);
fail_if(list == NULL);