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

eina gets lots of gcc attributes to its api. 

this should help with optimizations and code correctness, please see
"info gcc" for detailed explanation on these.

if you experience some functions not working as expected, please
double check if they're not marked with EINA_PURE or EINA_CONST, maybe
I misused them. Remove the macro and try again.

brief explanation:

 * EINA_WARN_UNUSED_RESULT: if you forgot to use the return of some
   function, it will emit a warning (and -Werror will make it an
   error). This way it will be harder to miss the attribution
   "l = eina_list_append(l, v)".

 * EINA_ARG_NONNULL(index, index...): if you give it an explicit NULL
   argument, or some tool (ie: clang) finds it could get a NULL but
   this is not accepted by API, then a warning will be emitted.  This
   will help those that still use eina_hash_add() as if it is
   evas_hash_add().

 * EINA_MALLOC: any non-NULL pointer it returns cannot alias any other
   pointer valid when function returns.

 * EINA_PURE: function have no effects other than the return and this
   return just depend on parameters and/or globals. You might call
   this function in a loop a thousand times and it will return the
   same value, thus you may move this function outside the loop and
   remove it.

 * EINA_CONST: stricter version of EINA_PURE, it will not check for
   global parameters, that is, you cannot consider pointer
   arguments. Use it for math things like "int sqrt(int)".

 * EINA_PRINTF(fmt, arg): will check format parameter specified in
   position "fmt" and passed arguments starting at position "arg", it
   will check for things like giving integers where short or strings
   were expected.

 * EINA_SCANF(fmt, arg): similar to eina_printf().

 * EINA_FORMAT(fmt): for use with things like dgettext(), it will get
   a printf-like format string and modifies it.

Please review and test it with your software, make sure you make clean
before you install the new version so it has any effect.

If you find some functions are missing EINA_WARN_UNUSED_RESULT and
EINA_ARG_NONNULL or others, please add them.



SVN revision: 38323
This commit is contained in:
Gustavo Sverzut Barbieri 2008-12-26 13:17:51 +00:00
parent 363ddc283d
commit b0ee5696a6
22 changed files with 245 additions and 166 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
legacy/eina/src/include/eina_accessor.h
View File

