« back to all changes in this revision
Viewing changes to vala/valamethod.c
- browse files at revision 47
- compare with another revision
- download diff
- download tarball
- view history from revision 47
- Committer: Bazaar Package Importer
- Author(s): Robert Ancell
- Date: 2011-03-17 09:35:15 UTC
- mfrom: (1.5.17 upstream)
- Revision ID: james.westby@ubuntu.com-20110317093515-veyqriw9egujkws2
Tags: 0.11.7-0ubuntu1
New upstream release
- files modified:
- .tarball-version
added
removed
vala/valamethod.c
1161
1161
gboolean (*is_instance_member) (ValaSymbol* self);
1162
1162
gboolean (*is_class_member) (ValaSymbol* self);
1163
1163
void (*process_deprecated_attribute) (ValaSymbol* self, ValaAttribute* attr);
1164
void (*process_experimental_attribute) (ValaSymbol* self, ValaAttribute* attr);
1164
1165
void (*add_namespace) (ValaSymbol* self, ValaNamespace* ns);
1165
1166
void (*add_class) (ValaSymbol* self, ValaClass* cl);
1166
1167
void (*add_interface) (ValaSymbol* self, ValaInterface* iface);
1563
1564
void vala_report_warning (ValaSourceReference* source, const gchar* message);
1564
1565
ValaSourceReference* vala_code_node_get_source_reference (ValaCodeNode* self);
1565
1566
void vala_symbol_process_deprecated_attribute (ValaSymbol* self, ValaAttribute* attr);
1567
void vala_symbol_process_experimental_attribute (ValaSymbol* self, ValaAttribute* attr);
1566
1568
gboolean vala_method_compatible (ValaMethod* self, ValaMethod* base_method, gchar** invalid_match);
1567
1569
ValaMemberBinding vala_method_get_binding (ValaMethod* self);
1568
1570
GType vala_reference_type_get_type (void) G_GNUC_CONST;
2073
2075
*/
2074
2076
gchar* vala_method_get_cname (ValaMethod* self) {
2075
2077
gchar* result = NULL;
2076
gchar* _tmp2_;
2078
gchar* _tmp1_;
2077
2079
g_return_val_if_fail (self != NULL, NULL);
2078
2080
if (self->priv->cname == NULL) {
2079
2081
gchar* _tmp0_ = NULL;
2080
gchar* _tmp1_;
2081
2082
_tmp0_ = vala_method_get_default_cname (self);
2082
_tmp1_ = _tmp0_;
2083
2083
_g_free0 (self->priv->cname);
2084
self->priv->cname = _tmp1_;
2084
self->priv->cname = _tmp0_;
2085
2085
}
2086
_tmp2_ = g_strdup (self->priv->cname);
2087
result = _tmp2_;
2086
_tmp1_ = g_strdup (self->priv->cname);
2087
result = _tmp1_;
2088
2088
return result;
2089
2089
}
2090
2090
2091
2091
2092
2092
gchar* vala_method_get_finish_cname (ValaMethod* self) {
2093
2093
gchar* result = NULL;
2094
gchar* _tmp2_;
2094
gchar* _tmp1_;
2095
2095
g_return_val_if_fail (self != NULL, NULL);
2096
2096
g_assert (self->priv->_coroutine);
2097
2097
if (self->priv->finish_name == NULL) {
2098
2098
gchar* _tmp0_ = NULL;
2099
gchar* _tmp1_;
2100
2099
_tmp0_ = vala_method_get_default_finish_cname (self);
2101
_tmp1_ = _tmp0_;
2102
2100
_g_free0 (self->priv->finish_name);
2103
self->priv->finish_name = _tmp1_;
2101
self->priv->finish_name = _tmp0_;
2104
2102
}
2105
_tmp2_ = g_strdup (self->priv->finish_name);
2106
result = _tmp2_;
2103
_tmp1_ = g_strdup (self->priv->finish_name);
2104
result = _tmp1_;
2107
2105
return result;
2108
2106
}
2109
2107
2110
2108
2111
2109
void vala_method_set_finish_cname (ValaMethod* self, const gchar* name) {
2112
2110
gchar* _tmp0_;
2113
gchar* _tmp1_;
2114
2111
g_return_if_fail (self != NULL);
2115
2112
g_return_if_fail (name != NULL);
2116
2113
_tmp0_ = g_strdup (name);
2117
_tmp1_ = _tmp0_;
2118
2114
_g_free0 (self->priv->finish_name);
2119
self->priv->finish_name = _tmp1_;
2115
self->priv->finish_name = _tmp0_;
2120
2116
}
2121
2117
2122
2118
2126
2122
*
2127
2123
* @return the name to be used in C code by default
2128
2124
*/
2125
static glong string_strnlen (gchar* str, glong maxlen) {
2126
glong result = 0L;
2127
gchar* _tmp0_ = NULL;
2128
gchar* end;
2129
_tmp0_ = memchr (str, 0, (gsize) maxlen);
2130
end = _tmp0_;
2131
if (end == NULL) {
2132
result = maxlen;
2133
return result;
2134
} else {
2135
result = (glong) (end - str);
2136
return result;
2137
}
2138
}
2139
2140
2129
2141
static gchar* string_substring (const gchar* self, glong offset, glong len) {
2130
2142
gchar* result = NULL;
2131
2143
glong string_length = 0L;
2139
2151
}
2140
2152
if (_tmp0_) {
2141
2153
glong _tmp1_;
2142
_tmp1_ = strnlen ((gchar*) self, (gsize) (offset + len));
2154
_tmp1_ = string_strnlen ((gchar*) self, offset + len);
2143
2155
string_length = _tmp1_;
2144
2156
} else {
2145
2157
gint _tmp2_;
2203
2215
_tmp11_ = string_substring (_tmp10_, (glong) 1, (glong) (-1));
2204
2216
_tmp12_ = _tmp11_;
2205
2217
_tmp13_ = g_strdup_printf ("_%s%s", _tmp9_, _tmp12_);
2206
result = (_tmp14_ = _tmp13_, _g_free0 (_tmp12_), _g_free0 (_tmp9_), _tmp14_);
2218
_tmp14_ = _tmp13_;
2219
_g_free0 (_tmp12_);
2220
_g_free0 (_tmp9_);
2221
result = _tmp14_;
2207
2222
return result;
2208
2223
} else {
2209
2224
ValaSymbol* _tmp15_ = NULL;
2217
2232
_tmp17_ = _tmp16_;
2218
2233
_tmp18_ = vala_symbol_get_name ((ValaSymbol*) self);
2219
2234
_tmp19_ = g_strdup_printf ("%s%s", _tmp17_, _tmp18_);
2220
result = (_tmp20_ = _tmp19_, _g_free0 (_tmp17_), _tmp20_);
2235
_tmp20_ = _tmp19_;
2236
_g_free0 (_tmp17_);
2237
result = _tmp20_;
2221
2238
return result;
2222
2239
}
2223
2240
}
2260
2277
_tmp5_ = _tmp4_;
2261
2278
_tmp6_ = vala_symbol_get_name ((ValaSymbol*) self);
2262
2279
_tmp7_ = g_strdup_printf ("%sreal_%s", _tmp5_, _tmp6_);
2263
result = (_tmp8_ = _tmp7_, _g_free0 (_tmp5_), _tmp8_);
2280
_tmp8_ = _tmp7_;
2281
_g_free0 (_tmp5_);
2282
result = _tmp8_;
2264
2283
return result;
2265
2284
} else {
2266
2285
gchar* _tmp9_ = NULL;
2281
2300
gchar* _tmp0_;
2282
2301
gchar* _result_;
2283
2302
gboolean _tmp1_;
2284
gchar* _tmp6_;
2303
gchar* _tmp5_;
2285
2304
g_return_val_if_fail (self != NULL, NULL);
2286
2305
g_return_val_if_fail (basename != NULL, NULL);
2287
2306
_tmp0_ = g_strdup (basename);
2291
2310
gint _tmp2_;
2292
2311
gint _tmp3_;
2293
2312
gchar* _tmp4_ = NULL;
2294
gchar* _tmp5_;
2295
2313
_tmp2_ = strlen (_result_);
2296
2314
_tmp3_ = strlen ("_async");
2297
2315
_tmp4_ = string_substring (_result_, (glong) 0, (glong) (_tmp2_ - _tmp3_));
2298
_tmp5_ = _tmp4_;
2299
2316
_g_free0 (_result_);
2300
_result_ = _tmp5_;
2317
_result_ = _tmp4_;
2301
2318
}
2302
_tmp6_ = g_strconcat (_result_, "_finish", NULL);
2319
_tmp5_ = g_strconcat (_result_, "_finish", NULL);
2303
2320
_g_free0 (_result_);
2304
_result_ = _tmp6_;
2321
_result_ = _tmp5_;
2305
2322
result = _result_;
2306
2323
return result;
2307
2324
}
2318
2335
_tmp0_ = vala_method_get_real_cname (self);
2319
2336
_tmp1_ = _tmp0_;
2320
2337
_tmp2_ = vala_method_get_finish_name_for_basename (self, _tmp1_);
2321
result = (_tmp3_ = _tmp2_, _g_free0 (_tmp1_), _tmp3_);
2338
_tmp3_ = _tmp2_;
2339
_g_free0 (_tmp1_);
2340
result = _tmp3_;
2322
2341
return result;
2323
2342
}
2324
2343
2346
2365
_tmp0_ = vala_method_get_cname (self);
2347
2366
_tmp1_ = _tmp0_;
2348
2367
_tmp2_ = vala_method_get_finish_name_for_basename (self, _tmp1_);
2349
result = (_tmp3_ = _tmp2_, _g_free0 (_tmp1_), _tmp3_);
2368
_tmp3_ = _tmp2_;
2369
_g_free0 (_tmp1_);
2370
result = _tmp3_;
2350
2371
return result;
2351
2372
}
2352
2373
2358
2379
*/
2359
2380
void vala_method_set_cname (ValaMethod* self, const gchar* cname) {
2360
2381
gchar* _tmp0_;
2361
gchar* _tmp1_;
2362
2382
g_return_if_fail (self != NULL);
2363
2383
g_return_if_fail (cname != NULL);
2364
2384
_tmp0_ = g_strdup (cname);
2365
_tmp1_ = _tmp0_;
2366
2385
_g_free0 (self->priv->cname);
2367
self->priv->cname = _tmp1_;
2386
self->priv->cname = _tmp0_;
2368
2387
}
2369
2388
2370
2389
2373
2392
gboolean _tmp3_;
2374
2393
gboolean _tmp8_;
2375
2394
gboolean _tmp11_;
2376
gboolean _tmp14_;
2377
gboolean _tmp17_;
2378
gboolean _tmp19_;
2379
gboolean _tmp21_;
2380
gboolean _tmp24_;
2381
gboolean _tmp26_;
2382
gboolean _tmp28_;
2383
gboolean _tmp30_;
2384
gboolean _tmp32_;
2385
gboolean _tmp34_;
2386
gboolean _tmp36_;
2387
gboolean _tmp38_;
2395
gboolean _tmp13_;
2396
gboolean _tmp16_;
2397
gboolean _tmp18_;
2398
gboolean _tmp20_;
2399
gboolean _tmp23_;
2400
gboolean _tmp25_;
2401
gboolean _tmp27_;
2402
gboolean _tmp29_;
2403
gboolean _tmp31_;
2404
gboolean _tmp33_;
2405
gboolean _tmp35_;
2406
gboolean _tmp37_;
2388
2407
g_return_if_fail (self != NULL);
2389
2408
g_return_if_fail (a != NULL);
2390
2409
_tmp0_ = vala_attribute_has_argument (a, "cname");
2437
2456
_tmp11_ = vala_attribute_has_argument (a, "finish_name");
2438
2457
if (_tmp11_) {
2439
2458
gchar* _tmp12_ = NULL;
2440
gchar* _tmp13_;
2441
2459
_tmp12_ = vala_attribute_get_string (a, "finish_name");
2442
_tmp13_ = _tmp12_;
2443
2460
_g_free0 (self->priv->finish_name);
2444
self->priv->finish_name = _tmp13_;
2445
}
2446
_tmp14_ = vala_attribute_has_argument (a, "sentinel");
2447
if (_tmp14_) {
2448
gchar* _tmp15_ = NULL;
2449
gchar* _tmp16_;
2450
_tmp15_ = vala_attribute_get_string (a, "sentinel");
2451
_tmp16_ = _tmp15_;
2452
vala_method_set_sentinel (self, _tmp16_);
2453
_g_free0 (_tmp16_);
2454
}
2455
_tmp17_ = vala_attribute_has_argument (a, "instance_pos");
2456
if (_tmp17_) {
2457
gdouble _tmp18_;
2458
_tmp18_ = vala_attribute_get_double (a, "instance_pos");
2459
vala_method_set_cinstance_parameter_position (self, _tmp18_);
2460
}
2461
_tmp19_ = vala_attribute_has_argument (a, "array_length");
2462
if (_tmp19_) {
2463
gboolean _tmp20_;
2464
_tmp20_ = vala_attribute_get_bool (a, "array_length");
2465
vala_method_set_no_array_length (self, !_tmp20_);
2466
}
2467
_tmp21_ = vala_attribute_has_argument (a, "array_length_type");
2468
if (_tmp21_) {
2469
gchar* _tmp22_ = NULL;
2470
gchar* _tmp23_;
2471
_tmp22_ = vala_attribute_get_string (a, "array_length_type");
2472
_tmp23_ = _tmp22_;
2473
vala_method_set_array_length_type (self, _tmp23_);
2474
_g_free0 (_tmp23_);
2475
}
2476
_tmp24_ = vala_attribute_has_argument (a, "array_null_terminated");
2477
if (_tmp24_) {
2478
gboolean _tmp25_;
2479
_tmp25_ = vala_attribute_get_bool (a, "array_null_terminated");
2480
vala_method_set_array_null_terminated (self, _tmp25_);
2481
}
2482
_tmp26_ = vala_attribute_has_argument (a, "array_length_pos");
2483
if (_tmp26_) {
2484
gdouble _tmp27_;
2485
_tmp27_ = vala_attribute_get_double (a, "array_length_pos");
2486
vala_method_set_carray_length_parameter_position (self, _tmp27_);
2487
}
2488
_tmp28_ = vala_attribute_has_argument (a, "delegate_target_pos");
2489
if (_tmp28_) {
2490
gdouble _tmp29_;
2491
_tmp29_ = vala_attribute_get_double (a, "delegate_target_pos");
2492
vala_method_set_cdelegate_target_parameter_position (self, _tmp29_);
2493
}
2494
_tmp30_ = vala_attribute_has_argument (a, "has_new_function");
2495
if (_tmp30_) {
2496
gboolean _tmp31_;
2497
_tmp31_ = vala_attribute_get_bool (a, "has_new_function");
2498
vala_method_set_has_new_function (self, _tmp31_);
2499
}
2500
_tmp32_ = vala_attribute_has_argument (a, "has_construct_function");
2501
if (_tmp32_) {
2502
gboolean _tmp33_;
2503
_tmp33_ = vala_attribute_get_bool (a, "has_construct_function");
2504
vala_method_set_has_construct_function (self, _tmp33_);
2505
}
2506
_tmp34_ = vala_attribute_has_argument (a, "generic_type_pos");
2507
if (_tmp34_) {
2508
gdouble _tmp35_;
2461
self->priv->finish_name = _tmp12_;
2462
}
2463
_tmp13_ = vala_attribute_has_argument (a, "sentinel");
2464
if (_tmp13_) {
2465
gchar* _tmp14_ = NULL;
2466
gchar* _tmp15_;
2467
_tmp14_ = vala_attribute_get_string (a, "sentinel");
2468
_tmp15_ = _tmp14_;
2469
vala_method_set_sentinel (self, _tmp15_);
2470
_g_free0 (_tmp15_);
2471
}
2472
_tmp16_ = vala_attribute_has_argument (a, "instance_pos");
2473
if (_tmp16_) {
2474
gdouble _tmp17_;
2475
_tmp17_ = vala_attribute_get_double (a, "instance_pos");
2476
vala_method_set_cinstance_parameter_position (self, _tmp17_);
2477
}
2478
_tmp18_ = vala_attribute_has_argument (a, "array_length");
2479
if (_tmp18_) {
2480
gboolean _tmp19_;
2481
_tmp19_ = vala_attribute_get_bool (a, "array_length");
2482
vala_method_set_no_array_length (self, !_tmp19_);
2483
}
2484
_tmp20_ = vala_attribute_has_argument (a, "array_length_type");
2485
if (_tmp20_) {
2486
gchar* _tmp21_ = NULL;
2487
gchar* _tmp22_;
2488
_tmp21_ = vala_attribute_get_string (a, "array_length_type");
2489
_tmp22_ = _tmp21_;
2490
vala_method_set_array_length_type (self, _tmp22_);
2491
_g_free0 (_tmp22_);
2492
}
2493
_tmp23_ = vala_attribute_has_argument (a, "array_null_terminated");
2494
if (_tmp23_) {
2495
gboolean _tmp24_;
2496
_tmp24_ = vala_attribute_get_bool (a, "array_null_terminated");
2497
vala_method_set_array_null_terminated (self, _tmp24_);
2498
}
2499
_tmp25_ = vala_attribute_has_argument (a, "array_length_pos");
2500
if (_tmp25_) {
2501
gdouble _tmp26_;
2502
_tmp26_ = vala_attribute_get_double (a, "array_length_pos");
2503
vala_method_set_carray_length_parameter_position (self, _tmp26_);
2504
}
2505
_tmp27_ = vala_attribute_has_argument (a, "delegate_target_pos");
2506
if (_tmp27_) {
2507
gdouble _tmp28_;
2508
_tmp28_ = vala_attribute_get_double (a, "delegate_target_pos");
2509
vala_method_set_cdelegate_target_parameter_position (self, _tmp28_);
2510
}
2511
_tmp29_ = vala_attribute_has_argument (a, "has_new_function");
2512
if (_tmp29_) {
2513
gboolean _tmp30_;
2514
_tmp30_ = vala_attribute_get_bool (a, "has_new_function");
2515
vala_method_set_has_new_function (self, _tmp30_);
2516
}
2517
_tmp31_ = vala_attribute_has_argument (a, "has_construct_function");
2518
if (_tmp31_) {
2519
gboolean _tmp32_;
2520
_tmp32_ = vala_attribute_get_bool (a, "has_construct_function");
2521
vala_method_set_has_construct_function (self, _tmp32_);
2522
}
2523
_tmp33_ = vala_attribute_has_argument (a, "generic_type_pos");
2524
if (_tmp33_) {
2525
gdouble _tmp34_;
2509
2526
vala_method_set_has_generic_type_parameter (self, TRUE);
2510
_tmp35_ = vala_attribute_get_double (a, "generic_type_pos");
2511
vala_method_set_generic_type_parameter_position (self, _tmp35_);
2512
}
2513
_tmp36_ = vala_attribute_has_argument (a, "simple_generics");
2514
if (_tmp36_) {
2515
gboolean _tmp37_;
2516
_tmp37_ = vala_attribute_get_bool (a, "simple_generics");
2517
vala_method_set_simple_generics (self, _tmp37_);
2518
}
2519
_tmp38_ = vala_attribute_has_argument (a, "returns_floating_reference");
2520
if (_tmp38_) {
2521
gboolean _tmp39_;
2522
_tmp39_ = vala_attribute_get_bool (a, "returns_floating_reference");
2523
vala_method_set_returns_floating_reference (self, _tmp39_);
2527
_tmp34_ = vala_attribute_get_double (a, "generic_type_pos");
2528
vala_method_set_generic_type_parameter_position (self, _tmp34_);
2529
}
2530
_tmp35_ = vala_attribute_has_argument (a, "simple_generics");
2531
if (_tmp35_) {
2532
gboolean _tmp36_;
2533
_tmp36_ = vala_attribute_get_bool (a, "simple_generics");
2534
vala_method_set_simple_generics (self, _tmp36_);
2535
}
2536
_tmp37_ = vala_attribute_has_argument (a, "returns_floating_reference");
2537
if (_tmp37_) {
2538
gboolean _tmp38_;
2539
_tmp38_ = vala_attribute_get_bool (a, "returns_floating_reference");
2540
vala_method_set_returns_floating_reference (self, _tmp38_);
2524
2541
}
2525
2542
}
2526
2543
2595
2612
_tmp12_ = _tmp11_;
2596
2613
vala_collection_clear ((ValaCollection*) _tmp12_);
2597
2614
_vala_iterable_unref0 (_tmp12_);
2615
} else {
2616
const gchar* _tmp13_ = NULL;
2617
_tmp13_ = vala_attribute_get_name (a);
2618
if (g_strcmp0 (_tmp13_, "Experimental") == 0) {
2619
vala_symbol_process_experimental_attribute ((ValaSymbol*) self, a);
2620
}
2598
2621
}
2599
2622
}
2600
2623
}
2622
2645
gchar* _invalid_match = NULL;
2623
2646
gboolean result = FALSE;
2624
2647
ValaObjectType* object_type;
2625
ValaSymbol* _tmp2_ = NULL;
2648
ValaSymbol* _tmp1_ = NULL;
2649
ValaDataType* _tmp9_ = NULL;
2650
ValaDataType* _tmp10_ = NULL;
2651
ValaDataType* actual_base_type;
2626
2652
ValaDataType* _tmp11_ = NULL;
2627
ValaDataType* _tmp12_ = NULL;
2628
ValaDataType* actual_base_type;
2629
ValaDataType* _tmp13_ = NULL;
2630
gboolean _tmp14_;
2631
ValaIterator* _tmp17_ = NULL;
2653
gboolean _tmp12_;
2654
ValaIterator* _tmp14_ = NULL;
2632
2655
ValaIterator* method_params_it;
2633
2656
gint param_index;
2634
gboolean _tmp37_;
2657
gboolean _tmp30_;
2635
2658
g_return_val_if_fail (self != NULL, FALSE);
2636
2659
g_return_val_if_fail (base_method != NULL, FALSE);
2637
2660
if (self->priv->_binding != base_method->priv->_binding) {
2638
2661
gchar* _tmp0_;
2639
gchar* _tmp1_;
2640
2662
_tmp0_ = g_strdup ("incompatible binding");
2641
_tmp1_ = _tmp0_;
2642
2663
_g_free0 (_invalid_match);
2643
_invalid_match = _tmp1_;
2664
_invalid_match = _tmp0_;
2644
2665
result = FALSE;
2645
2666
if (invalid_match) {
2646
2667
*invalid_match = _invalid_match;
2650
2671
return result;
2651
2672
}
2652
2673
object_type = NULL;
2653
_tmp2_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self);
2654
if (VALA_IS_OBJECT_TYPE_SYMBOL (_tmp2_)) {
2655
ValaSymbol* _tmp3_ = NULL;
2656
ValaObjectType* _tmp4_ = NULL;
2657
ValaObjectType* _tmp5_;
2658
_tmp3_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self);
2659
_tmp4_ = vala_object_type_new (VALA_OBJECT_TYPE_SYMBOL (_tmp3_));
2660
_tmp5_ = _tmp4_;
2674
_tmp1_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self);
2675
if (VALA_IS_OBJECT_TYPE_SYMBOL (_tmp1_)) {
2676
ValaSymbol* _tmp2_ = NULL;
2677
ValaObjectType* _tmp3_ = NULL;
2678
_tmp2_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self);
2679
_tmp3_ = vala_object_type_new (VALA_OBJECT_TYPE_SYMBOL (_tmp2_));
2661
2680
_vala_code_node_unref0 (object_type);
2662
object_type = _tmp5_;
2681
object_type = _tmp3_;
2663
2682
{
2664
ValaObjectTypeSymbol* _tmp6_ = NULL;
2665
ValaList* _tmp7_ = NULL;
2683
ValaObjectTypeSymbol* _tmp4_ = NULL;
2684
ValaList* _tmp5_ = NULL;
2666
2685
ValaList* _type_parameter_list;
2667
gint _tmp8_;
2686
gint _tmp6_;
2668
2687
gint _type_parameter_size;
2669
2688
gint _type_parameter_index;
2670
_tmp6_ = vala_object_type_get_type_symbol (object_type);
2671
_tmp7_ = vala_object_type_symbol_get_type_parameters (_tmp6_);
2672
_type_parameter_list = _tmp7_;
2673
_tmp8_ = vala_collection_get_size ((ValaCollection*) _type_parameter_list);
2674
_type_parameter_size = _tmp8_;
2689
_tmp4_ = vala_object_type_get_type_symbol (object_type);
2690
_tmp5_ = vala_object_type_symbol_get_type_parameters (_tmp4_);
2691
_type_parameter_list = _tmp5_;
2692
_tmp6_ = vala_collection_get_size ((ValaCollection*) _type_parameter_list);
2693
_type_parameter_size = _tmp6_;
2675
2694
_type_parameter_index = -1;
2676
2695
while (TRUE) {
2677
gpointer _tmp9_ = NULL;
2696
gpointer _tmp7_ = NULL;
2678
2697
ValaTypeParameter* type_parameter;
2679
ValaGenericType* _tmp10_ = NULL;
2698
ValaGenericType* _tmp8_ = NULL;
2680
2699
ValaGenericType* type_arg;
2681
2700
_type_parameter_index = _type_parameter_index + 1;
2682
2701
if (!(_type_parameter_index < _type_parameter_size)) {
2683
2702
break;
2684
2703
}
2685
_tmp9_ = vala_list_get (_type_parameter_list, _type_parameter_index);
2686
type_parameter = (ValaTypeParameter*) _tmp9_;
2687
_tmp10_ = vala_generic_type_new (type_parameter);
2688
type_arg = _tmp10_;
2704
_tmp7_ = vala_list_get (_type_parameter_list, _type_parameter_index);
2705
type_parameter = (ValaTypeParameter*) _tmp7_;
2706
_tmp8_ = vala_generic_type_new (type_parameter);
2707
type_arg = _tmp8_;
2689
2708
vala_data_type_set_value_owned ((ValaDataType*) type_arg, TRUE);
2690
2709
vala_data_type_add_type_argument ((ValaDataType*) object_type, (ValaDataType*) type_arg);
2691
2710
_vala_code_node_unref0 (type_arg);
2694
2713
_vala_iterable_unref0 (_type_parameter_list);
2695
2714
}
2696
2715
}
2697
_tmp11_ = vala_method_get_return_type (base_method);
2698
_tmp12_ = vala_data_type_get_actual_type (_tmp11_, (ValaDataType*) object_type, NULL, (ValaCodeNode*) self);
2699
actual_base_type = _tmp12_;
2700
_tmp13_ = vala_method_get_return_type (self);
2701
_tmp14_ = vala_data_type_equals (_tmp13_, actual_base_type);
2702
if (!_tmp14_) {
2703
gchar* _tmp15_;
2704
gchar* _tmp16_;
2705
_tmp15_ = g_strdup ("incompatible return type");
2706
_tmp16_ = _tmp15_;
2716
_tmp9_ = vala_method_get_return_type (base_method);
2717
_tmp10_ = vala_data_type_get_actual_type (_tmp9_, (ValaDataType*) object_type, NULL, (ValaCodeNode*) self);
2718
actual_base_type = _tmp10_;
2719
_tmp11_ = vala_method_get_return_type (self);
2720
_tmp12_ = vala_data_type_equals (_tmp11_, actual_base_type);
2721
if (!_tmp12_) {
2722
gchar* _tmp13_;
2723
_tmp13_ = g_strdup ("incompatible return type");
2707
2724
_g_free0 (_invalid_match);
2708
_invalid_match = _tmp16_;
2725
_invalid_match = _tmp13_;
2709
2726
result = FALSE;
2710
2727
_vala_code_node_unref0 (actual_base_type);
2711
2728
_vala_code_node_unref0 (object_type);
2716
2733
}
2717
2734
return result;
2718
2735
}
2719
_tmp17_ = vala_iterable_iterator ((ValaIterable*) self->priv->parameters);
2720
method_params_it = _tmp17_;
2736
_tmp14_ = vala_iterable_iterator ((ValaIterable*) self->priv->parameters);
2737
method_params_it = _tmp14_;
2721
2738
param_index = 1;
2722
2739
{
2723
ValaList* _tmp18_;
2740
ValaList* _tmp15_;
2724
2741
ValaList* _base_param_list;
2725
gint _tmp19_;
2742
gint _tmp16_;
2726
2743
gint _base_param_size;
2727
2744
gint _base_param_index;
2728
_tmp18_ = _vala_iterable_ref0 (base_method->priv->parameters);
2729
_base_param_list = _tmp18_;
2730
_tmp19_ = vala_collection_get_size ((ValaCollection*) _base_param_list);
2731
_base_param_size = _tmp19_;
2745
_tmp15_ = _vala_iterable_ref0 (base_method->priv->parameters);
2746
_base_param_list = _tmp15_;
2747
_tmp16_ = vala_collection_get_size ((ValaCollection*) _base_param_list);
2748
_base_param_size = _tmp16_;
2732
2749
_base_param_index = -1;
2733
2750
while (TRUE) {
2751
gpointer _tmp17_ = NULL;
2752
ValaParameter* base_param;
2753
gboolean _tmp18_;
2734
2754
gpointer _tmp20_ = NULL;
2735
ValaParameter* base_param;
2755
ValaParameter* param;
2736
2756
gboolean _tmp21_;
2737
gpointer _tmp24_ = NULL;
2738
ValaParameter* param;
2739
gboolean _tmp25_;
2740
gboolean _tmp26_;
2741
gboolean _tmp29_;
2757
gboolean _tmp22_;
2758
gboolean _tmp24_;
2742
2759
_base_param_index = _base_param_index + 1;
2743
2760
if (!(_base_param_index < _base_param_size)) {
2744
2761
break;
2745
2762
}
2746
_tmp20_ = vala_list_get (_base_param_list, _base_param_index);
2747
base_param = (ValaParameter*) _tmp20_;
2748
_tmp21_ = vala_iterator_next (method_params_it);
2749
if (!_tmp21_) {
2750
gchar* _tmp22_;
2763
_tmp17_ = vala_list_get (_base_param_list, _base_param_index);
2764
base_param = (ValaParameter*) _tmp17_;
2765
_tmp18_ = vala_iterator_next (method_params_it);
2766
if (!_tmp18_) {
2767
gchar* _tmp19_;
2768
_tmp19_ = g_strdup ("too few parameters");
2769
_g_free0 (_invalid_match);
2770
_invalid_match = _tmp19_;
2771
result = FALSE;
2772
_vala_code_node_unref0 (base_param);
2773
_vala_iterable_unref0 (_base_param_list);
2774
_vala_iterator_unref0 (method_params_it);
2775
_vala_code_node_unref0 (actual_base_type);
2776
_vala_code_node_unref0 (object_type);
2777
if (invalid_match) {
2778
*invalid_match = _invalid_match;
2779
} else {
2780
_g_free0 (_invalid_match);
2781
}
2782
return result;
2783
}
2784
_tmp20_ = vala_iterator_get (method_params_it);
2785
param = (ValaParameter*) _tmp20_;
2786
_tmp21_ = vala_parameter_get_ellipsis (base_param);
2787
_tmp22_ = vala_parameter_get_ellipsis (param);
2788
if (_tmp21_ != _tmp22_) {
2751
2789
gchar* _tmp23_;
2752
_tmp22_ = g_strdup ("too few parameters");
2753
_tmp23_ = _tmp22_;
2790
_tmp23_ = g_strdup ("ellipsis parameter mismatch");
2754
2791
_g_free0 (_invalid_match);
2755
2792
_invalid_match = _tmp23_;
2756
2793
result = FALSE;
2757
_vala_code_node_unref0 (base_param);
2758
_vala_iterable_unref0 (_base_param_list);
2759
_vala_iterator_unref0 (method_params_it);
2760
_vala_code_node_unref0 (actual_base_type);
2761
_vala_code_node_unref0 (object_type);
2762
if (invalid_match) {
2763
*invalid_match = _invalid_match;
2764
} else {
2765
_g_free0 (_invalid_match);
2766
}
2767
return result;
2768
}
2769
_tmp24_ = vala_iterator_get (method_params_it);
2770
param = (ValaParameter*) _tmp24_;
2771
_tmp25_ = vala_parameter_get_ellipsis (base_param);
2772
_tmp26_ = vala_parameter_get_ellipsis (param);
2773
if (_tmp25_ != _tmp26_) {
2774
gchar* _tmp27_;
2775
gchar* _tmp28_;
2776
_tmp27_ = g_strdup ("ellipsis parameter mismatch");
2777
_tmp28_ = _tmp27_;
2778
_g_free0 (_invalid_match);
2779
_invalid_match = _tmp28_;
2780
result = FALSE;
2781
2794
_vala_code_node_unref0 (param);
2782
2795
_vala_code_node_unref0 (base_param);
2783
2796
_vala_iterable_unref0 (_base_param_list);
2791
2804
}
2792
2805
return result;
2793
2806
}
2794
_tmp29_ = vala_parameter_get_ellipsis (base_param);
2795
if (!_tmp29_) {
2796
ValaDataType* _tmp30_ = NULL;
2797
ValaDataType* _tmp31_ = NULL;
2798
ValaDataType* _tmp32_;
2799
ValaDataType* _tmp33_ = NULL;
2800
gboolean _tmp34_;
2801
_tmp30_ = vala_variable_get_variable_type ((ValaVariable*) base_param);
2802
_tmp31_ = vala_data_type_get_actual_type (_tmp30_, (ValaDataType*) object_type, NULL, (ValaCodeNode*) self);
2803
_tmp32_ = _tmp31_;
2807
_tmp24_ = vala_parameter_get_ellipsis (base_param);
2808
if (!_tmp24_) {
2809
ValaDataType* _tmp25_ = NULL;
2810
ValaDataType* _tmp26_ = NULL;
2811
ValaDataType* _tmp27_ = NULL;
2812
gboolean _tmp28_;
2813
_tmp25_ = vala_variable_get_variable_type ((ValaVariable*) base_param);
2814
_tmp26_ = vala_data_type_get_actual_type (_tmp25_, (ValaDataType*) object_type, NULL, (ValaCodeNode*) self);
2804
2815
_vala_code_node_unref0 (actual_base_type);
2805
actual_base_type = _tmp32_;
2806
_tmp33_ = vala_variable_get_variable_type ((ValaVariable*) param);
2807
_tmp34_ = vala_data_type_equals (actual_base_type, _tmp33_);
2808
if (!_tmp34_) {
2809
gchar* _tmp35_ = NULL;
2810
gchar* _tmp36_;
2811
_tmp35_ = g_strdup_printf ("incompatible type of parameter %d", param_index);
2812
_tmp36_ = _tmp35_;
2816
actual_base_type = _tmp26_;
2817
_tmp27_ = vala_variable_get_variable_type ((ValaVariable*) param);
2818
_tmp28_ = vala_data_type_equals (actual_base_type, _tmp27_);
2819
if (!_tmp28_) {
2820
gchar* _tmp29_ = NULL;
2821
_tmp29_ = g_strdup_printf ("incompatible type of parameter %d", param_index);
2813
2822
_g_free0 (_invalid_match);
2814
_invalid_match = _tmp36_;
2823
_invalid_match = _tmp29_;
2815
2824
result = FALSE;
2816
2825
_vala_code_node_unref0 (param);
2817
2826
_vala_code_node_unref0 (base_param);
2833
2842
}
2834
2843
_vala_iterable_unref0 (_base_param_list);
2835
2844
}
2836
_tmp37_ = vala_iterator_next (method_params_it);
2837
if (_tmp37_) {
2838
gchar* _tmp38_;
2839
gchar* _tmp39_;
2840
_tmp38_ = g_strdup ("too many parameters");
2841
_tmp39_ = _tmp38_;
2845
_tmp30_ = vala_iterator_next (method_params_it);
2846
if (_tmp30_) {
2847
gchar* _tmp31_;
2848
_tmp31_ = g_strdup ("too many parameters");
2842
2849
_g_free0 (_invalid_match);
2843
_invalid_match = _tmp39_;
2850
_invalid_match = _tmp31_;
2844
2851
result = FALSE;
2845
2852
_vala_iterator_unref0 (method_params_it);
2846
2853
_vala_code_node_unref0 (actual_base_type);
2853
2860
return result;
2854
2861
}
2855
2862
{
2856
ValaList* _tmp40_ = NULL;
2863
ValaList* _tmp32_ = NULL;
2857
2864
ValaList* _method_error_type_list;
2858
gint _tmp41_;
2865
gint _tmp33_;
2859
2866
gint _method_error_type_size;
2860
2867
gint _method_error_type_index;
2861
_tmp40_ = vala_code_node_get_error_types ((ValaCodeNode*) self);
2862
_method_error_type_list = _tmp40_;
2863
_tmp41_ = vala_collection_get_size ((ValaCollection*) _method_error_type_list);
2864
_method_error_type_size = _tmp41_;
2868
_tmp32_ = vala_code_node_get_error_types ((ValaCodeNode*) self);
2869
_method_error_type_list = _tmp32_;
2870
_tmp33_ = vala_collection_get_size ((ValaCollection*) _method_error_type_list);
2871
_method_error_type_size = _tmp33_;
2865
2872
_method_error_type_index = -1;
2866
2873
while (TRUE) {
2867
gpointer _tmp42_ = NULL;
2874
gpointer _tmp34_ = NULL;
2868
2875
ValaDataType* method_error_type;
2869
2876
gboolean match;
2870
2877
_method_error_type_index = _method_error_type_index + 1;
2871
2878
if (!(_method_error_type_index < _method_error_type_size)) {
2872
2879
break;
2873
2880
}
2874
_tmp42_ = vala_list_get (_method_error_type_list, _method_error_type_index);
2875
method_error_type = (ValaDataType*) _tmp42_;
2881
_tmp34_ = vala_list_get (_method_error_type_list, _method_error_type_index);
2882
method_error_type = (ValaDataType*) _tmp34_;
2876
2883
match = FALSE;
2877
2884
{
2878
ValaList* _tmp43_ = NULL;
2885
ValaList* _tmp35_ = NULL;
2879
2886
ValaList* _base_method_error_type_list;
2880
gint _tmp44_;
2887
gint _tmp36_;
2881
2888
gint _base_method_error_type_size;
2882
2889
gint _base_method_error_type_index;
2883
_tmp43_ = vala_code_node_get_error_types ((ValaCodeNode*) base_method);
2884
_base_method_error_type_list = _tmp43_;
2885
_tmp44_ = vala_collection_get_size ((ValaCollection*) _base_method_error_type_list);
2886
_base_method_error_type_size = _tmp44_;
2890
_tmp35_ = vala_code_node_get_error_types ((ValaCodeNode*) base_method);
2891
_base_method_error_type_list = _tmp35_;
2892
_tmp36_ = vala_collection_get_size ((ValaCollection*) _base_method_error_type_list);
2893
_base_method_error_type_size = _tmp36_;
2887
2894
_base_method_error_type_index = -1;
2888
2895
while (TRUE) {
2889
gpointer _tmp45_ = NULL;
2896
gpointer _tmp37_ = NULL;
2890
2897
ValaDataType* base_method_error_type;
2891
gboolean _tmp46_;
2898
gboolean _tmp38_;
2892
2899
_base_method_error_type_index = _base_method_error_type_index + 1;
2893
2900
if (!(_base_method_error_type_index < _base_method_error_type_size)) {
2894
2901
break;
2895
2902
}
2896
_tmp45_ = vala_list_get (_base_method_error_type_list, _base_method_error_type_index);
2897
base_method_error_type = (ValaDataType*) _tmp45_;
2898
_tmp46_ = vala_data_type_compatible (method_error_type, base_method_error_type);
2899
if (_tmp46_) {
2903
_tmp37_ = vala_list_get (_base_method_error_type_list, _base_method_error_type_index);
2904
base_method_error_type = (ValaDataType*) _tmp37_;
2905
_tmp38_ = vala_data_type_compatible (method_error_type, base_method_error_type);
2906
if (_tmp38_) {
2900
2907
match = TRUE;
2901
2908
_vala_code_node_unref0 (base_method_error_type);
2902
2909
break;
2906
2913
_vala_iterable_unref0 (_base_method_error_type_list);
2907
2914
}
2908
2915
if (!match) {
2909
gchar* _tmp47_ = NULL;
2910
gchar* _tmp48_;
2911
gchar* _tmp49_ = NULL;
2912
gchar* _tmp50_;
2913
_tmp47_ = vala_code_node_to_string ((ValaCodeNode*) method_error_type);
2914
_tmp48_ = _tmp47_;
2915
_tmp49_ = g_strdup_printf ("incompatible error type `%s'", _tmp48_);
2916
_tmp50_ = _tmp49_;
2916
gchar* _tmp39_ = NULL;
2917
gchar* _tmp40_;
2918
gchar* _tmp41_ = NULL;
2919
_tmp39_ = vala_code_node_to_string ((ValaCodeNode*) method_error_type);
2920
_tmp40_ = _tmp39_;
2921
_tmp41_ = g_strdup_printf ("incompatible error type `%s'", _tmp40_);
2917
2922
_g_free0 (_invalid_match);
2918
_invalid_match = _tmp50_;
2919
_g_free0 (_tmp48_);
2923
_invalid_match = _tmp41_;
2924
_g_free0 (_tmp40_);
2920
2925
result = FALSE;
2921
2926
_vala_code_node_unref0 (method_error_type);
2922
2927
_vala_iterable_unref0 (_method_error_type_list);
2935
2940
_vala_iterable_unref0 (_method_error_type_list);
2936
2941
}
2937
2942
if (base_method->priv->_coroutine != self->priv->_coroutine) {
2938
gchar* _tmp51_;
2939
gchar* _tmp52_;
2940
_tmp51_ = g_strdup ("async mismatch");
2941
_tmp52_ = _tmp51_;
2943
gchar* _tmp42_;
2944
_tmp42_ = g_strdup ("async mismatch");
2942
2945
_g_free0 (_invalid_match);
2943
_invalid_match = _tmp52_;
2946
_invalid_match = _tmp42_;
2944
2947
result = FALSE;
2945
2948
_vala_iterator_unref0 (method_params_it);
2946
2949
_vala_code_node_unref0 (actual_base_type);
2971
2974
* @param p a type parameter
2972
2975
*/
2973
2976
void vala_method_add_type_parameter (ValaMethod* self, ValaTypeParameter* p) {
2974
ValaScope* _tmp2_ = NULL;
2975
const gchar* _tmp3_ = NULL;
2977
ValaScope* _tmp1_ = NULL;
2978
const gchar* _tmp2_ = NULL;
2976
2979
g_return_if_fail (self != NULL);
2977
2980
g_return_if_fail (p != NULL);
2978
2981
if (self->priv->type_parameters == NULL) {
2979
2982
ValaArrayList* _tmp0_ = NULL;
2980
ValaList* _tmp1_;
2981
2983
_tmp0_ = vala_array_list_new (VALA_TYPE_TYPEPARAMETER, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, g_direct_equal);
2982
_tmp1_ = (ValaList*) _tmp0_;
2983
2984
_vala_iterable_unref0 (self->priv->type_parameters);
2984
self->priv->type_parameters = _tmp1_;
2985
self->priv->type_parameters = (ValaList*) _tmp0_;
2985
2986
}
2986
2987
vala_collection_add ((ValaCollection*) self->priv->type_parameters, p);
2987
_tmp2_ = vala_symbol_get_scope ((ValaSymbol*) self);
2988
_tmp3_ = vala_symbol_get_name ((ValaSymbol*) p);
2989
vala_scope_add (_tmp2_, _tmp3_, (ValaSymbol*) p);
2988
_tmp1_ = vala_symbol_get_scope ((ValaSymbol*) self);
2989
_tmp2_ = vala_symbol_get_name ((ValaSymbol*) p);
2990
vala_scope_add (_tmp1_, _tmp2_, (ValaSymbol*) p);
2990
2991
}
2991
2992
2992
2993
2997
2998
*/
2998
2999
ValaList* vala_method_get_type_parameters (ValaMethod* self) {
2999
3000
ValaList* result = NULL;
3000
ValaList* _tmp3_;
3001
ValaList* _tmp2_;
3001
3002
g_return_val_if_fail (self != NULL, NULL);
3002
3003
if (self->priv->type_parameters != NULL) {
3003
3004
ValaList* _tmp0_;
3007
3008
}
3008
3009
if (vala_method__empty_type_parameter_list == NULL) {
3009
3010
ValaArrayList* _tmp1_ = NULL;
3010
ValaList* _tmp2_;
3011
3011
_tmp1_ = vala_array_list_new (VALA_TYPE_TYPEPARAMETER, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, g_direct_equal);
3012
_tmp2_ = (ValaList*) _tmp1_;
3013
3012
_vala_iterable_unref0 (vala_method__empty_type_parameter_list);
3014
vala_method__empty_type_parameter_list = _tmp2_;
3013
vala_method__empty_type_parameter_list = (ValaList*) _tmp1_;
3015
3014
}
3016
_tmp3_ = _vala_iterable_ref0 (vala_method__empty_type_parameter_list);
3017
result = _tmp3_;
3015
_tmp2_ = _vala_iterable_ref0 (vala_method__empty_type_parameter_list);
3016
result = _tmp2_;
3018
3017
return result;
3019
3018
}
3020
3019
3077
3076
g_return_if_fail (precondition != NULL);
3078
3077
if (self->priv->preconditions == NULL) {
3079
3078
ValaArrayList* _tmp0_ = NULL;
3080
ValaList* _tmp1_;
3081
3079
_tmp0_ = vala_array_list_new (VALA_TYPE_EXPRESSION, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, g_direct_equal);
3082
_tmp1_ = (ValaList*) _tmp0_;
3083
3080
_vala_iterable_unref0 (self->priv->preconditions);
3084
self->priv->preconditions = _tmp1_;
3081
self->priv->preconditions = (ValaList*) _tmp0_;
3085
3082
}
3086
3083
vala_collection_add ((ValaCollection*) self->priv->preconditions, precondition);
3087
3084
vala_code_node_set_parent_node ((ValaCodeNode*) precondition, (ValaCodeNode*) self);
3095
3092
*/
3096
3093
ValaList* vala_method_get_preconditions (ValaMethod* self) {
3097
3094
ValaList* result = NULL;
3098
ValaList* _tmp3_;
3095
ValaList* _tmp2_;
3099
3096
g_return_val_if_fail (self != NULL, NULL);
3100
3097
if (self->priv->preconditions != NULL) {
3101
3098
ValaList* _tmp0_;
3105
3102
}
3106
3103
if (vala_method__empty_expression_list == NULL) {
3107
3104
ValaArrayList* _tmp1_ = NULL;
3108
ValaList* _tmp2_;
3109
3105
_tmp1_ = vala_array_list_new (VALA_TYPE_EXPRESSION, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, g_direct_equal);
3110
_tmp2_ = (ValaList*) _tmp1_;
3111
3106
_vala_iterable_unref0 (vala_method__empty_expression_list);
3112
vala_method__empty_expression_list = _tmp2_;
3107
vala_method__empty_expression_list = (ValaList*) _tmp1_;
3113
3108
}
3114
_tmp3_ = _vala_iterable_ref0 (vala_method__empty_expression_list);
3115
result = _tmp3_;
3109
_tmp2_ = _vala_iterable_ref0 (vala_method__empty_expression_list);
3110
result = _tmp2_;
3116
3111
return result;
3117
3112
}
3118
3113
3127
3122
g_return_if_fail (postcondition != NULL);
3128
3123
if (self->priv->postconditions == NULL) {
3129
3124
ValaArrayList* _tmp0_ = NULL;
3130
ValaList* _tmp1_;
3131
3125
_tmp0_ = vala_array_list_new (VALA_TYPE_EXPRESSION, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, g_direct_equal);
3132
_tmp1_ = (ValaList*) _tmp0_;
3133
3126
_vala_iterable_unref0 (self->priv->postconditions);
3134
self->priv->postconditions = _tmp1_;
3127
self->priv->postconditions = (ValaList*) _tmp0_;
3135
3128
}
3136
3129
vala_collection_add ((ValaCollection*) self->priv->postconditions, postcondition);
3137
3130
vala_code_node_set_parent_node ((ValaCodeNode*) postcondition, (ValaCodeNode*) self);
3145
3138
*/
3146
3139
ValaList* vala_method_get_postconditions (ValaMethod* self) {
3147
3140
ValaList* result = NULL;
3148
ValaList* _tmp3_;
3141
ValaList* _tmp2_;
3149
3142
g_return_val_if_fail (self != NULL, NULL);
3150
3143
if (self->priv->postconditions != NULL) {
3151
3144
ValaList* _tmp0_;
3155
3148
}
3156
3149
if (vala_method__empty_expression_list == NULL) {
3157
3150
ValaArrayList* _tmp1_ = NULL;
3158
ValaList* _tmp2_;
3159
3151
_tmp1_ = vala_array_list_new (VALA_TYPE_EXPRESSION, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, g_direct_equal);
3160
_tmp2_ = (ValaList*) _tmp1_;
3161
3152
_vala_iterable_unref0 (vala_method__empty_expression_list);
3162
vala_method__empty_expression_list = _tmp2_;
3153
vala_method__empty_expression_list = (ValaList*) _tmp1_;
3163
3154
}
3164
_tmp3_ = _vala_iterable_ref0 (vala_method__empty_expression_list);
3165
result = _tmp3_;
3155
_tmp2_ = _vala_iterable_ref0 (vala_method__empty_expression_list);
3156
result = _tmp2_;
3166
3157
return result;
3167
3158
}
3168
3159
3203
3194
}
3204
3195
_tmp4_ = vala_list_get (error_types, i);
3205
3196
_tmp5_ = (ValaDataType*) _tmp4_;
3206
if ((_tmp6_ = _tmp5_ == old_type, _vala_code_node_unref0 (_tmp5_), _tmp6_)) {
3197
_tmp6_ = _tmp5_ == old_type;
3198
_vala_code_node_unref0 (_tmp5_);
3199
if (_tmp6_) {
3207
3200
vala_list_set (error_types, i, new_type);
3208
3201
_vala_iterable_unref0 (error_types);
3209
3202
return;
3257
3250
}
3258
3251
if (_tmp6_) {
3259
3252
ValaMethod* _tmp7_;
3260
ValaMethod* _tmp8_;
3261
3253
_tmp7_ = _vala_code_node_ref0 (self);
3262
_tmp8_ = _tmp7_;
3263
3254
_vala_code_node_unref0 (self->priv->_base_interface_method);
3264
self->priv->_base_interface_method = _tmp8_;
3255
self->priv->_base_interface_method = _tmp7_;
3265
3256
}
3266
3257
}
3267
3258
}
3450
3441
gchar* _tmp10_ = NULL;
3451
3442
gboolean _tmp11_;
3452
3443
ValaMethod* _tmp19_;
3453
ValaMethod* _tmp20_;
3454
3444
_tmp11_ = vala_method_compatible (self, base_method, &_tmp10_);
3455
3445
_g_free0 (invalid_match);
3456
3446
invalid_match = _tmp10_;
3482
3472
return;
3483
3473
}
3484
3474
_tmp19_ = _vala_code_node_ref0 (base_method);
3485
_tmp20_ = _tmp19_;
3486
3475
_vala_code_node_unref0 (self->priv->_base_interface_method);
3487
self->priv->_base_interface_method = _tmp20_;
3476
self->priv->_base_interface_method = _tmp19_;
3488
3477
_g_free0 (invalid_match);
3489
3478
_vala_code_node_unref0 (base_method);
3490
3479
_vala_code_node_unref0 (sym);
4519
4508
_tmp5_ = vala_symbol_get_full_name ((ValaSymbol*) self);
4520
4509
_tmp6_ = _tmp5_;
4521
4510
_tmp7_ = vala_code_context_get_entry_point_name (context);
4522
if ((_tmp8_ = g_strcmp0 (_tmp6_, _tmp7_) != 0, _g_free0 (_tmp6_), _tmp8_)) {
4511
_tmp8_ = g_strcmp0 (_tmp6_, _tmp7_) != 0;
4512
_g_free0 (_tmp6_);
4513
if (_tmp8_) {
4523
4514
result = FALSE;
4524
4515
return result;
4525
4516
}
4670
4661
ValaBooleanType* bool_type;
4671
4662
ValaSourceReference* _tmp8_ = NULL;
4672
4663
ValaMethod* _tmp9_ = NULL;
4673
ValaMethod* _tmp10_;
4674
ValaScope* _tmp11_ = NULL;
4675
gchar* _tmp12_ = NULL;
4664
ValaScope* _tmp10_ = NULL;
4665
gchar* _tmp11_ = NULL;
4666
gchar* _tmp12_;
4676
4667
gchar* _tmp13_;
4677
4668
gchar* _tmp14_;
4678
4669
_tmp0_ = vala_code_context_get ();
4682
4673
_tmp4_ = vala_scope_lookup (_tmp3_, "bool");
4683
4674
_tmp5_ = VALA_STRUCT (_tmp4_);
4684
4675
_tmp6_ = vala_boolean_type_new (_tmp5_);
4685
bool_type = (_tmp7_ = _tmp6_, _vala_code_node_unref0 (_tmp5_), _vala_code_context_unref0 (_tmp1_), _tmp7_);
4676
_tmp7_ = _tmp6_;
4677
_vala_code_node_unref0 (_tmp5_);
4678
_vala_code_context_unref0 (_tmp1_);
4679
bool_type = _tmp7_;
4686
4680
vala_data_type_set_value_owned ((ValaDataType*) bool_type, TRUE);
4687
4681
_tmp8_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
4688
4682
_tmp9_ = vala_method_new ("callback", (ValaDataType*) bool_type, _tmp8_, NULL);
4689
_tmp10_ = _tmp9_;
4690
4683
_vala_code_node_unref0 (self->priv->callback_method);
4691
self->priv->callback_method = _tmp10_;
4684
self->priv->callback_method = _tmp9_;
4692
4685
vala_symbol_set_access ((ValaSymbol*) self->priv->callback_method, VALA_SYMBOL_ACCESSIBILITY_PUBLIC);
4693
4686
vala_symbol_set_external ((ValaSymbol*) self->priv->callback_method, TRUE);
4694
4687
vala_method_set_binding (self->priv->callback_method, VALA_MEMBER_BINDING_INSTANCE);
4695
_tmp11_ = vala_symbol_get_scope ((ValaSymbol*) self);
4696
vala_symbol_set_owner ((ValaSymbol*) self->priv->callback_method, _tmp11_);
4688
_tmp10_ = vala_symbol_get_scope ((ValaSymbol*) self);
4689
vala_symbol_set_owner ((ValaSymbol*) self->priv->callback_method, _tmp10_);
4697
4690
vala_method_set_is_async_callback (self->priv->callback_method, TRUE);
4698
_tmp12_ = vala_method_get_real_cname (self);
4699
_tmp13_ = _tmp12_;
4700
_tmp14_ = g_strconcat (_tmp13_, "_co", NULL);
4691
_tmp11_ = vala_method_get_real_cname (self);
4692
_tmp12_ = _tmp11_;
4693
_tmp13_ = g_strconcat (_tmp12_, "_co", NULL);
4694
_tmp14_ = _tmp13_;
4701
4695
vala_method_set_cname (self->priv->callback_method, _tmp14_);
4702
4696
_g_free0 (_tmp14_);
4703
_g_free0 (_tmp13_);
4697
_g_free0 (_tmp12_);
4704
4698
_vala_code_node_unref0 (bool_type);
4705
4699
}
4706
4700
_tmp15_ = _vala_code_node_ref0 (self->priv->callback_method);
4741
4735
_tmp2_ = vala_code_context_get_root (_tmp1_);
4742
4736
_tmp3_ = vala_symbol_get_scope ((ValaSymbol*) _tmp2_);
4743
4737
_tmp4_ = vala_scope_lookup (_tmp3_, "GLib");
4744
glib_ns = (_tmp5_ = _tmp4_, _vala_code_context_unref0 (_tmp1_), _tmp5_);
4738
_tmp5_ = _tmp4_;
4739
_vala_code_context_unref0 (_tmp1_);
4740
glib_ns = _tmp5_;
4745
4741
_tmp6_ = vala_array_list_new (VALA_TYPE_PARAMETER, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, g_direct_equal);
4746
4742
params = _tmp6_;
4747
4743
{
4777
4773
_tmp12_ = vala_scope_lookup (_tmp11_, "AsyncReadyCallback");
4778
4774
_tmp13_ = VALA_DELEGATE (_tmp12_);
4779
4775
_tmp14_ = vala_delegate_type_new (_tmp13_);
4780
callback_type = (_tmp15_ = _tmp14_, _vala_code_node_unref0 (_tmp13_), _tmp15_);
4776
_tmp15_ = _tmp14_;
4777
_vala_code_node_unref0 (_tmp13_);
4778
callback_type = _tmp15_;
4781
4779
vala_data_type_set_nullable ((ValaDataType*) callback_type, TRUE);
4782
4780
vala_delegate_type_set_is_called_once (callback_type, TRUE);
4783
4781
_tmp16_ = vala_parameter_new ("_callback_", (ValaDataType*) callback_type, NULL);
4831
4829
_tmp3_ = vala_code_context_get_root (_tmp2_);
4832
4830
_tmp4_ = vala_symbol_get_scope ((ValaSymbol*) _tmp3_);
4833
4831
_tmp5_ = vala_scope_lookup (_tmp4_, "GLib");
4834
glib_ns = (_tmp6_ = _tmp5_, _vala_code_context_unref0 (_tmp2_), _tmp6_);
4832
_tmp6_ = _tmp5_;
4833
_vala_code_context_unref0 (_tmp2_);
4834
glib_ns = _tmp6_;
4835
4835
_tmp7_ = vala_symbol_get_scope (glib_ns);
4836
4836
_tmp8_ = vala_scope_lookup (_tmp7_, "AsyncResult");
4837
4837
_tmp9_ = VALA_OBJECT_TYPE_SYMBOL (_tmp8_);
4838
4838
_tmp10_ = vala_object_type_new (_tmp9_);
4839
result_type = (_tmp11_ = _tmp10_, _vala_code_node_unref0 (_tmp9_), _tmp11_);
4839
_tmp11_ = _tmp10_;
4840
_vala_code_node_unref0 (_tmp9_);
4841
result_type = _tmp11_;
4840
4842
_tmp12_ = vala_parameter_new ("_res_", (ValaDataType*) result_type, NULL);
4841
4843
result_param = _tmp12_;
4842
4844
vala_parameter_set_cparameter_position (result_param, 0.1);
4884
4886
g_assert (self->priv->_closure);
4885
4887
if (self->priv->captured_variables == NULL) {
4886
4888
ValaArrayList* _tmp0_ = NULL;
4887
ValaList* _tmp1_;
4888
4889
_tmp0_ = vala_array_list_new (VALA_TYPE_LOCAL_VARIABLE, (GBoxedCopyFunc) vala_code_node_ref, vala_code_node_unref, g_direct_equal);
4889
_tmp1_ = (ValaList*) _tmp0_;
4890
4890
_vala_iterable_unref0 (self->priv->captured_variables);
4891
self->priv->captured_variables = _tmp1_;
4891
self->priv->captured_variables = (ValaList*) _tmp0_;
4892
4892
}
4893
4893
vala_collection_add ((ValaCollection*) self->priv->captured_variables, local);
4894
4894
}
4947
4947
4948
4948
void vala_method_set_return_type (ValaMethod* self, ValaDataType* value) {
4949
4949
ValaDataType* _tmp0_;
4950
ValaDataType* _tmp1_;
4951
4950
g_return_if_fail (self != NULL);
4952
4951
_tmp0_ = _vala_code_node_ref0 (value);
4953
_tmp1_ = _tmp0_;
4954
4952
_vala_code_node_unref0 (self->priv->_return_type);
4955
self->priv->_return_type = _tmp1_;
4953
self->priv->_return_type = _tmp0_;
4956
4954
vala_code_node_set_parent_node ((ValaCodeNode*) self->priv->_return_type, (ValaCodeNode*) self);
4957
4955
}
4958
4956
4988
4986
if (self->priv->_vfunc_name == NULL) {
4989
4987
const gchar* _tmp0_ = NULL;
4990
4988
gchar* _tmp1_;
4991
gchar* _tmp2_;
4992
4989
_tmp0_ = vala_symbol_get_name ((ValaSymbol*) self);
4993
4990
_tmp1_ = g_strdup (_tmp0_);
4994
_tmp2_ = _tmp1_;
4995
4991
_g_free0 (self->priv->_vfunc_name);
4996
self->priv->_vfunc_name = _tmp2_;
4992
self->priv->_vfunc_name = _tmp1_;
4997
4993
}
4998
4994
result = self->priv->_vfunc_name;
4999
4995
return result;
5002
4998
5003
4999
void vala_method_set_vfunc_name (ValaMethod* self, const gchar* value) {
5004
5000
gchar* _tmp0_;
5005
gchar* _tmp1_;
5006
5001
g_return_if_fail (self != NULL);
5007
5002
_tmp0_ = g_strdup (value);
5008
_tmp1_ = _tmp0_;
5009
5003
_g_free0 (self->priv->_vfunc_name);
5010
self->priv->_vfunc_name = _tmp1_;
5004
self->priv->_vfunc_name = _tmp0_;
5011
5005
}
5012
5006
5013
5007
5025
5019
5026
5020
void vala_method_set_sentinel (ValaMethod* self, const gchar* value) {
5027
5021
gchar* _tmp0_;
5028
gchar* _tmp1_;
5029
5022
g_return_if_fail (self != NULL);
5030
5023
_tmp0_ = g_strdup (value);
5031
_tmp1_ = _tmp0_;
5032
5024
_g_free0 (self->priv->_sentinel);
5033
self->priv->_sentinel = _tmp1_;
5025
self->priv->_sentinel = _tmp0_;
5034
5026
}
5035
5027
5036
5028
5160
5152
5161
5153
void vala_method_set_this_parameter (ValaMethod* self, ValaParameter* value) {
5162
5154
ValaParameter* _tmp0_;
5163
ValaParameter* _tmp1_;
5164
5155
g_return_if_fail (self != NULL);
5165
5156
_tmp0_ = _vala_code_node_ref0 (value);
5166
_tmp1_ = _tmp0_;
5167
5157
_vala_code_node_unref0 (self->priv->_this_parameter);
5168
self->priv->_this_parameter = _tmp1_;
5158
self->priv->_this_parameter = _tmp0_;
5169
5159
}
5170
5160
5171
5161
5249
5239
5250
5240
void vala_method_set_array_length_type (ValaMethod* self, const gchar* value) {
5251
5241
gchar* _tmp0_;
5252
gchar* _tmp1_;
5253
5242
g_return_if_fail (self != NULL);
5254
5243
_tmp0_ = g_strdup (value);
5255
_tmp1_ = _tmp0_;
5256
5244
_g_free0 (self->priv->_array_length_type);
5257
self->priv->_array_length_type = _tmp1_;
5245
self->priv->_array_length_type = _tmp0_;
5258
5246
}
5259
5247
5260
5248
Loggerhead is a web-based interface for Breezy
Version: 2.0.1