diff --git a/legacy/eina/win32/patch/eina.diff b/legacy/eina/win32/patch/eina.diff new file mode 100644 index 0000000000..b68fbf4fdf --- /dev/null +++ b/legacy/eina/win32/patch/eina.diff @@ -0,0 +1,952 @@ +--- ../../src/lib/eina_array.c 2010-04-15 06:29:24 +0000 ++++ ../../src/lib/eina_array_new.c 2010-04-15 06:32:11 +0000 +@@ -144,21 +144,39 @@ + EINA_MAGIC_FAIL(d, EINA_MAGIC_ARRAY); \ + } while (0) + +-#define EINA_MAGIC_CHECK_ARRAY_ITERATOR(d, ...) \ ++#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); \ +- return __VA_ARGS__; \ ++ return; \ + } \ + } while (0) + +-#define EINA_MAGIC_CHECK_ARRAY_ACCESSOR(d, ...) \ ++#define EINA_MAGIC_CHECK_ARRAY_ITERATOR_RETURN(d,ret) \ ++ do { \ ++ if (!EINA_MAGIC_CHECK(d, EINA_MAGIC_ARRAY_ITERATOR)) \ ++ { \ ++ EINA_MAGIC_FAIL(d, EINA_MAGIC_ARRAY_ITERATOR); \ ++ return ret; \ ++ } \ ++ } 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); \ ++ return; \ ++ } \ ++ } while (0) ++ ++#define EINA_MAGIC_CHECK_ARRAY_ACCESSOR_RETURN(d,ret) \ + do { \ + if (!EINA_MAGIC_CHECK(d, EINA_MAGIC_ARRAY_ACCESSOR)) \ + { \ + EINA_MAGIC_FAIL(d, EINA_MAGIC_ACCESSOR); \ +- return __VA_ARGS__; \ ++ return ret; \ + } \ + } while (0) + +@@ -205,7 +223,7 @@ + static Eina_Bool + eina_array_iterator_next(Eina_Iterator_Array *it, void **data) + { +- EINA_MAGIC_CHECK_ARRAY_ITERATOR(it, EINA_FALSE); ++ EINA_MAGIC_CHECK_ARRAY_ITERATOR_RETURN(it, EINA_FALSE); + + if (!(it->index < eina_array_count_get(it->array))) + return EINA_FALSE; +@@ -218,7 +236,7 @@ + static Eina_Array * + eina_array_iterator_get_container(Eina_Iterator_Array *it) + { +- EINA_MAGIC_CHECK_ARRAY_ITERATOR(it, NULL); ++ EINA_MAGIC_CHECK_ARRAY_ITERATOR_RETURN(it, NULL); + return (Eina_Array *) it->array; + } + +@@ -232,7 +250,7 @@ + static Eina_Bool + eina_array_accessor_get_at(Eina_Accessor_Array *it, unsigned int idx, void **data) + { +- EINA_MAGIC_CHECK_ARRAY_ACCESSOR(it, EINA_FALSE); ++ EINA_MAGIC_CHECK_ARRAY_ACCESSOR_RETURN(it, EINA_FALSE); + + if (!(idx < eina_array_count_get(it->array))) + return EINA_FALSE; +@@ -244,7 +262,7 @@ + static Eina_Array * + eina_array_accessor_get_container(Eina_Accessor_Array *it) + { +- EINA_MAGIC_CHECK_ARRAY_ACCESSOR(it, NULL); ++ EINA_MAGIC_CHECK_ARRAY_ACCESSOR_RETURN(it, NULL); + return (Eina_Array *) it->array; + } + +--- ../../src/lib/eina_hash.c 2010-04-15 06:11:15 +0000 ++++ ../../src/lib/eina_hash_new.c 2010-04-14 16:59:57 +0000 +@@ -53,12 +53,21 @@ + EINA_MAGIC_FAIL(d, EINA_MAGIC_HASH); \ + } while(0) + +-#define EINA_MAGIC_CHECK_HASH_ITERATOR(d, ...) \ ++#define EINA_MAGIC_CHECK_HASH_ITERATOR(d) \ + do { \ + if (!EINA_MAGIC_CHECK(d, EINA_MAGIC_HASH_ITERATOR)) \ + { \ + EINA_MAGIC_FAIL(d, EINA_MAGIC_HASH_ITERATOR); \ +- return __VA_ARGS__; \ ++ return; \ ++ } \ ++ } while(0) ++ ++#define EINA_MAGIC_CHECK_HASH_ITERATOR_RET(d, ret) \ ++ do { \ ++ if (!EINA_MAGIC_CHECK(d, EINA_MAGIC_HASH_ITERATOR)) \ ++ { \ ++ EINA_MAGIC_FAIL(d, EINA_MAGIC_HASH_ITERATOR); \ ++ return ret; \ + } \ + } while(0) + +@@ -484,7 +493,7 @@ + { + Eina_Hash_El *stuff; + +- EINA_MAGIC_CHECK_HASH_ITERATOR(it, NULL); ++ EINA_MAGIC_CHECK_HASH_ITERATOR_RET(it, NULL); + + stuff = it->el; + +@@ -497,7 +506,7 @@ + { + Eina_Hash_El *stuff; + +- EINA_MAGIC_CHECK_HASH_ITERATOR(it, NULL); ++ EINA_MAGIC_CHECK_HASH_ITERATOR_RET(it, NULL); + + stuff = it->el; + +@@ -510,7 +519,7 @@ + { + Eina_Hash_El *stuff; + +- EINA_MAGIC_CHECK_HASH_ITERATOR(it, NULL); ++ EINA_MAGIC_CHECK_HASH_ITERATOR_RET(it, NULL); + + stuff = it->el; + +@@ -588,7 +597,7 @@ + static void * + _eina_hash_iterator_get_container(Eina_Iterator_Hash *it) + { +- EINA_MAGIC_CHECK_HASH_ITERATOR(it, NULL); ++ EINA_MAGIC_CHECK_HASH_ITERATOR_RET(it, NULL); + return (void *) it->hash; + } + +--- ../../src/lib/eina_list.c 2010-04-15 06:29:24 +0000 ++++ ../../src/lib/eina_list_new.c 2010-04-15 06:33:11 +0000 +@@ -98,30 +98,57 @@ + static const char EINA_MAGIC_LIST_ACCOUNTING_STR[] = "Eina List Accounting"; + + +-#define EINA_MAGIC_CHECK_LIST(d, ...) \ ++#define EINA_MAGIC_CHECK_LIST(d) \ + do { \ + if (!EINA_MAGIC_CHECK(d, EINA_MAGIC_LIST)) \ + { \ + EINA_MAGIC_FAIL(d, EINA_MAGIC_LIST); \ +- return __VA_ARGS__; \ ++ return; \ ++ } \ ++ } while(0) ++ ++#define EINA_MAGIC_CHECK_LIST_RETURN(d,ret) \ ++ do { \ ++ if (!EINA_MAGIC_CHECK(d, EINA_MAGIC_LIST)) \ ++ { \ ++ EINA_MAGIC_FAIL(d, EINA_MAGIC_LIST); \ ++ return ret; \ ++ } \ ++ } 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); \ ++ return; \ + } \ + } while(0) + +-#define EINA_MAGIC_CHECK_LIST_ITERATOR(d, ...) \ ++#define EINA_MAGIC_CHECK_LIST_ITERATOR_RETURN(d,ret) \ + do { \ + if (!EINA_MAGIC_CHECK(d, EINA_MAGIC_LIST_ITERATOR)) \ + { \ + EINA_MAGIC_FAIL(d, EINA_MAGIC_LIST_ITERATOR); \ +- return __VA_ARGS__; \ ++ return ret; \ ++ } \ ++ } 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); \ ++ return; \ + } \ + } while(0) + +-#define EINA_MAGIC_CHECK_LIST_ACCESSOR(d, ...) \ ++#define EINA_MAGIC_CHECK_LIST_ACCESSOR_RETURN(d,ret) \ + do { \ + if (!EINA_MAGIC_CHECK(d, EINA_MAGIC_LIST_ACCESSOR)) \ + { \ + EINA_MAGIC_FAIL(d, EINA_MAGIC_LIST_ACCESSOR); \ +- return __VA_ARGS__; \ ++ return ret; \ + } \ + } while(0) + +@@ -224,7 +251,7 @@ + static Eina_List * + _eina_list_setup_accounting(Eina_List *list) + { +- EINA_MAGIC_CHECK_LIST(list, NULL); ++ EINA_MAGIC_CHECK_LIST_RETURN(list, NULL); + + list->accounting = _eina_list_mempool_accounting_new(list); + if (!list->accounting) goto on_error; +@@ -267,7 +294,7 @@ + static Eina_Bool + eina_list_iterator_next(Eina_Iterator_List *it, void **data) + { +- EINA_MAGIC_CHECK_LIST_ITERATOR(it, EINA_FALSE); ++ EINA_MAGIC_CHECK_LIST_ITERATOR_RETURN(it, EINA_FALSE); + + if (it->current == NULL) return EINA_FALSE; + *data = eina_list_data_get(it->current); +@@ -280,7 +307,7 @@ + static Eina_Bool + eina_list_iterator_prev(Eina_Iterator_List *it, void **data) + { +- EINA_MAGIC_CHECK_LIST_ITERATOR(it, EINA_FALSE); ++ EINA_MAGIC_CHECK_LIST_ITERATOR_RETURN(it, EINA_FALSE); + + if (it->current == NULL) return EINA_FALSE; + *data = eina_list_data_get(it->current); +@@ -293,7 +320,7 @@ + static Eina_List * + eina_list_iterator_get_container(Eina_Iterator_List *it) + { +- EINA_MAGIC_CHECK_LIST_ITERATOR(it, NULL); ++ EINA_MAGIC_CHECK_LIST_ITERATOR_RETURN(it, NULL); + + return (Eina_List *) it->head; + } +@@ -313,7 +340,7 @@ + unsigned int middle; + unsigned int i; + +- EINA_MAGIC_CHECK_LIST_ACCESSOR(it, EINA_FALSE); ++ EINA_MAGIC_CHECK_LIST_ACCESSOR_RETURN(it, EINA_FALSE); + + if (idx >= eina_list_count(it->head)) return EINA_FALSE; + +@@ -378,7 +405,7 @@ + static Eina_List * + eina_list_accessor_get_container(Eina_Accessor_List *it) + { +- EINA_MAGIC_CHECK_LIST_ACCESSOR(it, NULL); ++ EINA_MAGIC_CHECK_LIST_ACCESSOR_RETURN(it, NULL); + + return (Eina_List *) it->head; + } +@@ -396,7 +423,7 @@ + { + Eina_List *prev = NULL; + +- EINA_MAGIC_CHECK_LIST(list, NULL); ++ EINA_MAGIC_CHECK_LIST_RETURN(list, NULL); + + for (; list; list = list->next) + { +@@ -582,7 +609,7 @@ + return _eina_list_setup_accounting(new_l); + } + +- EINA_MAGIC_CHECK_LIST(list, NULL); ++ EINA_MAGIC_CHECK_LIST_RETURN(list, NULL); + + l = list->accounting->last; + list->accounting->last = new_l; +@@ -637,7 +664,7 @@ + + if (!list) return _eina_list_setup_accounting(new_l); + +- EINA_MAGIC_CHECK_LIST(list, NULL); ++ EINA_MAGIC_CHECK_LIST_RETURN(list, NULL); + + list->prev = new_l; + +@@ -690,7 +717,7 @@ + Eina_List *l; + void *list_data; + +- if (list) EINA_MAGIC_CHECK_LIST(list, NULL); ++ if (list) EINA_MAGIC_CHECK_LIST_RETURN(list, NULL); + + EINA_LIST_FOREACH(list, l, list_data) + { +@@ -728,7 +755,7 @@ + new_l = _eina_list_mempool_list_new(list); + if (!new_l) return list; + +- EINA_MAGIC_CHECK_LIST(relative, NULL); ++ EINA_MAGIC_CHECK_LIST_RETURN(relative, NULL); + new_l->next = relative->next; + new_l->data = (void *)data; + +@@ -790,7 +817,7 @@ + Eina_List *l; + void *list_data; + +- if (list) EINA_MAGIC_CHECK_LIST(list, NULL); ++ if (list) EINA_MAGIC_CHECK_LIST_RETURN(list, NULL); + + EINA_LIST_FOREACH(list, l, list_data) + { +@@ -827,7 +854,7 @@ + new_l = _eina_list_mempool_list_new(list); + if (!new_l) return list; + +- EINA_MAGIC_CHECK_LIST(relative, NULL); ++ EINA_MAGIC_CHECK_LIST_RETURN(relative, NULL); + + new_l->prev = relative->prev; + new_l->next = relative; +@@ -899,7 +926,7 @@ + { + Eina_List *l; + +- if (list) EINA_MAGIC_CHECK_LIST(list, NULL); ++ if (list) EINA_MAGIC_CHECK_LIST_RETURN(list, NULL); + + l = eina_list_data_find_list(list, data); + return eina_list_remove_list(list, l); +@@ -946,7 +973,7 @@ + if (!list) return NULL; + if (!remove_list) return list; + +- EINA_MAGIC_CHECK_LIST(remove_list, NULL); ++ EINA_MAGIC_CHECK_LIST_RETURN(remove_list, NULL); + + if (remove_list->next) remove_list->next->prev = remove_list->prev; + if (remove_list->prev) +@@ -958,7 +985,7 @@ + return_l = remove_list->next; + if (remove_list == remove_list->accounting->last) + { +- EINA_MAGIC_CHECK_LIST(list, NULL); ++ EINA_MAGIC_CHECK_LIST_RETURN(list, NULL); + list->accounting->last = remove_list->prev; + } + _eina_list_mempool_list_free(remove_list); +@@ -981,7 +1008,7 @@ + + if (!list) return NULL; + +- EINA_MAGIC_CHECK_LIST(list, NULL); ++ EINA_MAGIC_CHECK_LIST_RETURN(list, NULL); + + for (l = list; l;) + { +@@ -1032,8 +1059,8 @@ + if (move_list == list) return list; + if (move_list->next == list) return move_list; + +- EINA_MAGIC_CHECK_LIST(list, NULL); +- EINA_MAGIC_CHECK_LIST(move_list, NULL); ++ EINA_MAGIC_CHECK_LIST_RETURN(list, NULL); ++ EINA_MAGIC_CHECK_LIST_RETURN(move_list, NULL); + + /* Remove the promoted item from the list. */ + if (!move_list->prev) +@@ -1094,8 +1121,8 @@ + /* Demoting tail to be tail. */ + if (move_list == list->accounting->last) return list; + +- EINA_MAGIC_CHECK_LIST(list, NULL); +- EINA_MAGIC_CHECK_LIST(move_list, NULL); ++ EINA_MAGIC_CHECK_LIST_RETURN(list, NULL); ++ EINA_MAGIC_CHECK_LIST_RETURN(move_list, NULL); + + /* Update pointer list if necessary. */ + if (list == move_list) +@@ -1160,7 +1187,7 @@ + const Eina_List *l; + void *list_data; + +- if (list) EINA_MAGIC_CHECK_LIST(list, NULL); ++ if (list) EINA_MAGIC_CHECK_LIST_RETURN(list, NULL); + + EINA_LIST_FOREACH(list, l, list_data) + { +@@ -1211,7 +1238,7 @@ + const Eina_List *l; + unsigned int i; + +- if (list) EINA_MAGIC_CHECK_LIST(list, NULL); ++ if (list) EINA_MAGIC_CHECK_LIST_RETURN(list, NULL); + + /* check for non-existing nodes */ + if ((!list) || (n > (list->accounting->count - 1))) +@@ -1328,7 +1355,7 @@ + + if (!list) return NULL; + +- EINA_MAGIC_CHECK_LIST(list, NULL); ++ EINA_MAGIC_CHECK_LIST_RETURN(list, NULL); + + l1 = list; + l2 = list->accounting->last; +@@ -1372,7 +1399,7 @@ + + if (!list) return NULL; + +- EINA_MAGIC_CHECK_LIST(list, NULL); ++ EINA_MAGIC_CHECK_LIST_RETURN(list, NULL); + + lclone = NULL; + EINA_LIST_FOREACH(list, l, data) +@@ -1405,7 +1432,7 @@ + + if (!list) return NULL; + +- EINA_MAGIC_CHECK_LIST(list, NULL); ++ EINA_MAGIC_CHECK_LIST_RETURN(list, NULL); + + lclone = NULL; + EINA_LIST_FOREACH(list, l, data) +@@ -1466,7 +1493,7 @@ + + EINA_SAFETY_ON_NULL_RETURN_VAL(func, list); + if (!list) return NULL; +- EINA_MAGIC_CHECK_LIST(list, NULL); ++ EINA_MAGIC_CHECK_LIST_RETURN(list, NULL); + + /* if the caller specified an invalid size, sort the whole list */ + if ((size == 0) || +--- ../../src/lib/eina_matrixsparse.c 2010-04-15 06:29:24 +0000 ++++ ../../src/lib/eina_matrixsparse_new.c 2010-04-15 06:33:48 +0000 +@@ -66,12 +66,21 @@ + static const char EINA_MAGIC_MATRIXSPARSE_CELL_ITERATOR_STR[] = "Eina Matrixsparse Cell Iterator"; + + +-#define EINA_MAGIC_CHECK_MATRIXSPARSE(d, ...) \ ++#define EINA_MAGIC_CHECK_MATRIXSPARSE(d) \ + do { \ + if (!EINA_MAGIC_CHECK(d, EINA_MAGIC_MATRIXSPARSE)) \ + { \ + EINA_MAGIC_FAIL(d, EINA_MAGIC_MATRIXSPARSE); \ +- return __VA_ARGS__; \ ++ return; \ ++ } \ ++ } while(0) ++ ++#define EINA_MAGIC_CHECK_MATRIXSPARSE_RET(d, ret) \ ++ do { \ ++ if (!EINA_MAGIC_CHECK(d, EINA_MAGIC_MATRIXSPARSE)) \ ++ { \ ++ EINA_MAGIC_FAIL(d, EINA_MAGIC_MATRIXSPARSE); \ ++ return ret; \ + } \ + } while(0) + +@@ -93,12 +102,21 @@ + } \ + } while(0) + +-#define EINA_MAGIC_CHECK_MATRIXSPARSE_ITERATOR(d, ...) \ ++#define EINA_MAGIC_CHECK_MATRIXSPARSE_ITERATOR(d) \ ++ do { \ ++ if (!EINA_MAGIC_CHECK(d, EINA_MAGIC_MATRIXSPARSE_ITERATOR)) \ ++ { \ ++ EINA_MAGIC_FAIL(d, EINA_MAGIC_MATRIXSPARSE_ITERATOR); \ ++ return; \ ++ } \ ++ } while(0) ++ ++#define EINA_MAGIC_CHECK_MATRIXSPARSE_ITERATOR_RET(d, ret) \ + do { \ + if (!EINA_MAGIC_CHECK(d, EINA_MAGIC_MATRIXSPARSE_ITERATOR)) \ + { \ + EINA_MAGIC_FAIL(d, EINA_MAGIC_MATRIXSPARSE_ITERATOR); \ +- return __VA_ARGS__; \ ++ return ret; \ + } \ + } while(0) + +@@ -663,7 +681,7 @@ + static Eina_Bool + _eina_matrixsparse_iterator_next(Eina_Matrixsparse_Iterator *it, void **data) + { +- EINA_MAGIC_CHECK_MATRIXSPARSE_ITERATOR(it, EINA_FALSE); ++ EINA_MAGIC_CHECK_MATRIXSPARSE_ITERATOR_RET(it, EINA_FALSE); + + /* do not touch it->idx */ + +@@ -683,7 +701,7 @@ + static Eina_Matrixsparse * + _eina_matrixsparse_iterator_get_container(Eina_Matrixsparse_Iterator *it) + { +- EINA_MAGIC_CHECK_MATRIXSPARSE_ITERATOR(it, NULL); ++ EINA_MAGIC_CHECK_MATRIXSPARSE_ITERATOR_RET(it, NULL); + return (Eina_Matrixsparse *)it->m; + } + +@@ -699,7 +717,7 @@ + static Eina_Bool + _eina_matrixsparse_iterator_complete_next(Eina_Matrixsparse_Iterator_Complete *it, void **data) + { +- EINA_MAGIC_CHECK_MATRIXSPARSE_ITERATOR(it, EINA_FALSE); ++ EINA_MAGIC_CHECK_MATRIXSPARSE_ITERATOR_RET(it, EINA_FALSE); + + if (it->idx.row >= it->m->size.rows) + return 0; +@@ -740,7 +758,7 @@ + static Eina_Matrixsparse * + _eina_matrixsparse_iterator_complete_get_container(Eina_Matrixsparse_Iterator_Complete *it) + { +- EINA_MAGIC_CHECK_MATRIXSPARSE_ITERATOR(it, NULL); ++ EINA_MAGIC_CHECK_MATRIXSPARSE_ITERATOR_RET(it, NULL); + return (Eina_Matrixsparse *)it->m; + } + +@@ -993,7 +1011,7 @@ + void (*free_func)(void *, void *); + void *user_data; + +- EINA_MAGIC_CHECK_MATRIXSPARSE(m, 0); ++ EINA_MAGIC_CHECK_MATRIXSPARSE_RET(m, 0); + EINA_SAFETY_ON_FALSE_RETURN_VAL(rows > 0, 0); + EINA_SAFETY_ON_FALSE_RETURN_VAL(cols > 0, 0); + +@@ -1100,7 +1118,7 @@ + EAPI Eina_Bool + eina_matrixsparse_cell_idx_get(const Eina_Matrixsparse *m, unsigned long row, unsigned long col, Eina_Matrixsparse_Cell **cell) + { +- EINA_MAGIC_CHECK_MATRIXSPARSE(m, 0); ++ EINA_MAGIC_CHECK_MATRIXSPARSE_RET(m, 0); + EINA_SAFETY_ON_NULL_RETURN_VAL(cell, 0); + *cell = NULL; + EINA_SAFETY_ON_FALSE_RETURN_VAL(row < m->size.rows, 0); +@@ -1142,7 +1160,7 @@ + eina_matrixsparse_data_idx_get(const Eina_Matrixsparse *m, unsigned long row, unsigned long col) + { + Eina_Matrixsparse_Cell *c; +- EINA_MAGIC_CHECK_MATRIXSPARSE(m, NULL); ++ EINA_MAGIC_CHECK_MATRIXSPARSE_RET(m, NULL); + c = _eina_matrixsparse_cell_idx_get(m, row, col); + if (c) return c->data; + else return NULL; +@@ -1213,7 +1231,7 @@ + + EINA_MAGIC_CHECK_MATRIXSPARSE_CELL(cell, 0); + EINA_MAGIC_CHECK_MATRIXSPARSE_ROW(cell->parent, 0); +- EINA_MAGIC_CHECK_MATRIXSPARSE(cell->parent->parent, 0); ++ EINA_MAGIC_CHECK_MATRIXSPARSE_RET(cell->parent->parent, 0); + + m = cell->parent->parent; + +@@ -1245,7 +1263,7 @@ + Eina_Matrixsparse_Cell *cell; + + if (p_old) *p_old = NULL; +- EINA_MAGIC_CHECK_MATRIXSPARSE(m, 0); ++ EINA_MAGIC_CHECK_MATRIXSPARSE_RET(m, 0); + EINA_SAFETY_ON_FALSE_RETURN_VAL(row < m->size.rows, 0); + EINA_SAFETY_ON_FALSE_RETURN_VAL(col < m->size.cols, 0); + +@@ -1281,7 +1299,7 @@ + { + Eina_Matrixsparse_Cell *cell; + +- EINA_MAGIC_CHECK_MATRIXSPARSE(m, 0); ++ EINA_MAGIC_CHECK_MATRIXSPARSE_RET(m, 0); + EINA_SAFETY_ON_FALSE_RETURN_VAL(row < m->size.rows, 0); + EINA_SAFETY_ON_FALSE_RETURN_VAL(col < m->size.cols, 0); + +@@ -1319,7 +1337,7 @@ + { + Eina_Matrixsparse_Row *r; + +- EINA_MAGIC_CHECK_MATRIXSPARSE(m, 0); ++ EINA_MAGIC_CHECK_MATRIXSPARSE_RET(m, 0); + EINA_SAFETY_ON_FALSE_RETURN_VAL(row < m->size.rows, 0); + + r = _eina_matrixsparse_row_idx_get(m, row); +@@ -1355,7 +1373,7 @@ + void (*free_func)(void *, void *); + void *user_data; + +- EINA_MAGIC_CHECK_MATRIXSPARSE(m, 0); ++ EINA_MAGIC_CHECK_MATRIXSPARSE_RET(m, 0); + EINA_SAFETY_ON_FALSE_RETURN_VAL(col < m->size.cols, 0); + + free_func = m->free.func; +@@ -1410,7 +1428,7 @@ + { + Eina_Matrixsparse_Cell *c; + +- EINA_MAGIC_CHECK_MATRIXSPARSE(m, 0); ++ EINA_MAGIC_CHECK_MATRIXSPARSE_RET(m, 0); + EINA_SAFETY_ON_FALSE_RETURN_VAL(row < m->size.rows, 0); + EINA_SAFETY_ON_FALSE_RETURN_VAL(col < m->size.cols, 0); + +@@ -1442,7 +1460,7 @@ + + EINA_MAGIC_CHECK_MATRIXSPARSE_CELL(cell, 0); + EINA_MAGIC_CHECK_MATRIXSPARSE_ROW(cell->parent, 0); +- EINA_MAGIC_CHECK_MATRIXSPARSE(cell->parent->parent, 0); ++ EINA_MAGIC_CHECK_MATRIXSPARSE_RET(cell->parent->parent, 0); + + m = cell->parent->parent; + +--- ../../src/lib/eina_strbuf.c 2010-04-15 06:17:34 +0000 ++++ ../../src/lib/eina_strbuf_new.c 2010-04-15 06:47:16 +0000 +@@ -33,12 +33,21 @@ + + static const char EINA_MAGIC_STRBUF_STR[] = "Eina Strbuf"; + +-#define EINA_MAGIC_CHECK_STRBUF(d, ...) \ ++#define EINA_MAGIC_CHECK_STRBUF(d) \ + do { \ + if (!EINA_MAGIC_CHECK((d), EINA_MAGIC_STRBUF)) \ + { \ + EINA_MAGIC_FAIL((d), EINA_MAGIC_STRBUF); \ +- return __VA_ARGS__; \ ++ return; \ ++ } \ ++ } while (0) ++ ++#define EINA_MAGIC_CHECK_STRBUF_RET(d, ret) \ ++ do { \ ++ if (!EINA_MAGIC_CHECK((d), EINA_MAGIC_STRBUF)) \ ++ { \ ++ EINA_MAGIC_FAIL((d), EINA_MAGIC_STRBUF); \ ++ return ret; \ + } \ + } while (0) + +@@ -344,7 +353,7 @@ + size_t len; + + EINA_SAFETY_ON_NULL_RETURN_VAL(str, EINA_FALSE); +- EINA_MAGIC_CHECK_STRBUF(buf, EINA_FALSE); ++ EINA_MAGIC_CHECK_STRBUF_RET(buf, EINA_FALSE); + + len = strlen(str); + if (EINA_UNLIKELY(!_eina_strbuf_grow(buf, buf->len + len))) +@@ -372,7 +381,7 @@ + char *esc; + + EINA_SAFETY_ON_NULL_RETURN_VAL(str, EINA_FALSE); +- EINA_MAGIC_CHECK_STRBUF(buf, EINA_FALSE); ++ EINA_MAGIC_CHECK_STRBUF_RET(buf, EINA_FALSE); + + esc = eina_str_escape(str); + if (EINA_UNLIKELY(!esc)) +@@ -416,7 +425,7 @@ + size_t len; + + EINA_SAFETY_ON_NULL_RETURN_VAL(str, EINA_FALSE); +- EINA_MAGIC_CHECK_STRBUF(buf, EINA_FALSE); ++ EINA_MAGIC_CHECK_STRBUF_RET(buf, EINA_FALSE); + + len = strlen(str); + if (len > maxlen) len = maxlen; +@@ -452,7 +461,7 @@ + eina_strbuf_append_length(Eina_Strbuf *buf, const char *str, size_t length) + { + EINA_SAFETY_ON_NULL_RETURN_VAL(str, EINA_FALSE); +- EINA_MAGIC_CHECK_STRBUF(buf, EINA_FALSE); ++ EINA_MAGIC_CHECK_STRBUF_RET(buf, EINA_FALSE); + + if (EINA_UNLIKELY(!_eina_strbuf_grow(buf, buf->len + length))) + return EINA_FALSE; +@@ -481,7 +490,7 @@ + Eina_Bool ret; + + EINA_SAFETY_ON_NULL_RETURN_VAL(fmt, EINA_FALSE); +- EINA_MAGIC_CHECK_STRBUF(buf, EINA_FALSE); ++ EINA_MAGIC_CHECK_STRBUF_RET(buf, EINA_FALSE); + + va_start(args, fmt); + len = vasprintf(&str, fmt, args); +@@ -512,7 +521,7 @@ + Eina_Bool ret; + + EINA_SAFETY_ON_NULL_RETURN_VAL(fmt, EINA_FALSE); +- EINA_MAGIC_CHECK_STRBUF(buf, EINA_FALSE); ++ EINA_MAGIC_CHECK_STRBUF_RET(buf, EINA_FALSE); + + len = vasprintf(&str, fmt, args); + +@@ -544,7 +553,7 @@ + size_t len; + + EINA_SAFETY_ON_NULL_RETURN_VAL(str, EINA_FALSE); +- EINA_MAGIC_CHECK_STRBUF(buf, EINA_FALSE); ++ EINA_MAGIC_CHECK_STRBUF_RET(buf, EINA_FALSE); + + if (pos >= buf->len) + return eina_strbuf_append(buf, str); +@@ -574,7 +583,7 @@ + char *esc; + + EINA_SAFETY_ON_NULL_RETURN_VAL(str, EINA_FALSE); +- EINA_MAGIC_CHECK_STRBUF(buf, EINA_FALSE); ++ EINA_MAGIC_CHECK_STRBUF_RET(buf, EINA_FALSE); + + esc = eina_str_escape(str); + if (EINA_UNLIKELY(!esc)) +@@ -609,7 +618,7 @@ + size_t len; + + EINA_SAFETY_ON_NULL_RETURN_VAL(str, EINA_FALSE); +- EINA_MAGIC_CHECK_STRBUF(buf, EINA_FALSE); ++ EINA_MAGIC_CHECK_STRBUF_RET(buf, EINA_FALSE); + + if (pos >= buf->len) + return eina_strbuf_append_n(buf, str, maxlen); +@@ -643,7 +652,7 @@ + eina_strbuf_insert_length(Eina_Strbuf *buf, const char *str, size_t length, size_t pos) + { + EINA_SAFETY_ON_NULL_RETURN_VAL(str, EINA_FALSE); +- EINA_MAGIC_CHECK_STRBUF(buf, EINA_FALSE); ++ EINA_MAGIC_CHECK_STRBUF_RET(buf, EINA_FALSE); + + if (pos >= buf->len) + return eina_strbuf_append_length(buf, str, length); +@@ -665,7 +674,7 @@ + EAPI Eina_Bool + eina_strbuf_append_char(Eina_Strbuf *buf, char c) + { +- EINA_MAGIC_CHECK_STRBUF(buf, EINA_FALSE); ++ EINA_MAGIC_CHECK_STRBUF_RET(buf, EINA_FALSE); + + if (EINA_UNLIKELY(!_eina_strbuf_grow(buf, buf->len + 1))) + return EINA_FALSE; +@@ -690,7 +699,7 @@ + EAPI Eina_Bool + eina_strbuf_insert_char(Eina_Strbuf *buf, char c, size_t pos) + { +- EINA_MAGIC_CHECK_STRBUF(buf, EINA_FALSE); ++ EINA_MAGIC_CHECK_STRBUF_RET(buf, EINA_FALSE); + + if (pos >= buf->len) + return eina_strbuf_append_char(buf, c); +@@ -715,7 +724,7 @@ + Eina_Bool ret; + + EINA_SAFETY_ON_NULL_RETURN_VAL(fmt, EINA_FALSE); +- EINA_MAGIC_CHECK_STRBUF(buf, EINA_FALSE); ++ EINA_MAGIC_CHECK_STRBUF_RET(buf, EINA_FALSE); + + va_start(args, pos); + len = vasprintf(&str, fmt, args); +@@ -745,7 +754,7 @@ + Eina_Bool ret; + + EINA_SAFETY_ON_NULL_RETURN_VAL(fmt, EINA_FALSE); +- EINA_MAGIC_CHECK_STRBUF(buf, EINA_FALSE); ++ EINA_MAGIC_CHECK_STRBUF_RET(buf, EINA_FALSE); + + len = vasprintf(&str, fmt, args); + +@@ -776,7 +785,7 @@ + { + size_t remove_len, tail_len; + +- EINA_MAGIC_CHECK_STRBUF(buf, EINA_FALSE); ++ EINA_MAGIC_CHECK_STRBUF_RET(buf, EINA_FALSE); + + if (end >= buf->len) + end = buf->len; +@@ -813,7 +822,7 @@ + EAPI const char * + eina_strbuf_string_get(const Eina_Strbuf *buf) + { +- EINA_MAGIC_CHECK_STRBUF(buf, NULL); ++ EINA_MAGIC_CHECK_STRBUF_RET(buf, NULL); + + return buf->buf; + } +@@ -836,7 +845,7 @@ + { + char *ret; + +- EINA_MAGIC_CHECK_STRBUF(buf, NULL); ++ EINA_MAGIC_CHECK_STRBUF_RET(buf, NULL); + + ret = buf->buf; + // TODO: Check return value and do something clever +@@ -855,7 +864,7 @@ + EAPI size_t + eina_strbuf_length_get(const Eina_Strbuf *buf) + { +- EINA_MAGIC_CHECK_STRBUF(buf, 0); ++ EINA_MAGIC_CHECK_STRBUF_RET(buf, 0); + + return buf->len; + } +@@ -881,7 +890,7 @@ + + EINA_SAFETY_ON_NULL_RETURN_VAL(str, EINA_FALSE); + EINA_SAFETY_ON_NULL_RETURN_VAL(with, EINA_FALSE); +- EINA_MAGIC_CHECK_STRBUF(buf, 0); ++ EINA_MAGIC_CHECK_STRBUF_RET(buf, 0); + + if (n == 0) + return EINA_FALSE; +@@ -939,7 +948,7 @@ + + EINA_SAFETY_ON_NULL_RETURN_VAL(str, 0); + EINA_SAFETY_ON_NULL_RETURN_VAL(with, 0); +- EINA_MAGIC_CHECK_STRBUF(buf, 0); ++ EINA_MAGIC_CHECK_STRBUF_RET(buf, 0); + + spos = strstr(buf->buf, str); + if (!spos || *spos == '\0') +--- ../../src/lib/eina_stringshare.c 2010-04-15 06:53:51 +0000 ++++ ../../src/lib/eina_stringshare_new.c 2010-04-15 06:35:44 +0000 +@@ -104,13 +104,23 @@ + static const char EINA_MAGIC_STRINGSHARE_NODE_STR[] = "Eina Stringshare Node"; + + +-#define EINA_MAGIC_CHECK_STRINGSHARE_HEAD(d, unlock, ...) \ ++#define EINA_MAGIC_CHECK_STRINGSHARE_HEAD(d, unlock) \ + do { \ + if (!EINA_MAGIC_CHECK((d), EINA_MAGIC_STRINGSHARE_HEAD)) \ + { \ + EINA_MAGIC_FAIL((d), EINA_MAGIC_STRINGSHARE_HEAD); \ + unlock; \ +- return __VA_ARGS__; \ ++ return; \ ++ } \ ++ } while (0) ++ ++#define EINA_MAGIC_CHECK_STRINGSHARE_HEAD_RET(d, unlock, ret) \ ++ do { \ ++ if (!EINA_MAGIC_CHECK((d), EINA_MAGIC_STRINGSHARE_HEAD)) \ ++ { \ ++ EINA_MAGIC_FAIL((d), EINA_MAGIC_STRINGSHARE_HEAD); \ ++ unlock; \ ++ return ret; \ + } \ + } while (0) + +@@ -371,7 +381,7 @@ + static int + _eina_stringshare_cmp(const Eina_Stringshare_Head *ed, const int *hash, __UNUSED__ int length, __UNUSED__ void *data) + { +- EINA_MAGIC_CHECK_STRINGSHARE_HEAD(ed, , 0); ++ EINA_MAGIC_CHECK_STRINGSHARE_HEAD_RET(ed, , 0); + + return ed->hash - *hash; + } +@@ -379,8 +389,8 @@ + static Eina_Rbtree_Direction + _eina_stringshare_node(const Eina_Stringshare_Head *left, const Eina_Stringshare_Head *right, __UNUSED__ void *data) + { +- EINA_MAGIC_CHECK_STRINGSHARE_HEAD(left, , 0); +- EINA_MAGIC_CHECK_STRINGSHARE_HEAD(right, , 0); ++ EINA_MAGIC_CHECK_STRINGSHARE_HEAD_RET(left, , 0); ++ EINA_MAGIC_CHECK_STRINGSHARE_HEAD_RET(right, , 0); + + if (left->hash - right->hash < 0) + return EINA_RBTREE_LEFT; +@@ -1138,7 +1148,7 @@ + return s; + } + +- EINA_MAGIC_CHECK_STRINGSHARE_HEAD(ed, STRINGSHARE_UNLOCK_BIG(), NULL); ++ EINA_MAGIC_CHECK_STRINGSHARE_HEAD_RET(ed, STRINGSHARE_UNLOCK_BIG(), NULL); + + el = _eina_stringshare_head_find(ed, str, slen); + if (el) +--- ../../src/lib/eina_tiler.c 2010-04-15 06:11:15 +0000 ++++ ../../src/lib/eina_tiler_new.c 2010-04-14 16:50:29 +0000 +@@ -110,22 +110,40 @@ + splitter_t splitter; + }; + +-#define EINA_MAGIC_CHECK_TILER(d, ...) \ ++#define EINA_MAGIC_CHECK_TILER(d) \ + do { \ + if (!EINA_MAGIC_CHECK(d, EINA_MAGIC_TILER)) \ + { \ + EINA_MAGIC_FAIL(d, EINA_MAGIC_TILER); \ +- return __VA_ARGS__; \ ++ return; \ + } \ + } while(0) + ++#define EINA_MAGIC_CHECK_TILER_RETURN(d,ret) \ ++ do { \ ++ if (!EINA_MAGIC_CHECK(d, EINA_MAGIC_TILER)) \ ++ { \ ++ EINA_MAGIC_FAIL(d, EINA_MAGIC_TILER); \ ++ return ret; \ ++ } \ ++ } while(0) ++ ++ ++#define EINA_MAGIC_CHECK_TILER_ITERATOR(d) \ ++ do { \ ++ if (!EINA_MAGIC_CHECK(d, EINA_MAGIC_TILER_ITERATOR)) \ ++ { \ ++ EINA_MAGIC_FAIL(d, EINA_MAGIC_TILER_ITERATOR); \ ++ return; \ ++ } \ ++ } while(0) + +-#define EINA_MAGIC_CHECK_TILER_ITERATOR(d, ...) \ ++#define EINA_MAGIC_CHECK_TILER_ITERATOR_RETURN(d,ret) \ + do { \ + if (!EINA_MAGIC_CHECK(d, EINA_MAGIC_TILER_ITERATOR)) \ + { \ + EINA_MAGIC_FAIL(d, EINA_MAGIC_TILER_ITERATOR); \ +- return __VA_ARGS__; \ ++ return ret; \ + } \ + } while(0) + +@@ -1081,7 +1099,7 @@ + + static void * _iterator_get_container(Eina_Iterator_Tiler *it) + { +- EINA_MAGIC_CHECK_TILER_ITERATOR(it, NULL); ++ EINA_MAGIC_CHECK_TILER_ITERATOR_RETURN(it, NULL); + return (void *)it->tiler; + } + +@@ -1134,7 +1152,7 @@ + { + Eina_Rectangle tmp; + +- EINA_MAGIC_CHECK_TILER(t, EINA_FALSE); ++ EINA_MAGIC_CHECK_TILER_RETURN(t, EINA_FALSE); + if ((r->w <= 0) || (r->h <= 0)) + return EINA_FALSE; + tmp = *r; +@@ -1171,7 +1189,7 @@ + { + Eina_Iterator_Tiler *it; + +- EINA_MAGIC_CHECK_TILER(t, NULL); ++ EINA_MAGIC_CHECK_TILER_RETURN(t, NULL); + it = calloc(1, sizeof (Eina_Iterator_Tiler)); + if (!it) return NULL; + diff --git a/legacy/eina/win32/start.bat b/legacy/eina/win32/start.bat index f4044e977b..6a0109335c 100644 --- a/legacy/eina/win32/start.bat +++ b/legacy/eina/win32/start.bat @@ -13,6 +13,7 @@ if not exist %EXT_DIR% ( rem Check for basic requirements for Visual Studio 2008 if "%VS90COMNTOOLS%" == "" ( echo ERROR: Microsoft Visual Studio 2008 is not installed. + echo ERROR: Try to launch Microsoft Visual Studio 2005. pause goto NOVS9 ) @@ -34,6 +35,12 @@ if "%VS80COMNTOOLS%" == "" ( set PROJECT_TYPE=vs8 set VSCOMMONTOOLS=%VS80COMNTOOLS%vsvars32.bat +rem Patching Eina +patch.exe --binary -p1 < %cd%\patch\eina.diff +echo INFO: Eina patched. + +pause + :STARTVS rem Setup common Win32 environment variables