@ -42,9 +42,9 @@ typedef void (*Eina_Accessor_Free_Callback)(Eina_Accessor *it);
struct _Eina_Accessor
{
Eina_Accessor_Get_At_Callback get_at;
Eina_Accessor_Get_Container_Callback get_container;
Eina_Accessor_Free_Callback free;
Eina_Accessor_Get_At_Callback get_at EINA_ARG_NONNULL(1, 3) EINA_WARN_UNUSED_RESULT;
Eina_Accessor_Get_Container_Callback get_container EINA_ARG_NONNULL(1) EINA_WARN_UNUSED_RESULT;
Eina_Accessor_Free_Callback free EINA_ARG_NONNULL(1);
#define EINA_MAGIC_ACCESSOR 0x98761232
EINA_MAGIC;
@ -55,16 +55,16 @@ struct _Eina_Accessor
#define FUNC_ACCESSOR_FREE(Function) ((Eina_Accessor_Free_Callback)Function)
EAPI void eina_accessor_free (Eina_Accessor *accessor);
EAPI void eina_accessor_free (Eina_Accessor *accessor) EINA_ARG_NONNULL(1);
EAPI Eina_Bool eina_accessor_data_get (Eina_Accessor *accessor, unsigned int position, void **data);
EAPI void *eina_accessor_container_get (Eina_Accessor *accessor);
EAPI Eina_Bool eina_accessor_data_get (Eina_Accessor *accessor, unsigned int position, void **data) EINA_ARG_NONNULL(1) EINA_PURE;
EAPI void *eina_accessor_container_get (Eina_Accessor *accessor) EINA_ARG_NONNULL(1) EINA_PURE;
EAPI void eina_accessor_over (Eina_Accessor *accessor,
Eina_Each cb,
unsigned int start,
unsigned int end,
const void *fdata);
const void *fdata) EINA_ARG_NONNULL(1, 2);
/**
* @}

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

@ -76,21 +76,21 @@ struct _Eina_Array
EAPI int eina_array_init (void);
EAPI int eina_array_shutdown (void);
EAPI Eina_Array *eina_array_new (unsigned int step);
EAPI void eina_array_free (Eina_Array *array);
EAPI void eina_array_step_set (Eina_Array *array, unsigned int step);
EAPI void eina_array_clean (Eina_Array *array);
EAPI void eina_array_flush (Eina_Array *array);
EAPI Eina_Bool eina_array_remove (Eina_Array *array, Eina_Bool (*keep)(void *data, void *gdata), void *gdata);
EAPI Eina_Array *eina_array_new (unsigned int step) EINA_WARN_UNUSED_RESULT EINA_MALLOC EINA_WARN_UNUSED_RESULT;
EAPI void eina_array_free (Eina_Array *array) EINA_ARG_NONNULL(1);
EAPI void eina_array_step_set (Eina_Array *array, unsigned int step) EINA_ARG_NONNULL(1);
EAPI void eina_array_clean (Eina_Array *array) EINA_ARG_NONNULL(1);
EAPI void eina_array_flush (Eina_Array *array) EINA_ARG_NONNULL(1);
EAPI Eina_Bool eina_array_remove (Eina_Array *array, Eina_Bool (*keep)(void *data, void *gdata), void *gdata) EINA_ARG_NONNULL(1, 2);
static inline Eina_Bool eina_array_push (Eina_Array *array, const void *data);
static inline void *eina_array_pop (Eina_Array *array);
static inline void *eina_array_data_get (const Eina_Array *array, unsigned int index);
static inline void eina_array_data_set (const Eina_Array *array, unsigned int index, const void *data);
static inline unsigned int eina_array_count_get (const Eina_Array *array);
static inline Eina_Bool eina_array_push (Eina_Array *array, const void *data) EINA_ARG_NONNULL(1, 2);
static inline void *eina_array_pop (Eina_Array *array) EINA_ARG_NONNULL(1);
static inline void *eina_array_data_get (const Eina_Array *array, unsigned int index) EINA_ARG_NONNULL(1) EINA_PURE;
static inline void eina_array_data_set (const Eina_Array *array, unsigned int index, const void *data) EINA_ARG_NONNULL(1, 3);
static inline unsigned int eina_array_count_get (const Eina_Array *array) EINA_ARG_NONNULL(1) EINA_PURE;
EAPI Eina_Iterator *eina_array_iterator_new (const Eina_Array *array);
EAPI Eina_Accessor *eina_array_accessor_new (const Eina_Array *array);
EAPI Eina_Iterator *eina_array_iterator_new (const Eina_Array *array) EINA_MALLOC EINA_ARG_NONNULL(1) EINA_WARN_UNUSED_RESULT;
EAPI Eina_Accessor *eina_array_accessor_new (const Eina_Array *array) EINA_MALLOC EINA_ARG_NONNULL(1) EINA_WARN_UNUSED_RESULT;
/**
* @def EINA_ARRAY_ITER_NEXT

8
legacy/eina/src/include/eina_convert.h
View File

@ -55,10 +55,10 @@ EAPI extern Eina_Error EINA_ERROR_CONVERT_OUTRUN_STRING_LENGTH;
EAPI int eina_convert_init(void);
EAPI int eina_convert_shutdown(void);
EAPI int eina_convert_itoa(int n, char *s);
EAPI int eina_convert_xtoa(unsigned int n, char *s);
EAPI int eina_convert_dtoa(double d, char *des);
EAPI Eina_Bool eina_convert_atod(const char *src, int length, long long *m, long *e);
EAPI int eina_convert_itoa(int n, char *s) EINA_ARG_NONNULL(2);
EAPI int eina_convert_xtoa(unsigned int n, char *s) EINA_ARG_NONNULL(2);
EAPI int eina_convert_dtoa(double d, char *des) EINA_ARG_NONNULL(2);
EAPI Eina_Bool eina_convert_atod(const char *src, int length, long long *m, long *e) EINA_ARG_NONNULL(1,3,4);
/**
* @}

10
legacy/eina/src/include/eina_counter.h
View File

@ -42,12 +42,12 @@ typedef struct _Eina_Counter Eina_Counter;
EAPI int eina_counter_init(void);
EAPI int eina_counter_shutdown(void);
EAPI Eina_Counter *eina_counter_add(const char *name);
EAPI void eina_counter_delete(Eina_Counter *counter);
EAPI Eina_Counter *eina_counter_add(const char *name) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
EAPI void eina_counter_delete(Eina_Counter *counter) EINA_ARG_NONNULL(1);
EAPI void eina_counter_start(Eina_Counter *counter);
EAPI void eina_counter_stop(Eina_Counter *counter, int specimen);
EAPI char *eina_counter_dump(Eina_Counter *counter);
EAPI void eina_counter_start(Eina_Counter *counter) EINA_ARG_NONNULL(1);
EAPI void eina_counter_stop(Eina_Counter *counter, int specimen) EINA_ARG_NONNULL(1);
EAPI char *eina_counter_dump(Eina_Counter *counter) EINA_ARG_NONNULL(1);
/**
* @}

8
legacy/eina/src/include/eina_error.h
View File

@ -111,19 +111,19 @@ EAPI extern Eina_Error EINA_ERROR_OUT_OF_MEMORY;
EAPI int eina_error_init(void);
EAPI int eina_error_shutdown(void);
EAPI Eina_Error eina_error_msg_register(const char *msg);
EAPI Eina_Error eina_error_msg_register(const char *msg) EINA_ARG_NONNULL(1);
EAPI Eina_Error eina_error_get(void);
EAPI void eina_error_set(Eina_Error err);
EAPI const char * eina_error_msg_get(Eina_Error error);
EAPI const char * eina_error_msg_get(Eina_Error error) EINA_PURE;
EAPI void eina_error_print(Eina_Error_Level level, const char *file,
const char *function, int line, const char *fmt, ...);
const char *function, int line, const char *fmt, ...) EINA_ARG_NONNULL(2, 3, 5) EINA_PRINTF(5, 6);
EAPI void eina_error_print_cb_stdout(Eina_Error_Level level, const char *file,
const char *fnc, int line, const char *fmt, void *data,
va_list args);
EAPI void eina_error_print_cb_file(Eina_Error_Level level, const char *file,
const char *fnc, int line, const char *fmt, void *data,
va_list args);
EAPI void eina_error_print_cb_set(Eina_Error_Print_Cb cb, void *data);
EAPI void eina_error_print_cb_set(Eina_Error_Print_Cb cb, void *data) EINA_ARG_NONNULL(1);
EAPI void eina_error_log_level_set(Eina_Error_Level level);
/**

4
legacy/eina/src/include/eina_file.h
View File

@ -50,8 +50,8 @@ typedef void (*Eina_File_Dir_List_Cb)(const char *name, const char *path, void *
*/
#define EINA_FILE_DIR_LIST_CB(function) ((Eina_File_Dir_List_Cb)function)
EAPI Eina_Bool eina_file_dir_list(const char *dir, Eina_Bool recursive, Eina_File_Dir_List_Cb cb, void *data);
EAPI Eina_Array *eina_file_split(char *path);
EAPI Eina_Bool eina_file_dir_list(const char *dir, Eina_Bool recursive, Eina_File_Dir_List_Cb cb, void *data) EINA_ARG_NONNULL(1, 3);
EAPI Eina_Array *eina_file_split(char *path) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
/**
* @}

40
legacy/eina/src/include/eina_hash.h
View File

@ -67,7 +67,7 @@ EAPI Eina_Hash * eina_hash_new(Eina_Key_Length key_length_cb,
Eina_Key_Cmp key_cmp_cb,
Eina_Key_Hash key_hash_cb,
Eina_Free_Cb data_free_cb,
int buckets_power_size);
int buckets_power_size) EINA_MALLOC EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1, 2, 3);
EAPI Eina_Hash * eina_hash_string_djb2_new(Eina_Free_Cb data_free_cb);
EAPI Eina_Hash * eina_hash_string_superfast_new(Eina_Free_Cb data_free_cb);
EAPI Eina_Hash * eina_hash_string_small_new(Eina_Free_Cb data_free_cb);
@ -75,43 +75,43 @@ EAPI Eina_Hash * eina_hash_int32_new(Eina_Free_Cb data_free_cb);
EAPI Eina_Hash * eina_hash_int64_new(Eina_Free_Cb data_free_cb);
EAPI Eina_Hash * eina_hash_pointer_new(Eina_Free_Cb data_free_cb);
EAPI Eina_Bool eina_hash_add(Eina_Hash *hash, const void *key, const void *data);
EAPI Eina_Bool eina_hash_direct_add(Eina_Hash *hash, const void *key, const void *data);
EAPI Eina_Bool eina_hash_del(Eina_Hash *hash, const void *key, const void *data);
EAPI void * eina_hash_find(const Eina_Hash *hash, const void *key);
EAPI void * eina_hash_modify(Eina_Hash *hash, const void *key, const void *data);
EAPI void eina_hash_free(Eina_Hash *hash);
EAPI int eina_hash_population(const Eina_Hash *hash);
EAPI Eina_Bool eina_hash_add(Eina_Hash *hash, const void *key, const void *data) EINA_ARG_NONNULL(1, 2, 3);
EAPI Eina_Bool eina_hash_direct_add(Eina_Hash *hash, const void *key, const void *data) EINA_ARG_NONNULL(1, 2, 3);
EAPI Eina_Bool eina_hash_del(Eina_Hash *hash, const void *key, const void *data) EINA_ARG_NONNULL(1);
EAPI void * eina_hash_find(const Eina_Hash *hash, const void *key) EINA_ARG_NONNULL(1, 2);
EAPI void * eina_hash_modify(Eina_Hash *hash, const void *key, const void *data) EINA_ARG_NONNULL(1, 2, 3);
EAPI void eina_hash_free(Eina_Hash *hash) EINA_ARG_NONNULL(1);
EAPI int eina_hash_population(const Eina_Hash *hash) EINA_ARG_NONNULL(1) EINA_PURE;
EAPI Eina_Bool eina_hash_add_by_hash(Eina_Hash *hash,
const void *key, int key_length, int key_hash,
const void *data);
const void *data) EINA_ARG_NONNULL(1, 2, 5);
EAPI Eina_Bool eina_hash_direct_add_by_hash(Eina_Hash *hash,
const void *key, int key_length, int key_hash,
const void *data);
const void *data) EINA_ARG_NONNULL(1, 2, 5);
EAPI Eina_Bool eina_hash_del_by_key_hash(Eina_Hash *hash, const void *key, int key_length, int key_hash);
EAPI Eina_Bool eina_hash_del_by_key_hash(Eina_Hash *hash, const void *key, int key_length, int key_hash) EINA_ARG_NONNULL(1, 2);
EAPI Eina_Bool eina_hash_del_by_key(Eina_Hash *hash, const void *key);
EAPI Eina_Bool eina_hash_del_by_data(Eina_Hash *hash, const void *data);
EAPI Eina_Bool eina_hash_del_by_key(Eina_Hash *hash, const void *key) EINA_ARG_NONNULL(1, 2);
EAPI Eina_Bool eina_hash_del_by_data(Eina_Hash *hash, const void *data) EINA_ARG_NONNULL(1, 2);
EAPI Eina_Bool eina_hash_del_by_hash(Eina_Hash *hash,
const void *key, int key_length, int key_hash,
const void *data);
const void *data) EINA_ARG_NONNULL(1);
EAPI void * eina_hash_find_by_hash(const Eina_Hash *hash,
const void *key, int key_length, int key_hash);
const void *key, int key_length, int key_hash) EINA_ARG_NONNULL(1, 2);
EAPI void * eina_hash_modify_by_hash(Eina_Hash *hash,
const void *key, int key_length, int key_hash,
const void *data);
const void *data) EINA_ARG_NONNULL(1, 2, 5);
EAPI Eina_Iterator * eina_hash_iterator_key_new(const Eina_Hash *hash);
EAPI Eina_Iterator * eina_hash_iterator_data_new(const Eina_Hash *hash);
EAPI Eina_Iterator * eina_hash_iterator_tuple_new(const Eina_Hash *hash);
EAPI Eina_Iterator * eina_hash_iterator_key_new(const Eina_Hash *hash) EINA_MALLOC EINA_ARG_NONNULL(1) EINA_WARN_UNUSED_RESULT;
EAPI Eina_Iterator * eina_hash_iterator_data_new(const Eina_Hash *hash) EINA_MALLOC EINA_ARG_NONNULL(1) EINA_WARN_UNUSED_RESULT;
EAPI Eina_Iterator * eina_hash_iterator_tuple_new(const Eina_Hash *hash) EINA_MALLOC EINA_ARG_NONNULL(1) EINA_WARN_UNUSED_RESULT;
typedef Eina_Bool (*Eina_Hash_Foreach)(const Eina_Hash *hash, const void *key, void *data, void *fdata);
EAPI void eina_hash_foreach(const Eina_Hash *hash,
Eina_Hash_Foreach cb,
const void *fdata);
const void *fdata) EINA_ARG_NONNULL(1, 2);
/* Paul Hsieh (http://www.azillionmonkeys.com/qed/hash.html) hash function
used by WebCore (http://webkit.org/blog/8/hashtables-part-2/) */

