enlightenment/efl
enlightenment
/
efl
8
7
Fork 14
Code Issues 13 Pull Requests 3 Projects Releases Wiki Activity
efl/src/bin/eolian_mono/eolian/mono/klass.hh

809 lines
41 KiB
C++
Raw Normal View History

eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
#ifndef EOLIAN_MONO_CLASS_DEFINITION_HPP
#define EOLIAN_MONO_CLASS_DEFINITION_HPP
#include "grammar/integral.hpp"
#include "grammar/generator.hpp"
#include "grammar/klass_def.hpp"
#include "function_blacklist.hh"
#include "grammar/indentation.hpp"
#include "grammar/list.hpp"
#include "grammar/alternative.hpp"
#include "type.hh"
#include "namespace.hh"
#include "function_definition.hh"
#include "function_registration.hh"
#include "function_declaration.hh"
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
#include "documentation.hh"
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
#include "grammar/string.hpp"
#include "grammar/attribute_replace.hpp"
#include "grammar/integral.hpp"
#include "grammar/case.hpp"
#include "using_decl.hh"
#include "utils.hh"
#include <string>
#include <algorithm>
namespace eolian_mono {
template <typename OutputIterator, typename Context>
static bool generate_static_cast_method(OutputIterator sink, const std::string &class_name, Context const &context)
{
return as_generator(
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
scope_tab << "///<summary>Casts obj into an instance of this type.</summary>\n"
<< scope_tab << "public static " << class_name << " static_cast(efl.Object obj)\n"
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
<< scope_tab << "{\n"
<< scope_tab << scope_tab << "if (obj == null)\n"
<< scope_tab << scope_tab << scope_tab << "throw new System.ArgumentNullException(\"obj\");\n"
<< scope_tab << scope_tab << "return new " << class_name << "Concrete(obj.raw_handle);\n"
<< scope_tab << "}\n"
).generate(sink, nullptr, context);
}
template <typename OutputIterator, typename Context>
static bool generate_equals_method(OutputIterator sink, Context const &context)
{
return as_generator(
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
scope_tab << "///<summary>Verifies if the given object is equals to this.</summary>\n"
<< scope_tab << "public override bool Equals(object obj)\n"
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
<< scope_tab << "{\n"
<< scope_tab << scope_tab << "var other = obj as efl.Object;\n"
<< scope_tab << scope_tab << "if (other == null)\n"
<< scope_tab << scope_tab << scope_tab << "return false;\n"
<< scope_tab << scope_tab << "return this.raw_handle == other.raw_handle;\n"
<< scope_tab << "}\n"
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
<< scope_tab << "///<summary>Gets the hash code for this object based on the native pointer it points to.</summary>\n"
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
<< scope_tab << "public override int GetHashCode()\n"
<< scope_tab << "{\n"
<< scope_tab << scope_tab << "return this.raw_handle.ToInt32();\n"
<< scope_tab << "}\n"
eolian_mono: Add underlying pointer to ToString It'll make easier to track where an object is coming from.
2018-01-22 13:12:33 -08:00
<< scope_tab << "///<summary>How native pointer in string representation.</summary>\n"
<< scope_tab << "public override String ToString()\n"
<< scope_tab << "{\n"
<< scope_tab << scope_tab << "return $\"{this.GetType().Name}@[{this.raw_handle.ToInt32():x}]\";\n"
<< scope_tab << "}\n"
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
).generate(sink, nullptr, context);
}
/* Get the actual number of functions of a class, checking for blacklisted ones */
static std::size_t
get_function_count(grammar::attributes::klass_def const& cls)
{
auto methods = cls.get_all_methods();
return std::count_if(methods.cbegin(), methods.cend(), [](grammar::attributes::function_def const& func)
{
return !is_function_blacklisted(func.c_name);
});
}
eolian_mono: Fix visibility of generated events Protected members do not make sense in sealed classes like the Concrete ones. Also document the placeholder field in extern structures.
2018-01-19 05:30:00 -08:00
template<typename Context>
static bool
is_inherit_context(Context const& context)
{
return context_find_tag<class_context>(context).current_wrapper_kind == class_context::inherit;
}
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
struct get_csharp_type_visitor
{
typedef get_csharp_type_visitor visitor_type;
typedef std::string result_type;
std::string operator()(grammar::attributes::regular_type_def const& type) const
{
std::stringstream csharp_name;
for (auto&& i : escape_namespace(type.namespaces))
csharp_name << utils::to_lowercase(i) << ".";
csharp_name << type.base_type;
return csharp_name.str();
}
std::string operator()(grammar::attributes::klass_name const& name) const
{
std::stringstream csharp_name;
for (auto&& i : escape_namespace(name.namespaces))
csharp_name << utils::to_lowercase(i) << ".";
csharp_name << name.eolian_name;
return csharp_name.str();
}
std::string operator()(attributes::complex_type_def const&) const
{
return "UNSUPPORTED";
}
};
struct get_event_args_visitor
{
std::string arg_type;
typedef get_event_args_visitor visitor_type;
typedef std::string result_type;
std::string operator()(grammar::attributes::regular_type_def const&) const
{
eolian_mono: Fix event argument for strings
2018-01-22 09:56:38 -08:00
if (arg_type == "string")
{
return "eina.StringConversion.NativeUtf8ToManagedString(evt.Info)";
}
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
return "(" + arg_type + ")Marshal.PtrToStructure(evt.Info, typeof(" + arg_type + "))";
}
std::string operator()(grammar::attributes::klass_name const&) const
{
return "new " + arg_type + "Concrete(evt.Info)";
}
std::string operator()(attributes::complex_type_def const&) const
{
return "UNSUPPORTED";
}
};
struct klass
{
template <typename OutputIterator, typename Context>
bool generate(OutputIterator sink, attributes::klass_def const& cls, Context const& context) const
{
std::string suffix, class_type;
switch(cls.type)
{
case attributes::class_type::regular:
case attributes::class_type::abstract_:
class_type = "class";
suffix = "CLASS";
break;
case attributes::class_type::mixin:
class_type = "interface";
suffix = "MIXIN";
break;
case attributes::class_type::interface_:
class_type = "interface";
suffix = "INTERFACE";
break;
}
std::vector<std::string> namespaces = escape_namespace(cls.namespaces);
auto open_namespace = *("namespace " << string << " { ") << "\n";
if(!as_generator(open_namespace).generate(sink, namespaces, add_lower_case_context(context))) return false;
auto methods = cls.get_all_methods();
// FIXME Generate local event argument wrappers
for (auto&& e : cls.events)
{
efl::eina::optional<grammar::attributes::type_def> etype = e.type;
if (!etype.is_engaged())
continue;
std::string evt_name = utils::to_uppercase(e.name);
std::replace(evt_name.begin(), evt_name.end(), ',', '_');
std::string arg_type = (*etype).original_type.visit(get_csharp_type_visitor{});
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
if (!as_generator("///<summary>Event argument wrapper for event " << string << ".</summary>\n"
).generate(sink, evt_name, context))
return false;
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
if (!as_generator("public class " << evt_name << "_Args : EventArgs {\n"
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
<< scope_tab << "///<summary>Actual event payload.</summary>\n"
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
<< scope_tab << "public " << arg_type << " arg { get; set; }\n"
<< "}\n").generate(sink, NULL, context))
return false;
}
// Interface class
{
auto iface_cxt = context_add_tag(class_context{class_context::interface}, context);
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
if(!as_generator(documentation).generate(sink, cls, iface_cxt))
return false;
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
if(!as_generator
(
"public " /*<< class_type*/ "interface" /*<<*/ " " << string << " : "
)
.generate(sink, cls.cxx_name, iface_cxt))
return false;
for(auto first = std::begin(cls.immediate_inherits)
, last = std::end(cls.immediate_inherits); first != last; ++first)
{
if(!as_generator("\n" << scope_tab << *(lower_case[string] << ".") << string << " ,")
.generate(sink, std::make_tuple(escape_namespace(first->namespaces), first->eolian_name), iface_cxt))
return false;
// if(std::next(first) != last)
// *sink++ = ',';
}
// if(cls.immediate_inherits.empty())
if(!as_generator("\n" << scope_tab << "efl.eo.IWrapper, IDisposable").generate(sink, attributes::unused, iface_cxt)) return false;
if(!as_generator("\n{\n").generate(sink, attributes::unused, iface_cxt)) return false;
if(!as_generator(*(scope_tab << function_declaration))
.generate(sink, cls.functions, iface_cxt)) return false;
// FIXME Move the event generator into another generator like function?
for (auto &&e : cls.events)
{
std::string wrapper_args_type;
std::string evt_name = utils::to_uppercase(e.name);
std::replace(evt_name.begin(), evt_name.end(), ',', '_');
efl::eina::optional<grammar::attributes::type_def> etype = e.type;
if (etype.is_engaged())
wrapper_args_type = "<" + evt_name + "_Args>";
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
if (!as_generator(documentation(1)).generate(sink, e, iface_cxt))
return false;
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
//FIXME Add a way to generate camelcase names
if (!as_generator(
scope_tab << "event EventHandler" << wrapper_args_type << " "
<< evt_name << ";\n"
).generate(sink, NULL, iface_cxt))
return false;
}
// End of interface declaration
if(!as_generator("}\n").generate(sink, attributes::unused, iface_cxt)) return false;
}
auto class_get_name = *(lower_case[string] << "_") << lower_case[string] << "_class_get";
// Concrete class
// if(class_type == "class")
{
auto concrete_cxt = context_add_tag(class_context{class_context::concrete}, context);
if(!as_generator
(
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
documentation
<< "sealed public class " << string << "Concrete : " << string << "\n{\n"
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
<< scope_tab << "System.IntPtr handle;\n"
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
<< scope_tab << "///<summary>Pointer to the native instance.</summary>\n"
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
<< scope_tab << "public System.IntPtr raw_handle {\n"
<< scope_tab << scope_tab << "get { return handle; }\n"
<< scope_tab << "}\n"
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
<< scope_tab << "///<summary>Pointer to the native class description.</summary>\n"
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
<< scope_tab << "public System.IntPtr raw_klass {\n"
<< scope_tab << scope_tab << "get { return efl.eo.Globals.efl_class_get(handle); }\n"
<< scope_tab << "}\n"
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
<< scope_tab << "///<summary>Delegate for function to be called from inside the native constructor.</summary>\n"
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
<< scope_tab << "public delegate void ConstructingMethod(" << string << " obj);\n"
<< scope_tab << "[System.Runtime.InteropServices.DllImport(" << context_find_tag<library_context>(concrete_cxt).actual_library_name(cls.filename)
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
<< ")] private static extern System.IntPtr\n"
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
<< scope_tab << scope_tab << class_get_name << "();\n"
<< (class_type == "class" ? "" : "/*")
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
<< scope_tab << "///<summary>Creates a new instance.</summary>\n"
<< scope_tab << "///<param>Parent instance.</param>\n"
<< scope_tab << "///<param>Delegate to call constructing methods that should be run inside the constructor.</param>\n"
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
<< scope_tab << "public " << string << "Concrete(efl.Object parent = null, ConstructingMethod init_cb=null)\n"
<< scope_tab << "{\n"
<< scope_tab << scope_tab << "System.IntPtr klass = " << class_get_name << "();\n"
<< scope_tab << scope_tab << "System.IntPtr parent_ptr = System.IntPtr.Zero;\n"
<< scope_tab << scope_tab << "if(parent != null)\n"
<< scope_tab << scope_tab << scope_tab << "parent_ptr = parent.raw_handle;\n"
<< scope_tab << scope_tab << "handle = efl.eo.Globals._efl_add_internal_start(\"file\", 0, klass, parent_ptr, 0, 0);\n"
<< scope_tab << scope_tab << "if (init_cb != null) {\n"
<< scope_tab << scope_tab << scope_tab << "init_cb(this);\n"
<< scope_tab << scope_tab << "}\n"
<< scope_tab << scope_tab << "handle = efl.eo.Globals._efl_add_end(handle, 0, 0);\n" // replace handle with the actual final handle
<< scope_tab << scope_tab << "register_event_proxies();\n"
<< scope_tab << scope_tab << "eina.Error.RaiseIfOccurred();\n"
<< scope_tab << "}\n"
<< (class_type == "class" ? "" : "*/")
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
<< scope_tab << "///<summary>Constructs an instance from a native pointer.</summary>\n"
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
<< scope_tab << "public " << string << "Concrete(System.IntPtr raw)\n"
<< scope_tab << "{\n"
<< scope_tab << scope_tab << "handle = raw;\n"
<< scope_tab << scope_tab << "register_event_proxies();\n"
<< scope_tab << "}\n"
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
<< scope_tab << "///<summary>Destructor.</summary>\n"
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
<< scope_tab << "~" << string << "Concrete()\n"
<< scope_tab << "{\n"
<< scope_tab << scope_tab << "Dispose(false);\n"
<< scope_tab << "}\n"
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
<< scope_tab << "///<summary>Releases the underlying native instance.</summary>\n"
eolian_mono: Fix visibility of generated events Protected members do not make sense in sealed classes like the Concrete ones. Also document the placeholder field in extern structures.
2018-01-19 05:30:00 -08:00
<< scope_tab << "internal void Dispose(bool disposing)\n"
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
<< scope_tab << "{\n"
<< scope_tab << scope_tab << "if (handle != System.IntPtr.Zero) {\n"
<< scope_tab << scope_tab << scope_tab << "efl.eo.Globals.efl_unref(handle);\n"
<< scope_tab << scope_tab << scope_tab << "handle = System.IntPtr.Zero;\n"
<< scope_tab << scope_tab << "}\n"
<< scope_tab << "}\n"
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
<< scope_tab << "///<summary>Releases the underlying native instance.</summary>\n"
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
<< scope_tab << "public void Dispose()\n"
<< scope_tab << "{\n"
<< scope_tab << scope_tab << "Dispose(true);\n"
<< scope_tab << scope_tab << "GC.SuppressFinalize(this);\n"
<< scope_tab << "}\n"
)
.generate(sink
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
, std::make_tuple( cls,
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
cls.cxx_name, cls.cxx_name, cls.cxx_name, cls.namespaces, cls.eolian_name
, cls.cxx_name, cls.namespaces, cls.eolian_name, cls.cxx_name
, cls.cxx_name)
, concrete_cxt))
return false;
if (!generate_static_cast_method(sink, cls.cxx_name, concrete_cxt))
return false;
if (!generate_equals_method(sink, concrete_cxt))
return false;
if (!generate_events(sink, cls, concrete_cxt))
return false;
if (!generate_events_registration(sink, cls, concrete_cxt))
return false;
// Concrete function definitions
if(!as_generator(*(function_definition))
.generate(sink, methods, concrete_cxt)) return false;
if(!as_generator("}\n").generate(sink, attributes::unused, concrete_cxt)) return false;
}
// Inherit class
if(class_type == "class")
{
auto inherit_cxt = context_add_tag(class_context{class_context::inherit}, context);
bool cls_has_string_return = has_string_return(cls);
bool cls_has_stringshare_return = has_stringshare_return(cls);
if(!as_generator
(
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
documentation
<< "public " << class_type << " " << string << "Inherit : " << string << "\n{\n"
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
<< scope_tab << "System.IntPtr handle;\n"
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
<< scope_tab << "internal static System.IntPtr klass = System.IntPtr.Zero;\n"
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
<< scope_tab << "private static readonly object klassAllocLock = new object();\n"
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
<< scope_tab << (cls_has_string_return ? ("internal Dictionary<String, IntPtr> cached_strings = new Dictionary<String, IntPtr>();") : "") << "\n"
<< scope_tab << (cls_has_stringshare_return ? ("internal Dictionary<String, IntPtr> cached_stringshares = new Dictionary<String, IntPtr>();") : "") << "\n"
<< scope_tab << "///<summary>Pointer to the native instance.</summary>\n"
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
<< scope_tab << "public System.IntPtr raw_handle {\n"
<< scope_tab << scope_tab << "get { return handle; }\n"
<< scope_tab << "}\n"
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
<< scope_tab << "///<summary>Pointer to the native class description.</summary>\n"
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
<< scope_tab << "public System.IntPtr raw_klass {\n"
<< scope_tab << scope_tab << "get { return klass; }\n"
<< scope_tab << "}\n"
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
<< scope_tab << "///<summary>Delegate for function to be called from inside the native constructor.</summary>\n"
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
<< scope_tab << "public delegate void ConstructingMethod(" << string << " obj);\n"
<< scope_tab << "[System.Runtime.InteropServices.DllImport(" << context_find_tag<library_context>(inherit_cxt).actual_library_name(cls.filename)
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
<< ")] private static extern System.IntPtr\n"
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
<< scope_tab << scope_tab << class_get_name << "();\n"
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
<< scope_tab << "///<summary>Creates a new instance.</summary>\n"
<< scope_tab << "///<param>Parent instance.</param>\n"
<< scope_tab << "///<param>Delegate to call constructing methods that should be run inside the constructor.</param>\n"
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
<< scope_tab << "public " << string << "Inherit(efl.Object parent = null, ConstructingMethod init_cb=null)\n"
<< scope_tab << "{\n"
<< scope_tab << scope_tab << "if (klass == System.IntPtr.Zero) {\n"
<< scope_tab << scope_tab << scope_tab << "lock (klassAllocLock) {\n"
<< scope_tab << scope_tab << scope_tab << scope_tab << "if (klass == System.IntPtr.Zero) {\n"
<< scope_tab << scope_tab << scope_tab << scope_tab << scope_tab << "klass = efl.eo.Globals.register_class(new efl.eo.Globals.class_initializer(" << string << "NativeInherit.class_initializer), " << class_get_name << "());\n"
//<< scope_tab << scope_tab << "klass = efl.eo.Globals.register_class(null/*new efl.eo.Globals.class_initializer(" << string << "NativeInherit.class_initializer)*/, " << class_get_name << "());\n"
<< scope_tab << scope_tab << scope_tab << scope_tab << "}\n"
<< scope_tab << scope_tab << scope_tab << "}\n"
<< scope_tab << scope_tab << "}\n"
<< scope_tab << scope_tab << "handle = efl.eo.Globals.instantiate_start(klass, parent);\n"
<< scope_tab << scope_tab << "if (init_cb != null) {\n"
<< scope_tab << scope_tab << scope_tab << "init_cb(this);\n"
<< scope_tab << scope_tab << "}\n"
<< scope_tab << scope_tab << "handle = efl.eo.Globals.instantiate_end(handle);\n"
<< scope_tab << scope_tab << "efl.eo.Globals.data_set(this);\n"
<< scope_tab << scope_tab << "register_event_proxies();\n"
<< scope_tab << scope_tab << "eina.Error.RaiseIfOccurred();\n"
<< scope_tab << "}\n"
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
<< scope_tab << "///<summary>Destructor.</summary>\n"
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
<< scope_tab << "~" << string << "Inherit()\n"
<< scope_tab << "{\n"
<< scope_tab << scope_tab << "Dispose(false);\n"
<< scope_tab << "}\n"
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
<< scope_tab << "///<summary>Releases the underlying native instance.</summary>\n"
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
<< scope_tab << "protected virtual void Dispose(bool disposing)\n"
<< scope_tab << "{\n"
<< scope_tab << scope_tab << "if (handle != System.IntPtr.Zero) {\n"
<< scope_tab << scope_tab << scope_tab << "efl.eo.Globals.efl_unref(handle);\n"
<< scope_tab << scope_tab << scope_tab << "handle = System.IntPtr.Zero;\n"
<< scope_tab << scope_tab << "}\n"
<< scope_tab << "}\n"
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
<< scope_tab << "///<summary>Releases the underlying native instance.</summary>\n"
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
<< scope_tab << "public void Dispose()\n"
<< scope_tab << "{\n"
<< scope_tab << (cls_has_string_return ? "efl.eo.Globals.free_dict_values(cached_strings);" : "") << "\n"
<< scope_tab << (cls_has_stringshare_return ? "efl.eo.Globals.free_stringshare_values(cached_stringshares);" : "") << "\n"
<< scope_tab << scope_tab << "Dispose(true);\n"
<< scope_tab << scope_tab << "GC.SuppressFinalize(this);\n"
<< scope_tab << "}\n"
)
.generate(sink
, std::make_tuple(
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
cls, cls.cxx_name, cls.cxx_name, cls.cxx_name, cls.namespaces, cls.eolian_name
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
, cls.cxx_name, cls.cxx_name, cls.namespaces, cls.eolian_name, cls.cxx_name
, cls.cxx_name)
, inherit_cxt))
return false;
if (!generate_static_cast_method(sink, cls.cxx_name, inherit_cxt))
return false;
if (!generate_equals_method(sink, inherit_cxt))
return false;
if (!generate_events(sink, cls, inherit_cxt))
return false;
if (!generate_events_registration(sink, cls, inherit_cxt))
return false;
// Inherit function definitions
if(!as_generator(*(function_definition(true)))
.generate(sink, methods, inherit_cxt)) return false;
if(!as_generator("}\n").generate(sink, attributes::unused, inherit_cxt)) return false;
}
std::size_t function_count = get_function_count(cls);
int function_registration_index = 0;
auto index_generator = [&function_registration_index]
{
return function_registration_index++;
};
// Native Inherit class
if(class_type == "class")
{
auto inative_cxt = context_add_tag(class_context{class_context::inherit_native}, context);
if(!as_generator
(
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
"internal " << class_type << " " << string << "NativeInherit {\n"
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
<< scope_tab << "public static byte class_initializer(IntPtr klass)\n"
<< scope_tab << "{\n"
<< scope_tab << scope_tab << "Efl_Op_Description[] descs = new Efl_Op_Description[" << grammar::int_ << "];\n"
)
.generate(sink, std::make_tuple(cls.cxx_name, function_count), inative_cxt))
return false;
// Native wrapper registration
if(!as_generator(*(function_registration(index_generator, cls)))
.generate(sink, methods, inative_cxt)) return false;
if(!as_generator
( scope_tab << scope_tab << "IntPtr descs_ptr = Marshal.AllocHGlobal(Marshal.SizeOf(descs[0])*" << function_count << ");\n"
<< scope_tab << scope_tab << "IntPtr ptr = descs_ptr;\n"
<< scope_tab << scope_tab << "for(int i = 0; i != " << function_count << "; ++i)\n"
<< scope_tab << scope_tab << "{\n"
<< scope_tab << scope_tab << scope_tab << "Marshal.StructureToPtr(descs[i], ptr, false);\n"
<< scope_tab << scope_tab << scope_tab << "ptr = IntPtr.Add(ptr, Marshal.SizeOf(descs[0]));\n"
<< scope_tab << scope_tab << "}\n"
<< scope_tab << scope_tab << "Efl_Object_Ops ops;\n"
<< scope_tab << scope_tab << "ops.descs = descs_ptr;\n"
<< scope_tab << scope_tab << "ops.count = (UIntPtr)" << function_count << ";\n"
<< scope_tab << scope_tab << "IntPtr ops_ptr = Marshal.AllocHGlobal(Marshal.SizeOf(ops));\n"
<< scope_tab << scope_tab << "Marshal.StructureToPtr(ops, ops_ptr, false);\n"
<< scope_tab << scope_tab << "efl.eo.Globals.efl_class_functions_set(klass, ops_ptr, IntPtr.Zero);\n"
).generate(sink, attributes::unused, inative_cxt)) return false;
if(!as_generator(scope_tab << scope_tab << "return 1;\n"
<< scope_tab << "}\n")
.generate(sink, attributes::unused, inative_cxt)) return false;
// Native method definitions
if(!as_generator(*(native_function_definition(cls)))
.generate(sink, methods, inative_cxt)) return false;
if(!as_generator("}\n").generate(sink, attributes::unused, inative_cxt)) return false;
}
auto close_namespace = *(lit("} ")) << "\n";
if(!as_generator(close_namespace).generate(sink, namespaces, context)) return false;
return true;
}
template <typename OutputIterator, typename Context>
bool generate_events_registration(OutputIterator sink, attributes::klass_def const& cls, Context const& context) const
{
// Event proxy registration
if (!as_generator(
scope_tab << "private void register_event_proxies()\n"
<< scope_tab << "{\n"
)
.generate(sink, NULL, context))
return false;
// Generate event registrations here
// Assigning the delegates
for (auto&& e : cls.events)
{
if (!as_generator(scope_tab << scope_tab << "evt_" << grammar::string_replace(',', '_') << "_delegate = "
<< "new efl.Event_Cb(on_" << grammar::string_replace(',', '_') << "_NativeCallback);\n")
.generate(sink, std::make_tuple(e.name, e.name), context))
return false;
}
for (auto&& c : cls.inherits)
{
eolian_mono: Fix build after Eolian_State Summary: eolian_mono now properly fills Eolian Unit when calling eolian_cxx classes and functions. Reviewers: felipealmeida Subscribers: cedric, jpeg Differential Revision: https://phab.enlightenment.org/D5614
2017-12-06 08:27:27 -08:00
attributes::klass_def klass(get_klass(c, cls.unit), cls.unit);
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
for (auto&& e : klass.events)
{
std::string wrapper_event_name = translate_inherited_event_name(e, klass);
if (!as_generator(scope_tab << scope_tab << "evt_" << wrapper_event_name << "_delegate = "
<< "new efl.Event_Cb(on_" << wrapper_event_name << "_NativeCallback);\n")
.generate(sink, NULL, context))
return false;
}
}
if (!as_generator(
scope_tab << "}\n"
).generate(sink, NULL, context))
return false;
return true;
}
static std::string translate_inherited_event_name(const attributes::event_def &evt, const attributes::klass_def &klass)
{
std::stringstream s;
for (auto&& n : klass.namespaces)
{
s << n;
s << '_';
}
std::string evt_name = utils::to_uppercase(evt.name);
std::replace(evt_name.begin(), evt_name.end(), ',', '_');
s << klass.cxx_name << '_' << evt_name;
return s.str();
}
template <typename OutputIterator, typename Context>
bool generate_events(OutputIterator sink, attributes::klass_def const& cls, Context const& context) const
{
if (!has_events(cls))
return true;
eolian_mono: Fix visibility of generated events Protected members do not make sense in sealed classes like the Concrete ones. Also document the placeholder field in extern structures.
2018-01-19 05:30:00 -08:00
std::string visibility = is_inherit_context(context) ? "protected" : "private";
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
if (!as_generator(scope_tab << "private readonly object eventLock = new object();\n"
<< scope_tab << "private Dictionary<string, int> event_cb_count = new Dictionary<string, int>();\n")
.generate(sink, NULL, context))
return false;
// Callback registration functions
if (!as_generator(
scope_tab << "private bool add_cpp_event_handler(string key, efl.Event_Cb evt_delegate) {\n"
<< scope_tab << scope_tab << "int event_count = 0;\n"
<< scope_tab << scope_tab << "if (!event_cb_count.TryGetValue(key, out event_count))\n"
<< scope_tab << scope_tab << scope_tab << "event_cb_count[key] = event_count;\n"
<< scope_tab << scope_tab << "if (event_count == 0) {\n"
efl-mono: Fix using right description pointer in event registration
2017-12-20 13:45:07 -08:00
<< scope_tab << scope_tab << scope_tab << "IntPtr desc = efl.eo.Globals.dlsym(efl.eo.Globals.RTLD_DEFAULT, key);\n"
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
<< scope_tab << scope_tab << scope_tab << "bool result = efl.eo.Globals.efl_event_callback_priority_add(handle, desc, 0, evt_delegate, System.IntPtr.Zero);\n"
<< scope_tab << scope_tab << scope_tab << "if (!result) {\n"
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
<< scope_tab << scope_tab << scope_tab << scope_tab << "eina.Log.Error($\"Failed to add event proxy for event {key}\");\n"
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
<< scope_tab << scope_tab << scope_tab << scope_tab << "return false;\n"
<< scope_tab << scope_tab << scope_tab << "}\n"
<< scope_tab << scope_tab << scope_tab << "eina.Error.RaiseIfOccurred();\n"
<< scope_tab << scope_tab << "} \n"
<< scope_tab << scope_tab << "event_cb_count[key]++;\n"
<< scope_tab << scope_tab << "return true;\n"
<< scope_tab << "}\n"
<< scope_tab << "private bool remove_cpp_event_handler(string key, efl.Event_Cb evt_delegate) {\n"
<< scope_tab << scope_tab << "int event_count = 0;\n"
<< scope_tab << scope_tab << "if (!event_cb_count.TryGetValue(key, out event_count))\n"
<< scope_tab << scope_tab << scope_tab << "event_cb_count[key] = event_count;\n"
<< scope_tab << scope_tab << "if (event_count == 1) {\n"
<< scope_tab << scope_tab << scope_tab << "efl.kw_event.Description desc = new efl.kw_event.Description(key);\n"
<< scope_tab << scope_tab << scope_tab << "bool result = efl.eo.Globals.efl_event_callback_del(handle, desc, evt_delegate, System.IntPtr.Zero);\n"
<< scope_tab << scope_tab << scope_tab << "if (!result) {\n"
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
<< scope_tab << scope_tab << scope_tab << scope_tab << "eina.Log.Error($\"Failed to remove event proxy for event {key}\");\n"
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
<< scope_tab << scope_tab << scope_tab << scope_tab << "return false;\n"
<< scope_tab << scope_tab << scope_tab << "}\n"
<< scope_tab << scope_tab << scope_tab << "eina.Error.RaiseIfOccurred();\n"
<< scope_tab << scope_tab << "} else if (event_count == 0) {\n"
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
<< scope_tab << scope_tab << scope_tab << "eina.Log.Error($\"Trying to remove proxy for event {key} when there is nothing registered.\");\n"
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
<< scope_tab << scope_tab << scope_tab << "return false;\n"
<< scope_tab << scope_tab << "} \n"
<< scope_tab << scope_tab << "event_cb_count[key]--;\n"
<< scope_tab << scope_tab << "return true;\n"
<< scope_tab << "}\n"
)
.generate(sink, NULL, context))
return false;
// Self events
for (auto&& e : cls.events)
{
std::string upper_name = utils::to_uppercase(e.name);
std::replace(upper_name.begin(), upper_name.end(), ',', '_');
std::string upper_c_name = utils::to_uppercase(e.c_name);
std::string event_name = e.name;
std::replace(event_name.begin(), event_name.end(), ',', '_');
std::string wrapper_args_type = "EventArgs";
std::string wrapper_args_template = "";
std::string event_args = "EventArgs args = EventArgs.Empty;\n";
efl::eina::optional<grammar::attributes::type_def> etype = e.type;
if (etype.is_engaged())
{
wrapper_args_type = upper_name + "_Args";
wrapper_args_template = "<" + wrapper_args_type + ">";
std::string arg_type = wrapper_args_type + " args = new " + wrapper_args_type + "();\n"; // = (*etype).original_type.visit(get_csharp_type_visitor{});
std::string actual_arg_type = (*etype).original_type.visit(get_csharp_type_visitor{});
arg_type += "args.arg = " + (*etype).original_type.visit(get_event_args_visitor{actual_arg_type}) + ";\n";
event_args = arg_type;
}
// Marshal.PtrToStructure for value types
// Wrapper event declaration
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
if(!as_generator(documentation(1)).generate(sink, e, context))
return false;
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
if(!as_generator(
eolian_mono: Fix visibility of generated events Protected members do not make sense in sealed classes like the Concrete ones. Also document the placeholder field in extern structures.
2018-01-19 05:30:00 -08:00
scope_tab << visibility << " event EventHandler" << wrapper_args_template << " " << upper_name << ";\n"
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
<< scope_tab << "///<summary>Method to raise event "<< event_name << ".</summary>\n"
eolian_mono: Fix visibility of generated events Protected members do not make sense in sealed classes like the Concrete ones. Also document the placeholder field in extern structures.
2018-01-19 05:30:00 -08:00
<< scope_tab << visibility << " void On_" << event_name << "(" << wrapper_args_type << " e)\n"
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
<< scope_tab << "{\n"
<< scope_tab << scope_tab << "EventHandler" << wrapper_args_template << " evt;\n"
<< scope_tab << scope_tab << "lock (eventLock) {\n"
<< scope_tab << scope_tab << scope_tab << "evt = " << upper_name << ";\n"
<< scope_tab << scope_tab << "}\n"
<< scope_tab << scope_tab << "if (evt != null) { evt(this, e); }\n"
<< scope_tab << "}\n"
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
<< scope_tab << "private void on_" << event_name << "_NativeCallback(System.IntPtr data, ref efl.Event evt)\n"
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
<< scope_tab << "{\n"
efl-mono: Fix using right description pointer in event registration
2017-12-20 13:45:07 -08:00
<< scope_tab << scope_tab << event_args
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
<< scope_tab << scope_tab << "try {\n"
<< scope_tab << scope_tab << scope_tab << "On_" << event_name << "(args);\n"
<< scope_tab << scope_tab << "} catch (Exception e) {\n"
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
<< scope_tab << scope_tab << scope_tab << "eina.Log.Error(e.ToString());\n"
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
<< scope_tab << scope_tab << scope_tab << "eina.Error.Set(eina.Error.EFL_ERROR);\n"
<< scope_tab << scope_tab << "}\n"
<< scope_tab << "}\n"
<< scope_tab << "efl.Event_Cb evt_" << event_name << "_delegate;\n"
<< scope_tab << "event EventHandler" << wrapper_args_template << " " << cls.cxx_name << "." << upper_name << "{\n")
.generate(sink, NULL, context))
return false;
if (!as_generator(
scope_tab << scope_tab << "add {\n"
<< scope_tab << scope_tab << scope_tab << "lock (eventLock) {\n"
<< scope_tab << scope_tab << scope_tab << scope_tab << "string key = \"_" << upper_c_name << "\";\n"
<< scope_tab << scope_tab << scope_tab << scope_tab << "if (add_cpp_event_handler(key, this.evt_" << event_name << "_delegate))\n"
<< scope_tab << scope_tab << scope_tab << scope_tab << scope_tab << upper_name << " += value;\n"
<< scope_tab << scope_tab << scope_tab << scope_tab << "else\n"
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
<< scope_tab << scope_tab << scope_tab << scope_tab << scope_tab << "eina.Log.Error($\"Error adding proxy for event {key}\");\n"
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
<< scope_tab << scope_tab << scope_tab << "}\n" // End of lock block
<< scope_tab << scope_tab << "}\n"
<< scope_tab << scope_tab << "remove {\n"
<< scope_tab << scope_tab << scope_tab << "lock (eventLock) {\n"
<< scope_tab << scope_tab << scope_tab << scope_tab << "string key = \"_" << upper_c_name << "\";\n"
<< scope_tab << scope_tab << scope_tab << scope_tab << "if (remove_cpp_event_handler(key, this.evt_" << event_name << "_delegate))\n"
<< scope_tab << scope_tab << scope_tab << scope_tab << scope_tab << upper_name << " -= value;\n"
<< scope_tab << scope_tab << scope_tab << scope_tab << "else\n"
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
<< scope_tab << scope_tab << scope_tab << scope_tab << scope_tab << "eina.Log.Error($\"Error removing proxy for event {key}\");\n"
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
<< scope_tab << scope_tab << scope_tab << "}\n" // End of lock block
<< scope_tab << scope_tab << "}\n"
<< scope_tab << "}\n")
.generate(sink, NULL, context))
return false;
}
// Inherited events
for (auto&& c : cls.inherits)
{
eolian_mono: Fix build after Eolian_State Summary: eolian_mono now properly fills Eolian Unit when calling eolian_cxx classes and functions. Reviewers: felipealmeida Subscribers: cedric, jpeg Differential Revision: https://phab.enlightenment.org/D5614
2017-12-06 08:27:27 -08:00
attributes::klass_def klass(get_klass(c, cls.unit), cls.unit);
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
// FIXME Enable inherited events registration. Beware of conflicting events
for (auto&& e : klass.events)
{
std::string wrapper_evt_name = translate_inherited_event_name(e, klass);
std::string upper_name = utils::to_uppercase(e.name);
std::replace(upper_name.begin(), upper_name.end(), ',', '_');
std::string upper_c_name = utils::to_uppercase(e.c_name);
std::stringstream wrapper_args_type;
std::string wrapper_args_template;
std::string event_args = "EventArgs args = EventArgs.Empty;\n";
efl::eina::optional<grammar::attributes::type_def> etype = e.type;
if (etype.is_engaged())
{
for (auto&& i : klass.namespaces)
{
wrapper_args_type << escape_keyword(utils::to_lowercase(i)) << ".";
}
wrapper_args_type << upper_name << "_Args";
wrapper_args_template = "<" + wrapper_args_type.str() + ">";
std::string arg_type = wrapper_args_type.str() + " args = new " + wrapper_args_type.str() + "();\n"; // = (*etype).original_type.visit(get_csharp_type_visitor{});
std::string actual_arg_type = (*etype).original_type.visit(get_csharp_type_visitor{});
arg_type += "args.arg = " + (*etype).original_type.visit(get_event_args_visitor{actual_arg_type}) + ";\n";
event_args = arg_type;
}
else
{
wrapper_args_type << "EventArgs";
}
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
if (!as_generator(documentation(1)).generate(sink, e, context))
return false;
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
if (!as_generator(
eolian_mono: Fix visibility of generated events Protected members do not make sense in sealed classes like the Concrete ones. Also document the placeholder field in extern structures.
2018-01-19 05:30:00 -08:00
scope_tab << visibility << " event EventHandler" << wrapper_args_template << " " << wrapper_evt_name << ";\n"
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
<< scope_tab << "///<summary>Method to raise event "<< wrapper_evt_name << ".</summary>\n"
eolian_mono: Fix visibility of generated events Protected members do not make sense in sealed classes like the Concrete ones. Also document the placeholder field in extern structures.
2018-01-19 05:30:00 -08:00
<< scope_tab << visibility << " void On_" << wrapper_evt_name << "(" << wrapper_args_type.str() << " e)\n"
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
<< scope_tab << "{\n"
<< scope_tab << scope_tab << "EventHandler" << wrapper_args_template << " evt;\n"
<< scope_tab << scope_tab << "lock (eventLock) {\n"
<< scope_tab << scope_tab << scope_tab << "evt = " << wrapper_evt_name << ";\n"
<< scope_tab << scope_tab << "}\n"
<< scope_tab << scope_tab << "if (evt != null) { evt(this, e); }\n"
<< scope_tab << "}\n"
<< scope_tab << "efl.Event_Cb evt_" << wrapper_evt_name << "_delegate;\n"
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
<< scope_tab << "private void on_" << wrapper_evt_name << "_NativeCallback(System.IntPtr data, ref efl.Event evt)"
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
<< scope_tab << "{\n"
efl-mono: Fix using right description pointer in event registration
2017-12-20 13:45:07 -08:00
<< scope_tab << scope_tab << event_args
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
<< scope_tab << scope_tab << "try {\n"
<< scope_tab << scope_tab << scope_tab << "On_" << wrapper_evt_name << "(args);\n"
<< scope_tab << scope_tab << "} catch (Exception e) {\n"
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
<< scope_tab << scope_tab << scope_tab << "eina.Log.Error(e.ToString());\n"
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
<< scope_tab << scope_tab << scope_tab << "eina.Error.Set(eina.Error.EFL_ERROR);\n"
<< scope_tab << scope_tab << "}\n"
<< scope_tab << "}\n"
<< scope_tab << "event EventHandler" << wrapper_args_template << " " << *(lower_case[string] << ".") << klass.cxx_name << ".")
.generate(sink, escape_namespace(klass.namespaces), context))
return false;
if (!as_generator(upper_name << " {\n"
<< scope_tab << scope_tab << "add {\n"
<< scope_tab << scope_tab << scope_tab << "lock (eventLock) {\n"
<< scope_tab << scope_tab << scope_tab << scope_tab << "string key = \"_" << upper_c_name << "\";\n"
<< scope_tab << scope_tab << scope_tab << scope_tab << "if (add_cpp_event_handler(key, this.evt_" << wrapper_evt_name << "_delegate))\n"
<< scope_tab << scope_tab << scope_tab << scope_tab << scope_tab << wrapper_evt_name << " += value;\n"
<< scope_tab << scope_tab << scope_tab << scope_tab << "else\n"
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
<< scope_tab << scope_tab << scope_tab << scope_tab << scope_tab << "eina.Log.Error($\"Error adding proxy for event {key}\");\n"
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
<< scope_tab << scope_tab << scope_tab << "}\n" // End of lock block
<< scope_tab << scope_tab << "}\n"
<< scope_tab << scope_tab << "remove {\n"
<< scope_tab << scope_tab << scope_tab << "lock (eventLock) {\n"
<< scope_tab << scope_tab << scope_tab << scope_tab << "string key = \"_" << upper_c_name << "\";\n"
<< scope_tab << scope_tab << scope_tab << scope_tab << "if (remove_cpp_event_handler(key, this.evt_" << wrapper_evt_name << "_delegate))\n"
<< scope_tab << scope_tab << scope_tab << scope_tab << scope_tab << wrapper_evt_name << " -= value;\n"
<< scope_tab << scope_tab << scope_tab << scope_tab << "else\n"
eolian-mono: Add documentation generation support This commit adds the "documentation" generator, which gets the documentation_def attribute of the given item and generates xml comments to be exported by MCS. For items requiring some customization of the generated comments (e.g. functions and its parameters), the helpers to generate the preamble (summary), body (paragraphs) and epilogue (currently just the @since tag) were added. Currently we do not support converting Eolian references into xmldoc references. As we explicitly generate Get/Set methods for properties, for now the generator tries to get the get/set specific documentation first. If it is not present, fallback to the common docs. Later this could be changed to generate the common one as paragraphs of the Get/Set. Also some generated code like the wrappers for calling C# methods from C can be private. This will cleanup the introspection results and warnings when generating documentation. Due to this visibility change, the binbuf tests had to be changed to add redirect calls to the native methods instead of directly calling the DllImport'd methods.
2017-12-06 16:03:55 -08:00
<< scope_tab << scope_tab << scope_tab << scope_tab << scope_tab << "eina.Log.Error($\"Error removing proxy for event {key}\");\n"
eolian_mono: Added code for eolian_mono generator Based on the eolian_cxx library generators. Buildsystem files will come in a future commmit.
2017-11-23 16:50:16 -08:00
<< scope_tab << scope_tab << scope_tab << "}\n" // End of lock block
<< scope_tab << scope_tab << "}\n"
<< scope_tab << "}\n")
.generate(sink, NULL, context))
return false;
}
}
return true;
}
};
struct klass const klass = {};
}
namespace efl { namespace eolian { namespace grammar {
template <>
struct is_eager_generator<struct ::eolian_mono::klass> : std::true_type {};
template <>
struct is_generator<struct ::eolian_mono::klass> : std::true_type {};
namespace type_traits {
template <>
struct attributes_needed<struct ::eolian_mono::klass> : std::integral_constant<int, 1> {};
}
} } }
#endif