This allows us to unify retrieval of docs for both regular and
overridden funcs without having two separate APIs. It's currently
missing validation and docgen is still not adjusted properly for
it either, but at least there's this. Enables retrieval of docs
for overridden funcs by default as well.
As there is no need to have separate is_auto, is_empty and
is_pure_virtual for functions and implements (each function has
its own base implement by default) I removed the function ones.
Instead, I added a way to retrieve a function's base implement
so that you can instead do the checks on the implement even when
you only have the function.
I also moved base implement build directly into the parser instead
of the database filler. That allows for significant cleanup. I
also removed distinction of implement pointers in Eolian_Function
for get and set as implements now always contain an entire thing
so the pointer was always the same anyway.
Things should still behave more or less the same, but ordering
of generated functions has changed because ordering of implements
has changed.
Previously one API used just virtual (incorrect) and one used
virtual_pure (which just sounds weird). So unify with a single
name, pure_virtual, similar as in other lanugages.
This does not change eo file syntax yet.
Now all error/unknown/etc values returned from APIs are zero,
previously it was a mix of zeroes and minus ones. Also, some
enums that had no error/invalid value before have one now, which
allows for better distinction between what is an error and what
is an intended result.
visit_unsafe member function visits the variant but assumes the
pre-condition that the variant is not empty. This avoids the
possibility of throwing an exception when the destructors
of the types used in variant are also guaranteed to be
noexcept.
CID 1367508
This removes EO APIs related to an unmaintained client/server
model for applications. The reasons for this removal are the
following:
- unused
- no support in E
- relies on dbus as the sole transport layer
- unmaintained since the original patches
- only EO API (iow: beta, never released API)
I've also never seen the test cases (in elementary_test) actually
work.
According to Gustavo (k-s), the original author of this feature
is not involved in EFL at the moment, and unlikely to be in the
near future.
Note that terminology has in the past used those APIs when it
was still using some beta EO APIs. This code is now long gone,
removed in terminology commit 3ffcbadd6f9881472db6 (2014/12/13,
for version 0.8.0)
If someone wants to step in and maintain the implementation,
protocol and (EO) API, then feel free to revert this patch
and revive the feature. But it will need to be more solid than
this implementation.
Adds two new type types, STATIC_ARRAY and TERMINATED_ARRAY. Static arrays are
only allowed as struct members right now - they translate to regular C static
arrays (allowing them elsewhere wouldn't be good, as C isn't very good at
working with the size information). Terminated arrays are basically sequences
of data terminated at the end. The base type of static arrays can be any type
that is not marked ref (explicit ref may get allowed later). The base type of
terminated arrays has the same restriction plus that it has to be either
implicitly reference type (i.e. translating to pointer in C), integer type
or a character. In case of ref types, the terminator is NULL. In case of
integer types, the terminator is a zero. In case of character types, the
terminator is also a zero (null terminator like C strings).
@feature
Inner type can now be retrieved as a base type of the type.
If the type has two inner types or more, there is a new API that allows you to
get the second inner type by calling it on the first one (same would apply to
getting third via second etc.).
This API is simpler to use and doesn't require an iterator.
It's now possible to mark struct fields and function params as "references",
which causes them to become pointers in C (in bindings, they become whatever
is necessary). They're not a part of the type and are much more restricted
than pointers, allowing bindings to be easier. This system will be gradually
utilized and expanded as required.
@feature
Modify the way hooks are defined and used by promise generation in
Eolian in the Eo API.
Instead of passing macro names as parameters to EO_FUNC_BODY macros,
just re-define the actual hooks when it is needed.
Add two parameters for macros that generate API functions in Eo so
that the generation can be customized with macros used by Eolian.
Signed-off-by: Cedric Bail <cedric@osg.samsung.com>
Add several garbage collector callbacks for cleaning allocated C and C++
data used inside v8:External objects.
Fix eo_unref of already freed object in eo_js_construct_from_eo.hh.
Ensure all structs are allocated with malloc.
Add test for garbage collection.
Had to created .sh script because shebang clause do not support multiple
arguments.
Add specialization of eina::iterator for Eo* C++ wrappers.
Specialize ibegin/iend methods in eina::list and eina::array of
Eo* wrappers to use the new eina::iterator.
Add unit test.
This allows generators to silence type errors in validation in order
to reduce duplicate error messages when generating multiple files.
Also adjusted the C generator to only emit type errors when generating
Eo header files.
@feature
Added eina_init to eina_domain initialization as to force eina_init to
happen before initialization of global eina domains. This fixes
eolian_js domain in src/bin/eolian_js.
Summary:
Fix doxygen's documentation generation.
A bug in doxygen makes it fail with the _libv8_property_callback_info_test
class.
We put a #ifndef EFL_DOXYGEN around it to avoid it being seen by doxygen.
Add a NOTE comment about this.
ref T3005
@fix
Test Plan: make doc must succeed
Reviewers: felipealmeida, stefan_schmidt
Projects: #efl
Differential Revision: https://phab.enlightenment.org/D3534
Local variables, when returned, are already moved or copy-elised. The
use of std::move removes the possibility of copy-elision, making it
possibly slower. Removed the wrong std::move use.
The pre-increment operator was being defined twice and being
implemented as a post-increment. Modified declaration to be
post-increment as it was supposed to be.
To configure efl sources with bindings to use in nodejs add ––with-js=nodejs in configure flags to generate node files
$ configure --with-js=nodejs
and compile normally with:
$ make
$ make install
To use, you have to require efl:
efl = require('efl')
The bindings is divided in two parts: generated and manually
written. The generation uses the Eolian library for parsing Eo files
and generate C++ code that is compiled against V8 interpreter library
to create a efl.node file that can be required in a node.js instance.
@feature
Fixed removal of op field from Eo_Op_Description and removed
unnecessary use of internal Eo API to implement the Eo API function
for theh constructor of the inherited class.
This hasn't been used for a while. Since we are going to break Eo a bit anyway
it's a good opportunity to drop this.
This may cause a slight performance issues with legacy events, such as
smart callbacks. This shouldn't really be a problem as we've migrated away from
them. If it does, we need to migrate the remaining parts. Only relevant
for callbacks that are added before the classes are created, which
shouldn't be possible except for smart, only for old evas callbacks.
It's now generalized to work properly with legacy functions
as well as correctly append suffixes. Thus, it can be easily
used with the documentation generator and in other places.
@feature
Sorry for last minute new API, but this one is necessary to implement
proper verification of references in docs, which I would like to have
in 1.15. It allows you to retrieve any kind of declaration by full
namespace, so that you can check for an existence of an Eolian decl,
rather than checking every type individually.
@feature
Summary:
Using C++ wrapper types in the signature of methods of the generated
classes.
Now, when the type is an Eo type defined in Eolian, eolian_cxx will detect
it and use the equivalent C++ wrapper.
Types defined in Eolian no longer need to be specified in the lookup table,
so removed them from there.
Disable wrapping of non-const char*. The current wrapper (unique_ptr) is
not suited for some required operations like ownership acquisition from
C code.
Fix constructing properties that only have the "set" method.
Fix translation of non-const parameters.
Modified Makefiles to allow proper inclusion of evas_cxx headers required
by some tests and examples.
Move one auxiliary function to another reader to make it more accessible.
@feature
Reviewers: felipealmeida, q66, cedric
Subscribers: cedric
Differential Revision: https://phab.enlightenment.org/D2752
This was not really useful and against the Eolian guidelines.
While I promised I won't break things until the 27th, I was ill
(still am), so I'm giving myself a 1 day pass. :P
Sometimes it is necessary to specify a different set of values for a
getter or a setter. This commit allows such specializations. This also
renders @const_get and @const_set useless (soon to be removed).
To function correctly, this required adjustment of several public APIs
as well as deprecation of eolian_function_parameter_get_by_name.
This function was not used in any generator and was pretty much
useless in the first place, so it was removed.
@fix
Added optional constructor methods for C++ Eolian wrappers.
Changed the interface of wrappers' main constructors.
If there are optional constructor methods they should be passed as variadic
template argument at the end of the constructor.
To support variadic template arguments, the optional "parent" parameter is
now the first parameter and there is another constructor without the
"parent" parameter.
Checking for @optinal and @nullable attributes instead of @nonull.
Now @nonull is the default, and eina::optional is only used when @optional
or @nullable attribute is specified.
The names of constructor methods no longer have the class name prefixed.
Added unit tests for checking the binding of optional constructors.
Added new .eo file to be used in the test.
Changed the generated documentation of constructors.
Changed the efl::eo::inherit accordingly, to address these new features.
Now the constructor methods should be explicit called in the
efl::eo::inherit constructor, which will receive them via variadic
template arguments.
Added another constructor to efl::eo::inherit for passing the parent
object.
Updated some tests and examples to follow the new interface.
Removed some code that is no longer necessary.
Also, fix Eolian C++ support for constructing properties. fix
assertion when parsing constructing properties.
Now if a property is a constructing property eolian_cxx will generate a
constructor method that have the property name (without the "_set" suffix).
Now an eina::optional that wraps a specific type can be constructed or
have content assigned to it using another eina::optional that wraps a
different type, provided that the two wrapped types are convertible
between each other.
Added "disengage" member function to be able to disengage a R-value
eina::optional of different contained type.
It also adds for increased convenience.
Fix constructing an engaged eina::optional from an disengaged one.
Fix small assertion problem of trying to construct an eina::optional
already flagged as engaged.
Fix incorrect use of std::move. Changed it to std::forward.
Added constexpr property for trivial constructors.
Added auxiliary function "make_optional".
Added unit test to check compatibility between eina::optionals of
convertible types.
Fixed crash when disconnecting event inside of its own event callback.
Instead of deleting the callback object immediately during disconnection
(which causes the callback to be freed), the deletion is now scheduled
for later (using ecore_main_loop_thread_safe_call_async).
Updated some Makefiles to proper include ecore now that it is used in
all event wrappers.
Added a unit test to verify crashes under these circumstances.
Using eina::string_view in eolian generated interfaces (instead of
std::string) to allow lightweight passing of both C strings and C++
std::string.
Also, No longer using eina::optional in generated headers for types
that already implements the concept of null state (like Eo wrappers
and eina_accessor).
Also fix allocating callback objects require by class methods
(i.e. static) in static vectors so the memory will be freed when the
programs exit.
Added a new test case for testing callbacks on class methods.
Moved method definitions and supplementary code from generated C++
wrappers to auxiliary header file (.eo.impl.hh) generated together
with the main ".eo.hh" file. Updated Makefiles to list such files in
the compilation and cleanup processes. Updated .gitignore to include
these new generated files.
Made general adjustments on the documentation of generated C++ wrappers
Added "PREDEFINED" preprocessor macro definition in the Doxyfile.in in
order to make some adjustments for better documentation in the C++
generated headers. Excluding generation of documentation for classes
in the "eo_cxx" namespace (the namespace for "abstract" eolian C++
wrappers). Now generating the documentation for the events too.
Hiding some auxiliary code from being documented. Some aesthetic
adjustments for generated white space. Generate documentation for the
main constructor of C++ wrappers and added auxiliary grammars to list
parameters names.
Add an implementation of string_view to Eina C++. It is a non owning
reference to a string that allows lightweight argument passing of both
C++ std::string and C strings (const char*) on interfaces.
This reverts commit 8bb13b626f.
Seems like this method is not so reliable after all :) Results
in precision loss for Eo IDs, so revert to the old hacky way.
Updated the code for the "inheritance helper" functions and classes
to be in conformance with the new wrapper architecture.
Member variable "parents" of efl::eo::eo_class struct was split in two
member variables, "ancestors" and "parents", the former containing all
Eo class ancestors and the later only the direct bases.
Changed all required files accordingly.
Check to avoid using biding string when the parameter is @out now matches
any variation of "char".
Add default constructor to efl::eo::concrete in order to allow it to be
NULL initialized in the "inheritance helper" classes.
Removed conflicting parent_set member function in the efl::eo::inherit
class.
Removed the "inheritance_extension_function" generator since it is no
longer used.
Overloaded address-of operator for C++ Eolian wrappers for implicit converting
to any ancestor pointer type when getting the object memory address.
Added new grammars to aid the creation of the pointer wrappers
responsible of doing the implicit conversions.
Added a unit test which checks the address-of overload for arbitrary classes.
Added new .eo files to be used in it.
Using a new architecture in the generated files that simplify multiple
inheritance and allows the use of interface types as parameters.
No longer using a hand-crafted C++ header for eo_base.eo.
This file was added to the generation process.
Updated all files that are dependent in the hand-crafted eo_base
C++ header.
Now there is a class that contains the essentials functions of the former
eo::base wrapper and that is used to create (through inheritance) the
"concrete" classes for all Eo generated wrappers.
No longer binding any function or property that are protected, private or
legacy for now.
eolian_type_instance is now a struct with general information for the
whole type.
Added the new header file namespace_generator.hh to hold namespace
generation grammars.
Separated declaration and definition of Eo wrappers methods.
Referring for most objects by its full name (starting at the global
namespace ::) in the generated files.
Created additional helper grammars to avoid code replication.
Removed a TODO comment referring to a doubt about inheritance of
constructor methods.
Added a TODO comment regarding memory allocation for callbacks in static
member functions.
No longer reverting to the native type when the parameter has "@out"
direction.
Added "is_out" member variable to eolian_type class.
With that, generators can keep track of the direction of the parameters.
Also added helper functions "type_is_out" and "type_is_complex".
Created "to_native" functions in eo_cxx_interop.hh to convert binding types
from C++ arguments to the actual C function arguments.
Added static assertions in these functions to enforce compatibility
between the binding and the native type (Required by @out parameters).
Reworked the overload of the "to_c" function for eo::base derivated
objects. Now there is a overload that rely in the compatibility
between the native type and the wrapper, enabling a wrapper to be used as
an output parameter.
Added callbacks to the event EO_EV_DEL for deleting heap-allocated
function objects. This will enforce that the allocated memory,
necessary for maintaining these callable objects alive, is freed at
least when the underlaying Eo object is destroyed.
Functions and constructor methods are now able to have multiple
callback types.
Removed some unused generators, since they become inconsistent now that
functions are required to handle multiple callback types.
Allocating callback objects in the constructor methods instead of
delaying it until the final constructor is called.
Created some generators to avoid code repetition.
Now the generator parameters_forward_to_c replicate the behavior of the
generator parameters_list. The generator parameters_list was, then,
removed since it have a less intuitive name.
Added a TODO comment regarding the behaviour of simple not translating
callbacks that are not followed by a user data pointer.
The generator parameter_type was moved from "parameters_generator.hh" to
"type_generator.hh" for more consistency and convenience.
Created a specialization of the eina::accessor for C++ Eo wrappers.
Created an override of the "accessor" methods in the eina::list specialization
for Eo wrappers (in eina_list.hh). It is necessary to create accessors with the
correct type.
Created specializations of std::is_base_of to avoid compilation errors related
with _Eo_Opaque type.
Added new test cases in "eina_cxx_test_accessor.cc" to test the accessor
specialization.
Added efl::eina::eina_init to the existing test cases to correctly do the
on demand initialization required by the tests.
@fix
"Eina_Stringshare *" type is interchangeable with "const char *".
The "stealing" constructor from efl::eina::stringshare was incorrectly
using "char *" instead "const char *", preventing it from being used.
This flag allows one to compile Eina++ replacing C++ exceptions with a
call to abort().
Please use EFL_CXX_THROW() macro instead of C++ throw() from now on.
Added empty wrapper constructor to generation from std::nullptr_t and
allowed efl::eo::base to be empty with proper copy-constructors and
assignment operators.
Lauro Moura
Ivan Furs
Daniel Kolesa
Felipe Magno de Almeida
Cedric BAIL
Jean-Philippe Andre
Stefan Schmidt
Tom Hacohen
Carsten Haitzler
Vitor Sousa
Daniel Kolesa
Daniel Zaoui
Larry Jr
Vinícius dos Santos Oliveira
Jean-Philippe ANDRE
Savio S. Machado
Savio Sena
Stefan Schmidt