eolian: struct/enum fixes and initial test for enums

src/bin/eolian/types_generator.c

@@ -107,6 +107,9 @@ types_header_generate(const char *eo_filename, Eina_Strbuf *buf)
    Eina_Iterator *itr = eolian_type_aliases_get_by_file(eo_filename);
    EINA_ITERATOR_FOREACH(itr, tp)
      {
+        /* avoid for the time being */
+        if (eolian_type_type_get(eolian_type_base_type_get(tp)) == EOLIAN_TYPE_ENUM)
+          continue;
         Eina_Strbuf *type_buf = _type_generate(tp);
         if (type_buf)
           {

src/lib/eolian/database_type.c

@@ -15,9 +15,10 @@ database_type_del(Eolian_Type *tp)
    if (tp->name) eina_stringshare_del(tp->name);
    if (tp->full_name) eina_stringshare_del(tp->full_name);
    if (tp->fields) eina_hash_free(tp->fields);
-   if (tp->field_names) eina_list_free(tp->field_names);
+   if (tp->field_names) EINA_LIST_FREE(tp->field_names, sp)
+     eina_stringshare_del(sp);
    if (tp->namespaces) EINA_LIST_FREE(tp->namespaces, sp)
-      eina_stringshare_del(sp);
+     eina_stringshare_del(sp);
    if (tp->comment) eina_stringshare_del(tp->comment);
    if (tp->legacy) eina_stringshare_del(tp->legacy);
    free(tp);
@@ -158,7 +159,7 @@ _etype_to_str(const Eolian_Type *tp, Eina_Strbuf *buf, const char *name)
         if (l != eina_list_last(tp->field_names))
           eina_strbuf_append(buf, ", ");
      }
-   eina_strbuf_append(buf, "}");
+   eina_strbuf_append(buf, " }");
    if (name)
      {
         eina_strbuf_append_char(buf, ' ');
@@ -359,7 +360,7 @@ database_type_print(Eolian_Type *tp)
              if (l != eina_list_last(tp->field_names))
                printf(", ");
           }
-        printf("}");
+        printf(" }");
      }
    if (tp->is_own)
      putchar(')');

src/lib/eolian/eo_parser.c

@@ -427,7 +427,6 @@ parse_expr_simple(Eo_Lexer *ls)
                    expr->value.s = eina_stringshare_add(eina_strbuf_string_get
                        (buf));
                    pop_strbuf(ls);
-                   eo_lexer_get(ls);
                    break;
                 }
              }
@@ -464,6 +463,7 @@ parse_expr_bin(Eo_Lexer *ls, int min_prec)
         int prec = get_binop_prec(op);
         if ((op < 0) || (prec < 0) || (prec < min_prec))
           break;
+        eo_lexer_get(ls);
         rhs = parse_expr_bin(ls, prec + 1);
         pop_expr(ls);
         pop_expr(ls);
@@ -598,7 +598,6 @@ parse_struct(Eo_Lexer *ls, const char *name, Eina_Bool is_extern,
         eina_hash_add(def->fields, fname, fdef);
         def->field_names = eina_list_append(def->field_names, fname);
         pop_type(ls);
-        eina_stringshare_del(fname);
         check_next(ls, ';');
         if (ls->t.token == TOK_COMMENT)
           {
@@ -694,7 +693,6 @@ parse_enum(Eo_Lexer *ls, const char *name, Eina_Bool is_extern,
           }
         eina_hash_add(def->fields, fname, fdef);
         def->field_names = eina_list_append(def->field_names, fname);
-        eina_stringshare_del(fname);
         Eina_Bool want_next = (ls->t.token == ',');
         if (want_next)
           eo_lexer_get(ls);

src/tests/eolian/data/enum.eo

@@ -0,0 +1,28 @@
+// regular named enum
+enum Foo {
+    bar,
+    baz = 5 * 3
+}
+
+enum Bar {
+    foo = enum Foo.baz
+}
+
+type Baz: enum _Baz {
+    flag1 = 1 << 0,
+    flag2 = 1 << 1,
+    flag3 = 1 << 2
+};
+
+const foo: int = Baz.flag1;
+
+class Enum {
+    methods {
+        foo {
+            params {
+                int idx;
+            }
+            return: own(char*);
+        }
+    }
+}

src/tests/eolian/data/struct_ref.c

@@ -22,8 +22,8 @@ typedef struct {
 } Bar;
 
 struct Named {
-  const char *something;
   int field;
+  const char *something;
 };
 
 struct Another {

src/tests/eolian/eolian_parsing.c

@@ -719,6 +719,24 @@ START_TEST(eolian_var)
 }
 END_TEST
 
+START_TEST(eolian_enum)
+{
+   const Eolian_Type *type = NULL;
+   const Eolian_Class *class;
+
+   eolian_init();
+
+   /* Parsing */
+   fail_if(!eolian_eo_file_parse(PACKAGE_DATA_DIR"/data/enum.eo"));
+
+   /* Check that the class Dummy is still readable */
+   fail_if(!(class = eolian_class_get_by_name("Enum")));
+   fail_if(!eolian_class_function_get_by_name(class, "foo", EOLIAN_METHOD));
+
+   eolian_shutdown();
+}
+END_TEST
+
 START_TEST(eolian_class_funcs)
 {
    const Eolian_Function *fid = NULL;
@@ -767,6 +785,7 @@ void eolian_parsing_test(TCase *tc)
    tcase_add_test(tc, eolian_struct);
    tcase_add_test(tc, eolian_extern);
    tcase_add_test(tc, eolian_var);
+   tcase_add_test(tc, eolian_enum);
    tcase_add_test(tc, eolian_class_funcs);
 }