diff --git a/src/lib/eolian_cxx/grammar/klass_def.hpp b/src/lib/eolian_cxx/grammar/klass_def.hpp index fbd8779e0f..4de294e836 100644 --- a/src/lib/eolian_cxx/grammar/klass_def.hpp +++ b/src/lib/eolian_cxx/grammar/klass_def.hpp @@ -372,6 +372,12 @@ namespace value_ownership const bool unmoved = false; }; +namespace is_by +{ + const bool reference = true; + const bool value = false; +}; + // type_def represents a type where it is used, like a method parameter or a struc field, in contrast to more // specifict types like struct_def, class_def, function_def, which represents a declaration of a type. struct type_def @@ -389,11 +395,11 @@ struct type_def type_def(variant_type original_type, std::string c_type, bool has_own, bool is_ptr, bool is_beta, std::string doc_summary) : original_type(original_type), c_type(c_type), has_own(has_own), is_ptr(is_ptr), is_beta(is_beta), doc_summary(doc_summary) {} - type_def(Eolian_Type const* eolian_type, Eolian_Unit const* unit, Eolian_C_Type_Type ctype, bool is_moved) + type_def(Eolian_Type const* eolian_type, Eolian_Unit const* unit, std::string const& ctype, bool is_moved, bool is_reference) { - set(eolian_type, unit, ctype, is_moved); + set(eolian_type, unit, ctype, is_moved, is_reference); } - void set(Eolian_Type const* eolian_type, Eolian_Unit const* unit, Eolian_C_Type_Type ctype, bool is_moved); + void set(Eolian_Type const* eolian_type, Eolian_Unit const* unit, std::string const & ctype, bool is_moved, bool is_reference); void set(Eolian_Expression_Type eolian_exp_type); friend inline bool operator<(type_def const& lhs, type_def const& rhs) @@ -433,14 +439,15 @@ inline bool operator!=(type_def const& lhs, type_def const& rhs) type_def const void_ {attributes::regular_type_def{"void", {qualifier_info::is_none, {}}, {}}, "void", false, false, false, ""}; -inline void type_def::set(Eolian_Type const* eolian_type, Eolian_Unit const* unit, Eolian_C_Type_Type ctype, bool is_moved) +inline void type_def::set(Eolian_Type const* eolian_type, Eolian_Unit const* unit, std::string const& ctype, bool is_moved, bool is_reference) { - c_type = ::eolian_type_c_type_get(eolian_type, ctype); + c_type = ctype; is_value_type = ('*' != c_type.back()); // ::eina_stringshare_del(stringshare); // this crashes Eolian_Type const* stp = eolian_type_base_type_get(eolian_type); has_own = is_moved; - is_ptr = !!::eolian_type_is_ptr(eolian_type); + + is_ptr = is_reference || eolian_type_is_ptr(eolian_type); Eolian_Typedecl const* decl = eolian_type_typedecl_get(eolian_type); is_beta = decl && eolian_object_is_beta(EOLIAN_OBJECT(decl)); @@ -452,7 +459,7 @@ inline void type_def::set(Eolian_Type const* eolian_type, Eolian_Unit const* uni switch( ::eolian_type_type_get(eolian_type)) { case EOLIAN_TYPE_VOID: - original_type = attributes::regular_type_def{"void", {qualifiers(eolian_type, is_moved), {}}, {}}; + original_type = attributes::regular_type_def{"void", {qualifiers(eolian_type, is_moved, is_ptr), {}}, {}}; break; case EOLIAN_TYPE_REGULAR: if (!stp) @@ -474,15 +481,19 @@ inline void type_def::set(Eolian_Type const* eolian_type, Eolian_Unit const* uni for(efl::eina::iterator namespace_iterator( ::eolian_type_namespaces_get(eolian_type)) , namespace_last; namespace_iterator != namespace_last; ++namespace_iterator) namespaces.push_back(&*namespace_iterator); - original_type = {regular_type_def{ ::eolian_type_short_name_get(eolian_type), {qualifiers(eolian_type, is_moved), {}}, namespaces, type_type, is_undefined}}; + original_type = {regular_type_def{ ::eolian_type_short_name_get(eolian_type), {qualifiers(eolian_type, is_moved, is_ptr), {}}, namespaces, type_type, is_undefined}}; } else { complex_type_def complex - {{::eolian_type_short_name_get(eolian_type), {qualifiers(eolian_type, is_moved), {}}, {}}, {}}; + {{::eolian_type_short_name_get(eolian_type), {qualifiers(eolian_type, is_moved, is_ptr), {}}, {}}, {}}; while (stp) { - complex.subtypes.push_back({stp, unit, EOLIAN_C_TYPE_DEFAULT, eolian_type_is_move(stp)}); + complex.subtypes.push_back({stp + , unit + , ::eolian_type_c_type_get(stp, EOLIAN_C_TYPE_DEFAULT) + , eolian_type_is_move(stp) + , is_by::value}); stp = eolian_type_next_type_get(stp); } original_type = complex; @@ -491,7 +502,7 @@ inline void type_def::set(Eolian_Type const* eolian_type, Eolian_Unit const* uni case EOLIAN_TYPE_CLASS: { Eolian_Class const* klass = eolian_type_class_get(eolian_type); - original_type = klass_name(klass, {qualifiers(eolian_type, is_moved), {}}); + original_type = klass_name(klass, {qualifiers(eolian_type, is_moved, is_ptr), {}}); } break; default: @@ -540,7 +551,12 @@ struct alias_def is_undefined = true; else { - base_type = type_def(::eolian_typedecl_base_type_get(alias_obj), unit, EOLIAN_C_TYPE_DEFAULT, value_ownership::unmoved); + auto eolian_type = ::eolian_typedecl_base_type_get(alias_obj); + base_type = type_def(eolian_type + , unit + , ::eolian_type_c_type_get(eolian_type, EOLIAN_C_TYPE_DEFAULT) + , value_ownership::unmoved + , is_by::value); is_undefined = false; } @@ -593,7 +609,11 @@ struct parameter_def documentation_def documentation, Eolian_Unit const* unit) : direction(std::move(direction)), type(std::move(type)), param_name(std::move(param_name)), documentation(documentation), unit(unit) {} parameter_def(Eolian_Function_Parameter const* param, Eolian_Unit const* unit) - : type( ::eolian_parameter_type_get(param), unit, EOLIAN_C_TYPE_PARAM, eolian_parameter_is_move(param)) + : type( ::eolian_parameter_type_get(param) + , unit + , eolian_parameter_c_type_get(param, EINA_FALSE) + , eolian_parameter_is_move(param) + , eolian_parameter_is_by_ref(param)) , param_name( ::eolian_parameter_name_get(param)), unit(unit) { Eolian_Parameter_Dir direction = ::eolian_parameter_direction_get(param); @@ -747,7 +767,11 @@ struct function_def return_documentation = eolian_function_return_documentation_get(function, type); scope = static_cast(eolian_function_scope_get(function, type)); if(r_type) - return_type.set(r_type, unit, EOLIAN_C_TYPE_RETURN, eolian_function_return_is_move(function, type)); + return_type.set(r_type + , unit + , eolian_function_return_c_type_get(function, type) + , eolian_function_return_is_move(function, type) + , eolian_function_return_is_by_ref(function, type)); if(type == EOLIAN_METHOD || type == EOLIAN_FUNCTION_POINTER) { for(efl::eina::iterator param_iterator ( ::eolian_function_parameters_get(function)) @@ -1003,7 +1027,11 @@ struct variable_def variable_def(Eolian_Variable const* variable, Eolian_Unit const* unit) : name(::eolian_variable_short_name_get(variable)) , full_name(::eolian_variable_name_get(variable)) - , base_type(::eolian_variable_base_type_get(variable), unit, ::EOLIAN_C_TYPE_DEFAULT, value_ownership::unmoved) + , base_type(::eolian_variable_base_type_get(variable) + , unit + , ::eolian_type_c_type_get(eolian_variable_base_type_get(variable), ::EOLIAN_C_TYPE_DEFAULT) + , value_ownership::unmoved + , is_by::value) , documentation(::eolian_variable_documentation_get(variable)) , type(static_cast(::eolian_variable_type_get(variable))) , expression_value() @@ -1087,7 +1115,12 @@ struct event_def event_def(Eolian_Event const* event, Eolian_Class const* cls, Eolian_Unit const* unit) : klass(cls, {attributes::qualifier_info::is_none, std::string()}) - , type( ::eolian_event_type_get(event) ? eina::optional{{::eolian_event_type_get(event), unit, EOLIAN_C_TYPE_DEFAULT, value_ownership::unmoved}} : eina::optional{}) + , type( ::eolian_event_type_get(event) ? eina::optional{{::eolian_event_type_get(event) + , unit + , ::eolian_type_c_type_get(::eolian_event_type_get(event), EOLIAN_C_TYPE_DEFAULT) + , value_ownership::unmoved + , is_by::value} + } : eina::optional{}) , name( ::eolian_event_name_get(event)) , c_name( ::eolian_event_c_macro_get(event)) , beta( ::eolian_event_is_beta(event)) @@ -1552,8 +1585,11 @@ struct struct_field_def { name = eolian_typedecl_struct_field_name_get(struct_field); try { - type.set(eolian_typedecl_struct_field_type_get(struct_field), unit, EOLIAN_C_TYPE_DEFAULT - , eolian_typedecl_struct_field_is_move(struct_field)); + type.set(eolian_typedecl_struct_field_type_get(struct_field) + , unit + , eolian_typedecl_struct_field_c_type_get(struct_field) + , eolian_typedecl_struct_field_is_move(struct_field) + , eolian_typedecl_struct_field_is_by_ref(struct_field)); } catch(std::runtime_error const&) { /* Silently skip pointer fields*/ } documentation = ::eolian_typedecl_struct_field_documentation_get(struct_field); } diff --git a/src/lib/eolian_cxx/grammar/qualifier_def.hpp b/src/lib/eolian_cxx/grammar/qualifier_def.hpp index cab3ca8667..0823010437 100644 --- a/src/lib/eolian_cxx/grammar/qualifier_def.hpp +++ b/src/lib/eolian_cxx/grammar/qualifier_def.hpp @@ -72,11 +72,11 @@ inline qualifier_bool operator^(qualifier_bool lhs, qualifier_info rhs) return lhs; } -inline qualifier_info qualifiers(Eolian_Type const* type, bool is_moved) +inline qualifier_info qualifiers(Eolian_Type const* type, bool is_moved, bool is_by_ref) { qualifier_info is_own = is_moved ? qualifier_info::is_own : qualifier_info::is_none; qualifier_info is_const = ::eolian_type_is_const(type) ? qualifier_info::is_const : qualifier_info::is_none; - qualifier_info is_ref = ::eolian_type_is_ptr(type) ? qualifier_info::is_ref : qualifier_info::is_none; + qualifier_info is_ref = is_by_ref ? qualifier_info::is_ref : qualifier_info::is_none; return is_own | is_const | is_ref; }