1 /* valadelegate.c generated by valac, the Vala compiler
2 * generated from valadelegate.vala, do not modify */
3
4 /* valadelegate.vala
5 *
6 * Copyright (C) 2006-2010 Jürg Billeter
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 *
22 * Author:
23 * Jürg Billeter <j@bitron.ch>
24 */
25
26 #include "vala.h"
27 #include <valagee.h>
28 #include <glib-object.h>
29 #include <glib.h>
30 #include <stdlib.h>
31 #include <string.h>
32
33 #define _vala_code_node_unref0(var) ((var == NULL) ? NULL : (var = (vala_code_node_unref (var), NULL)))
34 #define _g_free0(var) ((var == NULL) ? NULL : (var = (g_free (var), NULL)))
35 #define _vala_iterable_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterable_unref (var), NULL)))
36 #define _vala_iterator_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterator_unref (var), NULL)))
37 #define _vala_source_file_unref0(var) ((var == NULL) ? NULL : (var = (vala_source_file_unref (var), NULL)))
38
39 struct _ValaDelegatePrivate {
40 ValaDataType* _sender_type;
41 ValaList* type_parameters;
42 ValaList* parameters;
43 ValaDataType* _return_type;
44 gboolean* _has_target;
45 ValaList* error_types;
46 };
47
48 static gint ValaDelegate_private_offset;
49 static gpointer vala_delegate_parent_class = NULL;
50 static ValaCallableIface * vala_delegate_vala_callable_parent_iface = NULL;
51
52 static gboolean* _bool_dup (gboolean* self);
53 static gint vala_delegate_real_get_type_parameter_index (ValaTypeSymbol* base,
54 const gchar* name);
55 static void vala_delegate_real_add_parameter (ValaCallable* base,
56 ValaParameter* param);
57 static ValaList* vala_delegate_real_get_parameters (ValaCallable* base);
58 static void vala_delegate_real_accept (ValaCodeNode* base,
59 ValaCodeVisitor* visitor);
60 static void vala_delegate_real_accept_children (ValaCodeNode* base,
61 ValaCodeVisitor* visitor);
62 static gboolean vala_delegate_real_is_reference_type (ValaTypeSymbol* base);
63 static void vala_delegate_real_get_error_types (ValaCodeNode* base,
64 ValaCollection* collection,
65 ValaSourceReference* source_reference);
66 static void vala_delegate_real_replace_type (ValaCodeNode* base,
67 ValaDataType* old_type,
68 ValaDataType* new_type);
69 static gboolean vala_delegate_real_check (ValaCodeNode* base,
70 ValaCodeContext* context);
71 static void vala_delegate_finalize (ValaCodeNode * obj);
72 static GType vala_delegate_get_type_once (void);
73
74 static inline gpointer
vala_delegate_get_instance_private(ValaDelegate * self)75 vala_delegate_get_instance_private (ValaDelegate* self)
76 {
77 return G_STRUCT_MEMBER_P (self, ValaDelegate_private_offset);
78 }
79
80 static ValaDataType*
vala_delegate_real_get_return_type(ValaCallable * base)81 vala_delegate_real_get_return_type (ValaCallable* base)
82 {
83 ValaDataType* result;
84 ValaDelegate* self;
85 ValaDataType* _tmp0_;
86 self = (ValaDelegate*) base;
87 _tmp0_ = self->priv->_return_type;
88 result = _tmp0_;
89 return result;
90 }
91
92 static gpointer
_vala_code_node_ref0(gpointer self)93 _vala_code_node_ref0 (gpointer self)
94 {
95 return self ? vala_code_node_ref (self) : NULL;
96 }
97
98 static void
vala_delegate_real_set_return_type(ValaCallable * base,ValaDataType * value)99 vala_delegate_real_set_return_type (ValaCallable* base,
100 ValaDataType* value)
101 {
102 ValaDelegate* self;
103 ValaDataType* _tmp0_;
104 ValaDataType* _tmp1_;
105 self = (ValaDelegate*) base;
106 _tmp0_ = _vala_code_node_ref0 (value);
107 _vala_code_node_unref0 (self->priv->_return_type);
108 self->priv->_return_type = _tmp0_;
109 _tmp1_ = self->priv->_return_type;
110 vala_code_node_set_parent_node ((ValaCodeNode*) _tmp1_, (ValaCodeNode*) self);
111 }
112
113 static gboolean*
_bool_dup(gboolean * self)114 _bool_dup (gboolean* self)
115 {
116 gboolean* dup;
117 dup = g_new0 (gboolean, 1);
118 memcpy (dup, self, sizeof (gboolean));
119 return dup;
120 }
121
122 static gpointer
__bool_dup0(gpointer self)123 __bool_dup0 (gpointer self)
124 {
125 return self ? _bool_dup (self) : NULL;
126 }
127
128 gboolean
vala_delegate_get_has_target(ValaDelegate * self)129 vala_delegate_get_has_target (ValaDelegate* self)
130 {
131 gboolean result;
132 gboolean* _tmp0_;
133 gboolean* _tmp3_;
134 g_return_val_if_fail (self != NULL, FALSE);
135 _tmp0_ = self->priv->_has_target;
136 if (_tmp0_ == NULL) {
137 gboolean _tmp1_;
138 gboolean* _tmp2_;
139 _tmp1_ = vala_code_node_get_attribute_bool ((ValaCodeNode*) self, "CCode", "has_target", TRUE);
140 _tmp2_ = __bool_dup0 (&_tmp1_);
141 _g_free0 (self->priv->_has_target);
142 self->priv->_has_target = _tmp2_;
143 }
144 _tmp3_ = self->priv->_has_target;
145 result = *_tmp3_;
146 return result;
147 }
148
149 void
vala_delegate_set_has_target(ValaDelegate * self,gboolean value)150 vala_delegate_set_has_target (ValaDelegate* self,
151 gboolean value)
152 {
153 gboolean* _tmp0_;
154 g_return_if_fail (self != NULL);
155 _tmp0_ = __bool_dup0 (&value);
156 _g_free0 (self->priv->_has_target);
157 self->priv->_has_target = _tmp0_;
158 if (value) {
159 vala_code_node_remove_attribute_argument ((ValaCodeNode*) self, "CCode", "has_target");
160 } else {
161 vala_code_node_set_attribute_bool ((ValaCodeNode*) self, "CCode", "has_target", FALSE, NULL);
162 }
163 }
164
165 ValaDataType*
vala_delegate_get_sender_type(ValaDelegate * self)166 vala_delegate_get_sender_type (ValaDelegate* self)
167 {
168 ValaDataType* result;
169 ValaDataType* _tmp0_;
170 g_return_val_if_fail (self != NULL, NULL);
171 _tmp0_ = self->priv->_sender_type;
172 result = _tmp0_;
173 return result;
174 }
175
176 void
vala_delegate_set_sender_type(ValaDelegate * self,ValaDataType * value)177 vala_delegate_set_sender_type (ValaDelegate* self,
178 ValaDataType* value)
179 {
180 ValaDataType* _tmp0_;
181 g_return_if_fail (self != NULL);
182 _tmp0_ = _vala_code_node_ref0 (value);
183 _vala_code_node_unref0 (self->priv->_sender_type);
184 self->priv->_sender_type = _tmp0_;
185 }
186
187 /**
188 * Creates a new delegate.
189 *
190 * @param name delegate type name
191 * @param return_type return type
192 * @param source_reference reference to source code
193 * @return newly created delegate
194 */
195 ValaDelegate*
vala_delegate_construct(GType object_type,const gchar * name,ValaDataType * return_type,ValaSourceReference * source_reference,ValaComment * comment)196 vala_delegate_construct (GType object_type,
197 const gchar* name,
198 ValaDataType* return_type,
199 ValaSourceReference* source_reference,
200 ValaComment* comment)
201 {
202 ValaDelegate* self = NULL;
203 g_return_val_if_fail (return_type != NULL, NULL);
204 self = (ValaDelegate*) vala_typesymbol_construct (object_type, name, source_reference, comment);
205 vala_callable_set_return_type ((ValaCallable*) self, return_type);
206 return self;
207 }
208
209 ValaDelegate*
vala_delegate_new(const gchar * name,ValaDataType * return_type,ValaSourceReference * source_reference,ValaComment * comment)210 vala_delegate_new (const gchar* name,
211 ValaDataType* return_type,
212 ValaSourceReference* source_reference,
213 ValaComment* comment)
214 {
215 return vala_delegate_construct (VALA_TYPE_DELEGATE, name, return_type, source_reference, comment);
216 }
217
218 /**
219 * Appends the specified parameter to the list of type parameters.
220 *
221 * @param p a type parameter
222 */
223 void
vala_delegate_add_type_parameter(ValaDelegate * self,ValaTypeParameter * p)224 vala_delegate_add_type_parameter (ValaDelegate* self,
225 ValaTypeParameter* p)
226 {
227 ValaList* _tmp0_;
228 ValaScope* _tmp1_;
229 ValaScope* _tmp2_;
230 const gchar* _tmp3_;
231 const gchar* _tmp4_;
232 g_return_if_fail (self != NULL);
233 g_return_if_fail (p != NULL);
234 _tmp0_ = self->priv->type_parameters;
235 vala_collection_add ((ValaCollection*) _tmp0_, p);
236 _tmp1_ = vala_symbol_get_scope ((ValaSymbol*) self);
237 _tmp2_ = _tmp1_;
238 _tmp3_ = vala_symbol_get_name ((ValaSymbol*) p);
239 _tmp4_ = _tmp3_;
240 vala_scope_add (_tmp2_, _tmp4_, (ValaSymbol*) p);
241 }
242
243 ValaList*
vala_delegate_get_type_parameters(ValaDelegate * self)244 vala_delegate_get_type_parameters (ValaDelegate* self)
245 {
246 ValaList* _tmp0_;
247 ValaList* result = NULL;
248 g_return_val_if_fail (self != NULL, NULL);
249 _tmp0_ = self->priv->type_parameters;
250 result = _tmp0_;
251 return result;
252 }
253
254 gboolean
vala_delegate_has_type_parameters(ValaDelegate * self)255 vala_delegate_has_type_parameters (ValaDelegate* self)
256 {
257 gboolean _tmp0_ = FALSE;
258 ValaList* _tmp1_;
259 gboolean result = FALSE;
260 g_return_val_if_fail (self != NULL, FALSE);
261 _tmp1_ = self->priv->type_parameters;
262 if (_tmp1_ != NULL) {
263 ValaList* _tmp2_;
264 gint _tmp3_;
265 gint _tmp4_;
266 _tmp2_ = self->priv->type_parameters;
267 _tmp3_ = vala_collection_get_size ((ValaCollection*) _tmp2_);
268 _tmp4_ = _tmp3_;
269 _tmp0_ = _tmp4_ > 0;
270 } else {
271 _tmp0_ = FALSE;
272 }
273 result = _tmp0_;
274 return result;
275 }
276
277 static gpointer
_vala_iterable_ref0(gpointer self)278 _vala_iterable_ref0 (gpointer self)
279 {
280 return self ? vala_iterable_ref (self) : NULL;
281 }
282
283 static gint
vala_delegate_real_get_type_parameter_index(ValaTypeSymbol * base,const gchar * name)284 vala_delegate_real_get_type_parameter_index (ValaTypeSymbol* base,
285 const gchar* name)
286 {
287 ValaDelegate * self;
288 gint i = 0;
289 gint result = 0;
290 self = (ValaDelegate*) base;
291 g_return_val_if_fail (name != NULL, 0);
292 i = 0;
293 {
294 ValaList* _parameter_list = NULL;
295 ValaList* _tmp0_;
296 ValaList* _tmp1_;
297 gint _parameter_size = 0;
298 ValaList* _tmp2_;
299 gint _tmp3_;
300 gint _tmp4_;
301 gint _parameter_index = 0;
302 _tmp0_ = self->priv->type_parameters;
303 _tmp1_ = _vala_iterable_ref0 (_tmp0_);
304 _parameter_list = _tmp1_;
305 _tmp2_ = _parameter_list;
306 _tmp3_ = vala_collection_get_size ((ValaCollection*) _tmp2_);
307 _tmp4_ = _tmp3_;
308 _parameter_size = _tmp4_;
309 _parameter_index = -1;
310 while (TRUE) {
311 gint _tmp5_;
312 gint _tmp6_;
313 ValaTypeParameter* parameter = NULL;
314 ValaList* _tmp7_;
315 gpointer _tmp8_;
316 ValaTypeParameter* _tmp9_;
317 const gchar* _tmp10_;
318 const gchar* _tmp11_;
319 gint _tmp12_;
320 _parameter_index = _parameter_index + 1;
321 _tmp5_ = _parameter_index;
322 _tmp6_ = _parameter_size;
323 if (!(_tmp5_ < _tmp6_)) {
324 break;
325 }
326 _tmp7_ = _parameter_list;
327 _tmp8_ = vala_list_get (_tmp7_, _parameter_index);
328 parameter = (ValaTypeParameter*) _tmp8_;
329 _tmp9_ = parameter;
330 _tmp10_ = vala_symbol_get_name ((ValaSymbol*) _tmp9_);
331 _tmp11_ = _tmp10_;
332 if (g_strcmp0 (_tmp11_, name) == 0) {
333 result = i;
334 _vala_code_node_unref0 (parameter);
335 _vala_iterable_unref0 (_parameter_list);
336 return result;
337 }
338 _tmp12_ = i;
339 i = _tmp12_ + 1;
340 _vala_code_node_unref0 (parameter);
341 }
342 _vala_iterable_unref0 (_parameter_list);
343 }
344 result = -1;
345 return result;
346 }
347
348 /**
349 * Appends parameter to this callback function.
350 *
351 * @param param a formal parameter
352 */
353 static void
vala_delegate_real_add_parameter(ValaCallable * base,ValaParameter * param)354 vala_delegate_real_add_parameter (ValaCallable* base,
355 ValaParameter* param)
356 {
357 ValaDelegate * self;
358 ValaList* _tmp0_;
359 ValaScope* _tmp1_;
360 ValaScope* _tmp2_;
361 const gchar* _tmp3_;
362 const gchar* _tmp4_;
363 self = (ValaDelegate*) base;
364 g_return_if_fail (param != NULL);
365 _tmp0_ = self->priv->parameters;
366 vala_collection_add ((ValaCollection*) _tmp0_, param);
367 _tmp1_ = vala_symbol_get_scope ((ValaSymbol*) self);
368 _tmp2_ = _tmp1_;
369 _tmp3_ = vala_symbol_get_name ((ValaSymbol*) param);
370 _tmp4_ = _tmp3_;
371 vala_scope_add (_tmp2_, _tmp4_, (ValaSymbol*) param);
372 }
373
374 /**
375 * Return the parameter list.
376 *
377 * @return parameter list
378 */
379 static ValaList*
vala_delegate_real_get_parameters(ValaCallable * base)380 vala_delegate_real_get_parameters (ValaCallable* base)
381 {
382 ValaDelegate * self;
383 ValaList* _tmp0_;
384 ValaList* result = NULL;
385 self = (ValaDelegate*) base;
386 _tmp0_ = self->priv->parameters;
387 result = _tmp0_;
388 return result;
389 }
390
391 /**
392 * Checks whether the arguments and return type of the specified method
393 * matches this callback.
394 *
395 * @param m a method
396 * @return true if the specified method is compatible to this callback
397 */
398 gboolean
vala_delegate_matches_method(ValaDelegate * self,ValaMethod * m,ValaDataType * dt)399 vala_delegate_matches_method (ValaDelegate* self,
400 ValaMethod* m,
401 ValaDataType* dt)
402 {
403 gboolean _tmp0_ = FALSE;
404 gboolean _tmp1_;
405 gboolean _tmp2_;
406 ValaDataType* _tmp5_;
407 ValaDataType* _tmp6_;
408 ValaDataType* _tmp7_;
409 ValaDataType* _tmp8_;
410 ValaDataType* _tmp9_;
411 ValaDataType* _tmp10_;
412 gboolean _tmp11_;
413 ValaList* method_params = NULL;
414 ValaList* _tmp12_;
415 ValaList* _tmp13_;
416 ValaIterator* method_params_it = NULL;
417 ValaList* _tmp14_;
418 ValaIterator* _tmp15_;
419 gboolean _tmp16_ = FALSE;
420 ValaDataType* _tmp17_;
421 gboolean first = FALSE;
422 gboolean _tmp63_ = FALSE;
423 gboolean _tmp64_ = FALSE;
424 gboolean _tmp65_ = FALSE;
425 ValaIterator* _tmp79_;
426 ValaArrayList* method_error_types = NULL;
427 GEqualFunc _tmp80_;
428 ValaArrayList* _tmp81_;
429 ValaArrayList* _tmp82_;
430 gboolean _tmp83_ = FALSE;
431 gboolean _tmp84_ = FALSE;
432 ValaList* _tmp85_;
433 gboolean result = FALSE;
434 g_return_val_if_fail (self != NULL, FALSE);
435 g_return_val_if_fail (m != NULL, FALSE);
436 g_return_val_if_fail (dt != NULL, FALSE);
437 _tmp1_ = vala_method_get_coroutine (m);
438 _tmp2_ = _tmp1_;
439 if (_tmp2_) {
440 ValaSymbol* _tmp3_;
441 ValaSymbol* _tmp4_;
442 _tmp3_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self);
443 _tmp4_ = _tmp3_;
444 _tmp0_ = !VALA_IS_SIGNAL (_tmp4_);
445 } else {
446 _tmp0_ = FALSE;
447 }
448 if (_tmp0_) {
449 result = FALSE;
450 return result;
451 }
452 _tmp5_ = vala_callable_get_return_type ((ValaCallable*) m);
453 _tmp6_ = _tmp5_;
454 _tmp7_ = vala_callable_get_return_type ((ValaCallable*) self);
455 _tmp8_ = _tmp7_;
456 _tmp9_ = vala_data_type_get_actual_type (_tmp8_, dt, NULL, (ValaCodeNode*) self);
457 _tmp10_ = _tmp9_;
458 _tmp11_ = !vala_data_type_stricter (_tmp6_, _tmp10_);
459 _vala_code_node_unref0 (_tmp10_);
460 if (_tmp11_) {
461 result = FALSE;
462 return result;
463 }
464 _tmp12_ = vala_callable_get_parameters ((ValaCallable*) m);
465 _tmp13_ = _vala_iterable_ref0 (_tmp12_);
466 method_params = _tmp13_;
467 _tmp14_ = method_params;
468 _tmp15_ = vala_iterable_iterator ((ValaIterable*) _tmp14_);
469 method_params_it = _tmp15_;
470 _tmp17_ = self->priv->_sender_type;
471 if (_tmp17_ != NULL) {
472 ValaList* _tmp18_;
473 gint _tmp19_;
474 gint _tmp20_;
475 ValaList* _tmp21_;
476 gint _tmp22_;
477 gint _tmp23_;
478 _tmp18_ = method_params;
479 _tmp19_ = vala_collection_get_size ((ValaCollection*) _tmp18_);
480 _tmp20_ = _tmp19_;
481 _tmp21_ = self->priv->parameters;
482 _tmp22_ = vala_collection_get_size ((ValaCollection*) _tmp21_);
483 _tmp23_ = _tmp22_;
484 _tmp16_ = _tmp20_ == (_tmp23_ + 1);
485 } else {
486 _tmp16_ = FALSE;
487 }
488 if (_tmp16_) {
489 ValaIterator* _tmp24_;
490 ValaParameter* method_param = NULL;
491 ValaIterator* _tmp25_;
492 gpointer _tmp26_;
493 ValaDataType* _tmp27_;
494 ValaParameter* _tmp28_;
495 ValaDataType* _tmp29_;
496 ValaDataType* _tmp30_;
497 _tmp24_ = method_params_it;
498 vala_iterator_next (_tmp24_);
499 _tmp25_ = method_params_it;
500 _tmp26_ = vala_iterator_get (_tmp25_);
501 method_param = (ValaParameter*) _tmp26_;
502 _tmp27_ = self->priv->_sender_type;
503 _tmp28_ = method_param;
504 _tmp29_ = vala_variable_get_variable_type ((ValaVariable*) _tmp28_);
505 _tmp30_ = _tmp29_;
506 if (!vala_data_type_stricter (_tmp27_, _tmp30_)) {
507 result = FALSE;
508 _vala_code_node_unref0 (method_param);
509 _vala_iterator_unref0 (method_params_it);
510 _vala_iterable_unref0 (method_params);
511 return result;
512 }
513 _vala_code_node_unref0 (method_param);
514 }
515 first = TRUE;
516 {
517 ValaList* _param_list = NULL;
518 ValaList* _tmp31_;
519 ValaList* _tmp32_;
520 gint _param_size = 0;
521 ValaList* _tmp33_;
522 gint _tmp34_;
523 gint _tmp35_;
524 gint _param_index = 0;
525 _tmp31_ = self->priv->parameters;
526 _tmp32_ = _vala_iterable_ref0 (_tmp31_);
527 _param_list = _tmp32_;
528 _tmp33_ = _param_list;
529 _tmp34_ = vala_collection_get_size ((ValaCollection*) _tmp33_);
530 _tmp35_ = _tmp34_;
531 _param_size = _tmp35_;
532 _param_index = -1;
533 while (TRUE) {
534 gint _tmp36_;
535 gint _tmp37_;
536 ValaParameter* param = NULL;
537 ValaList* _tmp38_;
538 gpointer _tmp39_;
539 ValaDataType* method_param_type = NULL;
540 gboolean _tmp40_ = FALSE;
541 gboolean _tmp41_ = FALSE;
542 ValaParameter* _tmp56_;
543 ValaDataType* _tmp57_;
544 ValaDataType* _tmp58_;
545 ValaDataType* _tmp59_;
546 ValaDataType* _tmp60_;
547 ValaDataType* _tmp61_;
548 gboolean _tmp62_;
549 _param_index = _param_index + 1;
550 _tmp36_ = _param_index;
551 _tmp37_ = _param_size;
552 if (!(_tmp36_ < _tmp37_)) {
553 break;
554 }
555 _tmp38_ = _param_list;
556 _tmp39_ = vala_list_get (_tmp38_, _param_index);
557 param = (ValaParameter*) _tmp39_;
558 if (first) {
559 ValaMemberBinding _tmp42_;
560 ValaMemberBinding _tmp43_;
561 _tmp42_ = vala_method_get_binding (m);
562 _tmp43_ = _tmp42_;
563 _tmp41_ = _tmp43_ == VALA_MEMBER_BINDING_INSTANCE;
564 } else {
565 _tmp41_ = FALSE;
566 }
567 if (_tmp41_) {
568 gboolean _tmp44_;
569 gboolean _tmp45_;
570 _tmp44_ = vala_delegate_get_has_target (self);
571 _tmp45_ = _tmp44_;
572 _tmp40_ = !_tmp45_;
573 } else {
574 _tmp40_ = FALSE;
575 }
576 if (_tmp40_) {
577 ValaSymbol* _tmp46_;
578 ValaSymbol* _tmp47_;
579 ValaDataType* _tmp48_;
580 first = FALSE;
581 _tmp46_ = vala_symbol_get_parent_symbol ((ValaSymbol*) m);
582 _tmp47_ = _tmp46_;
583 _tmp48_ = vala_semantic_analyzer_get_data_type_for_symbol (_tmp47_);
584 _vala_code_node_unref0 (method_param_type);
585 method_param_type = _tmp48_;
586 } else {
587 ValaIterator* _tmp49_;
588 ValaIterator* _tmp50_;
589 gpointer _tmp51_;
590 ValaParameter* _tmp52_;
591 ValaDataType* _tmp53_;
592 ValaDataType* _tmp54_;
593 ValaDataType* _tmp55_;
594 _tmp49_ = method_params_it;
595 if (!vala_iterator_next (_tmp49_)) {
596 _vala_code_node_unref0 (method_param_type);
597 _vala_code_node_unref0 (param);
598 break;
599 }
600 _tmp50_ = method_params_it;
601 _tmp51_ = vala_iterator_get (_tmp50_);
602 _tmp52_ = (ValaParameter*) _tmp51_;
603 _tmp53_ = vala_variable_get_variable_type ((ValaVariable*) _tmp52_);
604 _tmp54_ = _tmp53_;
605 _tmp55_ = _vala_code_node_ref0 (_tmp54_);
606 _vala_code_node_unref0 (method_param_type);
607 method_param_type = _tmp55_;
608 _vala_code_node_unref0 (_tmp52_);
609 }
610 _tmp56_ = param;
611 _tmp57_ = vala_variable_get_variable_type ((ValaVariable*) _tmp56_);
612 _tmp58_ = _tmp57_;
613 _tmp59_ = vala_data_type_get_actual_type (_tmp58_, dt, NULL, (ValaCodeNode*) self);
614 _tmp60_ = _tmp59_;
615 _tmp61_ = method_param_type;
616 _tmp62_ = !vala_data_type_stricter (_tmp60_, _tmp61_);
617 _vala_code_node_unref0 (_tmp60_);
618 if (_tmp62_) {
619 result = FALSE;
620 _vala_code_node_unref0 (method_param_type);
621 _vala_code_node_unref0 (param);
622 _vala_iterable_unref0 (_param_list);
623 _vala_iterator_unref0 (method_params_it);
624 _vala_iterable_unref0 (method_params);
625 return result;
626 }
627 _vala_code_node_unref0 (method_param_type);
628 _vala_code_node_unref0 (param);
629 }
630 _vala_iterable_unref0 (_param_list);
631 }
632 if (first) {
633 gboolean _tmp66_;
634 gboolean _tmp67_;
635 _tmp66_ = vala_delegate_get_has_target (self);
636 _tmp67_ = _tmp66_;
637 _tmp65_ = !_tmp67_;
638 } else {
639 _tmp65_ = FALSE;
640 }
641 if (_tmp65_) {
642 gboolean _tmp68_ = FALSE;
643 ValaMemberBinding _tmp69_;
644 ValaMemberBinding _tmp70_;
645 _tmp69_ = vala_method_get_binding (m);
646 _tmp70_ = _tmp69_;
647 if (_tmp70_ == VALA_MEMBER_BINDING_INSTANCE) {
648 _tmp68_ = TRUE;
649 } else {
650 gboolean _tmp71_;
651 gboolean _tmp72_;
652 _tmp71_ = vala_method_get_closure (m);
653 _tmp72_ = _tmp71_;
654 _tmp68_ = _tmp72_;
655 }
656 _tmp64_ = _tmp68_;
657 } else {
658 _tmp64_ = FALSE;
659 }
660 if (_tmp64_) {
661 gboolean _tmp73_ = FALSE;
662 ValaList* _tmp74_;
663 gint _tmp75_;
664 gint _tmp76_;
665 _tmp74_ = self->priv->parameters;
666 _tmp75_ = vala_collection_get_size ((ValaCollection*) _tmp74_);
667 _tmp76_ = _tmp75_;
668 if (_tmp76_ == 0) {
669 _tmp73_ = TRUE;
670 } else {
671 gboolean _tmp77_;
672 gboolean _tmp78_;
673 _tmp77_ = vala_method_get_closure (m);
674 _tmp78_ = _tmp77_;
675 _tmp73_ = _tmp78_;
676 }
677 _tmp63_ = _tmp73_;
678 } else {
679 _tmp63_ = FALSE;
680 }
681 if (_tmp63_) {
682 result = FALSE;
683 _vala_iterator_unref0 (method_params_it);
684 _vala_iterable_unref0 (method_params);
685 return result;
686 }
687 _tmp79_ = method_params_it;
688 if (vala_iterator_next (_tmp79_)) {
689 result = FALSE;
690 _vala_iterator_unref0 (method_params_it);
691 _vala_iterable_unref0 (method_params);
692 return result;
693 }
694 _tmp80_ = g_direct_equal;
695 _tmp81_ = vala_array_list_new (VALA_TYPE_DATA_TYPE, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp80_);
696 method_error_types = _tmp81_;
697 _tmp82_ = method_error_types;
698 vala_code_node_get_error_types ((ValaCodeNode*) m, (ValaCollection*) _tmp82_, NULL);
699 _tmp85_ = self->priv->error_types;
700 if (_tmp85_ != NULL) {
701 ValaList* _tmp86_;
702 gint _tmp87_;
703 gint _tmp88_;
704 _tmp86_ = self->priv->error_types;
705 _tmp87_ = vala_collection_get_size ((ValaCollection*) _tmp86_);
706 _tmp88_ = _tmp87_;
707 _tmp84_ = _tmp88_ > 0;
708 } else {
709 _tmp84_ = FALSE;
710 }
711 if (_tmp84_) {
712 ValaArrayList* _tmp89_;
713 gint _tmp90_;
714 gint _tmp91_;
715 _tmp89_ = method_error_types;
716 _tmp90_ = vala_collection_get_size ((ValaCollection*) _tmp89_);
717 _tmp91_ = _tmp90_;
718 _tmp83_ = _tmp91_ == 0;
719 } else {
720 _tmp83_ = FALSE;
721 }
722 if (_tmp83_) {
723 result = FALSE;
724 _vala_iterable_unref0 (method_error_types);
725 _vala_iterator_unref0 (method_params_it);
726 _vala_iterable_unref0 (method_params);
727 return result;
728 }
729 {
730 ValaArrayList* _method_error_type_list = NULL;
731 ValaArrayList* _tmp92_;
732 ValaArrayList* _tmp93_;
733 gint _method_error_type_size = 0;
734 ValaArrayList* _tmp94_;
735 gint _tmp95_;
736 gint _tmp96_;
737 gint _method_error_type_index = 0;
738 _tmp92_ = method_error_types;
739 _tmp93_ = _vala_iterable_ref0 (_tmp92_);
740 _method_error_type_list = _tmp93_;
741 _tmp94_ = _method_error_type_list;
742 _tmp95_ = vala_collection_get_size ((ValaCollection*) _tmp94_);
743 _tmp96_ = _tmp95_;
744 _method_error_type_size = _tmp96_;
745 _method_error_type_index = -1;
746 while (TRUE) {
747 gint _tmp97_;
748 gint _tmp98_;
749 ValaDataType* method_error_type = NULL;
750 ValaArrayList* _tmp99_;
751 gpointer _tmp100_;
752 gboolean match = FALSE;
753 ValaList* _tmp101_;
754 _method_error_type_index = _method_error_type_index + 1;
755 _tmp97_ = _method_error_type_index;
756 _tmp98_ = _method_error_type_size;
757 if (!(_tmp97_ < _tmp98_)) {
758 break;
759 }
760 _tmp99_ = _method_error_type_list;
761 _tmp100_ = vala_list_get ((ValaList*) _tmp99_, _method_error_type_index);
762 method_error_type = (ValaDataType*) _tmp100_;
763 match = FALSE;
764 _tmp101_ = self->priv->error_types;
765 if (_tmp101_ != NULL) {
766 {
767 ValaList* _delegate_error_type_list = NULL;
768 ValaList* _tmp102_;
769 ValaList* _tmp103_;
770 gint _delegate_error_type_size = 0;
771 ValaList* _tmp104_;
772 gint _tmp105_;
773 gint _tmp106_;
774 gint _delegate_error_type_index = 0;
775 _tmp102_ = self->priv->error_types;
776 _tmp103_ = _vala_iterable_ref0 (_tmp102_);
777 _delegate_error_type_list = _tmp103_;
778 _tmp104_ = _delegate_error_type_list;
779 _tmp105_ = vala_collection_get_size ((ValaCollection*) _tmp104_);
780 _tmp106_ = _tmp105_;
781 _delegate_error_type_size = _tmp106_;
782 _delegate_error_type_index = -1;
783 while (TRUE) {
784 gint _tmp107_;
785 gint _tmp108_;
786 ValaDataType* delegate_error_type = NULL;
787 ValaList* _tmp109_;
788 gpointer _tmp110_;
789 ValaDataType* _tmp111_;
790 ValaDataType* _tmp112_;
791 _delegate_error_type_index = _delegate_error_type_index + 1;
792 _tmp107_ = _delegate_error_type_index;
793 _tmp108_ = _delegate_error_type_size;
794 if (!(_tmp107_ < _tmp108_)) {
795 break;
796 }
797 _tmp109_ = _delegate_error_type_list;
798 _tmp110_ = vala_list_get (_tmp109_, _delegate_error_type_index);
799 delegate_error_type = (ValaDataType*) _tmp110_;
800 _tmp111_ = method_error_type;
801 _tmp112_ = delegate_error_type;
802 if (vala_data_type_compatible (_tmp111_, _tmp112_)) {
803 match = TRUE;
804 _vala_code_node_unref0 (delegate_error_type);
805 break;
806 }
807 _vala_code_node_unref0 (delegate_error_type);
808 }
809 _vala_iterable_unref0 (_delegate_error_type_list);
810 }
811 }
812 if (!match) {
813 result = FALSE;
814 _vala_code_node_unref0 (method_error_type);
815 _vala_iterable_unref0 (_method_error_type_list);
816 _vala_iterable_unref0 (method_error_types);
817 _vala_iterator_unref0 (method_params_it);
818 _vala_iterable_unref0 (method_params);
819 return result;
820 }
821 _vala_code_node_unref0 (method_error_type);
822 }
823 _vala_iterable_unref0 (_method_error_type_list);
824 }
825 result = TRUE;
826 _vala_iterable_unref0 (method_error_types);
827 _vala_iterator_unref0 (method_params_it);
828 _vala_iterable_unref0 (method_params);
829 return result;
830 }
831
832 static void
vala_delegate_real_accept(ValaCodeNode * base,ValaCodeVisitor * visitor)833 vala_delegate_real_accept (ValaCodeNode* base,
834 ValaCodeVisitor* visitor)
835 {
836 ValaDelegate * self;
837 self = (ValaDelegate*) base;
838 g_return_if_fail (visitor != NULL);
839 vala_code_visitor_visit_delegate (visitor, self);
840 }
841
842 static void
vala_delegate_real_accept_children(ValaCodeNode * base,ValaCodeVisitor * visitor)843 vala_delegate_real_accept_children (ValaCodeNode* base,
844 ValaCodeVisitor* visitor)
845 {
846 ValaDelegate * self;
847 ValaDataType* _tmp10_;
848 ValaDataType* _tmp11_;
849 ValaList* _tmp22_;
850 self = (ValaDelegate*) base;
851 g_return_if_fail (visitor != NULL);
852 {
853 ValaList* _p_list = NULL;
854 ValaList* _tmp0_;
855 ValaList* _tmp1_;
856 gint _p_size = 0;
857 ValaList* _tmp2_;
858 gint _tmp3_;
859 gint _tmp4_;
860 gint _p_index = 0;
861 _tmp0_ = self->priv->type_parameters;
862 _tmp1_ = _vala_iterable_ref0 (_tmp0_);
863 _p_list = _tmp1_;
864 _tmp2_ = _p_list;
865 _tmp3_ = vala_collection_get_size ((ValaCollection*) _tmp2_);
866 _tmp4_ = _tmp3_;
867 _p_size = _tmp4_;
868 _p_index = -1;
869 while (TRUE) {
870 gint _tmp5_;
871 gint _tmp6_;
872 ValaTypeParameter* p = NULL;
873 ValaList* _tmp7_;
874 gpointer _tmp8_;
875 ValaTypeParameter* _tmp9_;
876 _p_index = _p_index + 1;
877 _tmp5_ = _p_index;
878 _tmp6_ = _p_size;
879 if (!(_tmp5_ < _tmp6_)) {
880 break;
881 }
882 _tmp7_ = _p_list;
883 _tmp8_ = vala_list_get (_tmp7_, _p_index);
884 p = (ValaTypeParameter*) _tmp8_;
885 _tmp9_ = p;
886 vala_code_node_accept ((ValaCodeNode*) _tmp9_, visitor);
887 _vala_code_node_unref0 (p);
888 }
889 _vala_iterable_unref0 (_p_list);
890 }
891 _tmp10_ = vala_callable_get_return_type ((ValaCallable*) self);
892 _tmp11_ = _tmp10_;
893 vala_code_node_accept ((ValaCodeNode*) _tmp11_, visitor);
894 {
895 ValaList* _param_list = NULL;
896 ValaList* _tmp12_;
897 ValaList* _tmp13_;
898 gint _param_size = 0;
899 ValaList* _tmp14_;
900 gint _tmp15_;
901 gint _tmp16_;
902 gint _param_index = 0;
903 _tmp12_ = self->priv->parameters;
904 _tmp13_ = _vala_iterable_ref0 (_tmp12_);
905 _param_list = _tmp13_;
906 _tmp14_ = _param_list;
907 _tmp15_ = vala_collection_get_size ((ValaCollection*) _tmp14_);
908 _tmp16_ = _tmp15_;
909 _param_size = _tmp16_;
910 _param_index = -1;
911 while (TRUE) {
912 gint _tmp17_;
913 gint _tmp18_;
914 ValaParameter* param = NULL;
915 ValaList* _tmp19_;
916 gpointer _tmp20_;
917 ValaParameter* _tmp21_;
918 _param_index = _param_index + 1;
919 _tmp17_ = _param_index;
920 _tmp18_ = _param_size;
921 if (!(_tmp17_ < _tmp18_)) {
922 break;
923 }
924 _tmp19_ = _param_list;
925 _tmp20_ = vala_list_get (_tmp19_, _param_index);
926 param = (ValaParameter*) _tmp20_;
927 _tmp21_ = param;
928 vala_code_node_accept ((ValaCodeNode*) _tmp21_, visitor);
929 _vala_code_node_unref0 (param);
930 }
931 _vala_iterable_unref0 (_param_list);
932 }
933 _tmp22_ = self->priv->error_types;
934 if (_tmp22_ != NULL) {
935 {
936 ValaList* _error_type_list = NULL;
937 ValaList* _tmp23_;
938 ValaList* _tmp24_;
939 gint _error_type_size = 0;
940 ValaList* _tmp25_;
941 gint _tmp26_;
942 gint _tmp27_;
943 gint _error_type_index = 0;
944 _tmp23_ = self->priv->error_types;
945 _tmp24_ = _vala_iterable_ref0 (_tmp23_);
946 _error_type_list = _tmp24_;
947 _tmp25_ = _error_type_list;
948 _tmp26_ = vala_collection_get_size ((ValaCollection*) _tmp25_);
949 _tmp27_ = _tmp26_;
950 _error_type_size = _tmp27_;
951 _error_type_index = -1;
952 while (TRUE) {
953 gint _tmp28_;
954 gint _tmp29_;
955 ValaDataType* error_type = NULL;
956 ValaList* _tmp30_;
957 gpointer _tmp31_;
958 ValaDataType* _tmp32_;
959 _error_type_index = _error_type_index + 1;
960 _tmp28_ = _error_type_index;
961 _tmp29_ = _error_type_size;
962 if (!(_tmp28_ < _tmp29_)) {
963 break;
964 }
965 _tmp30_ = _error_type_list;
966 _tmp31_ = vala_list_get (_tmp30_, _error_type_index);
967 error_type = (ValaDataType*) _tmp31_;
968 _tmp32_ = error_type;
969 vala_code_node_accept ((ValaCodeNode*) _tmp32_, visitor);
970 _vala_code_node_unref0 (error_type);
971 }
972 _vala_iterable_unref0 (_error_type_list);
973 }
974 }
975 }
976
977 static gboolean
vala_delegate_real_is_reference_type(ValaTypeSymbol * base)978 vala_delegate_real_is_reference_type (ValaTypeSymbol* base)
979 {
980 ValaDelegate * self;
981 gboolean result = FALSE;
982 self = (ValaDelegate*) base;
983 result = FALSE;
984 return result;
985 }
986
987 /**
988 * Adds an error type to the exceptions that can be
989 * thrown by this delegate.
990 */
991 void
vala_delegate_add_error_type(ValaDelegate * self,ValaDataType * error_type)992 vala_delegate_add_error_type (ValaDelegate* self,
993 ValaDataType* error_type)
994 {
995 ValaList* _tmp0_;
996 ValaList* _tmp3_;
997 g_return_if_fail (self != NULL);
998 g_return_if_fail (error_type != NULL);
999 _tmp0_ = self->priv->error_types;
1000 if (_tmp0_ == NULL) {
1001 GEqualFunc _tmp1_;
1002 ValaArrayList* _tmp2_;
1003 _tmp1_ = g_direct_equal;
1004 _tmp2_ = vala_array_list_new (VALA_TYPE_DATA_TYPE, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp1_);
1005 _vala_iterable_unref0 (self->priv->error_types);
1006 self->priv->error_types = (ValaList*) _tmp2_;
1007 }
1008 _tmp3_ = self->priv->error_types;
1009 vala_collection_add ((ValaCollection*) _tmp3_, error_type);
1010 vala_code_node_set_parent_node ((ValaCodeNode*) error_type, (ValaCodeNode*) self);
1011 }
1012
1013 static void
vala_delegate_real_get_error_types(ValaCodeNode * base,ValaCollection * collection,ValaSourceReference * source_reference)1014 vala_delegate_real_get_error_types (ValaCodeNode* base,
1015 ValaCollection* collection,
1016 ValaSourceReference* source_reference)
1017 {
1018 ValaDelegate * self;
1019 ValaList* _tmp0_;
1020 self = (ValaDelegate*) base;
1021 g_return_if_fail (collection != NULL);
1022 _tmp0_ = self->priv->error_types;
1023 if (_tmp0_ != NULL) {
1024 {
1025 ValaList* _error_type_list = NULL;
1026 ValaList* _tmp1_;
1027 ValaList* _tmp2_;
1028 gint _error_type_size = 0;
1029 ValaList* _tmp3_;
1030 gint _tmp4_;
1031 gint _tmp5_;
1032 gint _error_type_index = 0;
1033 _tmp1_ = self->priv->error_types;
1034 _tmp2_ = _vala_iterable_ref0 (_tmp1_);
1035 _error_type_list = _tmp2_;
1036 _tmp3_ = _error_type_list;
1037 _tmp4_ = vala_collection_get_size ((ValaCollection*) _tmp3_);
1038 _tmp5_ = _tmp4_;
1039 _error_type_size = _tmp5_;
1040 _error_type_index = -1;
1041 while (TRUE) {
1042 gint _tmp6_;
1043 gint _tmp7_;
1044 ValaDataType* error_type = NULL;
1045 ValaList* _tmp8_;
1046 gpointer _tmp9_;
1047 _error_type_index = _error_type_index + 1;
1048 _tmp6_ = _error_type_index;
1049 _tmp7_ = _error_type_size;
1050 if (!(_tmp6_ < _tmp7_)) {
1051 break;
1052 }
1053 _tmp8_ = _error_type_list;
1054 _tmp9_ = vala_list_get (_tmp8_, _error_type_index);
1055 error_type = (ValaDataType*) _tmp9_;
1056 if (source_reference != NULL) {
1057 ValaDataType* type = NULL;
1058 ValaDataType* _tmp10_;
1059 ValaDataType* _tmp11_;
1060 ValaDataType* _tmp12_;
1061 ValaDataType* _tmp13_;
1062 _tmp10_ = error_type;
1063 _tmp11_ = vala_data_type_copy (_tmp10_);
1064 type = _tmp11_;
1065 _tmp12_ = type;
1066 vala_code_node_set_source_reference ((ValaCodeNode*) _tmp12_, source_reference);
1067 _tmp13_ = type;
1068 vala_collection_add (collection, _tmp13_);
1069 _vala_code_node_unref0 (type);
1070 } else {
1071 ValaDataType* _tmp14_;
1072 _tmp14_ = error_type;
1073 vala_collection_add (collection, _tmp14_);
1074 }
1075 _vala_code_node_unref0 (error_type);
1076 }
1077 _vala_iterable_unref0 (_error_type_list);
1078 }
1079 }
1080 }
1081
1082 static void
vala_delegate_real_replace_type(ValaCodeNode * base,ValaDataType * old_type,ValaDataType * new_type)1083 vala_delegate_real_replace_type (ValaCodeNode* base,
1084 ValaDataType* old_type,
1085 ValaDataType* new_type)
1086 {
1087 ValaDelegate * self;
1088 ValaDataType* _tmp0_;
1089 ValaDataType* _tmp1_;
1090 ValaList* _tmp2_;
1091 self = (ValaDelegate*) base;
1092 g_return_if_fail (old_type != NULL);
1093 g_return_if_fail (new_type != NULL);
1094 _tmp0_ = vala_callable_get_return_type ((ValaCallable*) self);
1095 _tmp1_ = _tmp0_;
1096 if (_tmp1_ == old_type) {
1097 vala_callable_set_return_type ((ValaCallable*) self, new_type);
1098 return;
1099 }
1100 _tmp2_ = self->priv->error_types;
1101 if (_tmp2_ != NULL) {
1102 {
1103 gint i = 0;
1104 i = 0;
1105 {
1106 gboolean _tmp3_ = FALSE;
1107 _tmp3_ = TRUE;
1108 while (TRUE) {
1109 ValaList* _tmp5_;
1110 gint _tmp6_;
1111 gint _tmp7_;
1112 ValaList* _tmp8_;
1113 gpointer _tmp9_;
1114 ValaDataType* _tmp10_;
1115 gboolean _tmp11_;
1116 if (!_tmp3_) {
1117 gint _tmp4_;
1118 _tmp4_ = i;
1119 i = _tmp4_ + 1;
1120 }
1121 _tmp3_ = FALSE;
1122 _tmp5_ = self->priv->error_types;
1123 _tmp6_ = vala_collection_get_size ((ValaCollection*) _tmp5_);
1124 _tmp7_ = _tmp6_;
1125 if (!(i < _tmp7_)) {
1126 break;
1127 }
1128 _tmp8_ = self->priv->error_types;
1129 _tmp9_ = vala_list_get (_tmp8_, i);
1130 _tmp10_ = (ValaDataType*) _tmp9_;
1131 _tmp11_ = _tmp10_ == old_type;
1132 _vala_code_node_unref0 (_tmp10_);
1133 if (_tmp11_) {
1134 ValaList* _tmp12_;
1135 _tmp12_ = self->priv->error_types;
1136 vala_list_set (_tmp12_, i, new_type);
1137 return;
1138 }
1139 }
1140 }
1141 }
1142 }
1143 }
1144
1145 static gpointer
_vala_source_file_ref0(gpointer self)1146 _vala_source_file_ref0 (gpointer self)
1147 {
1148 return self ? vala_source_file_ref (self) : NULL;
1149 }
1150
1151 static gboolean
vala_delegate_real_check(ValaCodeNode * base,ValaCodeContext * context)1152 vala_delegate_real_check (ValaCodeNode* base,
1153 ValaCodeContext* context)
1154 {
1155 ValaDelegate * self;
1156 gboolean _tmp0_;
1157 gboolean _tmp1_;
1158 ValaSourceFile* old_source_file = NULL;
1159 ValaSemanticAnalyzer* _tmp4_;
1160 ValaSemanticAnalyzer* _tmp5_;
1161 ValaSourceFile* _tmp6_;
1162 ValaSourceFile* _tmp7_;
1163 ValaSourceFile* _tmp8_;
1164 ValaSourceReference* _tmp9_;
1165 ValaSourceReference* _tmp10_;
1166 ValaDataType* _tmp27_;
1167 ValaDataType* _tmp28_;
1168 ValaDataType* _tmp29_;
1169 ValaDataType* _tmp30_;
1170 ValaTypeSymbol* _tmp31_;
1171 ValaTypeSymbol* _tmp32_;
1172 ValaSemanticAnalyzer* _tmp33_;
1173 ValaSemanticAnalyzer* _tmp34_;
1174 ValaDataType* _tmp35_;
1175 ValaTypeSymbol* _tmp36_;
1176 ValaTypeSymbol* _tmp37_;
1177 ValaList* _tmp58_;
1178 ValaSemanticAnalyzer* _tmp81_;
1179 ValaSemanticAnalyzer* _tmp82_;
1180 ValaSourceFile* _tmp83_;
1181 gboolean _tmp84_;
1182 gboolean _tmp85_;
1183 gboolean result = FALSE;
1184 self = (ValaDelegate*) base;
1185 g_return_val_if_fail (context != NULL, FALSE);
1186 _tmp0_ = vala_code_node_get_checked ((ValaCodeNode*) self);
1187 _tmp1_ = _tmp0_;
1188 if (_tmp1_) {
1189 gboolean _tmp2_;
1190 gboolean _tmp3_;
1191 _tmp2_ = vala_code_node_get_error ((ValaCodeNode*) self);
1192 _tmp3_ = _tmp2_;
1193 result = !_tmp3_;
1194 return result;
1195 }
1196 vala_code_node_set_checked ((ValaCodeNode*) self, TRUE);
1197 _tmp4_ = vala_code_context_get_analyzer (context);
1198 _tmp5_ = _tmp4_;
1199 _tmp6_ = vala_semantic_analyzer_get_current_source_file (_tmp5_);
1200 _tmp7_ = _tmp6_;
1201 _tmp8_ = _vala_source_file_ref0 (_tmp7_);
1202 old_source_file = _tmp8_;
1203 _tmp9_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1204 _tmp10_ = _tmp9_;
1205 if (_tmp10_ != NULL) {
1206 ValaSemanticAnalyzer* _tmp11_;
1207 ValaSemanticAnalyzer* _tmp12_;
1208 ValaSourceReference* _tmp13_;
1209 ValaSourceReference* _tmp14_;
1210 ValaSourceFile* _tmp15_;
1211 ValaSourceFile* _tmp16_;
1212 _tmp11_ = vala_code_context_get_analyzer (context);
1213 _tmp12_ = _tmp11_;
1214 _tmp13_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1215 _tmp14_ = _tmp13_;
1216 _tmp15_ = vala_source_reference_get_file (_tmp14_);
1217 _tmp16_ = _tmp15_;
1218 vala_semantic_analyzer_set_current_source_file (_tmp12_, _tmp16_);
1219 }
1220 {
1221 ValaList* _p_list = NULL;
1222 ValaList* _tmp17_;
1223 ValaList* _tmp18_;
1224 gint _p_size = 0;
1225 ValaList* _tmp19_;
1226 gint _tmp20_;
1227 gint _tmp21_;
1228 gint _p_index = 0;
1229 _tmp17_ = self->priv->type_parameters;
1230 _tmp18_ = _vala_iterable_ref0 (_tmp17_);
1231 _p_list = _tmp18_;
1232 _tmp19_ = _p_list;
1233 _tmp20_ = vala_collection_get_size ((ValaCollection*) _tmp19_);
1234 _tmp21_ = _tmp20_;
1235 _p_size = _tmp21_;
1236 _p_index = -1;
1237 while (TRUE) {
1238 gint _tmp22_;
1239 gint _tmp23_;
1240 ValaTypeParameter* p = NULL;
1241 ValaList* _tmp24_;
1242 gpointer _tmp25_;
1243 ValaTypeParameter* _tmp26_;
1244 _p_index = _p_index + 1;
1245 _tmp22_ = _p_index;
1246 _tmp23_ = _p_size;
1247 if (!(_tmp22_ < _tmp23_)) {
1248 break;
1249 }
1250 _tmp24_ = _p_list;
1251 _tmp25_ = vala_list_get (_tmp24_, _p_index);
1252 p = (ValaTypeParameter*) _tmp25_;
1253 _tmp26_ = p;
1254 vala_code_node_check ((ValaCodeNode*) _tmp26_, context);
1255 _vala_code_node_unref0 (p);
1256 }
1257 _vala_iterable_unref0 (_p_list);
1258 }
1259 _tmp27_ = vala_callable_get_return_type ((ValaCallable*) self);
1260 _tmp28_ = _tmp27_;
1261 vala_code_node_check ((ValaCodeNode*) _tmp28_, context);
1262 _tmp29_ = vala_callable_get_return_type ((ValaCallable*) self);
1263 _tmp30_ = _tmp29_;
1264 _tmp31_ = vala_data_type_get_type_symbol (_tmp30_);
1265 _tmp32_ = _tmp31_;
1266 _tmp33_ = vala_code_context_get_analyzer (context);
1267 _tmp34_ = _tmp33_;
1268 _tmp35_ = _tmp34_->va_list_type;
1269 _tmp36_ = vala_data_type_get_type_symbol (_tmp35_);
1270 _tmp37_ = _tmp36_;
1271 if (_tmp32_ == _tmp37_) {
1272 ValaSourceReference* _tmp38_;
1273 ValaSourceReference* _tmp39_;
1274 ValaDataType* _tmp40_;
1275 ValaDataType* _tmp41_;
1276 ValaTypeSymbol* _tmp42_;
1277 ValaTypeSymbol* _tmp43_;
1278 gchar* _tmp44_;
1279 gchar* _tmp45_;
1280 gchar* _tmp46_;
1281 gchar* _tmp47_;
1282 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
1283 _tmp38_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1284 _tmp39_ = _tmp38_;
1285 _tmp40_ = vala_callable_get_return_type ((ValaCallable*) self);
1286 _tmp41_ = _tmp40_;
1287 _tmp42_ = vala_data_type_get_type_symbol (_tmp41_);
1288 _tmp43_ = _tmp42_;
1289 _tmp44_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp43_);
1290 _tmp45_ = _tmp44_;
1291 _tmp46_ = g_strdup_printf ("`%s' not supported as return type", _tmp45_);
1292 _tmp47_ = _tmp46_;
1293 vala_report_error (_tmp39_, _tmp47_);
1294 _g_free0 (_tmp47_);
1295 _g_free0 (_tmp45_);
1296 result = FALSE;
1297 _vala_source_file_unref0 (old_source_file);
1298 return result;
1299 }
1300 {
1301 ValaList* _param_list = NULL;
1302 ValaList* _tmp48_;
1303 ValaList* _tmp49_;
1304 gint _param_size = 0;
1305 ValaList* _tmp50_;
1306 gint _tmp51_;
1307 gint _tmp52_;
1308 gint _param_index = 0;
1309 _tmp48_ = self->priv->parameters;
1310 _tmp49_ = _vala_iterable_ref0 (_tmp48_);
1311 _param_list = _tmp49_;
1312 _tmp50_ = _param_list;
1313 _tmp51_ = vala_collection_get_size ((ValaCollection*) _tmp50_);
1314 _tmp52_ = _tmp51_;
1315 _param_size = _tmp52_;
1316 _param_index = -1;
1317 while (TRUE) {
1318 gint _tmp53_;
1319 gint _tmp54_;
1320 ValaParameter* param = NULL;
1321 ValaList* _tmp55_;
1322 gpointer _tmp56_;
1323 ValaParameter* _tmp57_;
1324 _param_index = _param_index + 1;
1325 _tmp53_ = _param_index;
1326 _tmp54_ = _param_size;
1327 if (!(_tmp53_ < _tmp54_)) {
1328 break;
1329 }
1330 _tmp55_ = _param_list;
1331 _tmp56_ = vala_list_get (_tmp55_, _param_index);
1332 param = (ValaParameter*) _tmp56_;
1333 _tmp57_ = param;
1334 if (!vala_code_node_check ((ValaCodeNode*) _tmp57_, context)) {
1335 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
1336 }
1337 _vala_code_node_unref0 (param);
1338 }
1339 _vala_iterable_unref0 (_param_list);
1340 }
1341 _tmp58_ = self->priv->error_types;
1342 if (_tmp58_ != NULL) {
1343 {
1344 ValaList* _error_type_list = NULL;
1345 ValaList* _tmp59_;
1346 ValaList* _tmp60_;
1347 gint _error_type_size = 0;
1348 ValaList* _tmp61_;
1349 gint _tmp62_;
1350 gint _tmp63_;
1351 gint _error_type_index = 0;
1352 _tmp59_ = self->priv->error_types;
1353 _tmp60_ = _vala_iterable_ref0 (_tmp59_);
1354 _error_type_list = _tmp60_;
1355 _tmp61_ = _error_type_list;
1356 _tmp62_ = vala_collection_get_size ((ValaCollection*) _tmp61_);
1357 _tmp63_ = _tmp62_;
1358 _error_type_size = _tmp63_;
1359 _error_type_index = -1;
1360 while (TRUE) {
1361 gint _tmp64_;
1362 gint _tmp65_;
1363 ValaDataType* error_type = NULL;
1364 ValaList* _tmp66_;
1365 gpointer _tmp67_;
1366 ValaDataType* _tmp68_;
1367 ValaSemanticAnalyzer* _tmp69_;
1368 ValaSemanticAnalyzer* _tmp70_;
1369 ValaDataType* _tmp71_;
1370 _error_type_index = _error_type_index + 1;
1371 _tmp64_ = _error_type_index;
1372 _tmp65_ = _error_type_size;
1373 if (!(_tmp64_ < _tmp65_)) {
1374 break;
1375 }
1376 _tmp66_ = _error_type_list;
1377 _tmp67_ = vala_list_get (_tmp66_, _error_type_index);
1378 error_type = (ValaDataType*) _tmp67_;
1379 _tmp68_ = error_type;
1380 vala_code_node_check ((ValaCodeNode*) _tmp68_, context);
1381 _tmp69_ = vala_code_context_get_analyzer (context);
1382 _tmp70_ = _tmp69_;
1383 _tmp71_ = error_type;
1384 if (!vala_semantic_analyzer_is_type_accessible (_tmp70_, (ValaSymbol*) self, _tmp71_)) {
1385 ValaSourceReference* _tmp72_;
1386 ValaSourceReference* _tmp73_;
1387 ValaDataType* _tmp74_;
1388 gchar* _tmp75_;
1389 gchar* _tmp76_;
1390 gchar* _tmp77_;
1391 gchar* _tmp78_;
1392 gchar* _tmp79_;
1393 gchar* _tmp80_;
1394 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
1395 _tmp72_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1396 _tmp73_ = _tmp72_;
1397 _tmp74_ = error_type;
1398 _tmp75_ = vala_code_node_to_string ((ValaCodeNode*) _tmp74_);
1399 _tmp76_ = _tmp75_;
1400 _tmp77_ = vala_symbol_get_full_name ((ValaSymbol*) self);
1401 _tmp78_ = _tmp77_;
1402 _tmp79_ = g_strdup_printf ("error type `%s' is less accessible than delegate `%s'", _tmp76_, _tmp78_);
1403 _tmp80_ = _tmp79_;
1404 vala_report_error (_tmp73_, _tmp80_);
1405 _g_free0 (_tmp80_);
1406 _g_free0 (_tmp78_);
1407 _g_free0 (_tmp76_);
1408 result = FALSE;
1409 _vala_code_node_unref0 (error_type);
1410 _vala_iterable_unref0 (_error_type_list);
1411 _vala_source_file_unref0 (old_source_file);
1412 return result;
1413 }
1414 _vala_code_node_unref0 (error_type);
1415 }
1416 _vala_iterable_unref0 (_error_type_list);
1417 }
1418 }
1419 _tmp81_ = vala_code_context_get_analyzer (context);
1420 _tmp82_ = _tmp81_;
1421 _tmp83_ = old_source_file;
1422 vala_semantic_analyzer_set_current_source_file (_tmp82_, _tmp83_);
1423 _tmp84_ = vala_code_node_get_error ((ValaCodeNode*) self);
1424 _tmp85_ = _tmp84_;
1425 result = !_tmp85_;
1426 _vala_source_file_unref0 (old_source_file);
1427 return result;
1428 }
1429
1430 static void
vala_delegate_class_init(ValaDelegateClass * klass,gpointer klass_data)1431 vala_delegate_class_init (ValaDelegateClass * klass,
1432 gpointer klass_data)
1433 {
1434 vala_delegate_parent_class = g_type_class_peek_parent (klass);
1435 ((ValaCodeNodeClass *) klass)->finalize = vala_delegate_finalize;
1436 g_type_class_adjust_private_offset (klass, &ValaDelegate_private_offset);
1437 ((ValaTypeSymbolClass *) klass)->get_type_parameter_index = (gint (*) (ValaTypeSymbol*, const gchar*)) vala_delegate_real_get_type_parameter_index;
1438 ((ValaCodeNodeClass *) klass)->accept = (void (*) (ValaCodeNode*, ValaCodeVisitor*)) vala_delegate_real_accept;
1439 ((ValaCodeNodeClass *) klass)->accept_children = (void (*) (ValaCodeNode*, ValaCodeVisitor*)) vala_delegate_real_accept_children;
1440 ((ValaTypeSymbolClass *) klass)->is_reference_type = (gboolean (*) (ValaTypeSymbol*)) vala_delegate_real_is_reference_type;
1441 ((ValaCodeNodeClass *) klass)->get_error_types = (void (*) (ValaCodeNode*, ValaCollection*, ValaSourceReference*)) vala_delegate_real_get_error_types;
1442 ((ValaCodeNodeClass *) klass)->replace_type = (void (*) (ValaCodeNode*, ValaDataType*, ValaDataType*)) vala_delegate_real_replace_type;
1443 ((ValaCodeNodeClass *) klass)->check = (gboolean (*) (ValaCodeNode*, ValaCodeContext*)) vala_delegate_real_check;
1444 }
1445
1446 static void
vala_delegate_vala_callable_interface_init(ValaCallableIface * iface,gpointer iface_data)1447 vala_delegate_vala_callable_interface_init (ValaCallableIface * iface,
1448 gpointer iface_data)
1449 {
1450 vala_delegate_vala_callable_parent_iface = g_type_interface_peek_parent (iface);
1451 iface->add_parameter = (void (*) (ValaCallable*, ValaParameter*)) vala_delegate_real_add_parameter;
1452 iface->get_parameters = (ValaList* (*) (ValaCallable*)) vala_delegate_real_get_parameters;
1453 iface->get_return_type = vala_delegate_real_get_return_type;
1454 iface->set_return_type = vala_delegate_real_set_return_type;
1455 }
1456
1457 static void
vala_delegate_instance_init(ValaDelegate * self,gpointer klass)1458 vala_delegate_instance_init (ValaDelegate * self,
1459 gpointer klass)
1460 {
1461 GEqualFunc _tmp0_;
1462 ValaArrayList* _tmp1_;
1463 GEqualFunc _tmp2_;
1464 ValaArrayList* _tmp3_;
1465 self->priv = vala_delegate_get_instance_private (self);
1466 _tmp0_ = g_direct_equal;
1467 _tmp1_ = vala_array_list_new (VALA_TYPE_TYPEPARAMETER, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp0_);
1468 self->priv->type_parameters = (ValaList*) _tmp1_;
1469 _tmp2_ = g_direct_equal;
1470 _tmp3_ = vala_array_list_new (VALA_TYPE_PARAMETER, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp2_);
1471 self->priv->parameters = (ValaList*) _tmp3_;
1472 }
1473
1474 static void
vala_delegate_finalize(ValaCodeNode * obj)1475 vala_delegate_finalize (ValaCodeNode * obj)
1476 {
1477 ValaDelegate * self;
1478 self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALA_TYPE_DELEGATE, ValaDelegate);
1479 _vala_code_node_unref0 (self->priv->_sender_type);
1480 _vala_iterable_unref0 (self->priv->type_parameters);
1481 _vala_iterable_unref0 (self->priv->parameters);
1482 _vala_code_node_unref0 (self->priv->_return_type);
1483 _g_free0 (self->priv->_has_target);
1484 _vala_iterable_unref0 (self->priv->error_types);
1485 VALA_CODE_NODE_CLASS (vala_delegate_parent_class)->finalize (obj);
1486 }
1487
1488 /**
1489 * Represents a function callback type.
1490 */
1491 static GType
vala_delegate_get_type_once(void)1492 vala_delegate_get_type_once (void)
1493 {
1494 static const GTypeInfo g_define_type_info = { sizeof (ValaDelegateClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_delegate_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaDelegate), 0, (GInstanceInitFunc) vala_delegate_instance_init, NULL };
1495 static const GInterfaceInfo vala_callable_info = { (GInterfaceInitFunc) vala_delegate_vala_callable_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
1496 GType vala_delegate_type_id;
1497 vala_delegate_type_id = g_type_register_static (VALA_TYPE_TYPESYMBOL, "ValaDelegate", &g_define_type_info, 0);
1498 g_type_add_interface_static (vala_delegate_type_id, VALA_TYPE_CALLABLE, &vala_callable_info);
1499 ValaDelegate_private_offset = g_type_add_instance_private (vala_delegate_type_id, sizeof (ValaDelegatePrivate));
1500 return vala_delegate_type_id;
1501 }
1502
1503 GType
vala_delegate_get_type(void)1504 vala_delegate_get_type (void)
1505 {
1506 static volatile gsize vala_delegate_type_id__volatile = 0;
1507 if (g_once_init_enter (&vala_delegate_type_id__volatile)) {
1508 GType vala_delegate_type_id;
1509 vala_delegate_type_id = vala_delegate_get_type_once ();
1510 g_once_init_leave (&vala_delegate_type_id__volatile, vala_delegate_type_id);
1511 }
1512 return vala_delegate_type_id__volatile;
1513 }
1514
1515