eolian: allow usage of stack Eina_Value in expr API

7 files changed, 72 insertions, 48 deletions

diff --git a/src/bin/eolian/types_generator.c b/src/bin/eolian/types_generator.c
index 9da055816f..a92ff436b2 100644
--- a/src/bin/eolian/types_generator.c
+++ b/src/bin/eolian/types_generator.c
@@ -134,11 +134,12 @@ _type_generate(const Eolian_Type *tp, Eina_Bool in_typedef)
                      eina_strbuf_append_printf(buf, "  %s", eina_strbuf_string_get(membuf));
                    else
                      {
-                        Eina_Value *v = NULL;
+                        Eina_Value v;
                         Eolian_Expression_Type et = eolian_expression_eval(member, EOLIAN_MASK_INT, &v);
-                        const char *lit = eolian_expression_value_to_literal(v, et);
+                        const char *lit = eolian_expression_value_to_literal(&v, et);
                         eina_strbuf_append_printf(buf, "  %s = %s", eina_strbuf_string_get(membuf), lit);
                         eina_stringshare_del(lit);
+                        eina_value_flush(&v);
                      }
                    next = eina_iterator_next(members, (void**)&member_name);
                    if (next)
diff --git a/src/lib/eolian/Eolian.h b/src/lib/eolian/Eolian.h
index 5dd39253cb..776c6eb078 100644
--- a/src/lib/eolian/Eolian.h
+++ b/src/lib/eolian/Eolian.h
@@ -1266,7 +1266,7 @@ EAPI Eina_Iterator *eolian_type_namespaces_get(const Eolian_Type *tp);
  *
  * @ingroup Eolian
  */
-EAPI Eolian_Expression_Type eolian_expression_eval(const Eolian_Expression *expr, Eolian_Expression_Mask m, Eina_Value **val);
+EAPI Eolian_Expression_Type eolian_expression_eval(const Eolian_Expression *expr, Eolian_Expression_Mask m, Eina_Value *val);
 
 /*
  * @brief Evaluate an Eolian expression given a type instead of a mask.
@@ -1281,7 +1281,7 @@ EAPI Eolian_Expression_Type eolian_expression_eval(const Eolian_Expression *expr
  *
  * @ingroup Eolian
  */
