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
Compilation was failing due to the changes in the Eolian library. The
generator has not been updated.
This patch fixes the compilation but not the tests that I let to my
lovely q66.
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).
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.
Added declaration of all inherited events on the concrete type to
avoid unnecessary type conversion on event callbacks.
Note that when two events happens to have the same name, only the
event of the derived class is declared in the concrete class. Access to
such events should be made through the base class type specification.
Fix on forwarding callback object (changed std::move to std::forward).
Additional line break at the end of event handling methods in the
generated headers to improve readability.
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.
Solved diamond inheritance problem by completely removing inheritance in
the abstract class.
All ancestors are inherited directly in the concrete class.
The algorithm that list the ancestors also avoid repetition.
Now concrete classes define methods too. This helps referring the correct
method directly by the object type (when there are methods with the same
name).
Moved the declaration and definition of constructor methods to the concrete
class, since they should not be used in derived classes.
Updated example that call "color_set".
With this model, if two ancestor classes have a method with the same name,
to call one of them from a derived class you must write the scoped name of
the member function in the wrapper.
In this case, either Evas.Object and Evas.SmartObject have a property
named "color".
Added "from_global" option to the full_name grammar too.
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.
In convert.cc: Reading functions instead of implements to convert the
Eolian_Class. It avoids creation of methods that do not belong to the
class, in special it avoids calling the default constructor twice in the
generated code.
No longer generating one constructor in the C++ wrapper for each eolian
class constructor, since the correct behavior demands that all constructor
should be called. Now the wrappers have "constructor methods" that
must be called when creating a new object.
Updated test cases and examples to match the new interface. Some class
constructors and some test cases have to be removed since they were based
on the wrong assumption that constructors are mutually exclusive.
Created new generators for forwarding parameters and for looping over
the relevant parameters to the C++ wrapper executing a generic lambda.
Added a TODO comment regarding the call of constructor methods of all
base classes. Currently there is no base type with constructors, so this
situation should be discussed more.
Added a TODO comment regarding the way callback parameters are being
processed.
Whenever a getter explicitly defines a void return the generated code
shall not convert single-parameter getters in any ways.
Actually the correct approach would be to delegate all conversions to
Eolian Database instead of for the generators.
Summary:
The generation of class prefixes was not taking into account the full
classname -- the namespace was not being prepended to it. Fixed that and
also re-organized the code a bit, removed some Wshadow warnings also.
This commit fixes 'make examples' and 'make check'.
Reviewers: tasn, cedric, q66
CC: felipealmeida, smohanty, cedric
Differential Revision: https://phab.enlightenment.org/D1100
Implemented namespaces
Added eolian_wrappers.hh with C++ code wrapping Eolain API
Changed eolian_cxx program options. Now they're eolian_gen's
Added functions to safe_str.hh (safe_lower, safe_upper, normalize_spaces, path_base)
Added a mocked version of type_lookup.hh in advance. The full
version will come as soon as complex-types are added.
Made apply again by Daniel Kolesa, original implementation by Savio Sena.
This new API supports function pointer types, multiple type subtypes, const attribute without parsing
the name string, own attribute for any partial type and more. This commit also updates the C and C++
generators so that they compile and generate correct code.
@feature
Eo.h depends on things that are generated by normal Eolian, and because Eolian C++
is generating code pre-build (WHY THE FUCK???), the dependencies are missing.
This removes the stupid include, but a more proper fix would be to move eolian_cxx
to be part of the build process and not pre-build.
The function eolian_implement_information_get was returning strings for
the class and the function. It was written in this way at the beginning
because it was not needed to verify the correctness of the class and
the function.
Now that we have the namespace feature, this function must check it,
meaning that the class and the function are now known.
So we can return them instead of returning the strings.
The generators had to find the class from the classname. It is no more
needed.
The C++ generator has been adapted to this new API.
Until now, the functions giving access to class information were taking
the class name as parameter.
Except the fact that we needed to search into a hash table for the internal
class structure, no flexibility is possible.
This change consists in modifying most of the APIs using the class name
with a new Eolian_Class type and adapt the code of the C and C++
generators accordingly.
Since there was a bug in Eolian (Spank on you Savio that you didn't tell
me :-)), the cxx generator needed some workaround that is no more
mandatory now.
Summary:
This patch adds 'eolian_cxx' -- a C++ bindings generator --
to the EFL tree. Eolian Cxx uses Eolian API to read .eo files and generate
.eo.hh. It relies/depends on Eo Cxx and Eina Cxx (both non-generated
bindings).
src/bin/eolian_cxx: The eolian_cxx program.
src/lib/eolian_cxx: A header-only library that implements the C++ code
generation that binds the .eo classes.
=Examples=
src/examples/eolian_cxx/eolian_cxx_simple_01.cc: The simplest example,
it just uses some "dummy" generated C++ classes.
src/examples/eolian_cxx/eolian_cxx_inherit_01.cc: Illustrates how
pure C++ classes inherit from .eo generated classes.
src/examples/evas/evas_cxx_rectangle.cc: More realistic example using
the generated bindings Evas Cxx. Still a bit shallow because we don't
have full fledged .eo descriptions yet, but will be improved.
=Important=
The generated code is not supported and not a stable API/ABI. It is
here to gather people interest and get review before we set things in
stone for release 1.11.
@feature
Reviewers: cedric, smohanty, raster, stefan_schmidt
CC: felipealmeida, JackDanielZ, cedric, stefan
Differential Revision: https://phab.enlightenment.org/D805
Signed-off-by: Cedric Bail <cedric.bail@free.fr>
Felipe Magno de Almeida
Vitor Sousa
Daniel Zaoui
Savio Sena
Daniel Kolesa
Savio Sena
Tom Hacohen