kimcinoo
/
efl
forked from enlightenment/efl
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
efl/src/lib/eolian_cxx/grammar/eo_class_generator.hh

266 lines
8.3 KiB
C++
Raw Normal View History

eolian_cxx: initial version of the EFL C++ Bindings Generator. 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>
2014-05-02 15:55:51 -07:00
#ifndef EOLIAN_CXX_EO_CLASS_GENERATOR_HH
#define EOLIAN_CXX_EO_CLASS_GENERATOR_HH
#include <iosfwd>
#include <string>
#include "eo_types.hh"
#include "tab.hh"
#include "comment.hh"
cxx: General C++ Eo wrapper generation improvement 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.
2014-12-17 05:47:19 -08:00
#include "namespace_generator.hh"
eolian_cxx: initial version of the EFL C++ Bindings Generator. 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>
2014-05-02 15:55:51 -07:00
#include "eo_class_constructors_generator.hh"
#include "eo_class_functions_generator.hh"
eolian-cxx: Initial version of complex types / callbacks / events implementation.
2014-07-16 17:29:47 -07:00
#include "eo_class_events_generator.hh"
eolian_cxx: initial version of the EFL C++ Bindings Generator. 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>
2014-05-02 15:55:51 -07:00
namespace efl { namespace eolian { namespace grammar {
struct eo_class_getter
{
eo_class const& _cls;
eo_class_getter(eo_class const& cls) : _cls(cls) {}
};
inline std::ostream&
operator<<(std::ostream& out, eo_class_getter const& x)
{
out << tab(1) << "static Eo_Class const* _eo_class()" << endl
<< tab(1) << "{" << endl
<< tab(2) << "return("<< x._cls.eo_name << ");" << endl
<< tab(1) << "}" << endl << endl;
return out;
}
cxx: General C++ Eo wrapper generation improvement 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.
2014-12-17 05:47:19 -08:00
struct concrete_eo_ptr_getter
{
eo_class const& _cls;
concrete_eo_ptr_getter(eo_class const& cls) : _cls(cls) {}
};
inline std::ostream&
operator<<(std::ostream& out, concrete_eo_ptr_getter const&)
{
eolian_cxx: Add protected methods and events to C++ wrappers and fixes 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.
2015-01-12 06:00:59 -08:00
out << comment("@internal", 1)
<< tab(1) << "Eo* _concrete_eo_ptr() const" << endl
cxx: General C++ Eo wrapper generation improvement 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.
2014-12-17 05:47:19 -08:00
<< tab(1) << "{" << endl
<< tab(2) << "return static_cast<::efl::eo::concrete const*>(static_cast<void const*>(this))->_eo_ptr();" << endl
<< tab(1) << "}" << endl << endl;
return out;
}
struct class_implicit_conversion_declaration
{
eo_class const& _cls;
class_implicit_conversion_declaration(eo_class const& cls) : _cls(cls) {}
};
inline std::ostream&
operator<<(std::ostream& out, class_implicit_conversion_declaration const& x)
{
out << tab(1) << "operator " << full_name(x._cls) << "() const;" << endl;
out << tab(1) << "operator " << full_name(x._cls) << "&();" << endl;
out << tab(1) << "operator " << full_name(x._cls) << " const&() const;" << endl;
return out << endl;
}
struct class_implicit_conversion_definition
{
eo_class const& _cls;
class_implicit_conversion_definition(eo_class const& cls) : _cls(cls) {}
};
inline std::ostream&
operator<<(std::ostream& out, class_implicit_conversion_definition const& x)
{
out << "inline " << abstract_full_name(x._cls) << "::operator "
<< full_name(x._cls) << "() const" << endl
<< "{" << endl
<< tab(1) << "return *static_cast<" << full_name(x._cls)
<< " const*>(static_cast<void const*>(this));" << endl
<< "}" << endl << endl;
out << "inline " << abstract_full_name(x._cls) << "::operator "
<< full_name(x._cls) << "&()" << endl
<< "{" << endl
<< tab(1) << "return *static_cast<" << full_name(x._cls)
<< "*>(static_cast<void*>(this));" << endl
<< "}" << endl << endl;
out << "inline " << abstract_full_name(x._cls) << "::operator "
<< full_name(x._cls) << " const&() const" << endl
<< "{" << endl
<< tab(1) << "return *static_cast<" << full_name(x._cls)
<< " const*>(static_cast<void const*>(this));" << endl
<< "}" << endl << endl;
return out;
}
eolian_cxx: Add implicit conversion of the returned pointer of C++ wrappers 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.
2014-12-23 11:40:11 -08:00
struct address_of_to_pointer
{
eo_class const& _cls;
bool _is_const;
address_of_to_pointer(eo_class const& cls, bool is_const)
: _cls(cls), _is_const(is_const)
{}
};
inline std::ostream&
operator<<(std::ostream& out, address_of_to_pointer const& x)
{
out << "operator " << full_name(x._cls) << (x._is_const ? " const" : "")
<< "*() const { return static_cast<" << full_name(x._cls)
<< (x._is_const ? " const" : "")
<< "*>(static_cast<D const*>(this)->p); }";
return out;
}
struct abstract_address_of
{
eo_class const& _cls;
abstract_address_of(eo_class const& cls) : _cls(cls) {}
};
inline std::ostream&
operator<<(std::ostream& out, abstract_address_of const& x)
{
eolian_cxx: Add protected methods and events to C++ wrappers and fixes 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.
2015-01-12 06:00:59 -08:00
out << comment("@cond LOCAL", 1);
eolian_cxx: Add implicit conversion of the returned pointer of C++ wrappers 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.
2014-12-23 11:40:11 -08:00
out << tab(1) << "template <typename D>" << endl
<< tab(1) << "struct address_of" << endl
<< tab(1) << "{" << endl
<< tab(2) << address_of_to_pointer(x._cls, false) << endl
<< tab(2) << address_of_to_pointer(x._cls, true) << endl
<< tab(1) << "};" << endl << endl;
out << tab(1) << "template <typename D>" << endl
<< tab(1) << "struct address_const_of" << endl
<< tab(1) << "{" << endl
<< tab(2) << address_of_to_pointer(x._cls, true) << endl
eolian_cxx: Add protected methods and events to C++ wrappers and fixes 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.
2015-01-12 06:00:59 -08:00
<< tab(1) << "};" << endl;
out << comment("@endcond", 1) << endl;
eolian_cxx: Add implicit conversion of the returned pointer of C++ wrappers 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.
2014-12-23 11:40:11 -08:00
return out;
}
struct address_of_inheritance
{
eo_class const& _cls;
std::string _struct_name;
address_of_inheritance(eo_class const& cls, std::string const& struct_name)
: _cls(cls), _struct_name(struct_name)
{}
};
inline std::ostream&
operator<<(std::ostream& out, address_of_inheritance const& x)
{
eolian_cxx: Fix compilation of inheritance from Eolian generated classes 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.
2014-12-30 15:18:40 -08:00
for (std::string const& parent : x._cls.ancestors)
eolian_cxx: Add implicit conversion of the returned pointer of C++ wrappers 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.
2014-12-23 11:40:11 -08:00
{
out << tab(2) << ", ::" << abstract_namespace << "::" << parent << "::"
<< x._struct_name << "<" << x._struct_name << ">" << endl;
}
return out;
}
struct concrete_address_of
{
eo_class const& _cls;
concrete_address_of(eo_class const& cls) : _cls(cls) {}
};
inline std::ostream&
operator<<(std::ostream& out, concrete_address_of const& x)
{
eolian_cxx: Add protected methods and events to C++ wrappers and fixes 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.
2015-01-12 06:00:59 -08:00
out << comment("@cond LOCAL", 1);
eolian_cxx: Add implicit conversion of the returned pointer of C++ wrappers 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.
2014-12-23 11:40:11 -08:00
std::vector<std::string> names {"address_of", "address_const_of"};
for (int is_const = 0; is_const != 2; ++is_const)
{
std::string const& name = names[is_const];
out << tab(1) << "struct " << name << endl
<< tab(2) << ": " << abstract_full_name(x._cls) << "::"
<< name << "<" << name << ">" << endl
<< address_of_inheritance(x._cls, name)
<< tab(2) << ", ::efl::eo::detail::concrete_" << name << endl
<< tab(1) << "{" << endl
<< tab(2) << "explicit " << name << "(" << full_name(x._cls)
<< (is_const ? " const" : "")
<< "* p)" << endl
<< tab(3) << ": ::efl::eo::detail::concrete_" << name << "(p)" << endl
<< tab(2) << "{}" << endl
<< tab(1) << "};" << endl
<< tab(1) << name << " operator&()"
<< (is_const ? " const" : "")
<< " { return " << name << "(this); }" << endl << endl;
}
eolian_cxx: Add protected methods and events to C++ wrappers and fixes 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.
2015-01-12 06:00:59 -08:00
out << comment("@endcond", 1) << endl;
eolian_cxx: Add implicit conversion of the returned pointer of C++ wrappers 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.
2014-12-23 11:40:11 -08:00
return out;
}
eolian_cxx: initial version of the EFL C++ Bindings Generator. 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>
2014-05-02 15:55:51 -07:00
inline void
eolian_cxx: Add protected methods and events to C++ wrappers and fixes 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.
2015-01-12 06:00:59 -08:00
eo_class_declarations_generator(std::ostream& out, eo_class const& cls)
eolian_cxx: initial version of the EFL C++ Bindings Generator. 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>
2014-05-02 15:55:51 -07:00
{
cxx: General C++ Eo wrapper generation improvement 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.
2014-12-17 05:47:19 -08:00
out << namespace_head(cls)
<< "struct " << cls.name << ";" << endl << endl
<< namespace_tail(cls)
eolian_cxx: Add protected methods and events to C++ wrappers and fixes 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.
2015-01-12 06:00:59 -08:00
<< comment("@cond EO_CXX_ABSTRACT")
cxx: General C++ Eo wrapper generation improvement 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.
2014-12-17 05:47:19 -08:00
<< "namespace " << abstract_namespace << " {" << endl << endl
<< namespace_head(cls)
<< comment(cls.comment)
eolian_cxx: initial version of the EFL C++ Bindings Generator. 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>
2014-05-02 15:55:51 -07:00
<< "struct " << cls.name << endl
<< '{' << endl
cxx: General C++ Eo wrapper generation improvement 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.
2014-12-17 05:47:19 -08:00
<< function_declarations(cls)
eolian_cxx: Declaring all inherited events on the concrete C++ wrapper 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.
2015-01-06 09:39:44 -08:00
<< events(cls, cls.own_events) << endl
cxx: General C++ Eo wrapper generation improvement 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.
2014-12-17 05:47:19 -08:00
<< eo_class_getter(cls)
<< class_implicit_conversion_declaration(cls)
eolian_cxx: Add implicit conversion of the returned pointer of C++ wrappers 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.
2014-12-23 11:40:11 -08:00
<< abstract_address_of(cls)
eolian_cxx: Add protected methods and events to C++ wrappers and fixes 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.
2015-01-12 06:00:59 -08:00
<< "private:" << endl << endl
cxx: General C++ Eo wrapper generation improvement 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.
2014-12-17 05:47:19 -08:00
<< concrete_eo_ptr_getter(cls)
<< "};" << endl << endl
<< namespace_tail(cls)
eolian_cxx: Add protected methods and events to C++ wrappers and fixes 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.
2015-01-12 06:00:59 -08:00
<< "}" << endl
<< comment("@endcond") << endl
cxx: General C++ Eo wrapper generation improvement 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.
2014-12-17 05:47:19 -08:00
<< namespace_head(cls)
eolian_cxx: Add protected methods and events to C++ wrappers and fixes 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.
2015-01-12 06:00:59 -08:00
<< comment(cls.comment, 0, "@brief Class " + cls.name)
cxx: General C++ Eo wrapper generation improvement 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.
2014-12-17 05:47:19 -08:00
<< "struct " << cls.name << endl
eolian_cxx: Fix "dreaded diamond" inheritance problem for C++ wrappers 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.
2014-12-19 08:34:15 -08:00
<< tab(2) << ": ::efl::eo::concrete" << endl
<< class_inheritance(cls)
cxx: General C++ Eo wrapper generation improvement 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.
2014-12-17 05:47:19 -08:00
<< '{' << endl
eolian_cxx: Fix "dreaded diamond" inheritance problem for C++ wrappers 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.
2014-12-19 08:34:15 -08:00
<< functors_constructor_methods(cls)
eolain_cxx: Fix C++ support for new Eolian features 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).
2015-03-26 07:48:09 -07:00
<< constructors_with_constructor_methods(cls)
eolian_cxx: initial version of the EFL C++ Bindings Generator. 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>
2014-05-02 15:55:51 -07:00
<< constructor_eo(cls)
<< copy_constructor(cls)
<< destructor(cls)
eolian_cxx: Fix "dreaded diamond" inheritance problem for C++ wrappers 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.
2014-12-19 08:34:15 -08:00
<< constructor_method_function_declarations(cls)
<< function_declarations(cls)
eolian_cxx: Declaring all inherited events on the concrete C++ wrapper 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.
2015-01-06 09:39:44 -08:00
<< events(cls, cls.concrete_events) << endl
eolian_cxx: Fix "dreaded diamond" inheritance problem for C++ wrappers 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.
2014-12-19 08:34:15 -08:00
<< eo_class_getter(cls)
eolian_cxx: Add implicit conversion of the returned pointer of C++ wrappers 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.
2014-12-23 11:40:11 -08:00
<< concrete_address_of(cls)
eolian_cxx: Add protected methods and events to C++ wrappers and fixes 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.
2015-01-12 06:00:59 -08:00
<< "private:" << endl << endl
eolian_cxx: Fix Eolian C++ generated wrapper inconsistencies 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.
2014-11-11 14:37:47 -08:00
<< function_call_constructor_methods(cls)
eolian_cxx: Add protected methods and events to C++ wrappers and fixes 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.
2015-01-12 06:00:59 -08:00
<< comment("@internal", 1)
<< tab(1) << "Eo* _concrete_eo_ptr() const { return _eo_ptr(); }" << endl
cxx: General C++ Eo wrapper generation improvement 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.
2014-12-17 05:47:19 -08:00
<< "};" << endl << endl
<< "static_assert(sizeof(" << full_name(cls) << ") == sizeof(Eo*), \"\");" << endl
<< "static_assert(std::is_standard_layout<" << full_name(cls) << ">::value, \"\");" << endl
<< endl
<< namespace_tail(cls)
eolian_cxx: Add protected methods and events to C++ wrappers and fixes 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.
2015-01-12 06:00:59 -08:00
<< endl;
}
inline void
eo_class_definitions_generator(std::ostream& out, eo_class const& cls)
{
out << constructor_method_function_definitions(cls)
eolian_cxx: Fix "dreaded diamond" inheritance problem for C++ wrappers 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.
2014-12-19 08:34:15 -08:00
<< function_definitions(cls, true)
<< function_definitions(cls, false)
cxx: General C++ Eo wrapper generation improvement 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.
2014-12-17 05:47:19 -08:00
<< class_implicit_conversion_definition(cls);
eolian_cxx: initial version of the EFL C++ Bindings Generator. 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>
2014-05-02 15:55:51 -07:00
}
} } } // namespace efl { namespace eolian { namespace grammar {
#endif // EOLIAN_CXX_EO_CLASS_GENERATOR_HH