-EAPI Eolian_Expression_Type eolian_expression_eval_type(const Eolian_Expression *expr, const Eolian_Type *type, Eina_Value **val);
+EAPI Eolian_Expression_Type eolian_expression_eval_type(const Eolian_Expression *expr, const Eolian_Type *type, Eina_Value *val);
 
 /*
  * @brief Convert the result of expression evaluation to a literal as in how
diff --git a/src/lib/eolian/database_expr.c b/src/lib/eolian/database_expr.c
index f2b202c209..aba1852acf 100644
--- a/src/lib/eolian/database_expr.c
+++ b/src/lib/eolian/database_expr.c
@@ -589,7 +589,7 @@ eval_exp(const Eolian_Expression *expr, Eolian_Expression_Mask mask,
 
 Eolian_Expression_Type
 database_expr_eval(const Eolian_Expression *expr, Eolian_Expression_Mask mask,
-                   Eina_Value **outval)
+                   Eina_Value *outval)
 {
    Eolian_Expression out;
    if (!mask)
@@ -601,52 +601,64 @@ database_expr_eval(const Eolian_Expression *expr, Eolian_Expression_Mask mask,
    switch (out.type)
      {
       case EOLIAN_EXPR_INT:
-        *outval = eina_value_new(EINA_VALUE_TYPE_INT);
-        eina_value_set(*outval, out.value.i);
+        if (!eina_value_setup(outval, EINA_VALUE_TYPE_INT))
+          return EOLIAN_EXPR_UNKNOWN;
+        eina_value_set(outval, out.value.i);
         break;
       case EOLIAN_EXPR_UINT:
-        *outval = eina_value_new(EINA_VALUE_TYPE_UINT);
-        eina_value_set(*outval, out.value.u);
+       if (!eina_value_setup(outval, EINA_VALUE_TYPE_UINT))
+          return EOLIAN_EXPR_UNKNOWN;
+        eina_value_set(outval, out.value.u);
         break;
       case EOLIAN_EXPR_LONG:
-        *outval = eina_value_new(EINA_VALUE_TYPE_LONG);
-        eina_value_set(*outval, out.value.l);
+        if (!eina_value_setup(outval, EINA_VALUE_TYPE_LONG))
+          return EOLIAN_EXPR_UNKNOWN;
+        eina_value_set(outval, out.value.l);
         break;
       case EOLIAN_EXPR_ULONG:
-        *outval = eina_value_new(EINA_VALUE_TYPE_ULONG);
-        eina_value_set(*outval, out.value.ul);
+        if (!eina_value_setup(outval, EINA_VALUE_TYPE_ULONG))
+          return EOLIAN_EXPR_UNKNOWN;
+        eina_value_set(outval, out.value.ul);
         break;
       case EOLIAN_EXPR_LLONG:
-        *outval = eina_value_new(EINA_VALUE_TYPE_INT64);
-        eina_value_set(*outval, out.value.ll);
+        if (!eina_value_setup(outval, EINA_VALUE_TYPE_INT64))
+          return EOLIAN_EXPR_UNKNOWN;
+        eina_value_set(outval, out.value.ll);
         break;
       case EOLIAN_EXPR_ULLONG:
-        *outval = eina_value_new(EINA_VALUE_TYPE_UINT64);
-        eina_value_set(*outval, out.value.ull);
+        if (!eina_value_setup(outval, EINA_VALUE_TYPE_UINT64))
+          return EOLIAN_EXPR_UNKNOWN;
+        eina_value_set(outval, out.value.ull);
         break;
       case EOLIAN_EXPR_FLOAT:
-        *outval = eina_value_new(EINA_VALUE_TYPE_FLOAT);
-        eina_value_set(*outval, out.value.f);
+        if (!eina_value_setup(outval, EINA_VALUE_TYPE_FLOAT))
+          return EOLIAN_EXPR_UNKNOWN;
+        eina_value_set(outval, out.value.f);
         break;
       case EOLIAN_EXPR_DOUBLE:
-        *outval = eina_value_new(EINA_VALUE_TYPE_DOUBLE);
-        eina_value_set(*outval, out.value.d);
+        if (!eina_value_setup(outval, EINA_VALUE_TYPE_DOUBLE))
+          return EOLIAN_EXPR_UNKNOWN;
+        eina_value_set(outval, out.value.d);
         break;
       case EOLIAN_EXPR_LDOUBLE:
-        *outval = eina_value_new(EINA_VALUE_TYPE_DOUBLE);
-        eina_value_set(*outval, (double)out.value.ld);
+        if (!eina_value_setup(outval, EINA_VALUE_TYPE_DOUBLE))
+          return EOLIAN_EXPR_UNKNOWN;
+        eina_value_set(outval, (double)out.value.ld);
         break;
       case EOLIAN_EXPR_STRING:
-        *outval = eina_value_new(EINA_VALUE_TYPE_STRINGSHARE);
-        eina_value_set(*outval, eina_stringshare_ref(out.value.s));
+        if (!eina_value_setup(outval, EINA_VALUE_TYPE_STRINGSHARE))
+          return EOLIAN_EXPR_UNKNOWN;
+        eina_value_set(outval, eina_stringshare_ref(out.value.s));
         break;
       case EOLIAN_EXPR_CHAR:
-        *outval = eina_value_new(EINA_VALUE_TYPE_CHAR);
-        eina_value_set(*outval, out.value.c);
+        if (!eina_value_setup(outval, EINA_VALUE_TYPE_CHAR))
+          return EOLIAN_EXPR_UNKNOWN;
+        eina_value_set(outval, out.value.c);
         break;
       case EOLIAN_EXPR_BOOL:
-        *outval = eina_value_new(EINA_VALUE_TYPE_UCHAR);
-        eina_value_set(*outval, out.value.b);
+        if (!eina_value_setup(outval, EINA_VALUE_TYPE_UCHAR))
+          return EOLIAN_EXPR_UNKNOWN;
+        eina_value_set(outval, out.value.b);
         break;
       case EOLIAN_EXPR_NULL:
         break;
diff --git a/src/lib/eolian/database_expr_api.c b/src/lib/eolian/database_expr_api.c
index c1b2f63264..d8da0c059c 100644
--- a/src/lib/eolian/database_expr_api.c
+++ b/src/lib/eolian/database_expr_api.c
@@ -3,7 +3,7 @@
 
 EAPI Eolian_Expression_Type
 eolian_expression_eval(const Eolian_Expression *expr, Eolian_Expression_Mask m,
-                       Eina_Value **val)
+                       Eina_Value *val)
 {
    EINA_SAFETY_ON_NULL_RETURN_VAL(expr, EOLIAN_EXPR_UNKNOWN);
    return database_expr_eval(expr, m, val);
@@ -11,7 +11,7 @@ eolian_expression_eval(const Eolian_Expression *expr, Eolian_Expression_Mask m,
 
 static Eolian_Expression_Type
 _eval_type(const Eolian_Expression *expr, const Eolian_Type *type,
-           Eina_Value **val)
+           Eina_Value *val)
 {
    if (!type)
      return EOLIAN_EXPR_UNKNOWN;
@@ -85,7 +85,7 @@ _eval_type(const Eolian_Expression *expr, const Eolian_Type *type,
 EAPI Eolian_Expression_Type
 eolian_expression_eval_type(const Eolian_Expression *expr,
                             const Eolian_Type *type,
-                            Eina_Value **val)
+                            Eina_Value *val)
 {
    EINA_SAFETY_ON_NULL_RETURN_VAL(expr, EOLIAN_EXPR_UNKNOWN);
    return _eval_type(expr, type, val);
diff --git a/src/lib/eolian/database_type.c b/src/lib/eolian/database_type.c
index 722d464c83..b6589b5052 100644
--- a/src/lib/eolian/database_type.c
+++ b/src/lib/eolian/database_type.c
@@ -147,14 +147,15 @@ _etype_to_str(const Eolian_Type *tp, Eina_Strbuf *buf, const char *name)
         eina_strbuf_append(buf, fname);
         if (ef->value)
           {
-             Eina_Value *val = NULL;
+             Eina_Value val;
              Eolian_Expression_Type et = eolian_expression_eval(ef->value,
                  EOLIAN_MASK_INT, &val);
              const char *ret;
              eina_strbuf_append(buf, " = ");
-             ret = eolian_expression_value_to_literal(val, et);
+             ret = eolian_expression_value_to_literal(&val, et);
              eina_strbuf_append(buf, ret);
              eina_stringshare_del(ret);
+             eina_value_flush(&val);
           }
         if (l != eina_list_last(tp->field_names))
           eina_strbuf_append(buf, ", ");
@@ -271,12 +272,13 @@ _typedef_print(Eolian_Type *tp)
 void
 database_expr_print(Eolian_Expression *exp)
 {
-   Eina_Value *val = NULL;
+   Eina_Value val;
    Eolian_Expression_Type et = eolian_expression_eval(exp, EOLIAN_MASK_ALL,
        &val);
-   const char *ret = eolian_expression_value_to_literal(val, et);
+   const char *ret = eolian_expression_value_to_literal(&val, et);
    printf("%s", ret);
    eina_stringshare_del(ret);
+   eina_value_flush(&val);
 }
 
 void
diff --git a/src/lib/eolian/eolian_database.h b/src/lib/eolian/eolian_database.h
index 58dadd7b16..59e21b95c2 100644
--- a/src/lib/eolian/eolian_database.h
+++ b/src/lib/eolian/eolian_database.h
@@ -272,7 +272,7 @@ void database_type_to_str(const Eolian_Type *tp, Eina_Strbuf *buf, const char *n
 
 /* expressions */
 
