mono: start generating enum

2 files changed, 66 insertions, 5 deletions

diff --git a/src/bin/eolian_mono/eolian_mono.cc b/src/bin/eolian_mono/eolian_mono.cc
index 5463787e30..e9763ac716 100644
--- a/src/bin/eolian_mono/eolian_mono.cc
+++ b/src/bin/eolian_mono/eolian_mono.cc
@@ -23,6 +23,7 @@
 #include <Eolian_Cxx.hh>
 
 #include <eolian_mono/klass.hh>
+#include <eolian_mono/enum_definition.hh>
 #include <eolian_mono/type_impl.hh>
 
 namespace eolian_mono {
@@ -60,8 +61,8 @@ run(options_type const& opts)
 {
    const Eolian_Class *klass = NULL;
    char* dup = strdup(opts.in_file.c_str());
-   char* base = basename(dup);
-   klass = ::eolian_class_get_by_file(base);
+   std::string basename_input = basename(dup);
+   klass = ::eolian_class_get_by_file(basename_input.c_str());
    free(dup);
 
    std::string class_file_name = opts.out_file;
@@ -92,15 +93,18 @@ run(options_type const& opts)
 
         eolian_mono::klass.generate(iterator, klass_def, efl::eolian::grammar::context_null());
      }
-   else
+   //else
      {
-       for (efl::eina::iterator<const Eolian_Typedecl> enum_iterator(::eolian_typedecl_enums_get_by_file(opts.in_file.c_str()))
+       EINA_CXX_DOM_LOG_ERR(eolian_mono::domain) << "No klass, probably a eot file? " << opts.in_file.c_str();
+       for (efl::eina::iterator<const Eolian_Typedecl> enum_iterator( ::eolian_typedecl_enums_get_by_file(basename_input.c_str()))
                , enum_last; enum_iterator != enum_last; ++enum_iterator)
          {
+            efl::eolian::grammar::attributes::enum_def enum_(&*enum_iterator);
             EINA_CXX_DOM_LOG_ERR(eolian_mono::domain) << "would be generating enum";
+
+            eolian_mono::enum_definition.generate(iterator, enum_, efl::eolian::grammar::context_null());
          }
     }
-   return;
 }
 
 static void
diff --git a/src/bin/eolian_mono/eolian_mono/enum_definition.hh b/src/bin/eolian_mono/eolian_mono/enum_definition.hh
new file mode 100644
index 0000000000..e1cf4cf073
--- /dev/null
+++ b/src/bin/eolian_mono/eolian_mono/enum_definition.hh
@@ -0,0 +1,57 @@
+#ifndef EOLIAN_MONO_ENUM_DEFINITION_HH
+#define EOLIAN_MONO_ENUM_DEFINITION_HH
+
+#include "grammar/generator.hpp"
+#include "grammar/klass_def.hpp"
+#include "grammar/indentation.hpp"
+#include "grammar/list.hpp"
+#include "grammar/alternative.hpp"
+#include "type.hh"
+#include "keyword.hh"
+#include "using_decl.hh"
+
+namespace eolian_mono {
+
+struct enum_definition_generator
+{
+  template <typename OutputIterator, typename Context>
+  bool generate(OutputIterator sink, attributes::enum_def const& enum_, Context const& context) const
+  {
+     std::vector<std::string> cpp_namespaces = attributes::cpp_namespaces(enum_.namespaces);
+
+     auto open_namespace = *("namespace " << string << " { ") << "\n";
+     if(!as_generator(open_namespace).generate(sink, cpp_namespaces, add_lower_case_context(context))) return false;
+
+     if(!as_generator
+        (
+         "public enum " << string << "\n{\n"
+         )
+        .generate(sink, enum_.cxx_name, context))
+       return false;
+
+     if(!as_generator("}\n").generate(sink, attributes::unused, context)) return false;
+
+     auto close_namespace = *(lit("} ")) << "\n";
+     if(!as_generator(close_namespace).generate(sink, cpp_namespaces, context)) return false;
+     
+     return true;
+  }
+};
+
+enum_definition_generator const enum_definition = {};
+
+}
+
+namespace efl { namespace eolian { namespace grammar {
+
+template <>
+struct is_eager_generator< ::eolian_mono::enum_definition_generator> : std::true_type {};
+
+namespace type_traits {
+template <>
+struct attributes_needed< ::eolian_mono::enum_definition_generator> : std::integral_constant<int, 1> {};
+}
+      
+} } }
+
+#endif