1 /* valasignal.c generated by valac, the Vala compiler
2 * generated from valasignal.vala, do not modify */
3
4 /* valasignal.vala
5 *
6 * Copyright (C) 2006-2012 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 <glib.h>
28 #include <valagee.h>
29 #include <glib-object.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 _vala_iterable_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterable_unref (var), NULL)))
35 #define _g_free0(var) (var = (g_free (var), NULL))
36
37 struct _ValaSignalPrivate {
38 gboolean _is_virtual;
39 ValaList* parameters;
40 ValaMethod* _default_handler;
41 ValaMethod* _emitter;
42 ValaDataType* _return_type;
43 ValaBlock* _body;
44 };
45
46 static gint ValaSignal_private_offset;
47 static gpointer vala_signal_parent_class = NULL;
48 static ValaCallableIface * vala_signal_vala_callable_parent_iface = NULL;
49
50 static void vala_signal_set_default_handler (ValaSignal* self,
51 ValaMethod* value);
52 static void vala_signal_set_emitter (ValaSignal* self,
53 ValaMethod* value);
54 static void vala_signal_real_add_parameter (ValaCallable* base,
55 ValaParameter* param);
56 static ValaList* vala_signal_real_get_parameters (ValaCallable* base);
57 static void vala_signal_real_accept (ValaCodeNode* base,
58 ValaCodeVisitor* visitor);
59 static void vala_signal_real_accept_children (ValaCodeNode* base,
60 ValaCodeVisitor* visitor);
61 static void vala_signal_real_replace_type (ValaCodeNode* base,
62 ValaDataType* old_type,
63 ValaDataType* new_type);
64 static gboolean vala_signal_real_check (ValaCodeNode* base,
65 ValaCodeContext* context);
66 static void vala_signal_finalize (ValaCodeNode * obj);
67 static GType vala_signal_get_type_once (void);
68
69 static inline gpointer
vala_signal_get_instance_private(ValaSignal * self)70 vala_signal_get_instance_private (ValaSignal* self)
71 {
72 return G_STRUCT_MEMBER_P (self, ValaSignal_private_offset);
73 }
74
75 static ValaDataType*
vala_signal_real_get_return_type(ValaCallable * base)76 vala_signal_real_get_return_type (ValaCallable* base)
77 {
78 ValaDataType* result;
79 ValaSignal* self;
80 ValaDataType* _tmp0_;
81 self = (ValaSignal*) base;
82 _tmp0_ = self->priv->_return_type;
83 result = _tmp0_;
84 return result;
85 }
86
87 static gpointer
_vala_code_node_ref0(gpointer self)88 _vala_code_node_ref0 (gpointer self)
89 {
90 return self ? vala_code_node_ref (self) : NULL;
91 }
92
93 static void
vala_signal_real_set_return_type(ValaCallable * base,ValaDataType * value)94 vala_signal_real_set_return_type (ValaCallable* base,
95 ValaDataType* value)
96 {
97 ValaSignal* self;
98 ValaDataType* _tmp0_;
99 ValaDataType* _tmp1_;
100 self = (ValaSignal*) base;
101 _tmp0_ = _vala_code_node_ref0 (value);
102 _vala_code_node_unref0 (self->priv->_return_type);
103 self->priv->_return_type = _tmp0_;
104 _tmp1_ = self->priv->_return_type;
105 vala_code_node_set_parent_node ((ValaCodeNode*) _tmp1_, (ValaCodeNode*) self);
106 }
107
108 ValaBlock*
vala_signal_get_body(ValaSignal * self)109 vala_signal_get_body (ValaSignal* self)
110 {
111 ValaBlock* result;
112 ValaBlock* _tmp0_;
113 g_return_val_if_fail (self != NULL, NULL);
114 _tmp0_ = self->priv->_body;
115 result = _tmp0_;
116 return result;
117 }
118
119 void
vala_signal_set_body(ValaSignal * self,ValaBlock * value)120 vala_signal_set_body (ValaSignal* self,
121 ValaBlock* value)
122 {
123 ValaBlock* _tmp0_;
124 ValaBlock* _tmp1_;
125 g_return_if_fail (self != NULL);
126 _tmp0_ = _vala_code_node_ref0 (value);
127 _vala_code_node_unref0 (self->priv->_body);
128 self->priv->_body = _tmp0_;
129 _tmp1_ = self->priv->_body;
130 if (_tmp1_ != NULL) {
131 ValaBlock* _tmp2_;
132 ValaScope* _tmp3_;
133 ValaScope* _tmp4_;
134 _tmp2_ = self->priv->_body;
135 _tmp3_ = vala_symbol_get_scope ((ValaSymbol*) self);
136 _tmp4_ = _tmp3_;
137 vala_symbol_set_owner ((ValaSymbol*) _tmp2_, _tmp4_);
138 }
139 }
140
141 gboolean
vala_signal_get_is_virtual(ValaSignal * self)142 vala_signal_get_is_virtual (ValaSignal* self)
143 {
144 gboolean result;
145 g_return_val_if_fail (self != NULL, FALSE);
146 result = self->priv->_is_virtual;
147 return result;
148 }
149
150 void
vala_signal_set_is_virtual(ValaSignal * self,gboolean value)151 vala_signal_set_is_virtual (ValaSignal* self,
152 gboolean value)
153 {
154 g_return_if_fail (self != NULL);
155 self->priv->_is_virtual = value;
156 }
157
158 ValaMethod*
vala_signal_get_default_handler(ValaSignal * self)159 vala_signal_get_default_handler (ValaSignal* self)
160 {
161 ValaMethod* result;
162 ValaMethod* _tmp0_;
163 g_return_val_if_fail (self != NULL, NULL);
164 _tmp0_ = self->priv->_default_handler;
165 result = _tmp0_;
166 return result;
167 }
168
169 static void
vala_signal_set_default_handler(ValaSignal * self,ValaMethod * value)170 vala_signal_set_default_handler (ValaSignal* self,
171 ValaMethod* value)
172 {
173 ValaMethod* _tmp0_;
174 g_return_if_fail (self != NULL);
175 _tmp0_ = _vala_code_node_ref0 (value);
176 _vala_code_node_unref0 (self->priv->_default_handler);
177 self->priv->_default_handler = _tmp0_;
178 }
179
180 ValaMethod*
vala_signal_get_emitter(ValaSignal * self)181 vala_signal_get_emitter (ValaSignal* self)
182 {
183 ValaMethod* result;
184 ValaMethod* _tmp0_;
185 g_return_val_if_fail (self != NULL, NULL);
186 _tmp0_ = self->priv->_emitter;
187 result = _tmp0_;
188 return result;
189 }
190
191 static void
vala_signal_set_emitter(ValaSignal * self,ValaMethod * value)192 vala_signal_set_emitter (ValaSignal* self,
193 ValaMethod* value)
194 {
195 ValaMethod* _tmp0_;
196 g_return_if_fail (self != NULL);
197 _tmp0_ = _vala_code_node_ref0 (value);
198 _vala_code_node_unref0 (self->priv->_emitter);
199 self->priv->_emitter = _tmp0_;
200 }
201
202 /**
203 * Creates a new signal.
204 *
205 * @param name signal name
206 * @param return_type signal return type
207 * @param source_reference reference to source code
208 * @return newly created signal
209 */
210 ValaSignal*
vala_signal_construct(GType object_type,const gchar * name,ValaDataType * return_type,ValaSourceReference * source_reference,ValaComment * comment)211 vala_signal_construct (GType object_type,
212 const gchar* name,
213 ValaDataType* return_type,
214 ValaSourceReference* source_reference,
215 ValaComment* comment)
216 {
217 ValaSignal* self = NULL;
218 g_return_val_if_fail (name != NULL, NULL);
219 g_return_val_if_fail (return_type != NULL, NULL);
220 self = (ValaSignal*) vala_symbol_construct (object_type, name, source_reference, comment);
221 vala_callable_set_return_type ((ValaCallable*) self, return_type);
222 return self;
223 }
224
225 ValaSignal*
vala_signal_new(const gchar * name,ValaDataType * return_type,ValaSourceReference * source_reference,ValaComment * comment)226 vala_signal_new (const gchar* name,
227 ValaDataType* return_type,
228 ValaSourceReference* source_reference,
229 ValaComment* comment)
230 {
231 return vala_signal_construct (VALA_TYPE_SIGNAL, name, return_type, source_reference, comment);
232 }
233
234 /**
235 * Appends parameter to signal handler.
236 *
237 * @param param a formal parameter
238 */
239 static void
vala_signal_real_add_parameter(ValaCallable * base,ValaParameter * param)240 vala_signal_real_add_parameter (ValaCallable* base,
241 ValaParameter* param)
242 {
243 ValaSignal * self;
244 ValaList* _tmp0_;
245 ValaScope* _tmp1_;
246 ValaScope* _tmp2_;
247 const gchar* _tmp3_;
248 const gchar* _tmp4_;
249 self = (ValaSignal*) base;
250 g_return_if_fail (param != NULL);
251 _tmp0_ = self->priv->parameters;
252 vala_collection_add ((ValaCollection*) _tmp0_, param);
253 _tmp1_ = vala_symbol_get_scope ((ValaSymbol*) self);
254 _tmp2_ = _tmp1_;
255 _tmp3_ = vala_symbol_get_name ((ValaSymbol*) param);
256 _tmp4_ = _tmp3_;
257 vala_scope_add (_tmp2_, _tmp4_, (ValaSymbol*) param);
258 }
259
260 static ValaList*
vala_signal_real_get_parameters(ValaCallable * base)261 vala_signal_real_get_parameters (ValaCallable* base)
262 {
263 ValaSignal * self;
264 ValaList* _tmp0_;
265 ValaList* result = NULL;
266 self = (ValaSignal*) base;
267 _tmp0_ = self->priv->parameters;
268 result = _tmp0_;
269 return result;
270 }
271
272 /**
273 * Returns generated delegate to be used for signal handlers.
274 *
275 * @return delegate
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 ValaDelegate*
vala_signal_get_delegate(ValaSignal * self,ValaDataType * sender_type,ValaCodeNode * node_reference)284 vala_signal_get_delegate (ValaSignal* self,
285 ValaDataType* sender_type,
286 ValaCodeNode* node_reference)
287 {
288 ValaDataType* actual_return_type = NULL;
289 ValaDataType* _tmp0_;
290 ValaDataType* _tmp1_;
291 ValaDataType* _tmp2_;
292 ValaDelegate* generated_delegate = NULL;
293 ValaDataType* _tmp3_;
294 ValaDelegate* _tmp4_;
295 ValaDelegate* _tmp5_;
296 ValaDelegate* _tmp6_;
297 ValaScope* _tmp7_;
298 ValaScope* _tmp8_;
299 ValaDataType* sender_param_type = NULL;
300 ValaDataType* _tmp9_;
301 ValaDataType* _tmp10_;
302 ValaDataType* _tmp11_;
303 ValaDelegate* _tmp12_;
304 ValaDataType* _tmp13_;
305 gboolean is_generic = FALSE;
306 ValaScope* _tmp89_;
307 ValaScope* _tmp90_;
308 ValaDelegate* _tmp91_;
309 ValaDelegate* result = NULL;
310 g_return_val_if_fail (self != NULL, NULL);
311 g_return_val_if_fail (sender_type != NULL, NULL);
312 g_return_val_if_fail (node_reference != NULL, NULL);
313 _tmp0_ = vala_callable_get_return_type ((ValaCallable*) self);
314 _tmp1_ = _tmp0_;
315 _tmp2_ = vala_data_type_get_actual_type (_tmp1_, sender_type, NULL, node_reference);
316 actual_return_type = _tmp2_;
317 _tmp3_ = actual_return_type;
318 _tmp4_ = vala_delegate_new (NULL, _tmp3_, NULL, NULL);
319 generated_delegate = _tmp4_;
320 _tmp5_ = generated_delegate;
321 vala_symbol_set_access ((ValaSymbol*) _tmp5_, VALA_SYMBOL_ACCESSIBILITY_PUBLIC);
322 _tmp6_ = generated_delegate;
323 _tmp7_ = vala_symbol_get_scope ((ValaSymbol*) self);
324 _tmp8_ = _tmp7_;
325 vala_symbol_set_owner ((ValaSymbol*) _tmp6_, _tmp8_);
326 _tmp9_ = vala_data_type_copy (sender_type);
327 sender_param_type = _tmp9_;
328 _tmp10_ = sender_param_type;
329 vala_data_type_set_value_owned (_tmp10_, FALSE);
330 _tmp11_ = sender_param_type;
331 vala_data_type_set_nullable (_tmp11_, FALSE);
332 _tmp12_ = generated_delegate;
333 _tmp13_ = sender_param_type;
334 vala_delegate_set_sender_type (_tmp12_, _tmp13_);
335 is_generic = FALSE;
336 {
337 ValaList* _param_list = NULL;
338 ValaList* _tmp14_;
339 ValaList* _tmp15_;
340 gint _param_size = 0;
341 ValaList* _tmp16_;
342 gint _tmp17_;
343 gint _tmp18_;
344 gint _param_index = 0;
345 _tmp14_ = self->priv->parameters;
346 _tmp15_ = _vala_iterable_ref0 (_tmp14_);
347 _param_list = _tmp15_;
348 _tmp16_ = _param_list;
349 _tmp17_ = vala_collection_get_size ((ValaCollection*) _tmp16_);
350 _tmp18_ = _tmp17_;
351 _param_size = _tmp18_;
352 _param_index = -1;
353 while (TRUE) {
354 gint _tmp19_;
355 gint _tmp20_;
356 ValaParameter* param = NULL;
357 ValaList* _tmp21_;
358 gpointer _tmp22_;
359 ValaParameter* actual_param = NULL;
360 ValaParameter* _tmp23_;
361 ValaParameter* _tmp24_;
362 ValaParameter* _tmp25_;
363 ValaParameter* _tmp26_;
364 ValaDataType* _tmp27_;
365 ValaDataType* _tmp28_;
366 ValaDataType* _tmp29_;
367 ValaDataType* _tmp30_;
368 ValaDelegate* _tmp31_;
369 ValaParameter* _tmp32_;
370 ValaParameter* _tmp33_;
371 ValaDataType* _tmp34_;
372 ValaDataType* _tmp35_;
373 _param_index = _param_index + 1;
374 _tmp19_ = _param_index;
375 _tmp20_ = _param_size;
376 if (!(_tmp19_ < _tmp20_)) {
377 break;
378 }
379 _tmp21_ = _param_list;
380 _tmp22_ = vala_list_get (_tmp21_, _param_index);
381 param = (ValaParameter*) _tmp22_;
382 _tmp23_ = param;
383 _tmp24_ = vala_parameter_copy (_tmp23_);
384 actual_param = _tmp24_;
385 _tmp25_ = actual_param;
386 _tmp26_ = actual_param;
387 _tmp27_ = vala_variable_get_variable_type ((ValaVariable*) _tmp26_);
388 _tmp28_ = _tmp27_;
389 _tmp29_ = vala_data_type_get_actual_type (_tmp28_, sender_type, NULL, node_reference);
390 _tmp30_ = _tmp29_;
391 vala_variable_set_variable_type ((ValaVariable*) _tmp25_, _tmp30_);
392 _vala_code_node_unref0 (_tmp30_);
393 _tmp31_ = generated_delegate;
394 _tmp32_ = actual_param;
395 vala_callable_add_parameter ((ValaCallable*) _tmp31_, _tmp32_);
396 _tmp33_ = actual_param;
397 _tmp34_ = vala_variable_get_variable_type ((ValaVariable*) _tmp33_);
398 _tmp35_ = _tmp34_;
399 if (vala_data_type_is_generic (_tmp35_)) {
400 is_generic = TRUE;
401 }
402 _vala_code_node_unref0 (actual_param);
403 _vala_code_node_unref0 (param);
404 }
405 _vala_iterable_unref0 (_param_list);
406 }
407 if (is_generic) {
408 ValaObjectTypeSymbol* cl = NULL;
409 ValaSymbol* _tmp36_;
410 ValaSymbol* _tmp37_;
411 _tmp36_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self);
412 _tmp37_ = _tmp36_;
413 cl = G_TYPE_CHECK_INSTANCE_CAST (_tmp37_, VALA_TYPE_OBJECT_TYPE_SYMBOL, ValaObjectTypeSymbol);
414 {
415 ValaList* _type_param_list = NULL;
416 ValaObjectTypeSymbol* _tmp38_;
417 ValaList* _tmp39_;
418 ValaList* _tmp40_;
419 gint _type_param_size = 0;
420 ValaList* _tmp41_;
421 gint _tmp42_;
422 gint _tmp43_;
423 gint _type_param_index = 0;
424 _tmp38_ = cl;
425 _tmp39_ = vala_object_type_symbol_get_type_parameters (_tmp38_);
426 _tmp40_ = _vala_iterable_ref0 (_tmp39_);
427 _type_param_list = _tmp40_;
428 _tmp41_ = _type_param_list;
429 _tmp42_ = vala_collection_get_size ((ValaCollection*) _tmp41_);
430 _tmp43_ = _tmp42_;
431 _type_param_size = _tmp43_;
432 _type_param_index = -1;
433 while (TRUE) {
434 gint _tmp44_;
435 gint _tmp45_;
436 ValaTypeParameter* type_param = NULL;
437 ValaList* _tmp46_;
438 gpointer _tmp47_;
439 ValaDelegate* _tmp48_;
440 ValaTypeParameter* _tmp49_;
441 const gchar* _tmp50_;
442 const gchar* _tmp51_;
443 ValaTypeParameter* _tmp52_;
444 ValaSourceReference* _tmp53_;
445 ValaSourceReference* _tmp54_;
446 ValaTypeParameter* _tmp55_;
447 ValaTypeParameter* _tmp56_;
448 _type_param_index = _type_param_index + 1;
449 _tmp44_ = _type_param_index;
450 _tmp45_ = _type_param_size;
451 if (!(_tmp44_ < _tmp45_)) {
452 break;
453 }
454 _tmp46_ = _type_param_list;
455 _tmp47_ = vala_list_get (_tmp46_, _type_param_index);
456 type_param = (ValaTypeParameter*) _tmp47_;
457 _tmp48_ = generated_delegate;
458 _tmp49_ = type_param;
459 _tmp50_ = vala_symbol_get_name ((ValaSymbol*) _tmp49_);
460 _tmp51_ = _tmp50_;
461 _tmp52_ = type_param;
462 _tmp53_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp52_);
463 _tmp54_ = _tmp53_;
464 _tmp55_ = vala_typeparameter_new (_tmp51_, _tmp54_);
465 _tmp56_ = _tmp55_;
466 vala_delegate_add_type_parameter (_tmp48_, _tmp56_);
467 _vala_code_node_unref0 (_tmp56_);
468 _vala_code_node_unref0 (type_param);
469 }
470 _vala_iterable_unref0 (_type_param_list);
471 }
472 {
473 ValaList* _param_list = NULL;
474 ValaDelegate* _tmp57_;
475 ValaList* _tmp58_;
476 ValaList* _tmp59_;
477 gint _param_size = 0;
478 ValaList* _tmp60_;
479 gint _tmp61_;
480 gint _tmp62_;
481 gint _param_index = 0;
482 _tmp57_ = generated_delegate;
483 _tmp58_ = vala_callable_get_parameters ((ValaCallable*) _tmp57_);
484 _tmp59_ = _vala_iterable_ref0 (_tmp58_);
485 _param_list = _tmp59_;
486 _tmp60_ = _param_list;
487 _tmp61_ = vala_collection_get_size ((ValaCollection*) _tmp60_);
488 _tmp62_ = _tmp61_;
489 _param_size = _tmp62_;
490 _param_index = -1;
491 while (TRUE) {
492 gint _tmp63_;
493 gint _tmp64_;
494 ValaParameter* param = NULL;
495 ValaList* _tmp65_;
496 gpointer _tmp66_;
497 _param_index = _param_index + 1;
498 _tmp63_ = _param_index;
499 _tmp64_ = _param_size;
500 if (!(_tmp63_ < _tmp64_)) {
501 break;
502 }
503 _tmp65_ = _param_list;
504 _tmp66_ = vala_list_get (_tmp65_, _param_index);
505 param = (ValaParameter*) _tmp66_;
506 {
507 ValaList* _type_param_list = NULL;
508 ValaDelegate* _tmp67_;
509 ValaList* _tmp68_;
510 ValaList* _tmp69_;
511 gint _type_param_size = 0;
512 ValaList* _tmp70_;
513 gint _tmp71_;
514 gint _tmp72_;
515 gint _type_param_index = 0;
516 _tmp67_ = generated_delegate;
517 _tmp68_ = vala_delegate_get_type_parameters (_tmp67_);
518 _tmp69_ = _vala_iterable_ref0 (_tmp68_);
519 _type_param_list = _tmp69_;
520 _tmp70_ = _type_param_list;
521 _tmp71_ = vala_collection_get_size ((ValaCollection*) _tmp70_);
522 _tmp72_ = _tmp71_;
523 _type_param_size = _tmp72_;
524 _type_param_index = -1;
525 while (TRUE) {
526 gint _tmp73_;
527 gint _tmp74_;
528 ValaTypeParameter* type_param = NULL;
529 ValaList* _tmp75_;
530 gpointer _tmp76_;
531 ValaParameter* _tmp77_;
532 ValaDataType* _tmp78_;
533 ValaDataType* _tmp79_;
534 ValaObjectTypeSymbol* _tmp80_;
535 ValaList* _tmp81_;
536 ValaObjectTypeSymbol* _tmp82_;
537 ValaTypeParameter* _tmp83_;
538 const gchar* _tmp84_;
539 const gchar* _tmp85_;
540 gpointer _tmp86_;
541 ValaTypeParameter* _tmp87_;
542 ValaTypeParameter* _tmp88_;
543 _type_param_index = _type_param_index + 1;
544 _tmp73_ = _type_param_index;
545 _tmp74_ = _type_param_size;
546 if (!(_tmp73_ < _tmp74_)) {
547 break;
548 }
549 _tmp75_ = _type_param_list;
550 _tmp76_ = vala_list_get (_tmp75_, _type_param_index);
551 type_param = (ValaTypeParameter*) _tmp76_;
552 _tmp77_ = param;
553 _tmp78_ = vala_variable_get_variable_type ((ValaVariable*) _tmp77_);
554 _tmp79_ = _tmp78_;
555 _tmp80_ = cl;
556 _tmp81_ = vala_object_type_symbol_get_type_parameters (_tmp80_);
557 _tmp82_ = cl;
558 _tmp83_ = type_param;
559 _tmp84_ = vala_symbol_get_name ((ValaSymbol*) _tmp83_);
560 _tmp85_ = _tmp84_;
561 _tmp86_ = vala_list_get (_tmp81_, vala_typesymbol_get_type_parameter_index ((ValaTypeSymbol*) _tmp82_, _tmp85_));
562 _tmp87_ = (ValaTypeParameter*) _tmp86_;
563 _tmp88_ = type_param;
564 vala_data_type_replace_type_parameter (_tmp79_, _tmp87_, _tmp88_);
565 _vala_code_node_unref0 (_tmp87_);
566 _vala_code_node_unref0 (type_param);
567 }
568 _vala_iterable_unref0 (_type_param_list);
569 }
570 _vala_code_node_unref0 (param);
571 }
572 _vala_iterable_unref0 (_param_list);
573 }
574 }
575 _tmp89_ = vala_symbol_get_scope ((ValaSymbol*) self);
576 _tmp90_ = _tmp89_;
577 _tmp91_ = generated_delegate;
578 vala_scope_add (_tmp90_, NULL, (ValaSymbol*) _tmp91_);
579 result = generated_delegate;
580 _vala_code_node_unref0 (sender_param_type);
581 _vala_code_node_unref0 (actual_return_type);
582 return result;
583 }
584
585 static void
vala_signal_real_accept(ValaCodeNode * base,ValaCodeVisitor * visitor)586 vala_signal_real_accept (ValaCodeNode* base,
587 ValaCodeVisitor* visitor)
588 {
589 ValaSignal * self;
590 self = (ValaSignal*) base;
591 g_return_if_fail (visitor != NULL);
592 vala_code_visitor_visit_signal (visitor, self);
593 }
594
595 static void
vala_signal_real_accept_children(ValaCodeNode * base,ValaCodeVisitor * visitor)596 vala_signal_real_accept_children (ValaCodeNode* base,
597 ValaCodeVisitor* visitor)
598 {
599 ValaSignal * self;
600 ValaDataType* _tmp0_;
601 ValaDataType* _tmp1_;
602 gboolean _tmp12_ = FALSE;
603 ValaMethod* _tmp13_;
604 ValaMethod* _tmp20_;
605 self = (ValaSignal*) base;
606 g_return_if_fail (visitor != NULL);
607 _tmp0_ = vala_callable_get_return_type ((ValaCallable*) self);
608 _tmp1_ = _tmp0_;
609 vala_code_node_accept ((ValaCodeNode*) _tmp1_, visitor);
610 {
611 ValaList* _param_list = NULL;
612 ValaList* _tmp2_;
613 ValaList* _tmp3_;
614 gint _param_size = 0;
615 ValaList* _tmp4_;
616 gint _tmp5_;
617 gint _tmp6_;
618 gint _param_index = 0;
619 _tmp2_ = self->priv->parameters;
620 _tmp3_ = _vala_iterable_ref0 (_tmp2_);
621 _param_list = _tmp3_;
622 _tmp4_ = _param_list;
623 _tmp5_ = vala_collection_get_size ((ValaCollection*) _tmp4_);
624 _tmp6_ = _tmp5_;
625 _param_size = _tmp6_;
626 _param_index = -1;
627 while (TRUE) {
628 gint _tmp7_;
629 gint _tmp8_;
630 ValaParameter* param = NULL;
631 ValaList* _tmp9_;
632 gpointer _tmp10_;
633 ValaParameter* _tmp11_;
634 _param_index = _param_index + 1;
635 _tmp7_ = _param_index;
636 _tmp8_ = _param_size;
637 if (!(_tmp7_ < _tmp8_)) {
638 break;
639 }
640 _tmp9_ = _param_list;
641 _tmp10_ = vala_list_get (_tmp9_, _param_index);
642 param = (ValaParameter*) _tmp10_;
643 _tmp11_ = param;
644 vala_code_node_accept ((ValaCodeNode*) _tmp11_, visitor);
645 _vala_code_node_unref0 (param);
646 }
647 _vala_iterable_unref0 (_param_list);
648 }
649 _tmp13_ = self->priv->_default_handler;
650 if (_tmp13_ == NULL) {
651 ValaBlock* _tmp14_;
652 ValaBlock* _tmp15_;
653 _tmp14_ = vala_signal_get_body (self);
654 _tmp15_ = _tmp14_;
655 _tmp12_ = _tmp15_ != NULL;
656 } else {
657 _tmp12_ = FALSE;
658 }
659 if (_tmp12_) {
660 ValaBlock* _tmp16_;
661 ValaBlock* _tmp17_;
662 _tmp16_ = vala_signal_get_body (self);
663 _tmp17_ = _tmp16_;
664 vala_code_node_accept ((ValaCodeNode*) _tmp17_, visitor);
665 } else {
666 ValaMethod* _tmp18_;
667 _tmp18_ = self->priv->_default_handler;
668 if (_tmp18_ != NULL) {
669 ValaMethod* _tmp19_;
670 _tmp19_ = self->priv->_default_handler;
671 vala_code_node_accept ((ValaCodeNode*) _tmp19_, visitor);
672 }
673 }
674 _tmp20_ = self->priv->_emitter;
675 if (_tmp20_ != NULL) {
676 ValaMethod* _tmp21_;
677 _tmp21_ = self->priv->_emitter;
678 vala_code_node_accept ((ValaCodeNode*) _tmp21_, visitor);
679 }
680 }
681
682 static void
vala_signal_real_replace_type(ValaCodeNode * base,ValaDataType * old_type,ValaDataType * new_type)683 vala_signal_real_replace_type (ValaCodeNode* base,
684 ValaDataType* old_type,
685 ValaDataType* new_type)
686 {
687 ValaSignal * self;
688 ValaDataType* _tmp0_;
689 ValaDataType* _tmp1_;
690 self = (ValaSignal*) base;
691 g_return_if_fail (old_type != NULL);
692 g_return_if_fail (new_type != NULL);
693 _tmp0_ = vala_callable_get_return_type ((ValaCallable*) self);
694 _tmp1_ = _tmp0_;
695 if (_tmp1_ == old_type) {
696 vala_callable_set_return_type ((ValaCallable*) self, new_type);
697 }
698 }
699
700 static gboolean
vala_signal_real_check(ValaCodeNode * base,ValaCodeContext * context)701 vala_signal_real_check (ValaCodeNode* base,
702 ValaCodeContext* context)
703 {
704 ValaSignal * self;
705 gboolean _tmp0_;
706 gboolean _tmp1_;
707 ValaClass* parent_cl = NULL;
708 ValaSymbol* _tmp4_;
709 ValaSymbol* _tmp5_;
710 gboolean _tmp6_ = FALSE;
711 ValaClass* _tmp7_;
712 ValaClass* _tmp13_;
713 ValaDataType* _tmp36_;
714 ValaDataType* _tmp37_;
715 ValaDataType* _tmp38_;
716 ValaDataType* _tmp39_;
717 ValaTypeSymbol* _tmp40_;
718 ValaTypeSymbol* _tmp41_;
719 ValaSemanticAnalyzer* _tmp42_;
720 ValaSemanticAnalyzer* _tmp43_;
721 ValaDataType* _tmp44_;
722 ValaTypeSymbol* _tmp45_;
723 ValaTypeSymbol* _tmp46_;
724 gboolean _tmp73_ = FALSE;
725 gboolean _tmp74_;
726 gboolean _tmp79_;
727 ValaAttribute* _tmp121_;
728 gboolean _tmp191_ = FALSE;
729 gboolean _tmp192_ = FALSE;
730 gboolean _tmp193_;
731 gboolean _tmp194_;
732 gboolean _tmp209_;
733 gboolean _tmp210_;
734 gboolean result = FALSE;
735 self = (ValaSignal*) base;
736 g_return_val_if_fail (context != NULL, FALSE);
737 _tmp0_ = vala_code_node_get_checked ((ValaCodeNode*) self);
738 _tmp1_ = _tmp0_;
739 if (_tmp1_) {
740 gboolean _tmp2_;
741 gboolean _tmp3_;
742 _tmp2_ = vala_code_node_get_error ((ValaCodeNode*) self);
743 _tmp3_ = _tmp2_;
744 result = !_tmp3_;
745 return result;
746 }
747 vala_code_node_set_checked ((ValaCodeNode*) self, TRUE);
748 _tmp4_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self);
749 _tmp5_ = _tmp4_;
750 parent_cl = VALA_IS_CLASS (_tmp5_) ? ((ValaClass*) _tmp5_) : NULL;
751 _tmp7_ = parent_cl;
752 if (_tmp7_ != NULL) {
753 ValaClass* _tmp8_;
754 gboolean _tmp9_;
755 gboolean _tmp10_;
756 _tmp8_ = parent_cl;
757 _tmp9_ = vala_class_get_is_compact (_tmp8_);
758 _tmp10_ = _tmp9_;
759 _tmp6_ = _tmp10_;
760 } else {
761 _tmp6_ = FALSE;
762 }
763 if (_tmp6_) {
764 ValaSourceReference* _tmp11_;
765 ValaSourceReference* _tmp12_;
766 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
767 _tmp11_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
768 _tmp12_ = _tmp11_;
769 vala_report_error (_tmp12_, "Signals are not supported in compact classes");
770 result = FALSE;
771 return result;
772 }
773 _tmp13_ = parent_cl;
774 if (_tmp13_ != NULL) {
775 {
776 ValaList* _base_type_list = NULL;
777 ValaClass* _tmp14_;
778 ValaList* _tmp15_;
779 ValaList* _tmp16_;
780 gint _base_type_size = 0;
781 ValaList* _tmp17_;
782 gint _tmp18_;
783 gint _tmp19_;
784 gint _base_type_index = 0;
785 _tmp14_ = parent_cl;
786 _tmp15_ = vala_class_get_base_types (_tmp14_);
787 _tmp16_ = _vala_iterable_ref0 (_tmp15_);
788 _base_type_list = _tmp16_;
789 _tmp17_ = _base_type_list;
790 _tmp18_ = vala_collection_get_size ((ValaCollection*) _tmp17_);
791 _tmp19_ = _tmp18_;
792 _base_type_size = _tmp19_;
793 _base_type_index = -1;
794 while (TRUE) {
795 gint _tmp20_;
796 gint _tmp21_;
797 ValaDataType* base_type = NULL;
798 ValaList* _tmp22_;
799 gpointer _tmp23_;
800 ValaDataType* _tmp24_;
801 ValaTypeSymbol* _tmp25_;
802 ValaTypeSymbol* _tmp26_;
803 const gchar* _tmp27_;
804 const gchar* _tmp28_;
805 ValaSymbol* _tmp29_;
806 ValaSymbol* _tmp30_;
807 gboolean _tmp31_;
808 _base_type_index = _base_type_index + 1;
809 _tmp20_ = _base_type_index;
810 _tmp21_ = _base_type_size;
811 if (!(_tmp20_ < _tmp21_)) {
812 break;
813 }
814 _tmp22_ = _base_type_list;
815 _tmp23_ = vala_list_get (_tmp22_, _base_type_index);
816 base_type = (ValaDataType*) _tmp23_;
817 _tmp24_ = base_type;
818 _tmp25_ = vala_data_type_get_type_symbol (_tmp24_);
819 _tmp26_ = _tmp25_;
820 _tmp27_ = vala_symbol_get_name ((ValaSymbol*) self);
821 _tmp28_ = _tmp27_;
822 _tmp29_ = vala_semantic_analyzer_symbol_lookup_inherited ((ValaSymbol*) _tmp26_, _tmp28_);
823 _tmp30_ = _tmp29_;
824 _tmp31_ = VALA_IS_SIGNAL (_tmp30_);
825 _vala_code_node_unref0 (_tmp30_);
826 if (_tmp31_) {
827 ValaSourceReference* _tmp32_;
828 ValaSourceReference* _tmp33_;
829 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
830 _tmp32_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
831 _tmp33_ = _tmp32_;
832 vala_report_error (_tmp33_, "Signals with the same name as a signal in a base type are not supporte" \
833 "d");
834 result = FALSE;
835 _vala_code_node_unref0 (base_type);
836 _vala_iterable_unref0 (_base_type_list);
837 return result;
838 }
839 _vala_code_node_unref0 (base_type);
840 }
841 _vala_iterable_unref0 (_base_type_list);
842 }
843 }
844 if (VALA_IS_DYNAMIC_SIGNAL (self)) {
845 gboolean _tmp34_;
846 gboolean _tmp35_;
847 _tmp34_ = vala_code_node_get_error ((ValaCodeNode*) self);
848 _tmp35_ = _tmp34_;
849 result = !_tmp35_;
850 return result;
851 }
852 _tmp36_ = vala_callable_get_return_type ((ValaCallable*) self);
853 _tmp37_ = _tmp36_;
854 vala_code_node_check ((ValaCodeNode*) _tmp37_, context);
855 _tmp38_ = vala_callable_get_return_type ((ValaCallable*) self);
856 _tmp39_ = _tmp38_;
857 _tmp40_ = vala_data_type_get_type_symbol (_tmp39_);
858 _tmp41_ = _tmp40_;
859 _tmp42_ = vala_code_context_get_analyzer (context);
860 _tmp43_ = _tmp42_;
861 _tmp44_ = _tmp43_->va_list_type;
862 _tmp45_ = vala_data_type_get_type_symbol (_tmp44_);
863 _tmp46_ = _tmp45_;
864 if (_tmp41_ == _tmp46_) {
865 ValaSourceReference* _tmp47_;
866 ValaSourceReference* _tmp48_;
867 ValaDataType* _tmp49_;
868 ValaDataType* _tmp50_;
869 ValaTypeSymbol* _tmp51_;
870 ValaTypeSymbol* _tmp52_;
871 gchar* _tmp53_;
872 gchar* _tmp54_;
873 gchar* _tmp55_;
874 gchar* _tmp56_;
875 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
876 _tmp47_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
877 _tmp48_ = _tmp47_;
878 _tmp49_ = vala_callable_get_return_type ((ValaCallable*) self);
879 _tmp50_ = _tmp49_;
880 _tmp51_ = vala_data_type_get_type_symbol (_tmp50_);
881 _tmp52_ = _tmp51_;
882 _tmp53_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp52_);
883 _tmp54_ = _tmp53_;
884 _tmp55_ = g_strdup_printf ("`%s' not supported as return type", _tmp54_);
885 _tmp56_ = _tmp55_;
886 vala_report_error (_tmp48_, _tmp56_);
887 _g_free0 (_tmp56_);
888 _g_free0 (_tmp54_);
889 result = FALSE;
890 return result;
891 }
892 {
893 ValaList* _param_list = NULL;
894 ValaList* _tmp57_;
895 ValaList* _tmp58_;
896 gint _param_size = 0;
897 ValaList* _tmp59_;
898 gint _tmp60_;
899 gint _tmp61_;
900 gint _param_index = 0;
901 _tmp57_ = self->priv->parameters;
902 _tmp58_ = _vala_iterable_ref0 (_tmp57_);
903 _param_list = _tmp58_;
904 _tmp59_ = _param_list;
905 _tmp60_ = vala_collection_get_size ((ValaCollection*) _tmp59_);
906 _tmp61_ = _tmp60_;
907 _param_size = _tmp61_;
908 _param_index = -1;
909 while (TRUE) {
910 gint _tmp62_;
911 gint _tmp63_;
912 ValaParameter* param = NULL;
913 ValaList* _tmp64_;
914 gpointer _tmp65_;
915 ValaParameter* _tmp66_;
916 gboolean _tmp67_;
917 gboolean _tmp68_;
918 ValaParameter* _tmp72_;
919 _param_index = _param_index + 1;
920 _tmp62_ = _param_index;
921 _tmp63_ = _param_size;
922 if (!(_tmp62_ < _tmp63_)) {
923 break;
924 }
925 _tmp64_ = _param_list;
926 _tmp65_ = vala_list_get (_tmp64_, _param_index);
927 param = (ValaParameter*) _tmp65_;
928 _tmp66_ = param;
929 _tmp67_ = vala_parameter_get_ellipsis (_tmp66_);
930 _tmp68_ = _tmp67_;
931 if (_tmp68_) {
932 ValaParameter* _tmp69_;
933 ValaSourceReference* _tmp70_;
934 ValaSourceReference* _tmp71_;
935 _tmp69_ = param;
936 _tmp70_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp69_);
937 _tmp71_ = _tmp70_;
938 vala_report_error (_tmp71_, "Signals with variable argument lists are not supported");
939 result = FALSE;
940 _vala_code_node_unref0 (param);
941 _vala_iterable_unref0 (_param_list);
942 return result;
943 }
944 _tmp72_ = param;
945 if (!vala_code_node_check ((ValaCodeNode*) _tmp72_, context)) {
946 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
947 }
948 _vala_code_node_unref0 (param);
949 }
950 _vala_iterable_unref0 (_param_list);
951 }
952 _tmp74_ = self->priv->_is_virtual;
953 if (!_tmp74_) {
954 ValaBlock* _tmp75_;
955 ValaBlock* _tmp76_;
956 _tmp75_ = vala_signal_get_body (self);
957 _tmp76_ = _tmp75_;
958 _tmp73_ = _tmp76_ != NULL;
959 } else {
960 _tmp73_ = FALSE;
961 }
962 if (_tmp73_) {
963 ValaSourceReference* _tmp77_;
964 ValaSourceReference* _tmp78_;
965 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
966 _tmp77_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
967 _tmp78_ = _tmp77_;
968 vala_report_error (_tmp78_, "Only virtual signals can have a default signal handler body");
969 }
970 _tmp79_ = self->priv->_is_virtual;
971 if (_tmp79_) {
972 const gchar* _tmp80_;
973 const gchar* _tmp81_;
974 ValaDataType* _tmp82_;
975 ValaDataType* _tmp83_;
976 ValaSourceReference* _tmp84_;
977 ValaSourceReference* _tmp85_;
978 ValaMethod* _tmp86_;
979 ValaMethod* _tmp87_;
980 ValaMethod* _tmp88_;
981 ValaScope* _tmp89_;
982 ValaScope* _tmp90_;
983 ValaMethod* _tmp91_;
984 ValaSymbolAccessibility _tmp92_;
985 ValaSymbolAccessibility _tmp93_;
986 ValaMethod* _tmp94_;
987 gboolean _tmp95_;
988 gboolean _tmp96_;
989 ValaMethod* _tmp97_;
990 gboolean _tmp98_;
991 gboolean _tmp99_;
992 ValaMethod* _tmp100_;
993 ValaMethod* _tmp101_;
994 ValaMethod* _tmp102_;
995 ValaBlock* _tmp103_;
996 ValaBlock* _tmp104_;
997 ValaObjectTypeSymbol* cl = NULL;
998 ValaSymbol* _tmp116_;
999 ValaSymbol* _tmp117_;
1000 ValaObjectTypeSymbol* _tmp118_;
1001 ValaMethod* _tmp119_;
1002 ValaMethod* _tmp120_;
1003 _tmp80_ = vala_symbol_get_name ((ValaSymbol*) self);
1004 _tmp81_ = _tmp80_;
1005 _tmp82_ = vala_callable_get_return_type ((ValaCallable*) self);
1006 _tmp83_ = _tmp82_;
1007 _tmp84_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1008 _tmp85_ = _tmp84_;
1009 _tmp86_ = vala_method_new (_tmp81_, _tmp83_, _tmp85_, NULL);
1010 _tmp87_ = _tmp86_;
1011 vala_signal_set_default_handler (self, _tmp87_);
1012 _vala_code_node_unref0 (_tmp87_);
1013 _tmp88_ = self->priv->_default_handler;
1014 _tmp89_ = vala_symbol_get_owner ((ValaSymbol*) self);
1015 _tmp90_ = _tmp89_;
1016 vala_symbol_set_owner ((ValaSymbol*) _tmp88_, _tmp90_);
1017 _tmp91_ = self->priv->_default_handler;
1018 _tmp92_ = vala_symbol_get_access ((ValaSymbol*) self);
1019 _tmp93_ = _tmp92_;
1020 vala_symbol_set_access ((ValaSymbol*) _tmp91_, _tmp93_);
1021 _tmp94_ = self->priv->_default_handler;
1022 _tmp95_ = vala_symbol_get_external ((ValaSymbol*) self);
1023 _tmp96_ = _tmp95_;
1024 vala_symbol_set_external ((ValaSymbol*) _tmp94_, _tmp96_);
1025 _tmp97_ = self->priv->_default_handler;
1026 _tmp98_ = vala_symbol_get_hides ((ValaSymbol*) self);
1027 _tmp99_ = _tmp98_;
1028 vala_symbol_set_hides ((ValaSymbol*) _tmp97_, _tmp99_);
1029 _tmp100_ = self->priv->_default_handler;
1030 vala_method_set_is_virtual (_tmp100_, TRUE);
1031 _tmp101_ = self->priv->_default_handler;
1032 vala_method_set_signal_reference (_tmp101_, self);
1033 _tmp102_ = self->priv->_default_handler;
1034 _tmp103_ = vala_signal_get_body (self);
1035 _tmp104_ = _tmp103_;
1036 vala_subroutine_set_body ((ValaSubroutine*) _tmp102_, _tmp104_);
1037 {
1038 ValaList* _param_list = NULL;
1039 ValaList* _tmp105_;
1040 ValaList* _tmp106_;
1041 gint _param_size = 0;
1042 ValaList* _tmp107_;
1043 gint _tmp108_;
1044 gint _tmp109_;
1045 gint _param_index = 0;
1046 _tmp105_ = self->priv->parameters;
1047 _tmp106_ = _vala_iterable_ref0 (_tmp105_);
1048 _param_list = _tmp106_;
1049 _tmp107_ = _param_list;
1050 _tmp108_ = vala_collection_get_size ((ValaCollection*) _tmp107_);
1051 _tmp109_ = _tmp108_;
1052 _param_size = _tmp109_;
1053 _param_index = -1;
1054 while (TRUE) {
1055 gint _tmp110_;
1056 gint _tmp111_;
1057 ValaParameter* param = NULL;
1058 ValaList* _tmp112_;
1059 gpointer _tmp113_;
1060 ValaMethod* _tmp114_;
1061 ValaParameter* _tmp115_;
1062 _param_index = _param_index + 1;
1063 _tmp110_ = _param_index;
1064 _tmp111_ = _param_size;
1065 if (!(_tmp110_ < _tmp111_)) {
1066 break;
1067 }
1068 _tmp112_ = _param_list;
1069 _tmp113_ = vala_list_get (_tmp112_, _param_index);
1070 param = (ValaParameter*) _tmp113_;
1071 _tmp114_ = self->priv->_default_handler;
1072 _tmp115_ = param;
1073 vala_callable_add_parameter ((ValaCallable*) _tmp114_, _tmp115_);
1074 _vala_code_node_unref0 (param);
1075 }
1076 _vala_iterable_unref0 (_param_list);
1077 }
1078 _tmp116_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self);
1079 _tmp117_ = _tmp116_;
1080 cl = VALA_IS_OBJECT_TYPE_SYMBOL (_tmp117_) ? ((ValaObjectTypeSymbol*) _tmp117_) : NULL;
1081 _tmp118_ = cl;
1082 _tmp119_ = self->priv->_default_handler;
1083 vala_object_type_symbol_add_hidden_method (_tmp118_, _tmp119_);
1084 _tmp120_ = self->priv->_default_handler;
1085 vala_code_node_check ((ValaCodeNode*) _tmp120_, context);
1086 }
1087 _tmp121_ = vala_code_node_get_attribute ((ValaCodeNode*) self, "HasEmitter");
1088 if (_tmp121_ != NULL) {
1089 const gchar* _tmp122_;
1090 const gchar* _tmp123_;
1091 ValaDataType* _tmp124_;
1092 ValaDataType* _tmp125_;
1093 ValaSourceReference* _tmp126_;
1094 ValaSourceReference* _tmp127_;
1095 ValaMethod* _tmp128_;
1096 ValaMethod* _tmp129_;
1097 ValaMethod* _tmp130_;
1098 ValaScope* _tmp131_;
1099 ValaScope* _tmp132_;
1100 ValaMethod* _tmp133_;
1101 ValaSymbolAccessibility _tmp134_;
1102 ValaSymbolAccessibility _tmp135_;
1103 ValaBlock* body = NULL;
1104 ValaSourceReference* _tmp136_;
1105 ValaSourceReference* _tmp137_;
1106 ValaBlock* _tmp138_;
1107 ValaMethodCall* call = NULL;
1108 const gchar* _tmp139_;
1109 const gchar* _tmp140_;
1110 ValaSourceReference* _tmp141_;
1111 ValaSourceReference* _tmp142_;
1112 ValaMemberAccess* _tmp143_;
1113 ValaMemberAccess* _tmp144_;
1114 ValaSourceReference* _tmp145_;
1115 ValaSourceReference* _tmp146_;
1116 ValaMethodCall* _tmp147_;
1117 ValaMethodCall* _tmp148_;
1118 ValaDataType* _tmp168_;
1119 ValaDataType* _tmp169_;
1120 ValaMethod* _tmp182_;
1121 ValaBlock* _tmp183_;
1122 ValaObjectTypeSymbol* cl = NULL;
1123 ValaSymbol* _tmp184_;
1124 ValaSymbol* _tmp185_;
1125 ValaObjectTypeSymbol* _tmp186_;
1126 ValaMethod* _tmp187_;
1127 gboolean _tmp188_;
1128 gboolean _tmp189_;
1129 _tmp122_ = vala_symbol_get_name ((ValaSymbol*) self);
1130 _tmp123_ = _tmp122_;
1131 _tmp124_ = vala_callable_get_return_type ((ValaCallable*) self);
1132 _tmp125_ = _tmp124_;
1133 _tmp126_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1134 _tmp127_ = _tmp126_;
1135 _tmp128_ = vala_method_new (_tmp123_, _tmp125_, _tmp127_, NULL);
1136 _tmp129_ = _tmp128_;
1137 vala_signal_set_emitter (self, _tmp129_);
1138 _vala_code_node_unref0 (_tmp129_);
1139 _tmp130_ = self->priv->_emitter;
1140 _tmp131_ = vala_symbol_get_owner ((ValaSymbol*) self);
1141 _tmp132_ = _tmp131_;
1142 vala_symbol_set_owner ((ValaSymbol*) _tmp130_, _tmp132_);
1143 _tmp133_ = self->priv->_emitter;
1144 _tmp134_ = vala_symbol_get_access ((ValaSymbol*) self);
1145 _tmp135_ = _tmp134_;
1146 vala_symbol_set_access ((ValaSymbol*) _tmp133_, _tmp135_);
1147 _tmp136_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1148 _tmp137_ = _tmp136_;
1149 _tmp138_ = vala_block_new (_tmp137_);
1150 body = _tmp138_;
1151 _tmp139_ = vala_symbol_get_name ((ValaSymbol*) self);
1152 _tmp140_ = _tmp139_;
1153 _tmp141_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1154 _tmp142_ = _tmp141_;
1155 _tmp143_ = vala_member_access_new_simple (_tmp140_, _tmp142_);
1156 _tmp144_ = _tmp143_;
1157 _tmp145_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1158 _tmp146_ = _tmp145_;
1159 _tmp147_ = vala_method_call_new ((ValaExpression*) _tmp144_, _tmp146_);
1160 _tmp148_ = _tmp147_;
1161 _vala_code_node_unref0 (_tmp144_);
1162 call = _tmp148_;
1163 {
1164 ValaList* _param_list = NULL;
1165 ValaList* _tmp149_;
1166 ValaList* _tmp150_;
1167 gint _param_size = 0;
1168 ValaList* _tmp151_;
1169 gint _tmp152_;
1170 gint _tmp153_;
1171 gint _param_index = 0;
1172 _tmp149_ = self->priv->parameters;
1173 _tmp150_ = _vala_iterable_ref0 (_tmp149_);
1174 _param_list = _tmp150_;
1175 _tmp151_ = _param_list;
1176 _tmp152_ = vala_collection_get_size ((ValaCollection*) _tmp151_);
1177 _tmp153_ = _tmp152_;
1178 _param_size = _tmp153_;
1179 _param_index = -1;
1180 while (TRUE) {
1181 gint _tmp154_;
1182 gint _tmp155_;
1183 ValaParameter* param = NULL;
1184 ValaList* _tmp156_;
1185 gpointer _tmp157_;
1186 ValaMethod* _tmp158_;
1187 ValaParameter* _tmp159_;
1188 ValaMethodCall* _tmp160_;
1189 ValaParameter* _tmp161_;
1190 const gchar* _tmp162_;
1191 const gchar* _tmp163_;
1192 ValaSourceReference* _tmp164_;
1193 ValaSourceReference* _tmp165_;
1194 ValaMemberAccess* _tmp166_;
1195 ValaMemberAccess* _tmp167_;
1196 _param_index = _param_index + 1;
1197 _tmp154_ = _param_index;
1198 _tmp155_ = _param_size;
1199 if (!(_tmp154_ < _tmp155_)) {
1200 break;
1201 }
1202 _tmp156_ = _param_list;
1203 _tmp157_ = vala_list_get (_tmp156_, _param_index);
1204 param = (ValaParameter*) _tmp157_;
1205 _tmp158_ = self->priv->_emitter;
1206 _tmp159_ = param;
1207 vala_callable_add_parameter ((ValaCallable*) _tmp158_, _tmp159_);
1208 _tmp160_ = call;
1209 _tmp161_ = param;
1210 _tmp162_ = vala_symbol_get_name ((ValaSymbol*) _tmp161_);
1211 _tmp163_ = _tmp162_;
1212 _tmp164_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1213 _tmp165_ = _tmp164_;
1214 _tmp166_ = vala_member_access_new_simple (_tmp163_, _tmp165_);
1215 _tmp167_ = _tmp166_;
1216 vala_method_call_add_argument (_tmp160_, (ValaExpression*) _tmp167_);
1217 _vala_code_node_unref0 (_tmp167_);
1218 _vala_code_node_unref0 (param);
1219 }
1220 _vala_iterable_unref0 (_param_list);
1221 }
1222 _tmp168_ = vala_callable_get_return_type ((ValaCallable*) self);
1223 _tmp169_ = _tmp168_;
1224 if (VALA_IS_VOID_TYPE (_tmp169_)) {
1225 ValaBlock* _tmp170_;
1226 ValaMethodCall* _tmp171_;
1227 ValaSourceReference* _tmp172_;
1228 ValaSourceReference* _tmp173_;
1229 ValaExpressionStatement* _tmp174_;
1230 ValaExpressionStatement* _tmp175_;
1231 _tmp170_ = body;
1232 _tmp171_ = call;
1233 _tmp172_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1234 _tmp173_ = _tmp172_;
1235 _tmp174_ = vala_expression_statement_new ((ValaExpression*) _tmp171_, _tmp173_);
1236 _tmp175_ = _tmp174_;
1237 vala_block_add_statement (_tmp170_, (ValaStatement*) _tmp175_);
1238 _vala_code_node_unref0 (_tmp175_);
1239 } else {
1240 ValaBlock* _tmp176_;
1241 ValaMethodCall* _tmp177_;
1242 ValaSourceReference* _tmp178_;
1243 ValaSourceReference* _tmp179_;
1244 ValaReturnStatement* _tmp180_;
1245 ValaReturnStatement* _tmp181_;
1246 _tmp176_ = body;
1247 _tmp177_ = call;
1248 _tmp178_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1249 _tmp179_ = _tmp178_;
1250 _tmp180_ = vala_return_statement_new ((ValaExpression*) _tmp177_, _tmp179_);
1251 _tmp181_ = _tmp180_;
1252 vala_block_add_statement (_tmp176_, (ValaStatement*) _tmp181_);
1253 _vala_code_node_unref0 (_tmp181_);
1254 }
1255 _tmp182_ = self->priv->_emitter;
1256 _tmp183_ = body;
1257 vala_subroutine_set_body ((ValaSubroutine*) _tmp182_, _tmp183_);
1258 _tmp184_ = vala_symbol_get_parent_symbol ((ValaSymbol*) self);
1259 _tmp185_ = _tmp184_;
1260 cl = VALA_IS_OBJECT_TYPE_SYMBOL (_tmp185_) ? ((ValaObjectTypeSymbol*) _tmp185_) : NULL;
1261 _tmp186_ = cl;
1262 _tmp187_ = self->priv->_emitter;
1263 vala_object_type_symbol_add_hidden_method (_tmp186_, _tmp187_);
1264 _tmp188_ = vala_symbol_get_external_package ((ValaSymbol*) self);
1265 _tmp189_ = _tmp188_;
1266 if (!_tmp189_) {
1267 ValaMethod* _tmp190_;
1268 _tmp190_ = self->priv->_emitter;
1269 vala_code_node_check ((ValaCodeNode*) _tmp190_, context);
1270 }
1271 _vala_code_node_unref0 (call);
1272 _vala_code_node_unref0 (body);
1273 }
1274 _tmp193_ = vala_symbol_get_external_package ((ValaSymbol*) self);
1275 _tmp194_ = _tmp193_;
1276 if (!_tmp194_) {
1277 gboolean _tmp195_;
1278 gboolean _tmp196_;
1279 _tmp195_ = vala_symbol_get_hides ((ValaSymbol*) self);
1280 _tmp196_ = _tmp195_;
1281 _tmp192_ = !_tmp196_;
1282 } else {
1283 _tmp192_ = FALSE;
1284 }
1285 if (_tmp192_) {
1286 ValaSymbol* _tmp197_;
1287 ValaSymbol* _tmp198_;
1288 _tmp197_ = vala_symbol_get_hidden_member ((ValaSymbol*) self);
1289 _tmp198_ = _tmp197_;
1290 _tmp191_ = _tmp198_ != NULL;
1291 _vala_code_node_unref0 (_tmp198_);
1292 } else {
1293 _tmp191_ = FALSE;
1294 }
1295 if (_tmp191_) {
1296 ValaSourceReference* _tmp199_;
1297 ValaSourceReference* _tmp200_;
1298 gchar* _tmp201_;
1299 gchar* _tmp202_;
1300 ValaSymbol* _tmp203_;
1301 ValaSymbol* _tmp204_;
1302 gchar* _tmp205_;
1303 gchar* _tmp206_;
1304 gchar* _tmp207_;
1305 gchar* _tmp208_;
1306 _tmp199_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1307 _tmp200_ = _tmp199_;
1308 _tmp201_ = vala_symbol_get_full_name ((ValaSymbol*) self);
1309 _tmp202_ = _tmp201_;
1310 _tmp203_ = vala_symbol_get_hidden_member ((ValaSymbol*) self);
1311 _tmp204_ = _tmp203_;
1312 _tmp205_ = vala_symbol_get_full_name (_tmp204_);
1313 _tmp206_ = _tmp205_;
1314 _tmp207_ = g_strdup_printf ("%s hides inherited signal `%s'. Use the `new' keyword if hiding was in" \
1315 "tentional", _tmp202_, _tmp206_);
1316 _tmp208_ = _tmp207_;
1317 vala_report_warning (_tmp200_, _tmp208_);
1318 _g_free0 (_tmp208_);
1319 _g_free0 (_tmp206_);
1320 _vala_code_node_unref0 (_tmp204_);
1321 _g_free0 (_tmp202_);
1322 }
1323 _tmp209_ = vala_code_node_get_error ((ValaCodeNode*) self);
1324 _tmp210_ = _tmp209_;
1325 result = !_tmp210_;
1326 return result;
1327 }
1328
1329 static void
vala_signal_class_init(ValaSignalClass * klass,gpointer klass_data)1330 vala_signal_class_init (ValaSignalClass * klass,
1331 gpointer klass_data)
1332 {
1333 vala_signal_parent_class = g_type_class_peek_parent (klass);
1334 ((ValaCodeNodeClass *) klass)->finalize = vala_signal_finalize;
1335 g_type_class_adjust_private_offset (klass, &ValaSignal_private_offset);
1336 ((ValaCodeNodeClass *) klass)->accept = (void (*) (ValaCodeNode*, ValaCodeVisitor*)) vala_signal_real_accept;
1337 ((ValaCodeNodeClass *) klass)->accept_children = (void (*) (ValaCodeNode*, ValaCodeVisitor*)) vala_signal_real_accept_children;
1338 ((ValaCodeNodeClass *) klass)->replace_type = (void (*) (ValaCodeNode*, ValaDataType*, ValaDataType*)) vala_signal_real_replace_type;
1339 ((ValaCodeNodeClass *) klass)->check = (gboolean (*) (ValaCodeNode*, ValaCodeContext*)) vala_signal_real_check;
1340 }
1341
1342 static void
vala_signal_vala_callable_interface_init(ValaCallableIface * iface,gpointer iface_data)1343 vala_signal_vala_callable_interface_init (ValaCallableIface * iface,
1344 gpointer iface_data)
1345 {
1346 vala_signal_vala_callable_parent_iface = g_type_interface_peek_parent (iface);
1347 iface->add_parameter = (void (*) (ValaCallable*, ValaParameter*)) vala_signal_real_add_parameter;
1348 iface->get_parameters = (ValaList* (*) (ValaCallable*)) vala_signal_real_get_parameters;
1349 iface->get_return_type = vala_signal_real_get_return_type;
1350 iface->set_return_type = vala_signal_real_set_return_type;
1351 }
1352
1353 static void
vala_signal_instance_init(ValaSignal * self,gpointer klass)1354 vala_signal_instance_init (ValaSignal * self,
1355 gpointer klass)
1356 {
1357 GEqualFunc _tmp0_;
1358 ValaArrayList* _tmp1_;
1359 self->priv = vala_signal_get_instance_private (self);
1360 _tmp0_ = g_direct_equal;
1361 _tmp1_ = vala_array_list_new (VALA_TYPE_PARAMETER, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp0_);
1362 self->priv->parameters = (ValaList*) _tmp1_;
1363 }
1364
1365 static void
vala_signal_finalize(ValaCodeNode * obj)1366 vala_signal_finalize (ValaCodeNode * obj)
1367 {
1368 ValaSignal * self;
1369 self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALA_TYPE_SIGNAL, ValaSignal);
1370 _vala_iterable_unref0 (self->priv->parameters);
1371 _vala_code_node_unref0 (self->priv->_default_handler);
1372 _vala_code_node_unref0 (self->priv->_emitter);
1373 _vala_code_node_unref0 (self->priv->_return_type);
1374 _vala_code_node_unref0 (self->priv->_body);
1375 VALA_CODE_NODE_CLASS (vala_signal_parent_class)->finalize (obj);
1376 }
1377
1378 /**
1379 * Represents an object signal. Signals enable objects to provide notifications.
1380 */
1381 static GType
vala_signal_get_type_once(void)1382 vala_signal_get_type_once (void)
1383 {
1384 static const GTypeInfo g_define_type_info = { sizeof (ValaSignalClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_signal_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaSignal), 0, (GInstanceInitFunc) vala_signal_instance_init, NULL };
1385 static const GInterfaceInfo vala_callable_info = { (GInterfaceInitFunc) vala_signal_vala_callable_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
1386 GType vala_signal_type_id;
1387 vala_signal_type_id = g_type_register_static (VALA_TYPE_SYMBOL, "ValaSignal", &g_define_type_info, 0);
1388 g_type_add_interface_static (vala_signal_type_id, VALA_TYPE_CALLABLE, &vala_callable_info);
1389 ValaSignal_private_offset = g_type_add_instance_private (vala_signal_type_id, sizeof (ValaSignalPrivate));
1390 return vala_signal_type_id;
1391 }
1392
1393 GType
vala_signal_get_type(void)1394 vala_signal_get_type (void)
1395 {
1396 static volatile gsize vala_signal_type_id__volatile = 0;
1397 if (g_once_init_enter (&vala_signal_type_id__volatile)) {
1398 GType vala_signal_type_id;
1399 vala_signal_type_id = vala_signal_get_type_once ();
1400 g_once_init_leave (&vala_signal_type_id__volatile, vala_signal_type_id);
1401 }
1402 return vala_signal_type_id__volatile;
1403 }
1404
1405