-Eolian_Expression_Type database_expr_eval(const Eolian_Expression *expr, Eolian_Expression_Mask mask, Eina_Value **out);
+Eolian_Expression_Type database_expr_eval(const Eolian_Expression *expr, Eolian_Expression_Mask mask, Eina_Value *out);
 void database_expr_del(Eolian_Expression *expr);
 void database_expr_print(Eolian_Expression *expr);
 
diff --git a/src/tests/eolian/eolian_parsing.c b/src/tests/eolian/eolian_parsing.c
index c1a9c7d3e5..e1a433c2b4 100644
--- a/src/tests/eolian/eolian_parsing.c
+++ b/src/tests/eolian/eolian_parsing.c
@@ -656,7 +656,7 @@ START_TEST(eolian_var)
    const Eolian_Type *type = NULL;
    const Eolian_Class *class;
    const char *name;
-   Eina_Value *v = NULL;
+   Eina_Value v;
    int i = 0;
    float f = 0.0f;
 
@@ -679,8 +679,9 @@ START_TEST(eolian_var)
    eina_stringshare_del(name);
    fail_if(!(exp = eolian_variable_value_get(var)));
    fail_if(eolian_expression_eval_type(exp, type, &v) != EOLIAN_EXPR_INT);
-   eina_value_get(v, &i);
+   eina_value_get(&v, &i);
    fail_if(i != 5);
+   eina_value_flush(&v);
 
    /* regular global */
    fail_if(!(var = eolian_variable_global_get_by_name("Bar")));
@@ -692,8 +693,9 @@ START_TEST(eolian_var)
    eina_stringshare_del(name);
    fail_if(!(exp = eolian_variable_value_get(var)));
    fail_if(eolian_expression_eval_type(exp, type, &v) != EOLIAN_EXPR_FLOAT);