18
legacy/eina/src/include/eina_inline_rectangle.x
View File

@ -26,7 +26,7 @@ eina_spans_intersect(int c1, int l1, int c2, int l2)
}
static inline Eina_Bool
eina_rectangle_is_empty(Eina_Rectangle *r)
eina_rectangle_is_empty(const Eina_Rectangle *r)
{
return ((r->w < 1) || (r->h < 1)) ? EINA_TRUE : EINA_FALSE;
}
@ -41,31 +41,31 @@ eina_rectangle_coords_from(Eina_Rectangle *r, int x, int y, int w, int h)
}
static inline Eina_Bool
eina_rectangles_intersect(Eina_Rectangle *r1, Eina_Rectangle *r2)
eina_rectangles_intersect(const Eina_Rectangle *r1, const Eina_Rectangle *r2)
{
return (eina_spans_intersect(r1->x, r1->w, r2->x, r2->w) && eina_spans_intersect(r1->y, r1->h, r2->y, r2->h)) ? EINA_TRUE : EINA_FALSE;
}
static inline Eina_Bool
eina_rectangle_xcoord_inside(Eina_Rectangle *r, int x)
eina_rectangle_xcoord_inside(const Eina_Rectangle *r, int x)
{
return ((x >= r->x) && (x < (r->x + r->w))) ? EINA_TRUE : EINA_FALSE;
}
static inline Eina_Bool
eina_rectangle_ycoord_inside(Eina_Rectangle *r, int y)
eina_rectangle_ycoord_inside(const Eina_Rectangle *r, int y)
{
return ((y >= r->y) && (y < (r->y + r->h))) ? EINA_TRUE : EINA_FALSE;
}
static inline Eina_Bool
eina_rectangle_coords_inside(Eina_Rectangle *r, int x, int y)
eina_rectangle_coords_inside(const Eina_Rectangle *r, int x, int y)
{
return (eina_rectangle_xcoord_inside(r, x) && eina_rectangle_ycoord_inside(r, y)) ? EINA_TRUE : EINA_FALSE;
}
static inline void
eina_rectangle_union(Eina_Rectangle *dst, Eina_Rectangle *src)
eina_rectangle_union(Eina_Rectangle *dst, const Eina_Rectangle *src)
{
/* left */
if (dst->x > src->x)
@ -88,7 +88,7 @@ eina_rectangle_union(Eina_Rectangle *dst, Eina_Rectangle *src)
}
static inline Eina_Bool
eina_rectangle_intersection(Eina_Rectangle *dst, Eina_Rectangle *src)
eina_rectangle_intersection(Eina_Rectangle *dst, const Eina_Rectangle *src)
{
if (!(eina_rectangles_intersect(dst, src)))
return EINA_FALSE;
@ -120,7 +120,7 @@ eina_rectangle_intersection(Eina_Rectangle *dst, Eina_Rectangle *src)
}
static inline void
eina_rectangle_rescale_in(Eina_Rectangle *out, Eina_Rectangle *in, Eina_Rectangle *res)
eina_rectangle_rescale_in(const Eina_Rectangle *out, const Eina_Rectangle *in, Eina_Rectangle *res)
{
res->x = in->x - out->x;
res->y = in->y - out->y;
@ -129,7 +129,7 @@ eina_rectangle_rescale_in(Eina_Rectangle *out, Eina_Rectangle *in, Eina_Rectangl
}
static inline void
eina_rectangle_rescale_out(Eina_Rectangle *out, Eina_Rectangle *in, Eina_Rectangle *res)
eina_rectangle_rescale_out(const Eina_Rectangle *out, const Eina_Rectangle *in, Eina_Rectangle *res)
{
res->x = out->x + in->x;
res->y = out->y + in->y;

20
legacy/eina/src/include/eina_inlist.h
View File

@ -39,17 +39,17 @@ struct _Eina_Inlist
#define EINA_INLIST Eina_Inlist __in_list
#define EINA_INLIST_GET(Inlist) &((Inlist)->__in_list)
EAPI Eina_Inlist * eina_inlist_append(Eina_Inlist *in_list, Eina_Inlist *in_item);
EAPI Eina_Inlist * eina_inlist_prepend(Eina_Inlist *in_list, Eina_Inlist *in_item);
EAPI Eina_Inlist * eina_inlist_append_relative(Eina_Inlist *in_list, Eina_Inlist *in_item, Eina_Inlist *in_relative);
EAPI Eina_Inlist * eina_inlist_prepend_relative(Eina_Inlist *in_list, Eina_Inlist *in_item, Eina_Inlist *in_relative);
EAPI Eina_Inlist * eina_inlist_remove(Eina_Inlist *in_list, Eina_Inlist *in_item);
EAPI Eina_Inlist * eina_inlist_find(Eina_Inlist *in_list, Eina_Inlist *in_item);
EAPI Eina_Inlist * eina_inlist_promote(Eina_Inlist *list, Eina_Inlist *item);
EAPI Eina_Inlist * eina_inlist_demote(Eina_Inlist *list, Eina_Inlist *item);
EAPI Eina_Inlist * eina_inlist_append(Eina_Inlist *in_list, Eina_Inlist *in_item) EINA_ARG_NONNULL(2) EINA_WARN_UNUSED_RESULT;
EAPI Eina_Inlist * eina_inlist_prepend(Eina_Inlist *in_list, Eina_Inlist *in_item) EINA_ARG_NONNULL(2) EINA_WARN_UNUSED_RESULT;
EAPI Eina_Inlist * eina_inlist_append_relative(Eina_Inlist *in_list, Eina_Inlist *in_item, Eina_Inlist *in_relative) EINA_ARG_NONNULL(1, 2, 3) EINA_WARN_UNUSED_RESULT;
EAPI Eina_Inlist * eina_inlist_prepend_relative(Eina_Inlist *in_list, Eina_Inlist *in_item, Eina_Inlist *in_relative) EINA_ARG_NONNULL(1, 2, 3) EINA_WARN_UNUSED_RESULT;
EAPI Eina_Inlist * eina_inlist_remove(Eina_Inlist *in_list, Eina_Inlist *in_item) EINA_ARG_NONNULL(1, 2) EINA_WARN_UNUSED_RESULT;
EAPI Eina_Inlist * eina_inlist_find(Eina_Inlist *in_list, Eina_Inlist *in_item) EINA_ARG_NONNULL(1, 2) EINA_WARN_UNUSED_RESULT;
EAPI Eina_Inlist * eina_inlist_promote(Eina_Inlist *list, Eina_Inlist *item) EINA_ARG_NONNULL(1, 2) EINA_WARN_UNUSED_RESULT;
EAPI Eina_Inlist * eina_inlist_demote(Eina_Inlist *list, Eina_Inlist *item) EINA_ARG_NONNULL(1, 2) EINA_WARN_UNUSED_RESULT;
EAPI Eina_Iterator *eina_inlist_iterator_new(const Eina_Inlist *in_list);
EAPI Eina_Accessor *eina_inlist_accessor_new(const Eina_Inlist *in_list);
EAPI Eina_Iterator *eina_inlist_iterator_new(const Eina_Inlist *in_list) EINA_MALLOC EINA_WARN_UNUSED_RESULT;
EAPI Eina_Accessor *eina_inlist_accessor_new(const Eina_Inlist *in_list) EINA_MALLOC EINA_WARN_UNUSED_RESULT;
#define EINA_INLIST_FOREACH(list, l) for (l = (void*)list; l; l = (void*)(l->__in_list.next))
#define EINA_INLIST_REVERSE_FOREACH(list, l) for (l = (list ? (void*)(list->last) : NULL); l; l = (void*)(l->__in_list.prev))

14
legacy/eina/src/include/eina_iterator.h
View File

@ -42,9 +42,9 @@ typedef void (*Eina_Iterator_Free_Callback)(Eina_Iterator *it);
struct _Eina_Iterator
{
Eina_Iterator_Next_Callback next;
Eina_Iterator_Get_Container_Callback get_container;
Eina_Iterator_Free_Callback free;
Eina_Iterator_Next_Callback next EINA_ARG_NONNULL(1, 2) EINA_WARN_UNUSED_RESULT;
Eina_Iterator_Get_Container_Callback get_container EINA_ARG_NONNULL(1) EINA_WARN_UNUSED_RESULT;
Eina_Iterator_Free_Callback free EINA_ARG_NONNULL(1);
#define EINA_MAGIC_ITERATOR 0x98761233
EINA_MAGIC;
@ -55,14 +55,14 @@ struct _Eina_Iterator
#define FUNC_ITERATOR_GET_CONTAINER(Function) ((Eina_Iterator_Get_Container_Callback)Function)
#define FUNC_ITERATOR_FREE(Function) ((Eina_Iterator_Free_Callback)Function)
EAPI void eina_iterator_free (Eina_Iterator *iterator);
EAPI void eina_iterator_free (Eina_Iterator *iterator) EINA_ARG_NONNULL(1);
EAPI void *eina_iterator_container_get (Eina_Iterator *iterator);
EAPI Eina_Bool eina_iterator_next (Eina_Iterator *iterator, void **data);
EAPI void *eina_iterator_container_get (Eina_Iterator *iterator) EINA_ARG_NONNULL(1) EINA_PURE;
EAPI Eina_Bool eina_iterator_next (Eina_Iterator *iterator, void **data) EINA_ARG_NONNULL(1, 2) EINA_WARN_UNUSED_RESULT;
EAPI void eina_iterator_foreach (Eina_Iterator *iterator,
Eina_Each callback,
const void *fdata);
const void *fdata) EINA_ARG_NONNULL(1, 2);
/**
* @}

8
legacy/eina/src/include/eina_lalloc.h
View File

@ -40,10 +40,10 @@ typedef void (*Eina_Lalloc_Free) (void *user_data);
typedef struct _Eina_Lalloc Eina_Lalloc;
EAPI Eina_Lalloc *eina_lalloc_new(void *data, Eina_Lalloc_Alloc alloc_cb, Eina_Lalloc_Free free_cb, int num_init);
EAPI void eina_lalloc_delete(Eina_Lalloc *a);
EAPI Eina_Bool eina_lalloc_elements_add(Eina_Lalloc *a, int num);
EAPI Eina_Bool eina_lalloc_element_add(Eina_Lalloc *a);
EAPI Eina_Lalloc *eina_lalloc_new(void *data, Eina_Lalloc_Alloc alloc_cb, Eina_Lalloc_Free free_cb, int num_init) EINA_ARG_NONNULL(2, 3);
EAPI void eina_lalloc_delete(Eina_Lalloc *a) EINA_ARG_NONNULL(1);
EAPI Eina_Bool eina_lalloc_elements_add(Eina_Lalloc *a, int num) EINA_ARG_NONNULL(1);
EAPI Eina_Bool eina_lalloc_element_add(Eina_Lalloc *a) EINA_ARG_NONNULL(1);
/**
* @}

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

@ -79,34 +79,34 @@ struct _Eina_List_Accounting
EAPI int eina_list_init(void);
EAPI int eina_list_shutdown(void);
EAPI Eina_List *eina_list_append (Eina_List *list, const void *data);
EAPI Eina_List *eina_list_prepend (Eina_List *list, const void *data);
EAPI Eina_List *eina_list_append_relative (Eina_List *list, const void *data, const void *relative);
EAPI Eina_List *eina_list_append_relative_list (Eina_List *list, const void *data, Eina_List *relative);
EAPI Eina_List *eina_list_prepend_relative (Eina_List *list, const void *data, const void *relative);
EAPI Eina_List *eina_list_prepend_relative_list (Eina_List *list, const void *data, Eina_List *relative);
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_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);
EAPI Eina_List *eina_list_reverse (Eina_List *list);
EAPI Eina_List *eina_list_sort (Eina_List *list, unsigned int size, Eina_Compare_Cb func);
EAPI Eina_List *eina_list_merge (Eina_List *left, Eina_List *right);
EAPI Eina_List *eina_list_sorted_merge(Eina_List *left, Eina_List *right, Eina_Compare_Cb func);
EAPI Eina_List *eina_list_append (Eina_List *list, const void *data) EINA_ARG_NONNULL(2) EINA_WARN_UNUSED_RESULT;
EAPI Eina_List *eina_list_prepend (Eina_List *list, const void *data) EINA_ARG_NONNULL(2) EINA_WARN_UNUSED_RESULT;
EAPI Eina_List *eina_list_append_relative (Eina_List *list, const void *data, const void *relative) EINA_ARG_NONNULL(1, 2, 3) EINA_WARN_UNUSED_RESULT;
EAPI Eina_List *eina_list_append_relative_list (Eina_List *list, const void *data, Eina_List *relative) EINA_ARG_NONNULL(1, 2, 3) EINA_WARN_UNUSED_RESULT;
EAPI Eina_List *eina_list_prepend_relative (Eina_List *list, const void *data, const void *relative) EINA_ARG_NONNULL(1, 2, 3) EINA_WARN_UNUSED_RESULT;
EAPI Eina_List *eina_list_prepend_relative_list (Eina_List *list, const void *data, Eina_List *relative) EINA_ARG_NONNULL(1, 2, 3) EINA_WARN_UNUSED_RESULT;
EAPI Eina_List *eina_list_remove (Eina_List *list, const void *data) EINA_ARG_NONNULL(1, 2) EINA_WARN_UNUSED_RESULT;
EAPI Eina_List *eina_list_remove_list (Eina_List *list, Eina_List *remove_list) EINA_ARG_NONNULL(1, 2) EINA_WARN_UNUSED_RESULT;
EAPI Eina_List *eina_list_promote_list (Eina_List *list, Eina_List *move_list) EINA_ARG_NONNULL(1, 2) EINA_WARN_UNUSED_RESULT;
EAPI void *eina_list_data_find(const Eina_List *list, const void *data) EINA_PURE EINA_ARG_NONNULL(1, 2) EINA_WARN_UNUSED_RESULT;
EAPI Eina_List *eina_list_data_find_list (const Eina_List *list, const void *data) EINA_PURE EINA_ARG_NONNULL(1, 2) EINA_WARN_UNUSED_RESULT;
EAPI Eina_List *eina_list_free (Eina_List *list) EINA_ARG_NONNULL(1);
EAPI void *eina_list_nth(const Eina_List *list, unsigned int n) EINA_PURE EINA_ARG_NONNULL(1) EINA_WARN_UNUSED_RESULT;
EAPI Eina_List *eina_list_nth_list (const Eina_List *list, unsigned int n) EINA_PURE EINA_ARG_NONNULL(1) EINA_WARN_UNUSED_RESULT;
EAPI Eina_List *eina_list_reverse (Eina_List *list) EINA_ARG_NONNULL(1) EINA_WARN_UNUSED_RESULT;
EAPI Eina_List *eina_list_sort (Eina_List *list, unsigned int size, Eina_Compare_Cb func) EINA_ARG_NONNULL(1, 3) EINA_WARN_UNUSED_RESULT;
EAPI Eina_List *eina_list_merge (Eina_List *left, Eina_List *right) EINA_ARG_NONNULL(1, 2) EINA_WARN_UNUSED_RESULT;
EAPI Eina_List *eina_list_sorted_merge(Eina_List *left, Eina_List *right, Eina_Compare_Cb func) EINA_ARG_NONNULL(1, 2, 3) EINA_WARN_UNUSED_RESULT;
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_get(const Eina_List *list);
static inline unsigned int eina_list_count(const Eina_List *list);
static inline Eina_List *eina_list_last (const Eina_List *list) EINA_PURE EINA_WARN_UNUSED_RESULT;
static inline Eina_List *eina_list_next (const Eina_List *list) EINA_PURE EINA_WARN_UNUSED_RESULT;
static inline Eina_List *eina_list_prev (const Eina_List *list) EINA_PURE EINA_WARN_UNUSED_RESULT;
static inline void *eina_list_data_get(const Eina_List *list) EINA_PURE EINA_WARN_UNUSED_RESULT;
static inline unsigned int eina_list_count(const Eina_List *list) EINA_PURE;
EAPI Eina_Iterator *eina_list_iterator_new(const Eina_List *list);
EAPI Eina_Accessor *eina_list_accessor_new(const Eina_List *list);
EAPI Eina_Iterator *eina_list_iterator_new(const Eina_List *list) EINA_MALLOC EINA_WARN_UNUSED_RESULT;
EAPI Eina_Accessor *eina_list_accessor_new(const Eina_List *list) EINA_MALLOC EINA_WARN_UNUSED_RESULT;
/**
* @def EINA_LIST_FOREACH

6
legacy/eina/src/include/eina_magic.h
View File

@ -36,10 +36,10 @@ typedef unsigned int Eina_Magic;
EAPI int eina_magic_string_init(void);
EAPI int eina_magic_string_shutdown(void);
EAPI const char* eina_magic_string_get(Eina_Magic magic);
EAPI void eina_magic_string_set(Eina_Magic magic, const char *magic_name);
EAPI const char* eina_magic_string_get(Eina_Magic magic) EINA_PURE EINA_WARN_UNUSED_RESULT;
EAPI void eina_magic_string_set(Eina_Magic magic, const char *magic_name) EINA_ARG_NONNULL(2);
EAPI void eina_magic_fail(void *d, Eina_Magic m, Eina_Magic req_m,
const char *file, const char *fnc, int line);
const char *file, const char *fnc, int line) EINA_ARG_NONNULL(4, 5);
#else

18
legacy/eina/src/include/eina_mempool.h
View File

@ -35,18 +35,18 @@ EAPI extern Eina_Error EINA_ERROR_NOT_MEMPOOL_MODULE;
EAPI int eina_mempool_init(void);
EAPI int eina_mempool_shutdown(void);
EAPI Eina_Mempool * eina_mempool_new(const char *module, const char *context, const char *options, ...);
EAPI void eina_mempool_delete(Eina_Mempool *mp);
EAPI Eina_Mempool * eina_mempool_new(const char *module, const char *context, const char *options, ...) EINA_MALLOC EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
EAPI void eina_mempool_delete(Eina_Mempool *mp) EINA_ARG_NONNULL(1);
static inline void * eina_mempool_realloc(Eina_Mempool *mp, void *element, unsigned int size);
static inline void * eina_mempool_alloc(Eina_Mempool *mp, unsigned int size);
static inline void eina_mempool_free(Eina_Mempool *mp, void *element);
static inline void * eina_mempool_realloc(Eina_Mempool *mp, void *element, unsigned int size) EINA_ARG_NONNULL(1) EINA_WARN_UNUSED_RESULT;
static inline void * eina_mempool_alloc(Eina_Mempool *mp, unsigned int size) EINA_MALLOC EINA_ARG_NONNULL(1) EINA_WARN_UNUSED_RESULT;
static inline void eina_mempool_free(Eina_Mempool *mp, void *element) EINA_ARG_NONNULL(1);
EAPI void eina_mempool_gc(Eina_Mempool *mp);
EAPI void eina_mempool_statistics(Eina_Mempool *mp);
EAPI void eina_mempool_gc(Eina_Mempool *mp) EINA_ARG_NONNULL(1);
EAPI void eina_mempool_statistics(Eina_Mempool *mp) EINA_ARG_NONNULL(1);
EAPI Eina_Bool eina_mempool_register(Eina_Mempool_Backend *be);
EAPI void eina_mempool_unregister(Eina_Mempool_Backend *be);
EAPI Eina_Bool eina_mempool_register(Eina_Mempool_Backend *be) EINA_ARG_NONNULL(1);
EAPI void eina_mempool_unregister(Eina_Mempool_Backend *be) EINA_ARG_NONNULL(1);
#include "eina_inline_mempool.x"
/** @} */

24
legacy/eina/src/include/eina_module.h
View File

@ -43,20 +43,20 @@ extern EAPI Eina_Error EINA_ERROR_MODULE_INIT_FAILED;
EAPI int eina_module_init(void);
EAPI int eina_module_shutdown(void);
EAPI Eina_Module * eina_module_new(const char *file);
EAPI Eina_Bool eina_module_delete(Eina_Module *m);
EAPI Eina_Bool eina_module_load(Eina_Module *module);
EAPI Eina_Bool eina_module_unload(Eina_Module *m);
EAPI void *eina_module_symbol_get(Eina_Module *module, const char *symbol);
EAPI const char * eina_module_file_get(Eina_Module *m);
EAPI Eina_Module * eina_module_new(const char *file) EINA_MALLOC EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
EAPI Eina_Bool eina_module_delete(Eina_Module *m) EINA_ARG_NONNULL(1);
EAPI Eina_Bool eina_module_load(Eina_Module *module) EINA_ARG_NONNULL(1);
EAPI Eina_Bool eina_module_unload(Eina_Module *m) EINA_ARG_NONNULL(1);
EAPI void *eina_module_symbol_get(Eina_Module *module, const char *symbol) EINA_PURE EINA_ARG_NONNULL(1, 2) EINA_WARN_UNUSED_RESULT;
EAPI const char * eina_module_file_get(Eina_Module *m) EINA_PURE EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
EAPI char *eina_module_symbol_path_get(const void *symbol, const char *sub_dir);
EAPI char *eina_module_environment_path_get(const char *env, const char *sub_dir);
EAPI char *eina_module_symbol_path_get(const void *symbol, const char *sub_dir) EINA_PURE EINA_MALLOC EINA_ARG_NONNULL(1, 2);
EAPI char *eina_module_environment_path_get(const char *env, const char *sub_dir) EINA_PURE EINA_MALLOC EINA_ARG_NONNULL(1, 2);
EAPI Eina_Array * eina_module_list_get(Eina_Array *array, const char *path, unsigned int recursive, Eina_Module_Cb cb, void *data);
EAPI void eina_module_list_load(Eina_Array *list);
EAPI void eina_module_list_unload(Eina_Array *list);
EAPI void eina_module_list_delete(Eina_Array *list);
EAPI Eina_Array * eina_module_list_get(Eina_Array *array, const char *path, unsigned int recursive, Eina_Module_Cb cb, void *data) EINA_MALLOC EINA_ARG_NONNULL(2) EINA_WARN_UNUSED_RESULT;
EAPI void eina_module_list_load(Eina_Array *list) EINA_ARG_NONNULL(1);
EAPI void eina_module_list_unload(Eina_Array *list) EINA_ARG_NONNULL(1);
EAPI void eina_module_list_delete(Eina_Array *list) EINA_ARG_NONNULL(1);
/** @} */

14
legacy/eina/src/include/eina_rbtree.h
View File

@ -55,15 +55,15 @@ typedef int (*Eina_Rbtree_Cmp_Key_Cb)(const Eina_Rbtree *node, const void *key,
typedef void (*Eina_Rbtree_Free_Cb)(Eina_Rbtree *node, void *data);
#define EINA_RBTREE_FREE_CB(Function) ((Eina_Rbtree_Free_Cb) Function)
EAPI Eina_Rbtree *eina_rbtree_inline_insert(Eina_Rbtree *root, Eina_Rbtree *node, Eina_Rbtree_Cmp_Node_Cb cmp, const void *data);
EAPI Eina_Rbtree *eina_rbtree_inline_remove(Eina_Rbtree *root, Eina_Rbtree *node, Eina_Rbtree_Cmp_Node_Cb cmp, const void *data);
EAPI void eina_rbtree_delete(Eina_Rbtree *root, Eina_Rbtree_Free_Cb func, void *data);
EAPI Eina_Rbtree *eina_rbtree_inline_insert(Eina_Rbtree *root, Eina_Rbtree *node, Eina_Rbtree_Cmp_Node_Cb cmp, const void *data) EINA_ARG_NONNULL(2, 3) EINA_WARN_UNUSED_RESULT;
EAPI Eina_Rbtree *eina_rbtree_inline_remove(Eina_Rbtree *root, Eina_Rbtree *node, Eina_Rbtree_Cmp_Node_Cb cmp, const void *data) EINA_ARG_NONNULL(1, 2, 3) EINA_WARN_UNUSED_RESULT;
EAPI void eina_rbtree_delete(Eina_Rbtree *root, Eina_Rbtree_Free_Cb func, void *data) EINA_ARG_NONNULL(1, 2);
static inline Eina_Rbtree *eina_rbtree_inline_lookup(const Eina_Rbtree *root, const void *key, int length, Eina_Rbtree_Cmp_Key_Cb cmp, const void *data);
static inline Eina_Rbtree *eina_rbtree_inline_lookup(const Eina_Rbtree *root, const void *key, int length, Eina_Rbtree_Cmp_Key_Cb cmp, const void *data) EINA_PURE EINA_ARG_NONNULL(1, 2, 4) EINA_WARN_UNUSED_RESULT;
EAPI Eina_Iterator *eina_rbtree_iterator_prefix(const Eina_Rbtree *root);
EAPI Eina_Iterator *eina_rbtree_iterator_infix(const Eina_Rbtree *root);
EAPI Eina_Iterator *eina_rbtree_iterator_postfix(const Eina_Rbtree *root);
EAPI Eina_Iterator *eina_rbtree_iterator_prefix(const Eina_Rbtree *root) EINA_MALLOC EINA_WARN_UNUSED_RESULT;
EAPI Eina_Iterator *eina_rbtree_iterator_infix(const Eina_Rbtree *root) EINA_MALLOC EINA_WARN_UNUSED_RESULT;
EAPI Eina_Iterator *eina_rbtree_iterator_postfix(const Eina_Rbtree *root) EINA_MALLOC EINA_WARN_UNUSED_RESULT;
#include "eina_inline_rbtree.x"

40
legacy/eina/src/include/eina_rectangle.h
View File

@ -40,27 +40,27 @@ typedef struct _Eina_Rectangle
typedef struct _Eina_Rectangle_Pool Eina_Rectangle_Pool;
static inline int eina_spans_intersect(int c1, int l1, int c2, int l2);
static inline Eina_Bool eina_rectangle_is_empty(Eina_Rectangle *r);
static inline void eina_rectangle_coords_from(Eina_Rectangle *r, int x, int y, int w, int h);
static inline Eina_Bool eina_rectangles_intersect(Eina_Rectangle *r1, Eina_Rectangle *r2);
static inline Eina_Bool eina_rectangle_xcoord_inside(Eina_Rectangle *r, int x);
static inline Eina_Bool eina_rectangle_ycoord_inside(Eina_Rectangle *r, int y);
static inline Eina_Bool eina_rectangle_coords_inside(Eina_Rectangle *r, int x, int y);
static inline void eina_rectangle_union(Eina_Rectangle *dst, Eina_Rectangle *src);
static inline Eina_Bool eina_rectangle_intersection(Eina_Rectangle *dst, Eina_Rectangle *src);
static inline void eina_rectangle_rescale_in(Eina_Rectangle *out, Eina_Rectangle *in, Eina_Rectangle *res);
static inline void eina_rectangle_rescale_out(Eina_Rectangle *out, Eina_Rectangle *in, Eina_Rectangle *res);
static inline int eina_spans_intersect(int c1, int l1, int c2, int l2) EINA_CONST EINA_WARN_UNUSED_RESULT;
static inline Eina_Bool eina_rectangle_is_empty(const Eina_Rectangle *r) EINA_PURE EINA_ARG_NONNULL(1) EINA_WARN_UNUSED_RESULT;
static inline void eina_rectangle_coords_from(Eina_Rectangle *r, int x, int y, int w, int h) EINA_ARG_NONNULL(1);
static inline Eina_Bool eina_rectangles_intersect(const Eina_Rectangle *r1, const Eina_Rectangle *r2) EINA_PURE EINA_ARG_NONNULL(1, 2) EINA_WARN_UNUSED_RESULT;
static inline Eina_Bool eina_rectangle_xcoord_inside(const Eina_Rectangle *r, int x) EINA_PURE EINA_ARG_NONNULL(1) EINA_WARN_UNUSED_RESULT;
static inline Eina_Bool eina_rectangle_ycoord_inside(const Eina_Rectangle *r, int y) EINA_PURE EINA_ARG_NONNULL(1) EINA_WARN_UNUSED_RESULT;
static inline Eina_Bool eina_rectangle_coords_inside(const Eina_Rectangle *r, int x, int y) EINA_PURE EINA_ARG_NONNULL(1) EINA_WARN_UNUSED_RESULT;
static inline void eina_rectangle_union(Eina_Rectangle *dst, const Eina_Rectangle *src) EINA_ARG_NONNULL(1, 2);
static inline Eina_Bool eina_rectangle_intersection(Eina_Rectangle *dst, const Eina_Rectangle *src) EINA_ARG_NONNULL(1, 2) EINA_WARN_UNUSED_RESULT;
static inline void eina_rectangle_rescale_in(const Eina_Rectangle *out, const Eina_Rectangle *in, Eina_Rectangle *res) EINA_ARG_NONNULL(1, 2, 3);
static inline void eina_rectangle_rescale_out(const Eina_Rectangle *out, const Eina_Rectangle *in, Eina_Rectangle *res) EINA_ARG_NONNULL(1, 2, 3);
EAPI Eina_Rectangle_Pool *eina_rectangle_pool_add(int w, int h);
EAPI Eina_Rectangle_Pool *eina_rectangle_pool_get(Eina_Rectangle *rect);
EAPI Eina_Bool eina_rectangle_pool_geometry_get(Eina_Rectangle_Pool *pool, int *w, int *h);
EAPI void *eina_rectangle_pool_data_get(Eina_Rectangle_Pool *pool);
EAPI void eina_rectangle_pool_data_set(Eina_Rectangle_Pool *pool, const void *data);
EAPI void eina_rectangle_pool_delete(Eina_Rectangle_Pool *pool);
EAPI int eina_rectangle_pool_count(Eina_Rectangle_Pool *pool);
EAPI Eina_Rectangle *eina_rectangle_pool_request(Eina_Rectangle_Pool *pool, int w, int h);
EAPI void eina_rectangle_pool_release(Eina_Rectangle *rect);
EAPI Eina_Rectangle_Pool *eina_rectangle_pool_add(int w, int h) EINA_MALLOC EINA_WARN_UNUSED_RESULT;
EAPI Eina_Rectangle_Pool *eina_rectangle_pool_get(Eina_Rectangle *rect) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
EAPI Eina_Bool eina_rectangle_pool_geometry_get(Eina_Rectangle_Pool *pool, int *w, int *h) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1) EINA_WARN_UNUSED_RESULT;
EAPI void *eina_rectangle_pool_data_get(Eina_Rectangle_Pool *pool) EINA_PURE EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
EAPI void eina_rectangle_pool_data_set(Eina_Rectangle_Pool *pool, const void *data) EINA_ARG_NONNULL(1);
EAPI void eina_rectangle_pool_delete(Eina_Rectangle_Pool *pool) EINA_ARG_NONNULL(1);
EAPI int eina_rectangle_pool_count(Eina_Rectangle_Pool *pool) EINA_PURE EINA_ARG_NONNULL(1) EINA_WARN_UNUSED_RESULT;
EAPI Eina_Rectangle *eina_rectangle_pool_request(Eina_Rectangle_Pool *pool, int w, int h) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1);
EAPI void eina_rectangle_pool_release(Eina_Rectangle *rect) EINA_ARG_NONNULL(1);
#include "eina_inline_rectangle.x"

4
legacy/eina/src/include/eina_stringshare.h
View File

@ -67,10 +67,10 @@
EAPI int eina_stringshare_init(void);
EAPI int eina_stringshare_shutdown(void);
EAPI const char *eina_stringshare_add(const char *str);
EAPI const char *eina_stringshare_add(const char *str) EINA_WARN_UNUSED_RESULT;
EAPI const char *eina_stringshare_ref(const char *str);
EAPI void eina_stringshare_del(const char *str);
EAPI int eina_stringshare_strlen(const char *str);
EAPI int eina_stringshare_strlen(const char *str) EINA_CONST EINA_WARN_UNUSED_RESULT;
EAPI void eina_stringshare_dump(void);
/**

80
legacy/eina/src/include/eina_types.h
View File

@ -45,6 +45,86 @@
# endif
#endif
#ifdef EINA_WARN_UNUSED_RESULT
# undef EINA_WARN_UNUSED_RESULT
#endif
#ifdef EINA_ARG_NONNULL
# undef EINA_ARG_NONNULL
#endif
#ifdef EINA_MALLOC
# undef EINA_MALLOC
#endif
#ifdef EINA_PURE
# undef EINA_PURE
#endif
#ifdef EINA_PRINTF
# undef EINA_PRINTF
#endif
#ifdef EINA_SCANF
# undef EINA_SCANF
#endif
#ifdef EINA_FORMAT
# undef EINA_FORMAT
#endif
#ifdef EINA_CONST
# undef EINA_CONST
#endif
#ifdef HAVE___ATTRIBUTE__
# ifdef __GNUC__
# if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
# define EINA_WARN_UNUSED_RESULT __attribute__ ((warn_unused_result))
# else
# define EINA_WARN_UNUSED_RESULT
# endif
# if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)
# define EINA_ARG_NONNULL(idx, ...) __attribute__ ((nonnull(idx, ## __VA_ARGS__)))
# else
# define EINA_ARG_NONNULL(idx, ...)
# endif
# if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96)
# define EINA_MALLOC __attribute__ ((malloc))
# define EINA_PURE __attribute__ ((pure))
# else
# define EINA_MALLOC
# define EINA_PURE
# endif
# if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ > 4)
# define EINA_PRINTF(fmt, arg) __attribute__((format (printf, fmt, arg)))
# define EINA_SCANF(fmt, arg) __attribute__((format (scanf, fmt, arg)))
# define EINA_FORMAT(fmt) __attribute__((format_arg(fmt)))
# define EINA_CONST __attribute__((const))
# else
# define EINA_PRINTF(fmt, arg)
# define EINA_SCANF(fmt, arg)
# define EINA_FORMAT(fmt)
# define EINA_CONST
# endif
# else /* no __GNUC__ */
# define EINA_WARN_UNUSED_RESULT
# define EINA_ARG_NONNULL(idx, ...)
# define EINA_MALLOC
# define EINA_PURE
# define EINA_PRINTF(fmt, arg)
# define EINA_SCANF(fmt, arg)
# define EINA_FORMAT(fmt)
# define EINA_CONST
# endif
#else /* no HAVE___ATTRIBUTE__ */
# define EINA_WARN_UNUSED_RESULT
# define EINA_ARG_NONNULL(idx, ...)
# define EINA_MALLOC
# define EINA_PURE
# define EINA_PRINTF(fmt, arg)
# define EINA_SCANF(fmt, arg)
# define EINA_FORMAT(fmt)
# define EINA_CONST
#endif
/* remove this TRUE/FALSE redifinitions */
#ifndef TRUE

2
legacy/eina/src/lib/eina_hash.c
View File

@ -687,7 +687,7 @@ eina_hash_new(Eina_Key_Length key_length_cb,
Eina_Hash *new;
eina_error_set(0);
if (!key_length_cb || !key_cmp_cb) return NULL;
if (!key_length_cb || !key_cmp_cb || !key_hash_cb) return NULL;
if (buckets_power_size < 3 || buckets_power_size > 16) return NULL;
new = malloc(sizeof (Eina_Hash));

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

@ -107,7 +107,7 @@ START_TEST(eina_inlist_simple)
fail_if(lst != (Eina_Inlist*) tmp);
tmp = (Eina_Test_Inlist*) eina_inlist_find(lst, EINA_INLIST_GET(prev));
eina_inlist_remove(lst, EINA_INLIST_GET(tmp));
lst = eina_inlist_remove(lst, EINA_INLIST_GET(tmp));
tmp = (Eina_Test_Inlist*) eina_inlist_find(lst, EINA_INLIST_GET(tmp));
fail_if(tmp != NULL);

1
legacy/eina/src/tests/eina_test_rectangle.c
View File

@ -29,7 +29,6 @@ START_TEST(eina_rectangle_pool)
{
Eina_Rectangle_Pool *pool;
Eina_Rectangle *rects[8][8];
Eina_Rectangle *rct;
int x;
int y;
int w;