[vala/0.54] codegen: Use a dedicated EmitContext for _variant_get*() functions
- From: Rico Tzschichholz <ricotz src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [vala/0.54] codegen: Use a dedicated EmitContext for _variant_get*() functions
- Date: Thu, 16 Dec 2021 07:23:40 +0000 (UTC)
commit c5db4fdc981fe9123c2337f5d1cd9115b5ba250b
Author: Rico Tzschichholz <ricotz ubuntu com>
Date: Mon Dec 13 19:35:47 2021 +0100
codegen: Use a dedicated EmitContext for _variant_get*() functions
codegen/valagvariantmodule.vala | 2 +
tests/basic-types/bug772426.c-expected | 12 +-
.../basic-types/gvariants-unboxing-safe.c-expected | 570 ++++++++++-----------
tests/basic-types/gvariants.c-expected | 404 +++++++--------
tests/dbus/bug602003_client.c-expected | 70 +--
tests/dbus/bug782719_client.c-expected | 70 +--
tests/dbus/dicts_client.c-expected | 70 +--
tests/structs/bug661945.c-expected | 36 +-
8 files changed, 618 insertions(+), 616 deletions(-)
---
diff --git a/codegen/valagvariantmodule.vala b/codegen/valagvariantmodule.vala
index 9f53ca010..be13d35b9 100644
--- a/codegen/valagvariantmodule.vala
+++ b/codegen/valagvariantmodule.vala
@@ -158,6 +158,7 @@ public class Vala.GVariantModule : GValueModule {
ccode.add_expression (ccall);
}
+ push_context (new EmitContext ());
push_function (cfunc);
CCodeExpression type_expr = null;
@@ -217,6 +218,7 @@ public class Vala.GVariantModule : GValueModule {
}
pop_function ();
+ pop_context ();
cfile.add_function_declaration (cfunc);
cfile.add_function (cfunc);
diff --git a/tests/basic-types/bug772426.c-expected b/tests/basic-types/bug772426.c-expected
index c9f08aa2a..07c92c0d1 100644
--- a/tests/basic-types/bug772426.c-expected
+++ b/tests/basic-types/bug772426.c-expected
@@ -44,12 +44,12 @@ static guint8*
_variant_get1 (GVariant* value,
gint* result_length1)
{
- gsize _tmp4__length;
- guint8* _tmp4_;
- _tmp4__length = g_variant_get_size (value);
- _tmp4_ = _vala_memdup2 (g_variant_get_data (value), _tmp4__length);
- *result_length1 = _tmp4__length;
- return _tmp4_;
+ gsize _tmp0__length;
+ guint8* _tmp0_;
+ _tmp0__length = g_variant_get_size (value);
+ _tmp0_ = _vala_memdup2 (g_variant_get_data (value), _tmp0__length);
+ *result_length1 = _tmp0__length;
+ return _tmp0_;
}
static void
diff --git a/tests/basic-types/gvariants-unboxing-safe.c-expected
b/tests/basic-types/gvariants-unboxing-safe.c-expected
index d7ce38f8c..acd53d71c 100644
--- a/tests/basic-types/gvariants-unboxing-safe.c-expected
+++ b/tests/basic-types/gvariants-unboxing-safe.c-expected
@@ -147,11 +147,11 @@ static gboolean*
_variant_get1 (GVariant* value)
{
if (value && g_variant_is_of_type (value, G_VARIANT_TYPE_BOOLEAN)) {
- gboolean _tmp3_;
- gboolean* _tmp4_;
- _tmp3_ = g_variant_get_boolean (value);
- _tmp4_ = __bool_dup0 (&_tmp3_);
- return _tmp4_;
+ gboolean _tmp0_;
+ gboolean* _tmp1_;
+ _tmp0_ = g_variant_get_boolean (value);
+ _tmp1_ = __bool_dup0 (&_tmp0_);
+ return _tmp1_;
} else {
return NULL;
}
@@ -176,11 +176,11 @@ static gint16*
_variant_get2 (GVariant* value)
{
if (value && g_variant_is_of_type (value, G_VARIANT_TYPE_INT16)) {
- gint16 _tmp7_;
- gint16* _tmp8_;
- _tmp7_ = g_variant_get_int16 (value);
- _tmp8_ = __int16_dup0 (&_tmp7_);
- return _tmp8_;
+ gint16 _tmp0_;
+ gint16* _tmp1_;
+ _tmp0_ = g_variant_get_int16 (value);
+ _tmp1_ = __int16_dup0 (&_tmp0_);
+ return _tmp1_;
} else {
return NULL;
}
@@ -205,11 +205,11 @@ static gint32*
_variant_get3 (GVariant* value)
{
if (value && g_variant_is_of_type (value, G_VARIANT_TYPE_INT32)) {
- gint32 _tmp11_;
- gint32* _tmp12_;
- _tmp11_ = g_variant_get_int32 (value);
- _tmp12_ = __int32_dup0 (&_tmp11_);
- return _tmp12_;
+ gint32 _tmp0_;
+ gint32* _tmp1_;
+ _tmp0_ = g_variant_get_int32 (value);
+ _tmp1_ = __int32_dup0 (&_tmp0_);
+ return _tmp1_;
} else {
return NULL;
}
@@ -245,11 +245,11 @@ static gboolean*
_variant_get5 (GVariant* value)
{
if (value && g_variant_is_of_type (value, G_VARIANT_TYPE_BOOLEAN)) {
- gboolean _tmp19_;
- gboolean* _tmp20_;
- _tmp19_ = g_variant_get_boolean (value);
- _tmp20_ = __bool_dup0 (&_tmp19_);
- return _tmp20_;
+ gboolean _tmp0_;
+ gboolean* _tmp1_;
+ _tmp0_ = g_variant_get_boolean (value);
+ _tmp1_ = __bool_dup0 (&_tmp0_);
+ return _tmp1_;
} else {
return NULL;
}
@@ -275,11 +275,11 @@ static gint32*
_variant_get6 (GVariant* value)
{
if (value && g_variant_is_of_type (value, G_VARIANT_TYPE_INT32)) {
- gint32 _tmp24_;
- gint32* _tmp25_;
- _tmp24_ = g_variant_get_int32 (value);
- _tmp25_ = __int32_dup0 (&_tmp24_);
- return _tmp25_;
+ gint32 _tmp0_;
+ gint32* _tmp1_;
+ _tmp0_ = g_variant_get_int32 (value);
+ _tmp1_ = __int32_dup0 (&_tmp0_);
+ return _tmp1_;
} else {
return NULL;
}
@@ -289,38 +289,38 @@ static gchar**
_variant_get7 (GVariant* value,
gint* result_length1)
{
- GVariantType* _tmp34_ = NULL;
- _tmp34_ = g_variant_type_new ("as");
- if (value && g_variant_is_of_type (value, _tmp34_)) {
- gchar** _tmp35_;
- gint _tmp35__length;
- gint _tmp35__size;
- gint _tmp35__length1;
- GVariantIter _tmp36_;
- GVariant* _tmp37_;
- gchar** _tmp38_;
- gint _tmp38__length1;
- _tmp35_ = g_new (gchar*, 5);
- _tmp35__length = 0;
- _tmp35__size = 4;
- _tmp35__length1 = 0;
- g_variant_iter_init (&_tmp36_, value);
- for (; (_tmp37_ = g_variant_iter_next_value (&_tmp36_)) != NULL; _tmp35__length1++) {
- if (_tmp35__size == _tmp35__length) {
- _tmp35__size = 2 * _tmp35__size;
- _tmp35_ = g_renew (gchar*, _tmp35_, _tmp35__size + 1);
+ GVariantType* _tmp0_ = NULL;
+ _tmp0_ = g_variant_type_new ("as");
+ if (value && g_variant_is_of_type (value, _tmp0_)) {
+ gchar** _tmp1_;
+ gint _tmp1__length;
+ gint _tmp1__size;
+ gint _tmp1__length1;
+ GVariantIter _tmp2_;
+ GVariant* _tmp3_;
+ gchar** _tmp4_;
+ gint _tmp4__length1;
+ _tmp1_ = g_new (gchar*, 5);
+ _tmp1__length = 0;
+ _tmp1__size = 4;
+ _tmp1__length1 = 0;
+ g_variant_iter_init (&_tmp2_, value);
+ for (; (_tmp3_ = g_variant_iter_next_value (&_tmp2_)) != NULL; _tmp1__length1++) {
+ if (_tmp1__size == _tmp1__length) {
+ _tmp1__size = 2 * _tmp1__size;
+ _tmp1_ = g_renew (gchar*, _tmp1_, _tmp1__size + 1);
}
- _tmp35_[_tmp35__length++] = g_variant_dup_string (_tmp37_, NULL);
- g_variant_unref (_tmp37_);
+ _tmp1_[_tmp1__length++] = g_variant_dup_string (_tmp3_, NULL);
+ g_variant_unref (_tmp3_);
}
- *result_length1 = _tmp35__length1;
- _tmp35_[_tmp35__length] = NULL;
- g_variant_type_free (_tmp34_);
- _tmp38_ = _tmp35_;
- _tmp38__length1 = -1;
- return _tmp38_;
+ *result_length1 = _tmp1__length1;
+ _tmp1_[_tmp1__length] = NULL;
+ g_variant_type_free (_tmp0_);
+ _tmp4_ = _tmp1_;
+ _tmp4__length1 = -1;
+ return _tmp4_;
} else {
- g_variant_type_free (_tmp34_);
+ g_variant_type_free (_tmp0_);
return NULL;
}
}
@@ -328,63 +328,63 @@ _variant_get7 (GVariant* value,
static GVariant*
_variant_new1 (Foo value)
{
- GVariantBuilder _tmp43_;
- g_variant_builder_init (&_tmp43_, G_VARIANT_TYPE_TUPLE);
- g_variant_builder_add_value (&_tmp43_, g_variant_new_string (value.s));
- g_variant_builder_add_value (&_tmp43_, g_variant_new_uint64 (value.u64));
- g_variant_builder_add_value (&_tmp43_, g_variant_new_boolean (value.b));
- return g_variant_ref_sink (g_variant_builder_end (&_tmp43_));
+ GVariantBuilder _tmp28_;
+ g_variant_builder_init (&_tmp28_, G_VARIANT_TYPE_TUPLE);
+ g_variant_builder_add_value (&_tmp28_, g_variant_new_string (value.s));
+ g_variant_builder_add_value (&_tmp28_, g_variant_new_uint64 (value.u64));
+ g_variant_builder_add_value (&_tmp28_, g_variant_new_boolean (value.b));
+ return g_variant_ref_sink (g_variant_builder_end (&_tmp28_));
}
static void
_variant_get8 (GVariant* value,
Foo * result)
{
- Foo _tmp49_;
- GVariantIter _tmp50_;
- GVariant* _tmp51_;
- GVariant* _tmp52_;
- GVariant* _tmp53_;
- g_variant_iter_init (&_tmp50_, value);
- _tmp51_ = g_variant_iter_next_value (&_tmp50_);
- _tmp49_.s = g_variant_dup_string (_tmp51_, NULL);
- g_variant_unref (_tmp51_);
- _tmp52_ = g_variant_iter_next_value (&_tmp50_);
- _tmp49_.u64 = g_variant_get_uint64 (_tmp52_);
- g_variant_unref (_tmp52_);
- _tmp53_ = g_variant_iter_next_value (&_tmp50_);
- _tmp49_.b = g_variant_get_boolean (_tmp53_);
- g_variant_unref (_tmp53_);
- *result = _tmp49_;
+ Foo _tmp0_;
+ GVariantIter _tmp1_;
+ GVariant* _tmp2_;
+ GVariant* _tmp3_;
+ GVariant* _tmp4_;
+ g_variant_iter_init (&_tmp1_, value);
+ _tmp2_ = g_variant_iter_next_value (&_tmp1_);
+ _tmp0_.s = g_variant_dup_string (_tmp2_, NULL);
+ g_variant_unref (_tmp2_);
+ _tmp3_ = g_variant_iter_next_value (&_tmp1_);
+ _tmp0_.u64 = g_variant_get_uint64 (_tmp3_);
+ g_variant_unref (_tmp3_);
+ _tmp4_ = g_variant_iter_next_value (&_tmp1_);
+ _tmp0_.b = g_variant_get_boolean (_tmp4_);
+ g_variant_unref (_tmp4_);
+ *result = _tmp0_;
}
static Foo*
_variant_get9 (GVariant* value)
{
- GVariantType* _tmp60_ = NULL;
- _tmp60_ = g_variant_type_new ("(stb)");
- if (value && g_variant_is_of_type (value, _tmp60_)) {
- Foo _tmp61_;
- GVariantIter _tmp62_;
- GVariant* _tmp63_;
- GVariant* _tmp64_;
- GVariant* _tmp65_;
- Foo* _tmp66_;
- g_variant_iter_init (&_tmp62_, value);
- _tmp63_ = g_variant_iter_next_value (&_tmp62_);
- _tmp61_.s = g_variant_dup_string (_tmp63_, NULL);
- g_variant_unref (_tmp63_);
- _tmp64_ = g_variant_iter_next_value (&_tmp62_);
- _tmp61_.u64 = g_variant_get_uint64 (_tmp64_);
- g_variant_unref (_tmp64_);
- _tmp65_ = g_variant_iter_next_value (&_tmp62_);
- _tmp61_.b = g_variant_get_boolean (_tmp65_);
- g_variant_unref (_tmp65_);
- g_variant_type_free (_tmp60_);
- _tmp66_ = _vala_memdup2 (&_tmp61_, sizeof (Foo));
- return _tmp66_;
+ GVariantType* _tmp0_ = NULL;
+ _tmp0_ = g_variant_type_new ("(stb)");
+ if (value && g_variant_is_of_type (value, _tmp0_)) {
+ Foo _tmp1_;
+ GVariantIter _tmp2_;
+ GVariant* _tmp3_;
+ GVariant* _tmp4_;
+ GVariant* _tmp5_;
+ Foo* _tmp6_;
+ g_variant_iter_init (&_tmp2_, value);
+ _tmp3_ = g_variant_iter_next_value (&_tmp2_);
+ _tmp1_.s = g_variant_dup_string (_tmp3_, NULL);
+ g_variant_unref (_tmp3_);
+ _tmp4_ = g_variant_iter_next_value (&_tmp2_);
+ _tmp1_.u64 = g_variant_get_uint64 (_tmp4_);
+ g_variant_unref (_tmp4_);
+ _tmp5_ = g_variant_iter_next_value (&_tmp2_);
+ _tmp1_.b = g_variant_get_boolean (_tmp5_);
+ g_variant_unref (_tmp5_);
+ g_variant_type_free (_tmp0_);
+ _tmp6_ = _vala_memdup2 (&_tmp1_, sizeof (Foo));
+ return _tmp6_;
} else {
- g_variant_type_free (_tmp60_);
+ g_variant_type_free (_tmp0_);
return NULL;
}
}
@@ -398,43 +398,43 @@ _g_free0_ (gpointer var)
static GVariant*
_variant_new2 (GHashTable* value)
{
- GVariantBuilder _tmp75_;
- GHashTableIter _tmp76_;
- gpointer _tmp77_;
- gpointer _tmp78_;
- g_hash_table_iter_init (&_tmp76_, value);
- g_variant_builder_init (&_tmp75_, G_VARIANT_TYPE ("a{ss}"));
- while (g_hash_table_iter_next (&_tmp76_, &_tmp77_, &_tmp78_)) {
+ GVariantBuilder _tmp48_;
+ GHashTableIter _tmp49_;
+ gpointer _tmp50_;
+ gpointer _tmp51_;
+ g_hash_table_iter_init (&_tmp49_, value);
+ g_variant_builder_init (&_tmp48_, G_VARIANT_TYPE ("a{ss}"));
+ while (g_hash_table_iter_next (&_tmp49_, &_tmp50_, &_tmp51_)) {
gchar* _key;
gchar* _value;
- _key = (gchar*) _tmp77_;
- _value = (gchar*) _tmp78_;
- g_variant_builder_add (&_tmp75_, "{?*}", g_variant_new_string (_key), g_variant_new_string
(_value));
+ _key = (gchar*) _tmp50_;
+ _value = (gchar*) _tmp51_;
+ g_variant_builder_add (&_tmp48_, "{?*}", g_variant_new_string (_key), g_variant_new_string
(_value));
}
- return g_variant_ref_sink (g_variant_builder_end (&_tmp75_));
+ return g_variant_ref_sink (g_variant_builder_end (&_tmp48_));
}
static GHashTable*
_variant_get10 (GVariant* value)
{
- GVariantType* _tmp82_ = NULL;
- _tmp82_ = g_variant_type_new ("a{ss}");
- if (value && g_variant_is_of_type (value, _tmp82_)) {
- GHashTable* _tmp83_;
- GVariantIter _tmp84_;
- GVariant* _tmp85_;
- GVariant* _tmp86_;
- GHashTable* _tmp87_;
- _tmp83_ = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
- g_variant_iter_init (&_tmp84_, value);
- while (g_variant_iter_loop (&_tmp84_, "{?*}", &_tmp85_, &_tmp86_)) {
- g_hash_table_insert (_tmp83_, g_variant_dup_string (_tmp85_, NULL),
g_variant_dup_string (_tmp86_, NULL));
+ GVariantType* _tmp0_ = NULL;
+ _tmp0_ = g_variant_type_new ("a{ss}");
+ if (value && g_variant_is_of_type (value, _tmp0_)) {
+ GHashTable* _tmp1_;
+ GVariantIter _tmp2_;
+ GVariant* _tmp3_;
+ GVariant* _tmp4_;
+ GHashTable* _tmp5_;
+ _tmp1_ = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
+ g_variant_iter_init (&_tmp2_, value);
+ while (g_variant_iter_loop (&_tmp2_, "{?*}", &_tmp3_, &_tmp4_)) {
+ g_hash_table_insert (_tmp1_, g_variant_dup_string (_tmp3_, NULL),
g_variant_dup_string (_tmp4_, NULL));
}
- g_variant_type_free (_tmp82_);
- _tmp87_ = _tmp83_;
- return _tmp87_;
+ g_variant_type_free (_tmp0_);
+ _tmp5_ = _tmp1_;
+ return _tmp5_;
} else {
- g_variant_type_free (_tmp82_);
+ g_variant_type_free (_tmp0_);
return NULL;
}
}
@@ -442,24 +442,24 @@ _variant_get10 (GVariant* value)
static GHashTable*
_variant_get11 (GVariant* value)
{
- GVariantType* _tmp92_ = NULL;
- _tmp92_ = g_variant_type_new ("a{is}");
- if (value && g_variant_is_of_type (value, _tmp92_)) {
- GHashTable* _tmp93_;
- GVariantIter _tmp94_;
- GVariant* _tmp95_;
- GVariant* _tmp96_;
- GHashTable* _tmp97_;
- _tmp93_ = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, g_free);
- g_variant_iter_init (&_tmp94_, value);
- while (g_variant_iter_loop (&_tmp94_, "{?*}", &_tmp95_, &_tmp96_)) {
- g_hash_table_insert (_tmp93_, (gpointer) ((gintptr) g_variant_get_int32 (_tmp95_)),
g_variant_dup_string (_tmp96_, NULL));
+ GVariantType* _tmp0_ = NULL;
+ _tmp0_ = g_variant_type_new ("a{is}");
+ if (value && g_variant_is_of_type (value, _tmp0_)) {
+ GHashTable* _tmp1_;
+ GVariantIter _tmp2_;
+ GVariant* _tmp3_;
+ GVariant* _tmp4_;
+ GHashTable* _tmp5_;
+ _tmp1_ = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, g_free);
+ g_variant_iter_init (&_tmp2_, value);
+ while (g_variant_iter_loop (&_tmp2_, "{?*}", &_tmp3_, &_tmp4_)) {
+ g_hash_table_insert (_tmp1_, (gpointer) ((gintptr) g_variant_get_int32 (_tmp3_)),
g_variant_dup_string (_tmp4_, NULL));
}
- g_variant_type_free (_tmp92_);
- _tmp97_ = _tmp93_;
- return _tmp97_;
+ g_variant_type_free (_tmp0_);
+ _tmp5_ = _tmp1_;
+ return _tmp5_;
} else {
- g_variant_type_free (_tmp92_);
+ g_variant_type_free (_tmp0_);
return NULL;
}
}
@@ -469,30 +469,30 @@ _vala_main (void)
{
GVariant* v = NULL;
GVariant* _tmp0_;
- GVariant* _tmp16_;
- gchar* _tmp26_;
- gchar* _tmp27_;
- gchar* _tmp28_;
- gchar** _tmp29_;
- gchar** _tmp30_;
- gint _tmp30__length1;
- GVariant* _tmp31_;
+ GVariant* _tmp10_;
+ gchar* _tmp16_;
+ gchar* _tmp17_;
+ gchar* _tmp18_;
+ gchar** _tmp19_;
+ gchar** _tmp20_;
+ gint _tmp20__length1;
+ GVariant* _tmp21_;
Foo vsrc = {0};
- gchar* _tmp40_;
- Foo _tmp41_ = {0};
- Foo _tmp42_;
- GVariant* _tmp44_;
- GVariant* _tmp45_;
- const gchar* _tmp46_;
+ gchar* _tmp25_;
+ Foo _tmp26_ = {0};
+ Foo _tmp27_;
+ GVariant* _tmp29_;
+ GVariant* _tmp30_;
+ const gchar* _tmp31_;
GHashTable* vsrc2 = NULL;
- GHashFunc _tmp68_;
- GEqualFunc _tmp69_;
- GHashTable* _tmp70_;
- gchar* _tmp71_;
- gchar* _tmp72_;
- gchar* _tmp73_;
- gchar* _tmp74_;
- GVariant* _tmp79_;
+ GHashFunc _tmp41_;
+ GEqualFunc _tmp42_;
+ GHashTable* _tmp43_;
+ gchar* _tmp44_;
+ gchar* _tmp45_;
+ gchar* _tmp46_;
+ gchar* _tmp47_;
+ GVariant* _tmp52_;
_tmp0_ = g_variant_new_int32 ((gint32) 4711);
g_variant_ref_sink (_tmp0_);
_g_variant_unref0 (v);
@@ -509,175 +509,175 @@ _vala_main (void)
}
{
gint16* i16 = NULL;
- GVariant* _tmp5_;
- gint16* _tmp6_;
- _tmp5_ = v;
- _tmp6_ = _variant_get2 (_tmp5_);
- i16 = _tmp6_;
+ GVariant* _tmp3_;
+ gint16* _tmp4_;
+ _tmp3_ = v;
+ _tmp4_ = _variant_get2 (_tmp3_);
+ i16 = _tmp4_;
_vala_assert (i16 == NULL, "i16 == null");
_g_free0 (i16);
}
{
gint32* i32 = NULL;
- GVariant* _tmp9_;
- gint32* _tmp10_;
- gint32 _tmp13_;
- _tmp9_ = v;
- _tmp10_ = _variant_get3 (_tmp9_);
- i32 = _tmp10_;
- _tmp13_ = (gint32) 4711;
- _vala_assert (_int32_equal (i32, &_tmp13_) == TRUE, "i32 == 4711");
+ GVariant* _tmp5_;
+ gint32* _tmp6_;
+ gint32 _tmp7_;
+ _tmp5_ = v;
+ _tmp6_ = _variant_get3 (_tmp5_);
+ i32 = _tmp6_;
+ _tmp7_ = (gint32) 4711;
+ _vala_assert (_int32_equal (i32, &_tmp7_) == TRUE, "i32 == 4711");
_g_free0 (i32);
}
{
gchar* s = NULL;
- GVariant* _tmp14_;
- gchar* _tmp15_;
- _tmp14_ = v;
- _tmp15_ = _variant_get4 (_tmp14_);
- s = _tmp15_;
+ GVariant* _tmp8_;
+ gchar* _tmp9_;
+ _tmp8_ = v;
+ _tmp9_ = _variant_get4 (_tmp8_);
+ s = _tmp9_;
_vala_assert (s == NULL, "s == null");
_g_free0 (s);
}
- _tmp16_ = g_variant_new_boolean (TRUE);
- g_variant_ref_sink (_tmp16_);
+ _tmp10_ = g_variant_new_boolean (TRUE);
+ g_variant_ref_sink (_tmp10_);
_g_variant_unref0 (v);
- v = _tmp16_;
+ v = _tmp10_;
{
gboolean* b = NULL;
- GVariant* _tmp17_;
- gboolean* _tmp18_;
- gboolean _tmp21_;
- _tmp17_ = v;
- _tmp18_ = _variant_get5 (_tmp17_);
- b = _tmp18_;
- _tmp21_ = TRUE;
- _vala_assert (_bool_equal (b, &_tmp21_) == TRUE, "b == true");
+ GVariant* _tmp11_;
+ gboolean* _tmp12_;
+ gboolean _tmp13_;
+ _tmp11_ = v;
+ _tmp12_ = _variant_get5 (_tmp11_);
+ b = _tmp12_;
+ _tmp13_ = TRUE;
+ _vala_assert (_bool_equal (b, &_tmp13_) == TRUE, "b == true");
_g_free0 (b);
}
{
gint32* i32 = NULL;
- GVariant* _tmp22_;
- gint32* _tmp23_;
- _tmp22_ = v;
- _tmp23_ = _variant_get6 (_tmp22_);
- i32 = _tmp23_;
+ GVariant* _tmp14_;
+ gint32* _tmp15_;
+ _tmp14_ = v;
+ _tmp15_ = _variant_get6 (_tmp14_);
+ i32 = _tmp15_;
_vala_assert (i32 == NULL, "i32 == null");
_g_free0 (i32);
}
- _tmp26_ = g_strdup ("foo");
- _tmp27_ = g_strdup ("bar");
- _tmp28_ = g_strdup ("manam");
- _tmp29_ = g_new0 (gchar*, 3 + 1);
- _tmp29_[0] = _tmp26_;
- _tmp29_[1] = _tmp27_;
- _tmp29_[2] = _tmp28_;
- _tmp30_ = _tmp29_;
- _tmp30__length1 = 3;
- _tmp31_ = g_variant_new_strv (_tmp30_, 3);
- g_variant_ref_sink (_tmp31_);
+ _tmp16_ = g_strdup ("foo");
+ _tmp17_ = g_strdup ("bar");
+ _tmp18_ = g_strdup ("manam");
+ _tmp19_ = g_new0 (gchar*, 3 + 1);
+ _tmp19_[0] = _tmp16_;
+ _tmp19_[1] = _tmp17_;
+ _tmp19_[2] = _tmp18_;
+ _tmp20_ = _tmp19_;
+ _tmp20__length1 = 3;
+ _tmp21_ = g_variant_new_strv (_tmp20_, 3);
+ g_variant_ref_sink (_tmp21_);
_g_variant_unref0 (v);
- v = _tmp31_;
- _tmp30_ = (_vala_array_free (_tmp30_, _tmp30__length1, (GDestroyNotify) g_free), NULL);
+ v = _tmp21_;
+ _tmp20_ = (_vala_array_free (_tmp20_, _tmp20__length1, (GDestroyNotify) g_free), NULL);
{
gchar** sa = NULL;
- GVariant* _tmp32_;
- gchar** _tmp33_ = NULL;
- gint _tmp33__length1 = 0;
+ GVariant* _tmp22_;
+ gchar** _tmp23_ = NULL;
+ gint _tmp23__length1 = 0;
gint sa_length1;
gint _sa_size_;
- const gchar* _tmp39_;
- _tmp32_ = v;
- _tmp33_ = _variant_get7 (_tmp32_, &_tmp33__length1);
- sa = _tmp33_;
- sa_length1 = _tmp33__length1;
+ const gchar* _tmp24_;
+ _tmp22_ = v;
+ _tmp23_ = _variant_get7 (_tmp22_, &_tmp23__length1);
+ sa = _tmp23_;
+ sa_length1 = _tmp23__length1;
_sa_size_ = sa_length1;
_vala_assert (sa != NULL, "sa != null");
- _tmp39_ = sa[2];
- _vala_assert (g_strcmp0 (_tmp39_, "manam") == 0, "sa[2] == \"manam\"");
+ _tmp24_ = sa[2];
+ _vala_assert (g_strcmp0 (_tmp24_, "manam") == 0, "sa[2] == \"manam\"");
sa = (_vala_array_free (sa, sa_length1, (GDestroyNotify) g_free), NULL);
}
- _tmp40_ = g_strdup ("foo");
- _g_free0 (_tmp41_.s);
- _tmp41_.s = _tmp40_;
- _tmp41_.u64 = G_MAXUINT64;
- _tmp41_.b = TRUE;
- vsrc = _tmp41_;
- _tmp42_ = vsrc;
- _tmp44_ = _variant_new1 (_tmp42_);
+ _tmp25_ = g_strdup ("foo");
+ _g_free0 (_tmp26_.s);
+ _tmp26_.s = _tmp25_;
+ _tmp26_.u64 = G_MAXUINT64;
+ _tmp26_.b = TRUE;
+ vsrc = _tmp26_;
+ _tmp27_ = vsrc;
+ _tmp29_ = _variant_new1 (_tmp27_);
_g_variant_unref0 (v);
- v = _tmp44_;
- _tmp45_ = v;
- _tmp46_ = g_variant_get_type_string (_tmp45_);
- _vala_assert (g_strcmp0 ("(stb)", _tmp46_) == 0, "\"(stb)\" == v.get_type_string ()");
+ v = _tmp29_;
+ _tmp30_ = v;
+ _tmp31_ = g_variant_get_type_string (_tmp30_);
+ _vala_assert (g_strcmp0 ("(stb)", _tmp31_) == 0, "\"(stb)\" == v.get_type_string ()");
{
Foo real_st = {0};
- GVariant* _tmp47_;
- Foo _tmp48_;
- Foo _tmp54_;
- const gchar* _tmp55_;
- Foo _tmp56_;
- Foo _tmp57_;
+ GVariant* _tmp32_;
+ Foo _tmp33_;
+ Foo _tmp34_;
+ const gchar* _tmp35_;
+ Foo _tmp36_;
+ Foo _tmp37_;
Foo* st = NULL;
- GVariant* _tmp58_;
- Foo* _tmp59_;
- const gchar* _tmp67_;
- _tmp47_ = v;
- _variant_get8 (_tmp47_, &_tmp48_);
- real_st = _tmp48_;
- _tmp54_ = real_st;
- _tmp55_ = _tmp54_.s;
- _vala_assert (g_strcmp0 (_tmp55_, "foo") == 0, "real_st.s == \"foo\"");
- _tmp56_ = real_st;
- _vala_assert (_tmp56_.u64 == G_MAXUINT64, "real_st.u64 == uint64.MAX");
- _tmp57_ = real_st;
- _vala_assert (_tmp57_.b == TRUE, "real_st.b == true");
- _tmp58_ = v;
- _tmp59_ = _variant_get9 (_tmp58_);
- st = _tmp59_;
+ GVariant* _tmp38_;
+ Foo* _tmp39_;
+ const gchar* _tmp40_;
+ _tmp32_ = v;
+ _variant_get8 (_tmp32_, &_tmp33_);
+ real_st = _tmp33_;
+ _tmp34_ = real_st;
+ _tmp35_ = _tmp34_.s;
+ _vala_assert (g_strcmp0 (_tmp35_, "foo") == 0, "real_st.s == \"foo\"");
+ _tmp36_ = real_st;
+ _vala_assert (_tmp36_.u64 == G_MAXUINT64, "real_st.u64 == uint64.MAX");
+ _tmp37_ = real_st;
+ _vala_assert (_tmp37_.b == TRUE, "real_st.b == true");
+ _tmp38_ = v;
+ _tmp39_ = _variant_get9 (_tmp38_);
+ st = _tmp39_;
_vala_assert (st != NULL, "st != null");
- _tmp67_ = (*st).s;
- _vala_assert (g_strcmp0 (_tmp67_, "foo") == 0, "st.s == \"foo\"");
+ _tmp40_ = (*st).s;
+ _vala_assert (g_strcmp0 (_tmp40_, "foo") == 0, "st.s == \"foo\"");
_vala_assert ((*st).u64 == G_MAXUINT64, "st.u64 == uint64.MAX");
_vala_assert ((*st).b == TRUE, "st.b == true");
_foo_free0 (st);
foo_destroy (&real_st);
}
- _tmp68_ = g_str_hash;
- _tmp69_ = g_str_equal;
- _tmp70_ = g_hash_table_new_full (_tmp68_, _tmp69_, _g_free0_, _g_free0_);
- vsrc2 = _tmp70_;
- _tmp71_ = g_strdup ("foo");
- _tmp72_ = g_strdup ("bar");
- g_hash_table_insert (vsrc2, _tmp71_, _tmp72_);
- _tmp73_ = g_strdup ("bar");
- _tmp74_ = g_strdup ("manam");
- g_hash_table_insert (vsrc2, _tmp73_, _tmp74_);
- _tmp79_ = _variant_new2 (vsrc2);
+ _tmp41_ = g_str_hash;
+ _tmp42_ = g_str_equal;
+ _tmp43_ = g_hash_table_new_full (_tmp41_, _tmp42_, _g_free0_, _g_free0_);
+ vsrc2 = _tmp43_;
+ _tmp44_ = g_strdup ("foo");
+ _tmp45_ = g_strdup ("bar");
+ g_hash_table_insert (vsrc2, _tmp44_, _tmp45_);
+ _tmp46_ = g_strdup ("bar");
+ _tmp47_ = g_strdup ("manam");
+ g_hash_table_insert (vsrc2, _tmp46_, _tmp47_);
+ _tmp52_ = _variant_new2 (vsrc2);
_g_variant_unref0 (v);
- v = _tmp79_;
+ v = _tmp52_;
{
GHashTable* dict = NULL;
- GVariant* _tmp80_;
- GHashTable* _tmp81_;
- gconstpointer _tmp88_;
- gconstpointer _tmp89_;
- _tmp80_ = v;
- _tmp81_ = _variant_get10 (_tmp80_);
- dict = _tmp81_;
- _tmp88_ = g_hash_table_lookup (dict, "foo");
- _vala_assert (g_strcmp0 ((const gchar*) _tmp88_, "bar") == 0, "dict.lookup (\"foo\") ==
\"bar\"");
- _tmp89_ = g_hash_table_lookup (dict, "bar");
- _vala_assert (g_strcmp0 ((const gchar*) _tmp89_, "manam") == 0, "dict.lookup (\"bar\") ==
\"manam\"");
+ GVariant* _tmp53_;
+ GHashTable* _tmp54_;
+ gconstpointer _tmp55_;
+ gconstpointer _tmp56_;
+ _tmp53_ = v;
+ _tmp54_ = _variant_get10 (_tmp53_);
+ dict = _tmp54_;
+ _tmp55_ = g_hash_table_lookup (dict, "foo");
+ _vala_assert (g_strcmp0 ((const gchar*) _tmp55_, "bar") == 0, "dict.lookup (\"foo\") ==
\"bar\"");
+ _tmp56_ = g_hash_table_lookup (dict, "bar");
+ _vala_assert (g_strcmp0 ((const gchar*) _tmp56_, "manam") == 0, "dict.lookup (\"bar\") ==
\"manam\"");
_g_hash_table_unref0 (dict);
}
{
GHashTable* dict = NULL;
- GVariant* _tmp90_;
- GHashTable* _tmp91_;
- _tmp90_ = v;
- _tmp91_ = _variant_get11 (_tmp90_);
- dict = _tmp91_;
+ GVariant* _tmp57_;
+ GHashTable* _tmp58_;
+ _tmp57_ = v;
+ _tmp58_ = _variant_get11 (_tmp57_);
+ dict = _tmp58_;
_vala_assert (dict == NULL, "dict == null");
_g_hash_table_unref0 (dict);
}
diff --git a/tests/basic-types/gvariants.c-expected b/tests/basic-types/gvariants.c-expected
index dc037ded2..c12ca233b 100644
--- a/tests/basic-types/gvariants.c-expected
+++ b/tests/basic-types/gvariants.c-expected
@@ -139,28 +139,28 @@ static gchar**
_variant_get2 (GVariant* value,
gint* result_length1)
{
- gchar** _tmp10_;
- gint _tmp10__length;
- gint _tmp10__size;
- gint _tmp10__length1;
- GVariantIter _tmp11_;
- GVariant* _tmp12_;
- _tmp10_ = g_new (gchar*, 5);
- _tmp10__length = 0;
- _tmp10__size = 4;
- _tmp10__length1 = 0;
- g_variant_iter_init (&_tmp11_, value);
- for (; (_tmp12_ = g_variant_iter_next_value (&_tmp11_)) != NULL; _tmp10__length1++) {
- if (_tmp10__size == _tmp10__length) {
- _tmp10__size = 2 * _tmp10__size;
- _tmp10_ = g_renew (gchar*, _tmp10_, _tmp10__size + 1);
+ gchar** _tmp0_;
+ gint _tmp0__length;
+ gint _tmp0__size;
+ gint _tmp0__length1;
+ GVariantIter _tmp1_;
+ GVariant* _tmp2_;
+ _tmp0_ = g_new (gchar*, 5);
+ _tmp0__length = 0;
+ _tmp0__size = 4;
+ _tmp0__length1 = 0;
+ g_variant_iter_init (&_tmp1_, value);
+ for (; (_tmp2_ = g_variant_iter_next_value (&_tmp1_)) != NULL; _tmp0__length1++) {
+ if (_tmp0__size == _tmp0__length) {
+ _tmp0__size = 2 * _tmp0__size;
+ _tmp0_ = g_renew (gchar*, _tmp0_, _tmp0__size + 1);
}
- _tmp10_[_tmp10__length++] = g_variant_dup_string (_tmp12_, NULL);
- g_variant_unref (_tmp12_);
+ _tmp0_[_tmp0__length++] = g_variant_dup_string (_tmp2_, NULL);
+ g_variant_unref (_tmp2_);
}
- *result_length1 = _tmp10__length1;
- _tmp10_[_tmp10__length] = NULL;
- return _tmp10_;
+ *result_length1 = _tmp0__length1;
+ _tmp0_[_tmp0__length] = NULL;
+ return _tmp0_;
}
void
@@ -179,7 +179,7 @@ string_array_conversion (void)
gint _tmp9__length1 = 0;
gint sa_length1;
gint _sa_size_;
- const gchar* _tmp13_;
+ const gchar* _tmp10_;
_tmp0_ = g_strdup ("foo");
_tmp1_ = g_strdup ("bar");
_tmp2_ = g_new0 (gchar*, 2 + 1);
@@ -196,8 +196,8 @@ string_array_conversion (void)
sa_length1 = _tmp9__length1;
_sa_size_ = sa_length1;
_vala_assert (sa_length1 == 2, "sa.length == 2");
- _tmp13_ = sa[1];
- _vala_assert (g_strcmp0 (_tmp13_, "bar") == 0, "sa[1] == \"bar\"");
+ _tmp10_ = sa[1];
+ _vala_assert (g_strcmp0 (_tmp10_, "bar") == 0, "sa[1] == \"bar\"");
sa = (_vala_array_free (sa, sa_length1, (GDestroyNotify) g_free), NULL);
_g_variant_unref0 (v);
}
@@ -230,37 +230,37 @@ _variant_get3 (GVariant* value,
gint* result_length1,
gint* result_length2)
{
- gchar** _tmp14_;
- gint _tmp14__length;
- gint _tmp14__size;
- gint _tmp14__length1;
- GVariantIter _tmp15_;
- GVariant* _tmp16_;
- _tmp14_ = g_new (gchar*, 5);
- _tmp14__length = 0;
- _tmp14__size = 4;
- _tmp14__length1 = 0;
- g_variant_iter_init (&_tmp15_, value);
- for (; (_tmp16_ = g_variant_iter_next_value (&_tmp15_)) != NULL; _tmp14__length1++) {
- gint _tmp14__length2;
- GVariantIter _tmp17_;
- GVariant* _tmp18_;
- _tmp14__length2 = 0;
- g_variant_iter_init (&_tmp17_, _tmp16_);
- for (; (_tmp18_ = g_variant_iter_next_value (&_tmp17_)) != NULL; _tmp14__length2++) {
- if (_tmp14__size == _tmp14__length) {
- _tmp14__size = 2 * _tmp14__size;
- _tmp14_ = g_renew (gchar*, _tmp14_, _tmp14__size + 1);
+ gchar** _tmp0_;
+ gint _tmp0__length;
+ gint _tmp0__size;
+ gint _tmp0__length1;
+ GVariantIter _tmp1_;
+ GVariant* _tmp2_;
+ _tmp0_ = g_new (gchar*, 5);
+ _tmp0__length = 0;
+ _tmp0__size = 4;
+ _tmp0__length1 = 0;
+ g_variant_iter_init (&_tmp1_, value);
+ for (; (_tmp2_ = g_variant_iter_next_value (&_tmp1_)) != NULL; _tmp0__length1++) {
+ gint _tmp0__length2;
+ GVariantIter _tmp3_;
+ GVariant* _tmp4_;
+ _tmp0__length2 = 0;
+ g_variant_iter_init (&_tmp3_, _tmp2_);
+ for (; (_tmp4_ = g_variant_iter_next_value (&_tmp3_)) != NULL; _tmp0__length2++) {
+ if (_tmp0__size == _tmp0__length) {
+ _tmp0__size = 2 * _tmp0__size;
+ _tmp0_ = g_renew (gchar*, _tmp0_, _tmp0__size + 1);
}
- _tmp14_[_tmp14__length++] = g_variant_dup_string (_tmp18_, NULL);
- g_variant_unref (_tmp18_);
+ _tmp0_[_tmp0__length++] = g_variant_dup_string (_tmp4_, NULL);
+ g_variant_unref (_tmp4_);
}
- *result_length2 = _tmp14__length2;
- g_variant_unref (_tmp16_);
+ *result_length2 = _tmp0__length2;
+ g_variant_unref (_tmp2_);
}
- *result_length1 = _tmp14__length1;
- _tmp14_[_tmp14__length] = NULL;
- return _tmp14_;
+ *result_length1 = _tmp0__length1;
+ _tmp0_[_tmp0__length] = NULL;
+ return _tmp0_;
}
void
@@ -283,9 +283,9 @@ string_array_2d_conversion (void)
gint _tmp13__length2 = 0;
gint sa_length1;
gint sa_length2;
- gint _tmp19_;
- gint _tmp20_;
- const gchar* _tmp21_;
+ gint _tmp14_;
+ gint _tmp15_;
+ const gchar* _tmp16_;
_tmp0_ = g_strdup ("foo");
_tmp1_ = g_strdup ("faz");
_tmp2_ = g_strdup ("bar");
@@ -306,12 +306,12 @@ string_array_2d_conversion (void)
sa = _tmp13_;
sa_length1 = _tmp13__length1;
sa_length2 = _tmp13__length2;
- _tmp19_ = sa_length1;
- _vala_assert (_tmp19_ == 2, "sa.length[0] == 2");
- _tmp20_ = sa_length2;
- _vala_assert (_tmp20_ == 2, "sa.length[1] == 2");
- _tmp21_ = sa[(1 * sa_length2) + 1];
- _vala_assert (g_strcmp0 (_tmp21_, "baz") == 0, "sa[1,1] == \"baz\"");
+ _tmp14_ = sa_length1;
+ _vala_assert (_tmp14_ == 2, "sa.length[0] == 2");
+ _tmp15_ = sa_length2;
+ _vala_assert (_tmp15_ == 2, "sa.length[1] == 2");
+ _tmp16_ = sa[(1 * sa_length2) + 1];
+ _vala_assert (g_strcmp0 (_tmp16_, "baz") == 0, "sa[1,1] == \"baz\"");
sa = (_vala_array_free (sa, sa_length1 * sa_length2, (GDestroyNotify) g_free), NULL);
_g_variant_unref0 (v);
}
@@ -352,46 +352,46 @@ _variant_get4 (GVariant* value,
gint* result_length2,
gint* result_length3)
{
- gchar** _tmp20_;
- gint _tmp20__length;
- gint _tmp20__size;
- gint _tmp20__length1;
- GVariantIter _tmp21_;
- GVariant* _tmp22_;
- _tmp20_ = g_new (gchar*, 5);
- _tmp20__length = 0;
- _tmp20__size = 4;
- _tmp20__length1 = 0;
- g_variant_iter_init (&_tmp21_, value);
- for (; (_tmp22_ = g_variant_iter_next_value (&_tmp21_)) != NULL; _tmp20__length1++) {
- gint _tmp20__length2;
- GVariantIter _tmp23_;
- GVariant* _tmp24_;
- _tmp20__length2 = 0;
- g_variant_iter_init (&_tmp23_, _tmp22_);
- for (; (_tmp24_ = g_variant_iter_next_value (&_tmp23_)) != NULL; _tmp20__length2++) {
- gint _tmp20__length3;
- GVariantIter _tmp25_;
- GVariant* _tmp26_;
- _tmp20__length3 = 0;
- g_variant_iter_init (&_tmp25_, _tmp24_);
- for (; (_tmp26_ = g_variant_iter_next_value (&_tmp25_)) != NULL; _tmp20__length3++) {
- if (_tmp20__size == _tmp20__length) {
- _tmp20__size = 2 * _tmp20__size;
- _tmp20_ = g_renew (gchar*, _tmp20_, _tmp20__size + 1);
+ gchar** _tmp0_;
+ gint _tmp0__length;
+ gint _tmp0__size;
+ gint _tmp0__length1;
+ GVariantIter _tmp1_;
+ GVariant* _tmp2_;
+ _tmp0_ = g_new (gchar*, 5);
+ _tmp0__length = 0;
+ _tmp0__size = 4;
+ _tmp0__length1 = 0;
+ g_variant_iter_init (&_tmp1_, value);
+ for (; (_tmp2_ = g_variant_iter_next_value (&_tmp1_)) != NULL; _tmp0__length1++) {
+ gint _tmp0__length2;
+ GVariantIter _tmp3_;
+ GVariant* _tmp4_;
+ _tmp0__length2 = 0;
+ g_variant_iter_init (&_tmp3_, _tmp2_);
+ for (; (_tmp4_ = g_variant_iter_next_value (&_tmp3_)) != NULL; _tmp0__length2++) {
+ gint _tmp0__length3;
+ GVariantIter _tmp5_;
+ GVariant* _tmp6_;
+ _tmp0__length3 = 0;
+ g_variant_iter_init (&_tmp5_, _tmp4_);
+ for (; (_tmp6_ = g_variant_iter_next_value (&_tmp5_)) != NULL; _tmp0__length3++) {
+ if (_tmp0__size == _tmp0__length) {
+ _tmp0__size = 2 * _tmp0__size;
+ _tmp0_ = g_renew (gchar*, _tmp0_, _tmp0__size + 1);
}
- _tmp20_[_tmp20__length++] = g_variant_dup_string (_tmp26_, NULL);
- g_variant_unref (_tmp26_);
+ _tmp0_[_tmp0__length++] = g_variant_dup_string (_tmp6_, NULL);
+ g_variant_unref (_tmp6_);
}
- *result_length3 = _tmp20__length3;
- g_variant_unref (_tmp24_);
+ *result_length3 = _tmp0__length3;
+ g_variant_unref (_tmp4_);
}
- *result_length2 = _tmp20__length2;
- g_variant_unref (_tmp22_);
+ *result_length2 = _tmp0__length2;
+ g_variant_unref (_tmp2_);
}
- *result_length1 = _tmp20__length1;
- _tmp20_[_tmp20__length] = NULL;
- return _tmp20_;
+ *result_length1 = _tmp0__length1;
+ _tmp0_[_tmp0__length] = NULL;
+ return _tmp0_;
}
void
@@ -421,13 +421,13 @@ string_array_3d_conversion (void)
gint sa_length1;
gint sa_length2;
gint sa_length3;
- gint _tmp27_;
- gint _tmp28_;
- gint _tmp29_;
- const gchar* _tmp30_;
- const gchar* _tmp31_;
- const gchar* _tmp32_;
- const gchar* _tmp33_;
+ gint _tmp20_;
+ gint _tmp21_;
+ gint _tmp22_;
+ const gchar* _tmp23_;
+ const gchar* _tmp24_;
+ const gchar* _tmp25_;
+ const gchar* _tmp26_;
_tmp0_ = g_strdup ("foo");
_tmp1_ = g_strdup ("bar");
_tmp2_ = g_strdup ("baz");
@@ -458,20 +458,20 @@ string_array_3d_conversion (void)
sa_length1 = _tmp19__length1;
sa_length2 = _tmp19__length2;
sa_length3 = _tmp19__length3;
- _tmp27_ = sa_length1;
- _vala_assert (_tmp27_ == 2, "sa.length[0] == 2");
- _tmp28_ = sa_length2;
- _vala_assert (_tmp28_ == 2, "sa.length[1] == 2");
- _tmp29_ = sa_length3;
- _vala_assert (_tmp29_ == 2, "sa.length[2] == 2");
- _tmp30_ = sa[(((0 * sa_length2) + 1) * sa_length3) + 0];
- _vala_assert (g_strcmp0 (_tmp30_, "baz") == 0, "sa[0,1,0] == \"baz\"");
- _tmp31_ = sa[(((0 * sa_length2) + 1) * sa_length3) + 1];
- _vala_assert (g_strcmp0 (_tmp31_, "man") == 0, "sa[0,1,1] == \"man\"");
- _tmp32_ = sa[(((1 * sa_length2) + 1) * sa_length3) + 0];
- _vala_assert (g_strcmp0 (_tmp32_, "baz2") == 0, "sa[1,1,0] == \"baz2\"");
- _tmp33_ = sa[(((1 * sa_length2) + 1) * sa_length3) + 1];
- _vala_assert (g_strcmp0 (_tmp33_, "man2") == 0, "sa[1,1,1] == \"man2\"");
+ _tmp20_ = sa_length1;
+ _vala_assert (_tmp20_ == 2, "sa.length[0] == 2");
+ _tmp21_ = sa_length2;
+ _vala_assert (_tmp21_ == 2, "sa.length[1] == 2");
+ _tmp22_ = sa_length3;
+ _vala_assert (_tmp22_ == 2, "sa.length[2] == 2");
+ _tmp23_ = sa[(((0 * sa_length2) + 1) * sa_length3) + 0];
+ _vala_assert (g_strcmp0 (_tmp23_, "baz") == 0, "sa[0,1,0] == \"baz\"");
+ _tmp24_ = sa[(((0 * sa_length2) + 1) * sa_length3) + 1];
+ _vala_assert (g_strcmp0 (_tmp24_, "man") == 0, "sa[0,1,1] == \"man\"");
+ _tmp25_ = sa[(((1 * sa_length2) + 1) * sa_length3) + 0];
+ _vala_assert (g_strcmp0 (_tmp25_, "baz2") == 0, "sa[1,1,0] == \"baz2\"");
+ _tmp26_ = sa[(((1 * sa_length2) + 1) * sa_length3) + 1];
+ _vala_assert (g_strcmp0 (_tmp26_, "man2") == 0, "sa[1,1,1] == \"man2\"");
sa = (_vala_array_free (sa, (sa_length1 * sa_length2) * sa_length3, (GDestroyNotify) g_free), NULL);
_g_variant_unref0 (v);
}
@@ -523,27 +523,27 @@ static gdouble*
_variant_get6 (GVariant* value,
gint* result_length1)
{
- gdouble* _tmp8_;
- gint _tmp8__length;
- gint _tmp8__size;
- gint _tmp8__length1;
- GVariantIter _tmp9_;
- GVariant* _tmp10_;
- _tmp8_ = g_new (gdouble, 5);
- _tmp8__length = 0;
- _tmp8__size = 4;
- _tmp8__length1 = 0;
- g_variant_iter_init (&_tmp9_, value);
- for (; (_tmp10_ = g_variant_iter_next_value (&_tmp9_)) != NULL; _tmp8__length1++) {
- if (_tmp8__size == _tmp8__length) {
- _tmp8__size = 2 * _tmp8__size;
- _tmp8_ = g_renew (gdouble, _tmp8_, _tmp8__size + 1);
+ gdouble* _tmp0_;
+ gint _tmp0__length;
+ gint _tmp0__size;
+ gint _tmp0__length1;
+ GVariantIter _tmp1_;
+ GVariant* _tmp2_;
+ _tmp0_ = g_new (gdouble, 5);
+ _tmp0__length = 0;
+ _tmp0__size = 4;
+ _tmp0__length1 = 0;
+ g_variant_iter_init (&_tmp1_, value);
+ for (; (_tmp2_ = g_variant_iter_next_value (&_tmp1_)) != NULL; _tmp0__length1++) {
+ if (_tmp0__size == _tmp0__length) {
+ _tmp0__size = 2 * _tmp0__size;
+ _tmp0_ = g_renew (gdouble, _tmp0_, _tmp0__size + 1);
}
- _tmp8_[_tmp8__length++] = g_variant_get_double (_tmp10_);
- g_variant_unref (_tmp10_);
+ _tmp0_[_tmp0__length++] = g_variant_get_double (_tmp2_);
+ g_variant_unref (_tmp2_);
}
- *result_length1 = _tmp8__length1;
- return _tmp8_;
+ *result_length1 = _tmp0__length1;
+ return _tmp0_;
}
void
@@ -560,7 +560,7 @@ double_array_conversion (void)
gint _tmp7__length1 = 0;
gint da_length1;
gint _da_size_;
- gdouble _tmp11_;
+ gdouble _tmp8_;
_tmp0_ = g_new0 (gdouble, 2);
_tmp0_[0] = 42.23;
_tmp0_[1] = 47.11;
@@ -575,8 +575,8 @@ double_array_conversion (void)
da_length1 = _tmp7__length1;
_da_size_ = da_length1;
_vala_assert (da_length1 == 2, "da.length == 2");
- _tmp11_ = da[1];
- _vala_assert (_tmp11_ == 47.11, "da[1] == 47.11");
+ _tmp8_ = da[1];
+ _vala_assert (_tmp8_ == 47.11, "da[1] == 47.11");
da = (g_free (da), NULL);
_g_variant_unref0 (v);
}
@@ -609,36 +609,36 @@ _variant_get7 (GVariant* value,
gint* result_length1,
gint* result_length2)
{
- gdouble* _tmp10_;
- gint _tmp10__length;
- gint _tmp10__size;
- gint _tmp10__length1;
- GVariantIter _tmp11_;
- GVariant* _tmp12_;
- _tmp10_ = g_new (gdouble, 5);
- _tmp10__length = 0;
- _tmp10__size = 4;
- _tmp10__length1 = 0;
- g_variant_iter_init (&_tmp11_, value);
- for (; (_tmp12_ = g_variant_iter_next_value (&_tmp11_)) != NULL; _tmp10__length1++) {
- gint _tmp10__length2;
- GVariantIter _tmp13_;
- GVariant* _tmp14_;
- _tmp10__length2 = 0;
- g_variant_iter_init (&_tmp13_, _tmp12_);
- for (; (_tmp14_ = g_variant_iter_next_value (&_tmp13_)) != NULL; _tmp10__length2++) {
- if (_tmp10__size == _tmp10__length) {
- _tmp10__size = 2 * _tmp10__size;
- _tmp10_ = g_renew (gdouble, _tmp10_, _tmp10__size + 1);
+ gdouble* _tmp0_;
+ gint _tmp0__length;
+ gint _tmp0__size;
+ gint _tmp0__length1;
+ GVariantIter _tmp1_;
+ GVariant* _tmp2_;
+ _tmp0_ = g_new (gdouble, 5);
+ _tmp0__length = 0;
+ _tmp0__size = 4;
+ _tmp0__length1 = 0;
+ g_variant_iter_init (&_tmp1_, value);
+ for (; (_tmp2_ = g_variant_iter_next_value (&_tmp1_)) != NULL; _tmp0__length1++) {
+ gint _tmp0__length2;
+ GVariantIter _tmp3_;
+ GVariant* _tmp4_;
+ _tmp0__length2 = 0;
+ g_variant_iter_init (&_tmp3_, _tmp2_);
+ for (; (_tmp4_ = g_variant_iter_next_value (&_tmp3_)) != NULL; _tmp0__length2++) {
+ if (_tmp0__size == _tmp0__length) {
+ _tmp0__size = 2 * _tmp0__size;
+ _tmp0_ = g_renew (gdouble, _tmp0_, _tmp0__size + 1);
}
- _tmp10_[_tmp10__length++] = g_variant_get_double (_tmp14_);
- g_variant_unref (_tmp14_);
+ _tmp0_[_tmp0__length++] = g_variant_get_double (_tmp4_);
+ g_variant_unref (_tmp4_);
}
- *result_length2 = _tmp10__length2;
- g_variant_unref (_tmp12_);
+ *result_length2 = _tmp0__length2;
+ g_variant_unref (_tmp2_);
}
- *result_length1 = _tmp10__length1;
- return _tmp10_;
+ *result_length1 = _tmp0__length1;
+ return _tmp0_;
}
void
@@ -657,9 +657,9 @@ double_array_2d_conversion (void)
gint _tmp9__length2 = 0;
gint da_length1;
gint da_length2;
- gint _tmp15_;
- gint _tmp16_;
- gdouble _tmp17_;
+ gint _tmp10_;
+ gint _tmp11_;
+ gdouble _tmp12_;
_tmp0_ = g_new0 (gdouble, 2 * 2);
_tmp0_[0] = 42.23;
_tmp0_[1] = 11.47;
@@ -676,12 +676,12 @@ double_array_2d_conversion (void)
da = _tmp9_;
da_length1 = _tmp9__length1;
da_length2 = _tmp9__length2;
- _tmp15_ = da_length1;
- _vala_assert (_tmp15_ == 2, "da.length[0] == 2");
- _tmp16_ = da_length2;
- _vala_assert (_tmp16_ == 2, "da.length[1] == 2");
- _tmp17_ = da[(1 * da_length2) + 1];
- _vala_assert (_tmp17_ == 23.42, "da[1,1] == 23.42");
+ _tmp10_ = da_length1;
+ _vala_assert (_tmp10_ == 2, "da.length[0] == 2");
+ _tmp11_ = da_length2;
+ _vala_assert (_tmp11_ == 2, "da.length[1] == 2");
+ _tmp12_ = da[(1 * da_length2) + 1];
+ _vala_assert (_tmp12_ == 23.42, "da[1,1] == 23.42");
da = (g_free (da), NULL);
_g_variant_unref0 (v);
}
@@ -757,22 +757,22 @@ static void
_variant_get8 (GVariant* value,
Foo * result)
{
- Foo _tmp6_;
- GVariantIter _tmp7_;
- GVariant* _tmp8_;
- GVariant* _tmp9_;
- GVariant* _tmp10_;
- g_variant_iter_init (&_tmp7_, value);
- _tmp8_ = g_variant_iter_next_value (&_tmp7_);
- _tmp6_.s = g_variant_dup_string (_tmp8_, NULL);
- g_variant_unref (_tmp8_);
- _tmp9_ = g_variant_iter_next_value (&_tmp7_);
- _tmp6_.u64 = g_variant_get_uint64 (_tmp9_);
- g_variant_unref (_tmp9_);
- _tmp10_ = g_variant_iter_next_value (&_tmp7_);
- _tmp6_.b = g_variant_get_boolean (_tmp10_);
- g_variant_unref (_tmp10_);
- *result = _tmp6_;
+ Foo _tmp0_;
+ GVariantIter _tmp1_;
+ GVariant* _tmp2_;
+ GVariant* _tmp3_;
+ GVariant* _tmp4_;
+ g_variant_iter_init (&_tmp1_, value);
+ _tmp2_ = g_variant_iter_next_value (&_tmp1_);
+ _tmp0_.s = g_variant_dup_string (_tmp2_, NULL);
+ g_variant_unref (_tmp2_);
+ _tmp3_ = g_variant_iter_next_value (&_tmp1_);
+ _tmp0_.u64 = g_variant_get_uint64 (_tmp3_);
+ g_variant_unref (_tmp3_);
+ _tmp4_ = g_variant_iter_next_value (&_tmp1_);
+ _tmp0_.b = g_variant_get_boolean (_tmp4_);
+ g_variant_unref (_tmp4_);
+ *result = _tmp0_;
}
void
@@ -786,10 +786,10 @@ struct_conversion (void)
GVariant* _tmp4_;
Foo st = {0};
Foo _tmp5_;
- Foo _tmp11_;
- const gchar* _tmp12_;
- Foo _tmp13_;
- Foo _tmp14_;
+ Foo _tmp6_;
+ const gchar* _tmp7_;
+ Foo _tmp8_;
+ Foo _tmp9_;
_tmp0_ = g_strdup ("foo");
_g_free0 (_tmp1_.s);
_tmp1_.s = _tmp0_;
@@ -801,13 +801,13 @@ struct_conversion (void)
v = _tmp4_;
_variant_get8 (v, &_tmp5_);
st = _tmp5_;
- _tmp11_ = st;
- _tmp12_ = _tmp11_.s;
- _vala_assert (g_strcmp0 (_tmp12_, "foo") == 0, "st.s == \"foo\"");
- _tmp13_ = st;
- _vala_assert (_tmp13_.u64 == G_MAXUINT64, "st.u64 == uint64.MAX");
- _tmp14_ = st;
- _vala_assert (_tmp14_.b == TRUE, "st.b == true");
+ _tmp6_ = st;
+ _tmp7_ = _tmp6_.s;
+ _vala_assert (g_strcmp0 (_tmp7_, "foo") == 0, "st.s == \"foo\"");
+ _tmp8_ = st;
+ _vala_assert (_tmp8_.u64 == G_MAXUINT64, "st.u64 == uint64.MAX");
+ _tmp9_ = st;
+ _vala_assert (_tmp9_.b == TRUE, "st.b == true");
foo_destroy (&st);
_g_variant_unref0 (v);
foo_destroy (&s);
diff --git a/tests/dbus/bug602003_client.c-expected b/tests/dbus/bug602003_client.c-expected
index 38836347a..86d159c79 100644
--- a/tests/dbus/bug602003_client.c-expected
+++ b/tests/dbus/bug602003_client.c-expected
@@ -327,28 +327,28 @@ static gchar**
_variant_get1 (GVariant* value,
gint* result_length1)
{
- gchar** _tmp5_;
- gint _tmp5__length;
- gint _tmp5__size;
- gint _tmp5__length1;
- GVariantIter _tmp6_;
- GVariant* _tmp7_;
- _tmp5_ = g_new (gchar*, 5);
- _tmp5__length = 0;
- _tmp5__size = 4;
- _tmp5__length1 = 0;
- g_variant_iter_init (&_tmp6_, value);
- for (; (_tmp7_ = g_variant_iter_next_value (&_tmp6_)) != NULL; _tmp5__length1++) {
- if (_tmp5__size == _tmp5__length) {
- _tmp5__size = 2 * _tmp5__size;
- _tmp5_ = g_renew (gchar*, _tmp5_, _tmp5__size + 1);
+ gchar** _tmp0_;
+ gint _tmp0__length;
+ gint _tmp0__size;
+ gint _tmp0__length1;
+ GVariantIter _tmp1_;
+ GVariant* _tmp2_;
+ _tmp0_ = g_new (gchar*, 5);
+ _tmp0__length = 0;
+ _tmp0__size = 4;
+ _tmp0__length1 = 0;
+ g_variant_iter_init (&_tmp1_, value);
+ for (; (_tmp2_ = g_variant_iter_next_value (&_tmp1_)) != NULL; _tmp0__length1++) {
+ if (_tmp0__size == _tmp0__length) {
+ _tmp0__size = 2 * _tmp0__size;
+ _tmp0_ = g_renew (gchar*, _tmp0_, _tmp0__size + 1);
}
- _tmp5_[_tmp5__length++] = g_variant_dup_string (_tmp7_, NULL);
- g_variant_unref (_tmp7_);
+ _tmp0_[_tmp0__length++] = g_variant_dup_string (_tmp2_, NULL);
+ g_variant_unref (_tmp2_);
}
- *result_length1 = _tmp5__length1;
- _tmp5_[_tmp5__length] = NULL;
- return _tmp5_;
+ *result_length1 = _tmp0__length1;
+ _tmp0_[_tmp0__length] = NULL;
+ return _tmp0_;
}
static void
@@ -365,9 +365,9 @@ _vala_main (void)
gint _tmp4__length1 = 0;
gint s_length1;
gint _s_size_;
- gboolean _tmp8_ = FALSE;
- gchar** _tmp9_;
- gint _tmp9__length1;
+ gboolean _tmp5_ = FALSE;
+ gchar** _tmp6_;
+ gint _tmp6__length1;
GError* _inner_error0_ = NULL;
_tmp0_ = (Test*) g_initable_new (TYPE_TEST_PROXY, NULL, &_inner_error0_, "g-flags", 0, "g-name",
"org.example.Test", "g-bus-type", G_BUS_TYPE_SESSION, "g-object-path", "/org/example/test",
"g-interface-name", "org.example.Test", NULL);
test = (Test*) _tmp0_;
@@ -390,20 +390,20 @@ _vala_main (void)
s = _tmp4_;
s_length1 = _tmp4__length1;
_s_size_ = s_length1;
- _tmp9_ = s;
- _tmp9__length1 = s_length1;
- if (_tmp9__length1 == 1) {
- gchar** _tmp10_;
- gint _tmp10__length1;
- const gchar* _tmp11_;
- _tmp10_ = s;
- _tmp10__length1 = s_length1;
- _tmp11_ = _tmp10_[0];
- _tmp8_ = g_strcmp0 (_tmp11_, "hello") == 0;
+ _tmp6_ = s;
+ _tmp6__length1 = s_length1;
+ if (_tmp6__length1 == 1) {
+ gchar** _tmp7_;
+ gint _tmp7__length1;
+ const gchar* _tmp8_;
+ _tmp7_ = s;
+ _tmp7__length1 = s_length1;
+ _tmp8_ = _tmp7_[0];
+ _tmp5_ = g_strcmp0 (_tmp8_, "hello") == 0;
} else {
- _tmp8_ = FALSE;
+ _tmp5_ = FALSE;
}
- _vala_assert (_tmp8_, "s.length == 1 && s[0] == \"hello\"");
+ _vala_assert (_tmp5_, "s.length == 1 && s[0] == \"hello\"");
s = (_vala_array_free (s, s_length1, (GDestroyNotify) g_free), NULL);
_g_variant_unref0 (v);
_g_object_unref0 (test);
diff --git a/tests/dbus/bug782719_client.c-expected b/tests/dbus/bug782719_client.c-expected
index a5883c89f..3c287d617 100644
--- a/tests/dbus/bug782719_client.c-expected
+++ b/tests/dbus/bug782719_client.c-expected
@@ -384,28 +384,28 @@ static gchar**
_variant_get1 (GVariant* value,
gint* result_length1)
{
- gchar** _tmp14_;
- gint _tmp14__length;
- gint _tmp14__size;
- gint _tmp14__length1;
- GVariantIter _tmp15_;
- GVariant* _tmp16_;
- _tmp14_ = g_new (gchar*, 5);
- _tmp14__length = 0;
- _tmp14__size = 4;
- _tmp14__length1 = 0;
- g_variant_iter_init (&_tmp15_, value);
- for (; (_tmp16_ = g_variant_iter_next_value (&_tmp15_)) != NULL; _tmp14__length1++) {
- if (_tmp14__size == _tmp14__length) {
- _tmp14__size = 2 * _tmp14__size;
- _tmp14_ = g_renew (gchar*, _tmp14_, _tmp14__size + 1);
+ gchar** _tmp0_;
+ gint _tmp0__length;
+ gint _tmp0__size;
+ gint _tmp0__length1;
+ GVariantIter _tmp1_;
+ GVariant* _tmp2_;
+ _tmp0_ = g_new (gchar*, 5);
+ _tmp0__length = 0;
+ _tmp0__size = 4;
+ _tmp0__length1 = 0;
+ g_variant_iter_init (&_tmp1_, value);
+ for (; (_tmp2_ = g_variant_iter_next_value (&_tmp1_)) != NULL; _tmp0__length1++) {
+ if (_tmp0__size == _tmp0__length) {
+ _tmp0__size = 2 * _tmp0__size;
+ _tmp0_ = g_renew (gchar*, _tmp0_, _tmp0__size + 1);
}
- _tmp14_[_tmp14__length++] = g_variant_dup_string (_tmp16_, NULL);
- g_variant_unref (_tmp16_);
+ _tmp0_[_tmp0__length++] = g_variant_dup_string (_tmp2_, NULL);
+ g_variant_unref (_tmp2_);
}
- *result_length1 = _tmp14__length1;
- _tmp14_[_tmp14__length] = NULL;
- return _tmp14_;
+ *result_length1 = _tmp0__length1;
+ _tmp0_[_tmp0__length] = NULL;
+ return _tmp0_;
}
static void
@@ -433,9 +433,9 @@ _vala_main (void)
gint _tmp13__length1 = 0;
gint s_length1;
gint _s_size_;
- gboolean _tmp17_ = FALSE;
- gchar** _tmp18_;
- gint _tmp18__length1;
+ gboolean _tmp14_ = FALSE;
+ gchar** _tmp15_;
+ gint _tmp15__length1;
GError* _inner_error0_ = NULL;
_tmp0_ = (Test*) g_initable_new (TYPE_TEST_PROXY, NULL, &_inner_error0_, "g-flags", 0, "g-name",
"org.example.Test", "g-bus-type", G_BUS_TYPE_SESSION, "g-object-path", "/org/example/test",
"g-interface-name", "org.example.Test", NULL);
test = (Test*) _tmp0_;
@@ -472,20 +472,20 @@ _vala_main (void)
s = _tmp13_;
s_length1 = _tmp13__length1;
_s_size_ = s_length1;
- _tmp18_ = s;
- _tmp18__length1 = s_length1;
- if (_tmp18__length1 == 1) {
- gchar** _tmp19_;
- gint _tmp19__length1;
- const gchar* _tmp20_;
- _tmp19_ = s;
- _tmp19__length1 = s_length1;
- _tmp20_ = _tmp19_[0];
- _tmp17_ = g_strcmp0 (_tmp20_, "hello") == 0;
+ _tmp15_ = s;
+ _tmp15__length1 = s_length1;
+ if (_tmp15__length1 == 1) {
+ gchar** _tmp16_;
+ gint _tmp16__length1;
+ const gchar* _tmp17_;
+ _tmp16_ = s;
+ _tmp16__length1 = s_length1;
+ _tmp17_ = _tmp16_[0];
+ _tmp14_ = g_strcmp0 (_tmp17_, "hello") == 0;
} else {
- _tmp17_ = FALSE;
+ _tmp14_ = FALSE;
}
- _vala_assert (_tmp17_, "s.length == 1 && s[0] == \"hello\"");
+ _vala_assert (_tmp14_, "s.length == 1 && s[0] == \"hello\"");
s = (_vala_array_free (s, s_length1, (GDestroyNotify) g_free), NULL);
_g_variant_unref0 (v);
_g_hash_table_unref0 (nested_dict);
diff --git a/tests/dbus/dicts_client.c-expected b/tests/dbus/dicts_client.c-expected
index d7de6e2fc..16a66e5c4 100644
--- a/tests/dbus/dicts_client.c-expected
+++ b/tests/dbus/dicts_client.c-expected
@@ -356,28 +356,28 @@ static gchar**
_variant_get1 (GVariant* value,
gint* result_length1)
{
- gchar** _tmp10_;
- gint _tmp10__length;
- gint _tmp10__size;
- gint _tmp10__length1;
- GVariantIter _tmp11_;
- GVariant* _tmp12_;
- _tmp10_ = g_new (gchar*, 5);
- _tmp10__length = 0;
- _tmp10__size = 4;
- _tmp10__length1 = 0;
- g_variant_iter_init (&_tmp11_, value);
- for (; (_tmp12_ = g_variant_iter_next_value (&_tmp11_)) != NULL; _tmp10__length1++) {
- if (_tmp10__size == _tmp10__length) {
- _tmp10__size = 2 * _tmp10__size;
- _tmp10_ = g_renew (gchar*, _tmp10_, _tmp10__size + 1);
+ gchar** _tmp0_;
+ gint _tmp0__length;
+ gint _tmp0__size;
+ gint _tmp0__length1;
+ GVariantIter _tmp1_;
+ GVariant* _tmp2_;
+ _tmp0_ = g_new (gchar*, 5);
+ _tmp0__length = 0;
+ _tmp0__size = 4;
+ _tmp0__length1 = 0;
+ g_variant_iter_init (&_tmp1_, value);
+ for (; (_tmp2_ = g_variant_iter_next_value (&_tmp1_)) != NULL; _tmp0__length1++) {
+ if (_tmp0__size == _tmp0__length) {
+ _tmp0__size = 2 * _tmp0__size;
+ _tmp0_ = g_renew (gchar*, _tmp0_, _tmp0__size + 1);
}
- _tmp10_[_tmp10__length++] = g_variant_dup_string (_tmp12_, NULL);
- g_variant_unref (_tmp12_);
+ _tmp0_[_tmp0__length++] = g_variant_dup_string (_tmp2_, NULL);
+ g_variant_unref (_tmp2_);
}
- *result_length1 = _tmp10__length1;
- _tmp10_[_tmp10__length] = NULL;
- return _tmp10_;
+ *result_length1 = _tmp0__length1;
+ _tmp0_[_tmp0__length] = NULL;
+ return _tmp0_;
}
static void
@@ -400,9 +400,9 @@ _vala_main (void)
gint _tmp9__length1 = 0;
gint s_length1;
gint _s_size_;
- gboolean _tmp13_ = FALSE;
- gchar** _tmp14_;
- gint _tmp14__length1;
+ gboolean _tmp10_ = FALSE;
+ gchar** _tmp11_;
+ gint _tmp11__length1;
GError* _inner_error0_ = NULL;
_tmp0_ = (Test*) g_initable_new (TYPE_TEST_PROXY, NULL, &_inner_error0_, "g-flags", 0, "g-name",
"org.example.Test", "g-bus-type", G_BUS_TYPE_SESSION, "g-object-path", "/org/example/test",
"g-interface-name", "org.example.Test", NULL);
test = (Test*) _tmp0_;
@@ -433,20 +433,20 @@ _vala_main (void)
s = _tmp9_;
s_length1 = _tmp9__length1;
_s_size_ = s_length1;
- _tmp14_ = s;
- _tmp14__length1 = s_length1;
- if (_tmp14__length1 == 1) {
- gchar** _tmp15_;
- gint _tmp15__length1;
- const gchar* _tmp16_;
- _tmp15_ = s;
- _tmp15__length1 = s_length1;
- _tmp16_ = _tmp15_[0];
- _tmp13_ = g_strcmp0 (_tmp16_, "hello") == 0;
+ _tmp11_ = s;
+ _tmp11__length1 = s_length1;
+ if (_tmp11__length1 == 1) {
+ gchar** _tmp12_;
+ gint _tmp12__length1;
+ const gchar* _tmp13_;
+ _tmp12_ = s;
+ _tmp12__length1 = s_length1;
+ _tmp13_ = _tmp12_[0];
+ _tmp10_ = g_strcmp0 (_tmp13_, "hello") == 0;
} else {
- _tmp13_ = FALSE;
+ _tmp10_ = FALSE;
}
- _vala_assert (_tmp13_, "s.length == 1 && s[0] == \"hello\"");
+ _vala_assert (_tmp10_, "s.length == 1 && s[0] == \"hello\"");
s = (_vala_array_free (s, s_length1, (GDestroyNotify) g_free), NULL);
_g_variant_unref0 (v);
_g_hash_table_unref0 (dict);
diff --git a/tests/structs/bug661945.c-expected b/tests/structs/bug661945.c-expected
index f4b3538a2..06becc5d2 100644
--- a/tests/structs/bug661945.c-expected
+++ b/tests/structs/bug661945.c-expected
@@ -85,18 +85,18 @@ static void
_variant_get1 (GVariant* value,
Foo * result)
{
- Foo _tmp4_;
- GVariantIter _tmp5_;
- GVariant* _tmp6_;
- GVariant* _tmp7_;
- g_variant_iter_init (&_tmp5_, value);
- _tmp6_ = g_variant_iter_next_value (&_tmp5_);
- _tmp4_.a = g_variant_get_int32 (_tmp6_);
- g_variant_unref (_tmp6_);
- _tmp7_ = g_variant_iter_next_value (&_tmp5_);
- _tmp4_.b = g_variant_get_int32 (_tmp7_);
- g_variant_unref (_tmp7_);
- *result = _tmp4_;
+ Foo _tmp0_;
+ GVariantIter _tmp1_;
+ GVariant* _tmp2_;
+ GVariant* _tmp3_;
+ g_variant_iter_init (&_tmp1_, value);
+ _tmp2_ = g_variant_iter_next_value (&_tmp1_);
+ _tmp0_.a = g_variant_get_int32 (_tmp2_);
+ g_variant_unref (_tmp2_);
+ _tmp3_ = g_variant_iter_next_value (&_tmp1_);
+ _tmp0_.b = g_variant_get_int32 (_tmp3_);
+ g_variant_unref (_tmp3_);
+ *result = _tmp0_;
}
static void
@@ -107,8 +107,8 @@ _vala_main (void)
GVariant* _tmp2_;
Foo b = {0};
Foo _tmp3_;
- Foo _tmp8_;
- Foo _tmp9_;
+ Foo _tmp4_;
+ Foo _tmp5_;
memset (&_tmp0_, 0, sizeof (Foo));
_tmp0_.a = 2;
_tmp0_.b = 3;
@@ -116,10 +116,10 @@ _vala_main (void)
a = _tmp2_;
_variant_get1 (a, &_tmp3_);
b = _tmp3_;
- _tmp8_ = b;
- _vala_assert (_tmp8_.a == 2, "b.a == 2");
- _tmp9_ = b;
- _vala_assert (_tmp9_.b == 3, "b.b == 3");
+ _tmp4_ = b;
+ _vala_assert (_tmp4_.a == 2, "b.a == 2");
+ _tmp5_ = b;
+ _vala_assert (_tmp5_.b == 3, "b.b == 3");
_g_variant_unref0 (a);
}
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