-   eina_value_get(v, &f);
+   eina_value_get(&v, &f);
    fail_if(((int)f) != 10);
+   eina_value_flush(&v);
 
    /* no-value global */
    fail_if(!(var = eolian_variable_global_get_by_name("Baz")));
@@ -726,7 +728,7 @@ START_TEST(eolian_enum)
    const Eolian_Class *class;
    const Eolian_Expression *exp;
    const char *name;
-   Eina_Value *v = NULL;
+   Eina_Value v;
    int i = 0;
 
    eolian_init();
@@ -743,8 +745,9 @@ START_TEST(eolian_enum)
    fail_if(!(eolian_type_enum_field_exists(type, "first")));
    fail_if(!(exp = eolian_type_enum_field_get(type, "first")));
    fail_if(eolian_expression_eval(exp, EOLIAN_MASK_ALL, &v) != EOLIAN_EXPR_INT);
-   eina_value_get(v, &i);
+   eina_value_get(&v, &i);
    fail_if(i != 0);
+   eina_value_flush(&v);
 
    fail_if(!(eolian_type_enum_field_exists(type, "bar")));
    fail_if(eolian_type_enum_field_get(type, "bar"));
@@ -752,16 +755,18 @@ START_TEST(eolian_enum)
    fail_if(!(eolian_type_enum_field_exists(type, "baz")));
    fail_if(!(exp = eolian_type_enum_field_get(type, "baz")));
    fail_if(eolian_expression_eval(exp, EOLIAN_MASK_ALL, &v) != EOLIAN_EXPR_INT);
-   eina_value_get(v, &i);
+   eina_value_get(&v, &i);
    fail_if(i != 15);
+   eina_value_flush(&v);
 
    fail_if(!(type = eolian_type_enum_get_by_name("Bar")));
 
    fail_if(!(eolian_type_enum_field_exists(type, "foo")));
    fail_if(!(exp = eolian_type_enum_field_get(type, "foo")));
    fail_if(eolian_expression_eval(exp, EOLIAN_MASK_ALL, &v) != EOLIAN_EXPR_INT);
-   eina_value_get(v, &i);
+   eina_value_get(&v, &i);
    fail_if(i != 15);
+   eina_value_flush(&v);
 
    fail_if(!(type = eolian_type_alias_get_by_name("Baz")));
    fail_if(!(type = eolian_type_base_type_get(type)));
@@ -769,20 +774,23 @@ START_TEST(eolian_enum)
    fail_if(!(eolian_type_enum_field_exists(type, "flag1")));
    fail_if(!(exp = eolian_type_enum_field_get(type, "flag1")));
    fail_if(eolian_expression_eval(exp, EOLIAN_MASK_ALL, &v) != EOLIAN_EXPR_INT);
-   eina_value_get(v, &i);
+   eina_value_get(&v, &i);
    fail_if(i != (1 << 0));
+   eina_value_flush(&v);
 
    fail_if(!(eolian_type_enum_field_exists(type, "flag2")));
    fail_if(!(exp = eolian_type_enum_field_get(type, "flag2")));
    fail_if(eolian_expression_eval(exp, EOLIAN_MASK_ALL, &v) != EOLIAN_EXPR_INT);
-   eina_value_get(v, &i);
+   eina_value_get(&v, &i);
    fail_if(i != (1 << 1));
+   eina_value_flush(&v);
 
    fail_if(!(eolian_type_enum_field_exists(type, "flag3")));
    fail_if(!(exp = eolian_type_enum_field_get(type, "flag3")));
    fail_if(eolian_expression_eval(exp, EOLIAN_MASK_ALL, &v) != EOLIAN_EXPR_INT);
-   eina_value_get(v, &i);
+   eina_value_get(&v, &i);
    fail_if(i != (1 << 2));
+   eina_value_flush(&v);
 
    fail_if(!(var = eolian_variable_constant_get_by_name("Bah")));
    fail_if(eolian_variable_type_get(var) != EOLIAN_VAR_CONSTANT);
@@ -793,8 +801,9 @@ START_TEST(eolian_enum)
    eina_stringshare_del(name);
    fail_if(!(exp = eolian_variable_value_get(var)));
    fail_if(eolian_expression_eval_type(exp, type, &v) != EOLIAN_EXPR_INT);
-   eina_value_get(v, &i);
+   eina_value_get(&v, &i);
    fail_if(i != (1 << 0));
+   eina_value_flush(&v);
 
    eolian_shutdown();
 }