EINA_LOG_ERR(), EINA_LOG_DBG() and other macros.
This will help us to avoid the cumbersome work of having to define the
local macros. I still find the 3-letter macros handy, but we are not
forced to use them now.
I did a small modification to keep the EINA_LOG_DOMAIN_GLOBAL and use
a different symbol for the define, it is EINA_LOG_DOMAIN_DEFAULT. The
documentation was updated to highlight the 2 usage scenario and care
that must be used.
By: Peter Johnson <tam@hiddenrock.com>
SVN revision: 46700
Some of them were working because they were inline, so the compiler
would know an just ignore the flag.
For lists and rbtree there is no problem as after each operation we
must change the pointer to the new head, thus the compiler will
consider it changed.
SVN revision: 46583
I forgot that EINA_CONST refer to the pointer itself, not to its
contents, as such the pointer did not changed, so gcc was optimizing
subsequent fetches of the value.
There should be another optimization to check for this... but then I
guess it's just c++
SVN revision: 46580
* eina_str_split() now does the minimum number of passes and
allocations. The first pass figures out the string size (strlen())
and number of delimiters, so we can allocate the exact number of
elements in array. The second repeats the loop copying elements to
string and also setting them to the result array.
* eina_str_split_full() is a variation of eina_str_split() that
returns also the number of elements in array, in the case you need
to pre-allocate another array to copy.
* eina_strlen_bounded() is introduced to limit strlen() results, this
is used in has_prefix and has_suffix, but possibly other use cases
where string must be of a maximum size as we don't do useless
iterations;
SVN revision: 46547
SORT_MIN and SORT_MAX are not used in eina, and will result in errors if
used. eina_list_sort(list, EINA_SORT_MAX, ...) will not give the
expexted result.
SVN revision: 45222
as we are on the modules context not the array.
All the referenced projects are changed too. Remember that the list_free()
already calls the unload() on each module so no need to call list_unload()
SVN revision: 44978
* move internal _init and _shutdown functions in the Global
part of the code, as it is where they belong
* fix minor documentation stuff
SVN revision: 44730
Mark both array and module as const as we'll not modify them anyhow
inside this function.
Also mark this function as pure, so gcc will know how to optimize
multiple calls of it. Not that important for this function, but
doesn't hurt either.
SVN revision: 43918
In this case slc->first wasn't being set, as well as the info.col and
info.row. This could bring some strange behavior like a call to
eina_tile_grid_slicer_next() not returning false.
SVN revision: 42783
This new iterator receives a rectangle as argument and tile_w X tile_h sized
tile, and slices the rectangle iterating over it on each iteration.
SVN revision: 42427
It's pointless to be able to change magic number string after it's
created, so let's avoid walking the existing list and just remove
places where strings were being duplicated (list/array both inited
magic strings for accessor/iterators).
Also an optimization, register using an array and sort it before
searching. Sort will just happen when array was changed, and this is
just done when eina_magic_string_get() is called.
SVN revision: 42310
Being able to indivually initialize individual modules was initially
"good", but at end it's putting complexities on users that would try
to "optimize" by doing just what they used, but in the end most people
would get them wrong, users would have to do lots of code and etc. At
the end it does not worth.
Most module init just register handful errors and log domains, so are
cheap. The exception is mempool users, that would dlopen() stuff, but
people that are concerned (embedded) can just compile those statically
in eina.
Since at the end any real application would use most of modules, we
actually end saving lots of function calls that would do nothing other
than increment a global counter.
I also did the init/shutdown use an array, making it easier to
maintain. The inital dependencies were analysed by a script I wrote, I
hope it's all right.
Please fix any breakages you find!
SVN revision: 42300
Users may opt to set EINA_LOG_LEVEL_MAXIMUM to some integer and macro
will then evaluate to check for that value before actually call
eina_log_print() macro. By using optimizations compilers will
effectivelly compile out the code if it is never reached, thus saving
the check and function call in possible critical paths.
SVN revision: 42269
Sparse Matrix was implemented and tested by Rafael Antognolli and
myself in order to implement optimized large sparse matrix walk in
some products, one of them WebKit-EFL optimizations.
We have done extensive tests, with good code coverage. Similar to
lists/inlists, we keep pointer to last known element and similar to
iterators we keep reference to last accessed row and cell inside
rows. This allows fast sequential access (for i... for j... m[i,j]),
that is our most common usage case.
Rows are kept in a list, with cells inside that row as another
list. It's not similar to most book implementations where cells keep
reference to their sibling cells in other rows as well, we opted to
not do that to save some pointers and make algorithms simpler, still
do great for our use case.
This code was developed on behalf of our client, that wants to remain
unnamed so far. Thanks client ;-)
SVN revision: 42243
All these individual init functions are getting messy, some modules
lack them and it's easy to get inconsistent. Safety check needs error
and log, but these need safety checks as well, some modules (lalloc,
rbtree and others) use safety checks but provide no _init().
I want to know if we really gain something to init individual
modules. It should not be that expensive as init should not allocate
heavy resources and the recommendation is to call eina_init() so most
users will do that anyway.
If people agree I'll unmark all *_init() as EAPI and make them private
to eina lib.
SVN revision: 42214
eina_log_threads_enable() and then get thread safe logging with
non-main threads being printed with special notation to easily spot
those.
SVN revision: 42199
* stderr logger was doing prefix properly but user message to stdout, fixed.
* log is improved:
* grep-able, it shows the 3 letter level name as prefix, unknown levels
will have their number printed.
* colors just on prefix, less polluted output still easy to spot.
* function names are highlighted.
SVN revision: 42197
* more docs.
* do not getenv("EINA_LOG_ABORT") everytime, just at init.
* EINA_UNLIKELY() in some critical paths (not that big impact anyway)
* eina_log_print_cb_stderr() and use it by default.
SVN revision: 42196
* eina_error might be kept for error messages and codes, but it's logging API
will be deprecated. For now, it's been kept for not breaking others code and
for a smoother transition.
* Added test for new logging API, also demonstrates usage.
SVN revision: 41960
Kubo just found that docs could be improved and macro could be
simplified during his learning of EFL. Big bonus he did the
improvements =)
SVN revision: 41799
<dieb_> weird, undefined refernce to eina_cpu_count
<raster> you have no cpus!
<dieb_> dammit!
<Sachiel> try eina_hamster_count
<dieb_> lo
<raster> oh god
<raster> now u did it
<raster> i have to add that
<dieb_> heheheh
SVN revision: 41727
eina_list_search_sorted_near_list() was broken and barfed at my face
during development of eina_list_sorted_insert(), so I rewrote it
following more traditional approach, also adding special cases for
head/tail remembering that random access in lists is not as fast as
array. I also simplified that code.
eina_list_sorted_insert() should be fast, O(log2 n) insert, with
special cases to insert already sorted arrays forwards or backwards,
however I believe that it's better to simply append/prepend in those
cases (if known).
SVN revision: 41625
This should not impact anybody, at least in SVN I got no hits for this
function.
The new parameter contains the result of the last call to func(), so
we can know if the node is smaller, bigger or exactly the requested
value and don't need to call func() on node to know for sure.
SVN revision: 41623
configure time) in an exported header. Use only macros
defined by the compilers, which is sufficient and simpler.
* Add missing EINA_DEPRECATED in some cases.
SVN revision: 41199
what is modified:
eina_counter_add -> eina_counter_new
eina_counter_delete -> eina_counter_free
eina_lalloc_delete -> eina_lalloc_free
eina_mempool_new -> eina_mempool_add
eina_mempool_delete -> eina_mempool_del
eina_mempool_alloc -> eina_mempool_malloc
eina_tiler_del -> eina_tiler_free
It remains some questions: have the following API a good name:
eina_module_list_delete
eina_list_free
eina_rbtree_delete
(see ticket #286)
If you find any problem, please report in that thread
SVN revision: 41187
and configure.ac)
* include eina_config.h explicitely in files where the macros
of eina_config.h are used
* define eina_magic_string_init() and eina_magic_string_shutdown()
even when the mugle option is set (magic disabled)
* formatting and fix in configure.ac
SVN revision: 40962
I was replicating this code in many places, it should go into eina itself.
It's the right way to change strings that you don't know are
stringshared before, since it will first add a reference and then
remove, making it impossible to have references to go 0 and string
being released before adding new references, fixing the following
possible problem:
x = eina_stringshare_add("x");
replace(x, x);
then:
incorrect_replace(const char **b, const char *a) {
eina_stringshare_del(*b); /* reference gets to 0 */
eina_stringshare_add(a); /* BUG!!! */
*b = a;
}
SVN revision: 39903
* docs: be clear if it's a copy or in-place.
* clone: add some apis to create a copy while operates, sort should
do the same.
* reversed iterator: new call to walk the list reversed, will make
life easier in some cases.
SVN revision: 39515
EINA_ITERATOR_FOREACH() and EINA_ACCESSOR_FOREACH() are new macros to
help us forget about nasty C details (like cast to (void **)).
Document most iterators and accessors.
All iterators now set EINA_ERROR_OUT_OF_MEMORY if it's the case.
SVN revision: 39267
now EINA_INLIST_GET(bla)->next will work, before it was like
&bla->__in_list->next
which is wrong, since __in_list is not a pointer, rather the memory itself.
SVN revision: 39210
safety checks will report null pointers and other error conditions on
public api's and can be disabled by compile time check.
note that in order to have these checks working we need to make
EINA_ARG_NONNULL() void, otherwise GCC can remove these checks since
they're known to be false.
This commit also make two minor changes:
* list and hash accessors and iterators are created even for empty
entities. This is correct in my point of view since NULL should
indicate error. Having these in were an optimziation, but not
worth it, these are not the most common case and hitting this path
is not of much cost.
* unmarked some parameters as nonnull, mainly on list and inlist.
SVN revision: 38327
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
* evas: if we automatically destroy hash, check for NULL before
handling it to eina api, which expect elements to be created with
eina_hash_new() and thus will fail on NULL.
* eina: add magic checking for eina_hash and eina_hash_iterator, this will
help spot when NULL is used.
* eina_hash_foreach: do not try to create the iterator if hash is NULL.
SVN revision: 37982
By using simpler functions for hash element deletion we can avoid the
hack to shut up GCC warking about hash_num not being used. As these
simple functions are more often needed than the catch-all, expose them
as well.
SVN revision: 37962
Keep EINA_MAGIC at the end of the structure (WHEN POSSIBLE! Watch out
flexible arrays like char str[] at the end!)
this way if parts use EINA_MAGIC and others do not, it will possible overflow and valgrind can help us.
WARNING: make uninstall before update! Then make clean and make install, check if everything is working with "make check".
SVN revision: 37961
eina_magic.h MUST include eina_config.h, otherwise it will not
consider EINA_MAGIC stuff. Worse than that, some files were including
that directly and were considering EINA_MAGIC attribute even if the
file that alloc'ed the memory were not!
Also add missing EINA_MAGIC_SET() to iterators and accessors.
SVN revision: 37960
Many places in EFL we just create walk something, create a list with
walked data, return, then the user walks it again and then deletes
(which will walk again). For such cases it's way better to define
iterators or accessors.
I'm not moving any EFL code to it now, but if people are interested,
things like evas_render_method_list(), evas_font_available_list(),
evas_objects_at_xy_get(), evas_objects_in_rectangle_get(),
evas_object_smart_members_get() are good candidates. If the subject is
already using Eina list, then you can just use
eina_list_iterator_new() and return it, otherwise you can define your
own iterator, which is very easy.
SVN revision: 37956
This is a faster "add", if we know we're using a shared string we know
the node without any need to search it, just increment reference and
exit.
SVN revision: 37458
This makes clear what size and if we have a signal or not in our type,
so no compilers have the right to choose different for us (like they
do with enum).
Also fixes compile of C++ programs with eina_rectangle.h, that
contains some inline code, the expression evaluates a boolean
expression and compiler does not know how to convert that to old
Eina_Bool.
SVN revision: 36939