1 /* valasemanticanalyzer.c generated by valac, the Vala compiler
2 * generated from valasemanticanalyzer.vala, do not modify */
3
4 /* valasemanticanalyzer.vala
5 *
6 * Copyright (C) 2006-2010 Jürg Billeter
7 * Copyright (C) 2006-2008 Raffaele Sandrini
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 *
23 * Author:
24 * Jürg Billeter <j@bitron.ch>
25 * Raffaele Sandrini <raffaele@sandrini.ch>
26 */
27
28 #include "vala.h"
29 #include <glib.h>
30 #include <valagee.h>
31 #include <glib-object.h>
32 #include <stdlib.h>
33 #include <string.h>
34
35 #define _vala_code_context_unref0(var) ((var == NULL) ? NULL : (var = (vala_code_context_unref (var), NULL)))
36 #define _vala_code_node_unref0(var) ((var == NULL) ? NULL : (var = (vala_code_node_unref (var), NULL)))
37 #define _vala_source_file_unref0(var) ((var == NULL) ? NULL : (var = (vala_source_file_unref (var), NULL)))
38 #define _vala_iterable_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterable_unref (var), NULL)))
39 #define _g_free0(var) (var = (g_free (var), NULL))
40 #define _vala_iterator_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterator_unref (var), NULL)))
41
42 struct _ValaSemanticAnalyzerPrivate {
43 ValaCodeContext* context;
44 ValaSymbol* _current_symbol;
45 ValaSourceFile* _current_source_file;
46 ValaDelegate* destroy_notify;
47 };
48
49 static gint ValaSemanticAnalyzer_private_offset;
50 static gpointer vala_semantic_analyzer_parent_class = NULL;
51
52 static void vala_semantic_analyzer_real_visit_source_file (ValaCodeVisitor* base,
53 ValaSourceFile* file);
54 static gboolean vala_semantic_analyzer_check_argument (ValaSemanticAnalyzer* self,
55 ValaExpression* arg,
56 gint i,
57 ValaParameterDirection direction);
58 static ValaDataType* vala_semantic_analyzer_get_instance_base_type (ValaDataType* instance_type,
59 ValaDataType* base_type,
60 ValaCodeNode* node_reference);
61 G_GNUC_INTERNAL ValaDataType* vala_semantic_analyzer_get_instance_base_type_for_member (ValaDataType* derived_instance_type,
62 ValaTypeSymbol* type_symbol,
63 ValaCodeNode* node_reference);
64 static ValaStruct* vala_semantic_analyzer_get_arithmetic_struct (ValaSemanticAnalyzer* self,
65 ValaDataType* type);
66 static void vala_semantic_analyzer_check_type_argument (ValaSemanticAnalyzer* self,
67 ValaDataType* type_arg);
68 static void vala_semantic_analyzer_finalize (ValaCodeVisitor * obj);
69 static GType vala_semantic_analyzer_get_type_once (void);
70
71 static inline gpointer
vala_semantic_analyzer_get_instance_private(ValaSemanticAnalyzer * self)72 vala_semantic_analyzer_get_instance_private (ValaSemanticAnalyzer* self)
73 {
74 return G_STRUCT_MEMBER_P (self, ValaSemanticAnalyzer_private_offset);
75 }
76
77 ValaSymbol*
vala_semantic_analyzer_get_current_symbol(ValaSemanticAnalyzer * self)78 vala_semantic_analyzer_get_current_symbol (ValaSemanticAnalyzer* self)
79 {
80 ValaSymbol* result;
81 ValaSymbol* _tmp0_;
82 g_return_val_if_fail (self != NULL, NULL);
83 _tmp0_ = self->priv->_current_symbol;
84 result = _tmp0_;
85 return result;
86 }
87
88 static gpointer
_vala_code_node_ref0(gpointer self)89 _vala_code_node_ref0 (gpointer self)
90 {
91 return self ? vala_code_node_ref (self) : NULL;
92 }
93
94 void
vala_semantic_analyzer_set_current_symbol(ValaSemanticAnalyzer * self,ValaSymbol * value)95 vala_semantic_analyzer_set_current_symbol (ValaSemanticAnalyzer* self,
96 ValaSymbol* value)
97 {
98 ValaSymbol* _tmp0_;
99 g_return_if_fail (self != NULL);
100 _tmp0_ = _vala_code_node_ref0 (value);
101 _vala_code_node_unref0 (self->priv->_current_symbol);
102 self->priv->_current_symbol = _tmp0_;
103 }
104
105 ValaSourceFile*
vala_semantic_analyzer_get_current_source_file(ValaSemanticAnalyzer * self)106 vala_semantic_analyzer_get_current_source_file (ValaSemanticAnalyzer* self)
107 {
108 ValaSourceFile* result;
109 ValaSourceFile* _tmp0_;
110 g_return_val_if_fail (self != NULL, NULL);
111 _tmp0_ = self->priv->_current_source_file;
112 result = _tmp0_;
113 return result;
114 }
115
116 static gpointer
_vala_source_file_ref0(gpointer self)117 _vala_source_file_ref0 (gpointer self)
118 {
119 return self ? vala_source_file_ref (self) : NULL;
120 }
121
122 void
vala_semantic_analyzer_set_current_source_file(ValaSemanticAnalyzer * self,ValaSourceFile * value)123 vala_semantic_analyzer_set_current_source_file (ValaSemanticAnalyzer* self,
124 ValaSourceFile* value)
125 {
126 ValaSourceFile* _tmp0_;
127 g_return_if_fail (self != NULL);
128 _tmp0_ = _vala_source_file_ref0 (value);
129 _vala_source_file_unref0 (self->priv->_current_source_file);
130 self->priv->_current_source_file = _tmp0_;
131 }
132
133 ValaTypeSymbol*
vala_semantic_analyzer_get_current_type_symbol(ValaSemanticAnalyzer * self)134 vala_semantic_analyzer_get_current_type_symbol (ValaSemanticAnalyzer* self)
135 {
136 ValaTypeSymbol* result;
137 ValaSymbol* sym = NULL;
138 ValaSymbol* _tmp0_;
139 g_return_val_if_fail (self != NULL, NULL);
140 _tmp0_ = self->priv->_current_symbol;
141 sym = _tmp0_;
142 while (TRUE) {
143 ValaSymbol* _tmp1_;
144 ValaSymbol* _tmp2_;
145 ValaSymbol* _tmp4_;
146 ValaSymbol* _tmp5_;
147 ValaSymbol* _tmp6_;
148 _tmp1_ = sym;
149 if (!(_tmp1_ != NULL)) {
150 break;
151 }
152 _tmp2_ = sym;
153 if (VALA_IS_TYPESYMBOL (_tmp2_)) {
154 ValaSymbol* _tmp3_;
155 _tmp3_ = sym;
156 result = G_TYPE_CHECK_INSTANCE_CAST (_tmp3_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol);
157 return result;
158 }
159 _tmp4_ = sym;
160 _tmp5_ = vala_symbol_get_parent_symbol (_tmp4_);
161 _tmp6_ = _tmp5_;
162 sym = _tmp6_;
163 }
164 result = NULL;
165 return result;
166 }
167
168 ValaClass*
vala_semantic_analyzer_get_current_class(ValaSemanticAnalyzer * self)169 vala_semantic_analyzer_get_current_class (ValaSemanticAnalyzer* self)
170 {
171 ValaClass* result;
172 ValaTypeSymbol* _tmp0_;
173 ValaTypeSymbol* _tmp1_;
174 g_return_val_if_fail (self != NULL, NULL);
175 _tmp0_ = vala_semantic_analyzer_get_current_type_symbol (self);
176 _tmp1_ = _tmp0_;
177 result = VALA_IS_CLASS (_tmp1_) ? ((ValaClass*) _tmp1_) : NULL;
178 return result;
179 }
180
181 ValaStruct*
vala_semantic_analyzer_get_current_struct(ValaSemanticAnalyzer * self)182 vala_semantic_analyzer_get_current_struct (ValaSemanticAnalyzer* self)
183 {
184 ValaStruct* result;
185 ValaTypeSymbol* _tmp0_;
186 ValaTypeSymbol* _tmp1_;
187 g_return_val_if_fail (self != NULL, NULL);
188 _tmp0_ = vala_semantic_analyzer_get_current_type_symbol (self);
189 _tmp1_ = _tmp0_;
190 result = VALA_IS_STRUCT (_tmp1_) ? ((ValaStruct*) _tmp1_) : NULL;
191 return result;
192 }
193
194 ValaMethod*
vala_semantic_analyzer_get_current_method(ValaSemanticAnalyzer * self)195 vala_semantic_analyzer_get_current_method (ValaSemanticAnalyzer* self)
196 {
197 ValaMethod* result;
198 ValaSymbol* sym = NULL;
199 ValaSymbol* _tmp0_;
200 ValaSymbol* _tmp5_;
201 g_return_val_if_fail (self != NULL, NULL);
202 _tmp0_ = self->priv->_current_symbol;
203 sym = _tmp0_;
204 while (TRUE) {
205 ValaSymbol* _tmp1_;
206 ValaSymbol* _tmp2_;
207 ValaSymbol* _tmp3_;
208 ValaSymbol* _tmp4_;
209 _tmp1_ = sym;
210 if (!VALA_IS_BLOCK (_tmp1_)) {
211 break;
212 }
213 _tmp2_ = sym;
214 _tmp3_ = vala_symbol_get_parent_symbol (_tmp2_);
215 _tmp4_ = _tmp3_;
216 sym = _tmp4_;
217 }
218 _tmp5_ = sym;
219 result = VALA_IS_METHOD (_tmp5_) ? ((ValaMethod*) _tmp5_) : NULL;
220 return result;
221 }
222
223 ValaMethod*
vala_semantic_analyzer_get_current_async_method(ValaSemanticAnalyzer * self)224 vala_semantic_analyzer_get_current_async_method (ValaSemanticAnalyzer* self)
225 {
226 ValaMethod* result;
227 ValaSymbol* sym = NULL;
228 ValaSymbol* _tmp0_;
229 ValaSymbol* _tmp13_;
230 g_return_val_if_fail (self != NULL, NULL);
231 _tmp0_ = self->priv->_current_symbol;
232 sym = _tmp0_;
233 while (TRUE) {
234 gboolean _tmp1_ = FALSE;
235 ValaSymbol* _tmp2_;
236 ValaMethod* m = NULL;
237 ValaSymbol* _tmp4_;
238 gboolean _tmp5_ = FALSE;
239 ValaMethod* _tmp6_;
240 ValaSymbol* _tmp10_;
241 ValaSymbol* _tmp11_;
242 ValaSymbol* _tmp12_;
243 _tmp2_ = sym;
244 if (VALA_IS_BLOCK (_tmp2_)) {
245 _tmp1_ = TRUE;
246 } else {
247 ValaSymbol* _tmp3_;
248 _tmp3_ = sym;
249 _tmp1_ = VALA_IS_METHOD (_tmp3_);
250 }
251 if (!_tmp1_) {
252 break;
253 }
254 _tmp4_ = sym;
255 m = VALA_IS_METHOD (_tmp4_) ? ((ValaMethod*) _tmp4_) : NULL;
256 _tmp6_ = m;
257 if (_tmp6_ != NULL) {
258 ValaMethod* _tmp7_;
259 gboolean _tmp8_;
260 gboolean _tmp9_;
261 _tmp7_ = m;
262 _tmp8_ = vala_method_get_coroutine (_tmp7_);
263 _tmp9_ = _tmp8_;
264 _tmp5_ = _tmp9_;
265 } else {
266 _tmp5_ = FALSE;
267 }
268 if (_tmp5_) {
269 break;
270 }
271 _tmp10_ = sym;
272 _tmp11_ = vala_symbol_get_parent_symbol (_tmp10_);
273 _tmp12_ = _tmp11_;
274 sym = _tmp12_;
275 }
276 _tmp13_ = sym;
277 result = VALA_IS_METHOD (_tmp13_) ? ((ValaMethod*) _tmp13_) : NULL;
278 return result;
279 }
280
281 ValaPropertyAccessor*
vala_semantic_analyzer_get_current_property_accessor(ValaSemanticAnalyzer * self)282 vala_semantic_analyzer_get_current_property_accessor (ValaSemanticAnalyzer* self)
283 {
284 ValaPropertyAccessor* result;
285 ValaSymbol* sym = NULL;
286 ValaSymbol* _tmp0_;
287 ValaSymbol* _tmp5_;
288 g_return_val_if_fail (self != NULL, NULL);
289 _tmp0_ = self->priv->_current_symbol;
290 sym = _tmp0_;
291 while (TRUE) {
292 ValaSymbol* _tmp1_;
293 ValaSymbol* _tmp2_;
294 ValaSymbol* _tmp3_;
295 ValaSymbol* _tmp4_;
296 _tmp1_ = sym;
297 if (!VALA_IS_BLOCK (_tmp1_)) {
298 break;
299 }
300 _tmp2_ = sym;
301 _tmp3_ = vala_symbol_get_parent_symbol (_tmp2_);
302 _tmp4_ = _tmp3_;
303 sym = _tmp4_;
304 }
305 _tmp5_ = sym;
306 result = VALA_IS_PROPERTY_ACCESSOR (_tmp5_) ? ((ValaPropertyAccessor*) _tmp5_) : NULL;
307 return result;
308 }
309
310 ValaSymbol*
vala_semantic_analyzer_get_current_method_or_property_accessor(ValaSemanticAnalyzer * self)311 vala_semantic_analyzer_get_current_method_or_property_accessor (ValaSemanticAnalyzer* self)
312 {
313 ValaSymbol* result;
314 ValaSymbol* sym = NULL;
315 ValaSymbol* _tmp0_;
316 ValaSymbol* _tmp5_;
317 g_return_val_if_fail (self != NULL, NULL);
318 _tmp0_ = self->priv->_current_symbol;
319 sym = _tmp0_;
320 while (TRUE) {
321 ValaSymbol* _tmp1_;
322 ValaSymbol* _tmp2_;
323 ValaSymbol* _tmp3_;
324 ValaSymbol* _tmp4_;
325 _tmp1_ = sym;
326 if (!VALA_IS_BLOCK (_tmp1_)) {
327 break;
328 }
329 _tmp2_ = sym;
330 _tmp3_ = vala_symbol_get_parent_symbol (_tmp2_);
331 _tmp4_ = _tmp3_;
332 sym = _tmp4_;
333 }
334 _tmp5_ = sym;
335 if (VALA_IS_METHOD (_tmp5_)) {
336 ValaSymbol* _tmp6_;
337 _tmp6_ = sym;
338 result = _tmp6_;
339 return result;
340 } else {
341 ValaSymbol* _tmp7_;
342 _tmp7_ = sym;
343 if (VALA_IS_PROPERTY_ACCESSOR (_tmp7_)) {
344 ValaSymbol* _tmp8_;
345 _tmp8_ = sym;
346 result = _tmp8_;
347 return result;
348 } else {
349 result = NULL;
350 return result;
351 }
352 }
353 }
354
355 ValaDataType*
vala_semantic_analyzer_get_current_return_type(ValaSemanticAnalyzer * self)356 vala_semantic_analyzer_get_current_return_type (ValaSemanticAnalyzer* self)
357 {
358 ValaDataType* result;
359 ValaMethod* m = NULL;
360 ValaMethod* _tmp0_;
361 ValaMethod* _tmp1_;
362 ValaMethod* _tmp2_;
363 ValaPropertyAccessor* acc = NULL;
364 ValaPropertyAccessor* _tmp6_;
365 ValaPropertyAccessor* _tmp7_;
366 ValaPropertyAccessor* _tmp8_;
367 gboolean _tmp16_ = FALSE;
368 g_return_val_if_fail (self != NULL, NULL);
369 _tmp0_ = vala_semantic_analyzer_get_current_method (self);
370 _tmp1_ = _tmp0_;
371 m = _tmp1_;
372 _tmp2_ = m;
373 if (_tmp2_ != NULL) {
374 ValaMethod* _tmp3_;
375 ValaDataType* _tmp4_;
376 ValaDataType* _tmp5_;
377 _tmp3_ = m;
378 _tmp4_ = vala_callable_get_return_type ((ValaCallable*) _tmp3_);
379 _tmp5_ = _tmp4_;
380 result = _tmp5_;
381 return result;
382 }
383 _tmp6_ = vala_semantic_analyzer_get_current_property_accessor (self);
384 _tmp7_ = _tmp6_;
385 acc = _tmp7_;
386 _tmp8_ = acc;
387 if (_tmp8_ != NULL) {
388 ValaPropertyAccessor* _tmp9_;
389 gboolean _tmp10_;
390 gboolean _tmp11_;
391 _tmp9_ = acc;
392 _tmp10_ = vala_property_accessor_get_readable (_tmp9_);
393 _tmp11_ = _tmp10_;
394 if (_tmp11_) {
395 ValaPropertyAccessor* _tmp12_;
396 ValaDataType* _tmp13_;
397 ValaDataType* _tmp14_;
398 _tmp12_ = acc;
399 _tmp13_ = vala_property_accessor_get_value_type (_tmp12_);
400 _tmp14_ = _tmp13_;
401 result = _tmp14_;
402 return result;
403 } else {
404 ValaDataType* _tmp15_;
405 _tmp15_ = self->void_type;
406 result = _tmp15_;
407 return result;
408 }
409 }
410 if (vala_semantic_analyzer_is_in_constructor (self)) {
411 _tmp16_ = TRUE;
412 } else {
413 _tmp16_ = vala_semantic_analyzer_is_in_destructor (self);
414 }
415 if (_tmp16_) {
416 ValaDataType* _tmp17_;
417 _tmp17_ = self->void_type;
418 result = _tmp17_;
419 return result;
420 }
421 result = NULL;
422 return result;
423 }
424
425 ValaSemanticAnalyzer*
vala_semantic_analyzer_construct(GType object_type)426 vala_semantic_analyzer_construct (GType object_type)
427 {
428 ValaSemanticAnalyzer* self = NULL;
429 self = (ValaSemanticAnalyzer*) vala_code_visitor_construct (object_type);
430 return self;
431 }
432
433 ValaSemanticAnalyzer*
vala_semantic_analyzer_new(void)434 vala_semantic_analyzer_new (void)
435 {
436 return vala_semantic_analyzer_construct (VALA_TYPE_SEMANTIC_ANALYZER);
437 }
438
439 /**
440 * Analyze and check code in the specified context.
441 *
442 * @param context a code context
443 */
444 static gpointer
_vala_code_context_ref0(gpointer self)445 _vala_code_context_ref0 (gpointer self)
446 {
447 return self ? vala_code_context_ref (self) : NULL;
448 }
449
450 void
vala_semantic_analyzer_analyze(ValaSemanticAnalyzer * self,ValaCodeContext * context)451 vala_semantic_analyzer_analyze (ValaSemanticAnalyzer* self,
452 ValaCodeContext* context)
453 {
454 ValaCodeContext* _tmp0_;
455 ValaNamespace* root_symbol = NULL;
456 ValaNamespace* _tmp1_;
457 ValaNamespace* _tmp2_;
458 ValaNamespace* _tmp3_;
459 ValaNamespace* _tmp4_;
460 ValaScope* _tmp5_;
461 ValaScope* _tmp6_;
462 ValaSymbol* _tmp7_;
463 ValaStruct* _tmp8_;
464 ValaBooleanType* _tmp9_;
465 ValaNamespace* _tmp10_;
466 ValaScope* _tmp11_;
467 ValaScope* _tmp12_;
468 ValaSymbol* _tmp13_;
469 ValaStruct* _tmp14_;
470 ValaIntegerType* _tmp15_;
471 ValaNamespace* _tmp16_;
472 ValaScope* _tmp17_;
473 ValaScope* _tmp18_;
474 ValaSymbol* _tmp19_;
475 ValaStruct* _tmp20_;
476 ValaIntegerType* _tmp21_;
477 ValaNamespace* _tmp22_;
478 ValaScope* _tmp23_;
479 ValaScope* _tmp24_;
480 ValaSymbol* _tmp25_;
481 ValaStruct* _tmp26_;
482 ValaIntegerType* _tmp27_;
483 ValaNamespace* _tmp28_;
484 ValaScope* _tmp29_;
485 ValaScope* _tmp30_;
486 ValaSymbol* _tmp31_;
487 ValaStruct* _tmp32_;
488 ValaIntegerType* _tmp33_;
489 ValaNamespace* _tmp34_;
490 ValaScope* _tmp35_;
491 ValaScope* _tmp36_;
492 ValaSymbol* _tmp37_;
493 ValaStruct* _tmp38_;
494 ValaIntegerType* _tmp39_;
495 ValaNamespace* _tmp40_;
496 ValaScope* _tmp41_;
497 ValaScope* _tmp42_;
498 ValaSymbol* _tmp43_;
499 ValaStruct* _tmp44_;
500 ValaIntegerType* _tmp45_;
501 ValaNamespace* _tmp46_;
502 ValaScope* _tmp47_;
503 ValaScope* _tmp48_;
504 ValaSymbol* _tmp49_;
505 ValaStruct* _tmp50_;
506 ValaIntegerType* _tmp51_;
507 ValaNamespace* _tmp52_;
508 ValaScope* _tmp53_;
509 ValaScope* _tmp54_;
510 ValaSymbol* _tmp55_;
511 ValaStruct* _tmp56_;
512 ValaIntegerType* _tmp57_;
513 ValaNamespace* _tmp58_;
514 ValaScope* _tmp59_;
515 ValaScope* _tmp60_;
516 ValaSymbol* _tmp61_;
517 ValaStruct* _tmp62_;
518 ValaIntegerType* _tmp63_;
519 ValaNamespace* _tmp64_;
520 ValaScope* _tmp65_;
521 ValaScope* _tmp66_;
522 ValaSymbol* _tmp67_;
523 ValaStruct* _tmp68_;
524 ValaIntegerType* _tmp69_;
525 ValaNamespace* _tmp70_;
526 ValaScope* _tmp71_;
527 ValaScope* _tmp72_;
528 ValaSymbol* _tmp73_;
529 ValaStruct* _tmp74_;
530 ValaIntegerType* _tmp75_;
531 ValaNamespace* _tmp76_;
532 ValaScope* _tmp77_;
533 ValaScope* _tmp78_;
534 ValaSymbol* _tmp79_;
535 ValaStruct* _tmp80_;
536 ValaIntegerType* _tmp81_;
537 ValaNamespace* _tmp82_;
538 ValaScope* _tmp83_;
539 ValaScope* _tmp84_;
540 ValaSymbol* _tmp85_;
541 ValaStruct* _tmp86_;
542 ValaIntegerType* _tmp87_;
543 ValaNamespace* _tmp88_;
544 ValaScope* _tmp89_;
545 ValaScope* _tmp90_;
546 ValaSymbol* _tmp91_;
547 ValaStruct* _tmp92_;
548 ValaIntegerType* _tmp93_;
549 ValaNamespace* _tmp94_;
550 ValaScope* _tmp95_;
551 ValaScope* _tmp96_;
552 ValaSymbol* _tmp97_;
553 ValaStruct* _tmp98_;
554 ValaIntegerType* _tmp99_;
555 ValaNamespace* _tmp100_;
556 ValaScope* _tmp101_;
557 ValaScope* _tmp102_;
558 ValaSymbol* _tmp103_;
559 ValaStruct* _tmp104_;
560 ValaIntegerType* _tmp105_;
561 ValaNamespace* _tmp106_;
562 ValaScope* _tmp107_;
563 ValaScope* _tmp108_;
564 ValaSymbol* _tmp109_;
565 ValaStruct* _tmp110_;
566 ValaFloatingType* _tmp111_;
567 ValaNamespace* _tmp112_;
568 ValaScope* _tmp113_;
569 ValaScope* _tmp114_;
570 ValaSymbol* _tmp115_;
571 ValaClass* _tmp116_;
572 ValaObjectType* _tmp117_;
573 ValaNamespace* _tmp118_;
574 ValaScope* _tmp119_;
575 ValaScope* _tmp120_;
576 ValaSymbol* _tmp121_;
577 ValaStruct* _tmp122_;
578 ValaStructValueType* _tmp123_;
579 ValaStruct* unichar_struct = NULL;
580 ValaNamespace* _tmp124_;
581 ValaScope* _tmp125_;
582 ValaScope* _tmp126_;
583 ValaSymbol* _tmp127_;
584 ValaStruct* _tmp128_;
585 ValaProfile _tmp131_;
586 ValaProfile _tmp132_;
587 ValaNamespace* _tmp240_;
588 ValaNamespace* _tmp241_;
589 ValaNamespace* _tmp242_;
590 g_return_if_fail (self != NULL);
591 g_return_if_fail (context != NULL);
592 _tmp0_ = _vala_code_context_ref0 (context);
593 _vala_code_context_unref0 (self->priv->context);
594 self->priv->context = _tmp0_;
595 _tmp1_ = vala_code_context_get_root (context);
596 _tmp2_ = _tmp1_;
597 _tmp3_ = _vala_code_node_ref0 (_tmp2_);
598 root_symbol = _tmp3_;
599 _tmp4_ = root_symbol;
600 _tmp5_ = vala_symbol_get_scope ((ValaSymbol*) _tmp4_);
601 _tmp6_ = _tmp5_;
602 _tmp7_ = vala_scope_lookup (_tmp6_, "bool");
603 _tmp8_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp7_, VALA_TYPE_STRUCT, ValaStruct);
604 _tmp9_ = vala_boolean_type_new (_tmp8_);
605 _vala_code_node_unref0 (self->bool_type);
606 self->bool_type = (ValaDataType*) _tmp9_;
607 _vala_code_node_unref0 (_tmp8_);
608 _tmp10_ = root_symbol;
609 _tmp11_ = vala_symbol_get_scope ((ValaSymbol*) _tmp10_);
610 _tmp12_ = _tmp11_;
611 _tmp13_ = vala_scope_lookup (_tmp12_, "char");
612 _tmp14_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp13_, VALA_TYPE_STRUCT, ValaStruct);
613 _tmp15_ = vala_integer_type_new (_tmp14_, NULL, NULL);
614 _vala_code_node_unref0 (self->char_type);
615 self->char_type = (ValaDataType*) _tmp15_;
616 _vala_code_node_unref0 (_tmp14_);
617 _tmp16_ = root_symbol;
618 _tmp17_ = vala_symbol_get_scope ((ValaSymbol*) _tmp16_);
619 _tmp18_ = _tmp17_;
620 _tmp19_ = vala_scope_lookup (_tmp18_, "uchar");
621 _tmp20_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp19_, VALA_TYPE_STRUCT, ValaStruct);
622 _tmp21_ = vala_integer_type_new (_tmp20_, NULL, NULL);
623 _vala_code_node_unref0 (self->uchar_type);
624 self->uchar_type = (ValaDataType*) _tmp21_;
625 _vala_code_node_unref0 (_tmp20_);
626 _tmp22_ = root_symbol;
627 _tmp23_ = vala_symbol_get_scope ((ValaSymbol*) _tmp22_);
628 _tmp24_ = _tmp23_;
629 _tmp25_ = vala_scope_lookup (_tmp24_, "short");
630 _tmp26_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp25_, VALA_TYPE_STRUCT, ValaStruct);
631 _tmp27_ = vala_integer_type_new (_tmp26_, NULL, NULL);
632 _vala_code_node_unref0 (self->short_type);
633 self->short_type = (ValaDataType*) _tmp27_;
634 _vala_code_node_unref0 (_tmp26_);
635 _tmp28_ = root_symbol;
636 _tmp29_ = vala_symbol_get_scope ((ValaSymbol*) _tmp28_);
637 _tmp30_ = _tmp29_;
638 _tmp31_ = vala_scope_lookup (_tmp30_, "ushort");
639 _tmp32_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp31_, VALA_TYPE_STRUCT, ValaStruct);
640 _tmp33_ = vala_integer_type_new (_tmp32_, NULL, NULL);
641 _vala_code_node_unref0 (self->ushort_type);
642 self->ushort_type = (ValaDataType*) _tmp33_;
643 _vala_code_node_unref0 (_tmp32_);
644 _tmp34_ = root_symbol;
645 _tmp35_ = vala_symbol_get_scope ((ValaSymbol*) _tmp34_);
646 _tmp36_ = _tmp35_;
647 _tmp37_ = vala_scope_lookup (_tmp36_, "int");
648 _tmp38_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp37_, VALA_TYPE_STRUCT, ValaStruct);
649 _tmp39_ = vala_integer_type_new (_tmp38_, NULL, NULL);
650 _vala_code_node_unref0 (self->int_type);
651 self->int_type = (ValaDataType*) _tmp39_;
652 _vala_code_node_unref0 (_tmp38_);
653 _tmp40_ = root_symbol;
654 _tmp41_ = vala_symbol_get_scope ((ValaSymbol*) _tmp40_);
655 _tmp42_ = _tmp41_;
656 _tmp43_ = vala_scope_lookup (_tmp42_, "uint");
657 _tmp44_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp43_, VALA_TYPE_STRUCT, ValaStruct);
658 _tmp45_ = vala_integer_type_new (_tmp44_, NULL, NULL);
659 _vala_code_node_unref0 (self->uint_type);
660 self->uint_type = (ValaDataType*) _tmp45_;
661 _vala_code_node_unref0 (_tmp44_);
662 _tmp46_ = root_symbol;
663 _tmp47_ = vala_symbol_get_scope ((ValaSymbol*) _tmp46_);
664 _tmp48_ = _tmp47_;
665 _tmp49_ = vala_scope_lookup (_tmp48_, "long");
666 _tmp50_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp49_, VALA_TYPE_STRUCT, ValaStruct);
667 _tmp51_ = vala_integer_type_new (_tmp50_, NULL, NULL);
668 _vala_code_node_unref0 (self->long_type);
669 self->long_type = (ValaDataType*) _tmp51_;
670 _vala_code_node_unref0 (_tmp50_);
671 _tmp52_ = root_symbol;
672 _tmp53_ = vala_symbol_get_scope ((ValaSymbol*) _tmp52_);
673 _tmp54_ = _tmp53_;
674 _tmp55_ = vala_scope_lookup (_tmp54_, "ulong");
675 _tmp56_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp55_, VALA_TYPE_STRUCT, ValaStruct);
676 _tmp57_ = vala_integer_type_new (_tmp56_, NULL, NULL);
677 _vala_code_node_unref0 (self->ulong_type);
678 self->ulong_type = (ValaDataType*) _tmp57_;
679 _vala_code_node_unref0 (_tmp56_);
680 _tmp58_ = root_symbol;
681 _tmp59_ = vala_symbol_get_scope ((ValaSymbol*) _tmp58_);
682 _tmp60_ = _tmp59_;
683 _tmp61_ = vala_scope_lookup (_tmp60_, "int8");
684 _tmp62_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp61_, VALA_TYPE_STRUCT, ValaStruct);
685 _tmp63_ = vala_integer_type_new (_tmp62_, NULL, NULL);
686 _vala_code_node_unref0 (self->int8_type);
687 self->int8_type = (ValaDataType*) _tmp63_;
688 _vala_code_node_unref0 (_tmp62_);
689 _tmp64_ = root_symbol;
690 _tmp65_ = vala_symbol_get_scope ((ValaSymbol*) _tmp64_);
691 _tmp66_ = _tmp65_;
692 _tmp67_ = vala_scope_lookup (_tmp66_, "uint8");
693 _tmp68_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp67_, VALA_TYPE_STRUCT, ValaStruct);
694 _tmp69_ = vala_integer_type_new (_tmp68_, NULL, NULL);
695 _vala_code_node_unref0 (self->uint8_type);
696 self->uint8_type = (ValaDataType*) _tmp69_;
697 _vala_code_node_unref0 (_tmp68_);
698 _tmp70_ = root_symbol;
699 _tmp71_ = vala_symbol_get_scope ((ValaSymbol*) _tmp70_);
700 _tmp72_ = _tmp71_;
701 _tmp73_ = vala_scope_lookup (_tmp72_, "int16");
702 _tmp74_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp73_, VALA_TYPE_STRUCT, ValaStruct);
703 _tmp75_ = vala_integer_type_new (_tmp74_, NULL, NULL);
704 _vala_code_node_unref0 (self->int16_type);
705 self->int16_type = (ValaDataType*) _tmp75_;
706 _vala_code_node_unref0 (_tmp74_);
707 _tmp76_ = root_symbol;
708 _tmp77_ = vala_symbol_get_scope ((ValaSymbol*) _tmp76_);
709 _tmp78_ = _tmp77_;
710 _tmp79_ = vala_scope_lookup (_tmp78_, "uint16");
711 _tmp80_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp79_, VALA_TYPE_STRUCT, ValaStruct);
712 _tmp81_ = vala_integer_type_new (_tmp80_, NULL, NULL);
713 _vala_code_node_unref0 (self->uint16_type);
714 self->uint16_type = (ValaDataType*) _tmp81_;
715 _vala_code_node_unref0 (_tmp80_);
716 _tmp82_ = root_symbol;
717 _tmp83_ = vala_symbol_get_scope ((ValaSymbol*) _tmp82_);
718 _tmp84_ = _tmp83_;
719 _tmp85_ = vala_scope_lookup (_tmp84_, "int32");
720 _tmp86_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp85_, VALA_TYPE_STRUCT, ValaStruct);
721 _tmp87_ = vala_integer_type_new (_tmp86_, NULL, NULL);
722 _vala_code_node_unref0 (self->int32_type);
723 self->int32_type = (ValaDataType*) _tmp87_;
724 _vala_code_node_unref0 (_tmp86_);
725 _tmp88_ = root_symbol;
726 _tmp89_ = vala_symbol_get_scope ((ValaSymbol*) _tmp88_);
727 _tmp90_ = _tmp89_;
728 _tmp91_ = vala_scope_lookup (_tmp90_, "uint32");
729 _tmp92_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp91_, VALA_TYPE_STRUCT, ValaStruct);
730 _tmp93_ = vala_integer_type_new (_tmp92_, NULL, NULL);
731 _vala_code_node_unref0 (self->uint32_type);
732 self->uint32_type = (ValaDataType*) _tmp93_;
733 _vala_code_node_unref0 (_tmp92_);
734 _tmp94_ = root_symbol;
735 _tmp95_ = vala_symbol_get_scope ((ValaSymbol*) _tmp94_);
736 _tmp96_ = _tmp95_;
737 _tmp97_ = vala_scope_lookup (_tmp96_, "size_t");
738 _tmp98_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp97_, VALA_TYPE_STRUCT, ValaStruct);
739 _tmp99_ = vala_integer_type_new (_tmp98_, NULL, NULL);
740 _vala_code_node_unref0 (self->size_t_type);
741 self->size_t_type = (ValaDataType*) _tmp99_;
742 _vala_code_node_unref0 (_tmp98_);
743 _tmp100_ = root_symbol;
744 _tmp101_ = vala_symbol_get_scope ((ValaSymbol*) _tmp100_);
745 _tmp102_ = _tmp101_;
746 _tmp103_ = vala_scope_lookup (_tmp102_, "ssize_t");
747 _tmp104_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp103_, VALA_TYPE_STRUCT, ValaStruct);
748 _tmp105_ = vala_integer_type_new (_tmp104_, NULL, NULL);
749 _vala_code_node_unref0 (self->ssize_t_type);
750 self->ssize_t_type = (ValaDataType*) _tmp105_;
751 _vala_code_node_unref0 (_tmp104_);
752 _tmp106_ = root_symbol;
753 _tmp107_ = vala_symbol_get_scope ((ValaSymbol*) _tmp106_);
754 _tmp108_ = _tmp107_;
755 _tmp109_ = vala_scope_lookup (_tmp108_, "double");
756 _tmp110_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp109_, VALA_TYPE_STRUCT, ValaStruct);
757 _tmp111_ = vala_floating_type_new (_tmp110_);
758 _vala_code_node_unref0 (self->double_type);
759 self->double_type = (ValaDataType*) _tmp111_;
760 _vala_code_node_unref0 (_tmp110_);
761 _tmp112_ = root_symbol;
762 _tmp113_ = vala_symbol_get_scope ((ValaSymbol*) _tmp112_);
763 _tmp114_ = _tmp113_;
764 _tmp115_ = vala_scope_lookup (_tmp114_, "string");
765 _tmp116_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp115_, VALA_TYPE_CLASS, ValaClass);
766 _tmp117_ = vala_object_type_new ((ValaObjectTypeSymbol*) _tmp116_);
767 _vala_code_node_unref0 (self->string_type);
768 self->string_type = (ValaDataType*) _tmp117_;
769 _vala_code_node_unref0 (_tmp116_);
770 _tmp118_ = root_symbol;
771 _tmp119_ = vala_symbol_get_scope ((ValaSymbol*) _tmp118_);
772 _tmp120_ = _tmp119_;
773 _tmp121_ = vala_scope_lookup (_tmp120_, "va_list");
774 _tmp122_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp121_, VALA_TYPE_STRUCT, ValaStruct);
775 _tmp123_ = vala_struct_value_type_new (_tmp122_);
776 _vala_code_node_unref0 (self->va_list_type);
777 self->va_list_type = (ValaDataType*) _tmp123_;
778 _vala_code_node_unref0 (_tmp122_);
779 _tmp124_ = root_symbol;
780 _tmp125_ = vala_symbol_get_scope ((ValaSymbol*) _tmp124_);
781 _tmp126_ = _tmp125_;
782 _tmp127_ = vala_scope_lookup (_tmp126_, "unichar");
783 unichar_struct = G_TYPE_CHECK_INSTANCE_CAST (_tmp127_, VALA_TYPE_STRUCT, ValaStruct);
784 _tmp128_ = unichar_struct;
785 if (_tmp128_ != NULL) {
786 ValaStruct* _tmp129_;
787 ValaIntegerType* _tmp130_;
788 _tmp129_ = unichar_struct;
789 _tmp130_ = vala_integer_type_new (_tmp129_, NULL, NULL);
790 _vala_code_node_unref0 (self->unichar_type);
791 self->unichar_type = (ValaDataType*) _tmp130_;
792 }
793 _tmp131_ = vala_code_context_get_profile (context);
794 _tmp132_ = _tmp131_;
795 if (_tmp132_ == VALA_PROFILE_GOBJECT) {
796 ValaSymbol* glib_ns = NULL;
797 ValaNamespace* _tmp133_;
798 ValaScope* _tmp134_;
799 ValaScope* _tmp135_;
800 ValaSymbol* _tmp136_;
801 ValaSymbol* _tmp137_;
802 ValaScope* _tmp138_;
803 ValaScope* _tmp139_;
804 ValaSymbol* _tmp140_;
805 ValaSymbol* _tmp141_;
806 ValaScope* _tmp142_;
807 ValaScope* _tmp143_;
808 ValaSymbol* _tmp144_;
809 ValaStruct* _tmp145_;
810 ValaIntegerType* _tmp146_;
811 ValaSymbol* _tmp147_;
812 ValaScope* _tmp148_;
813 ValaScope* _tmp149_;
814 ValaSymbol* _tmp150_;
815 ValaStruct* _tmp151_;
816 ValaStructValueType* _tmp152_;
817 ValaSymbol* _tmp153_;
818 ValaScope* _tmp154_;
819 ValaScope* _tmp155_;
820 ValaSymbol* _tmp156_;
821 ValaClass* _tmp157_;
822 ValaObjectType* _tmp158_;
823 ValaSymbol* _tmp159_;
824 ValaScope* _tmp160_;
825 ValaScope* _tmp161_;
826 ValaSymbol* _tmp162_;
827 ValaClass* _tmp163_;
828 ValaObjectType* _tmp164_;
829 ValaSymbol* _tmp165_;
830 ValaScope* _tmp166_;
831 ValaScope* _tmp167_;
832 ValaSymbol* _tmp168_;
833 ValaClass* _tmp169_;
834 ValaObjectType* _tmp170_;
835 ValaSymbol* _tmp171_;
836 ValaScope* _tmp172_;
837 ValaScope* _tmp173_;
838 ValaSymbol* _tmp174_;
839 ValaClass* _tmp175_;
840 ValaObjectType* _tmp176_;
841 ValaSymbol* _tmp177_;
842 ValaScope* _tmp178_;
843 ValaScope* _tmp179_;
844 ValaSymbol* _tmp180_;
845 ValaClass* _tmp181_;
846 ValaObjectType* _tmp182_;
847 ValaSymbol* _tmp183_;
848 ValaScope* _tmp184_;
849 ValaScope* _tmp185_;
850 ValaSymbol* _tmp186_;
851 ValaNamespace* _tmp187_;
852 ValaScope* _tmp188_;
853 ValaScope* _tmp189_;
854 ValaSymbol* _tmp190_;
855 ValaSymbol* _tmp191_;
856 ValaScope* _tmp192_;
857 ValaScope* _tmp193_;
858 ValaSymbol* _tmp194_;
859 ValaClass* _tmp195_;
860 ValaObjectType* _tmp196_;
861 ValaSymbol* _tmp197_;
862 ValaScope* _tmp198_;
863 ValaScope* _tmp199_;
864 ValaSymbol* _tmp200_;
865 ValaSymbol* _tmp201_;
866 ValaScope* _tmp202_;
867 ValaScope* _tmp203_;
868 ValaSymbol* _tmp204_;
869 ValaStruct* _tmp205_;
870 ValaStructValueType* _tmp206_;
871 ValaSymbol* _tmp207_;
872 ValaScope* _tmp208_;
873 ValaScope* _tmp209_;
874 ValaSymbol* _tmp210_;
875 ValaDelegate* _tmp211_;
876 ValaDelegateType* _tmp212_;
877 ValaSymbol* _tmp213_;
878 ValaScope* _tmp214_;
879 ValaScope* _tmp215_;
880 ValaSymbol* _tmp216_;
881 ValaDelegate* _tmp217_;
882 ValaDelegateType* _tmp218_;
883 _tmp133_ = root_symbol;
884 _tmp134_ = vala_symbol_get_scope ((ValaSymbol*) _tmp133_);
885 _tmp135_ = _tmp134_;
886 _tmp136_ = vala_scope_lookup (_tmp135_, "GLib");
887 glib_ns = _tmp136_;
888 _tmp137_ = glib_ns;
889 _tmp138_ = vala_symbol_get_scope (_tmp137_);
890 _tmp139_ = _tmp138_;
891 _tmp140_ = vala_scope_lookup (_tmp139_, "Object");
892 _vala_code_node_unref0 (self->object_type);
893 self->object_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp140_, VALA_TYPE_CLASS, ValaClass);
894 _tmp141_ = glib_ns;
895 _tmp142_ = vala_symbol_get_scope (_tmp141_);
896 _tmp143_ = _tmp142_;
897 _tmp144_ = vala_scope_lookup (_tmp143_, "Type");
898 _tmp145_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp144_, VALA_TYPE_STRUCT, ValaStruct);
899 _tmp146_ = vala_integer_type_new (_tmp145_, NULL, NULL);
900 _vala_code_node_unref0 (self->type_type);
901 self->type_type = (ValaDataType*) _tmp146_;
902 _vala_code_node_unref0 (_tmp145_);
903 _tmp147_ = glib_ns;
904 _tmp148_ = vala_symbol_get_scope (_tmp147_);
905 _tmp149_ = _tmp148_;
906 _tmp150_ = vala_scope_lookup (_tmp149_, "Value");
907 _tmp151_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp150_, VALA_TYPE_STRUCT, ValaStruct);
908 _tmp152_ = vala_struct_value_type_new (_tmp151_);
909 _vala_code_node_unref0 (self->gvalue_type);
910 self->gvalue_type = _tmp152_;
911 _vala_code_node_unref0 (_tmp151_);
912 _tmp153_ = glib_ns;
913 _tmp154_ = vala_symbol_get_scope (_tmp153_);
914 _tmp155_ = _tmp154_;
915 _tmp156_ = vala_scope_lookup (_tmp155_, "Variant");
916 _tmp157_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp156_, VALA_TYPE_CLASS, ValaClass);
917 _tmp158_ = vala_object_type_new ((ValaObjectTypeSymbol*) _tmp157_);
918 _vala_code_node_unref0 (self->gvariant_type);
919 self->gvariant_type = _tmp158_;
920 _vala_code_node_unref0 (_tmp157_);
921 _tmp159_ = glib_ns;
922 _tmp160_ = vala_symbol_get_scope (_tmp159_);
923 _tmp161_ = _tmp160_;
924 _tmp162_ = vala_scope_lookup (_tmp161_, "List");
925 _tmp163_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp162_, VALA_TYPE_CLASS, ValaClass);
926 _tmp164_ = vala_object_type_new ((ValaObjectTypeSymbol*) _tmp163_);
927 _vala_code_node_unref0 (self->glist_type);
928 self->glist_type = (ValaDataType*) _tmp164_;
929 _vala_code_node_unref0 (_tmp163_);
930 _tmp165_ = glib_ns;
931 _tmp166_ = vala_symbol_get_scope (_tmp165_);
932 _tmp167_ = _tmp166_;
933 _tmp168_ = vala_scope_lookup (_tmp167_, "SList");
934 _tmp169_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp168_, VALA_TYPE_CLASS, ValaClass);
935 _tmp170_ = vala_object_type_new ((ValaObjectTypeSymbol*) _tmp169_);
936 _vala_code_node_unref0 (self->gslist_type);
937 self->gslist_type = (ValaDataType*) _tmp170_;
938 _vala_code_node_unref0 (_tmp169_);
939 _tmp171_ = glib_ns;
940 _tmp172_ = vala_symbol_get_scope (_tmp171_);
941 _tmp173_ = _tmp172_;
942 _tmp174_ = vala_scope_lookup (_tmp173_, "Array");
943 _tmp175_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp174_, VALA_TYPE_CLASS, ValaClass);
944 _tmp176_ = vala_object_type_new ((ValaObjectTypeSymbol*) _tmp175_);
945 _vala_code_node_unref0 (self->garray_type);
946 self->garray_type = (ValaDataType*) _tmp176_;
947 _vala_code_node_unref0 (_tmp175_);
948 _tmp177_ = glib_ns;
949 _tmp178_ = vala_symbol_get_scope (_tmp177_);
950 _tmp179_ = _tmp178_;
951 _tmp180_ = vala_scope_lookup (_tmp179_, "ValueArray");
952 _tmp181_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp180_, VALA_TYPE_CLASS, ValaClass);
953 _tmp182_ = vala_object_type_new ((ValaObjectTypeSymbol*) _tmp181_);
954 _vala_code_node_unref0 (self->gvaluearray_type);
955 self->gvaluearray_type = (ValaDataType*) _tmp182_;
956 _vala_code_node_unref0 (_tmp181_);
957 _tmp183_ = glib_ns;
958 _tmp184_ = vala_symbol_get_scope (_tmp183_);
959 _tmp185_ = _tmp184_;
960 _tmp186_ = vala_scope_lookup (_tmp185_, "Error");
961 _vala_code_node_unref0 (self->gerror_type);
962 self->gerror_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp186_, VALA_TYPE_CLASS, ValaClass);
963 _tmp187_ = root_symbol;
964 _tmp188_ = vala_symbol_get_scope ((ValaSymbol*) _tmp187_);
965 _tmp189_ = _tmp188_;
966 _tmp190_ = vala_scope_lookup (_tmp189_, "GLib");
967 _tmp191_ = _tmp190_;
968 _tmp192_ = vala_symbol_get_scope (_tmp191_);
969 _tmp193_ = _tmp192_;
970 _tmp194_ = vala_scope_lookup (_tmp193_, "Regex");
971 _tmp195_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp194_, VALA_TYPE_CLASS, ValaClass);
972 _tmp196_ = vala_object_type_new ((ValaObjectTypeSymbol*) _tmp195_);
973 _vala_code_node_unref0 (self->regex_type);
974 self->regex_type = (ValaDataType*) _tmp196_;
975 _vala_code_node_unref0 (_tmp195_);
976 _vala_code_node_unref0 (_tmp191_);
977 _tmp197_ = glib_ns;
978 _tmp198_ = vala_symbol_get_scope (_tmp197_);
979 _tmp199_ = _tmp198_;
980 _tmp200_ = vala_scope_lookup (_tmp199_, "Source");
981 _vala_code_node_unref0 (self->gsource_type);
982 self->gsource_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp200_, VALA_TYPE_CLASS, ValaClass);
983 _tmp201_ = glib_ns;
984 _tmp202_ = vala_symbol_get_scope (_tmp201_);
985 _tmp203_ = _tmp202_;
986 _tmp204_ = vala_scope_lookup (_tmp203_, "pointer");
987 _tmp205_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp204_, VALA_TYPE_STRUCT, ValaStruct);
988 _tmp206_ = vala_struct_value_type_new (_tmp205_);
989 _vala_code_node_unref0 (self->delegate_target_type);
990 self->delegate_target_type = (ValaDataType*) _tmp206_;
991 _vala_code_node_unref0 (_tmp205_);
992 _tmp207_ = glib_ns;
993 _tmp208_ = vala_symbol_get_scope (_tmp207_);
994 _tmp209_ = _tmp208_;
995 _tmp210_ = vala_scope_lookup (_tmp209_, "DestroyNotify");
996 _vala_code_node_unref0 (self->priv->destroy_notify);
997 self->priv->destroy_notify = G_TYPE_CHECK_INSTANCE_CAST (_tmp210_, VALA_TYPE_DELEGATE, ValaDelegate);
998 _tmp211_ = self->priv->destroy_notify;
999 _tmp212_ = vala_delegate_type_new (_tmp211_);
1000 _vala_code_node_unref0 (self->delegate_target_destroy_type);
1001 self->delegate_target_destroy_type = _tmp212_;
1002 _tmp213_ = glib_ns;
1003 _tmp214_ = vala_symbol_get_scope (_tmp213_);
1004 _tmp215_ = _tmp214_;
1005 _tmp216_ = vala_scope_lookup (_tmp215_, "BoxedCopyFunc");
1006 _tmp217_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp216_, VALA_TYPE_DELEGATE, ValaDelegate);
1007 _tmp218_ = vala_delegate_type_new (_tmp217_);
1008 _vala_code_node_unref0 (self->generics_dup_func_type);
1009 self->generics_dup_func_type = _tmp218_;
1010 _vala_code_node_unref0 (_tmp217_);
1011 _vala_code_node_unref0 (glib_ns);
1012 } else {
1013 ValaVoidType* _tmp219_;
1014 ValaVoidType* _tmp220_;
1015 ValaPointerType* _tmp221_;
1016 ValaVoidType* _tmp222_;
1017 ValaVoidType* _tmp223_;
1018 ValaDelegate* _tmp224_;
1019 ValaDelegate* _tmp225_;
1020 ValaVoidType* _tmp226_;
1021 ValaVoidType* _tmp227_;
1022 ValaPointerType* _tmp228_;
1023 ValaPointerType* _tmp229_;
1024 ValaParameter* _tmp230_;
1025 ValaParameter* _tmp231_;
1026 ValaDelegate* _tmp232_;
1027 ValaDelegate* _tmp233_;
1028 ValaNamespace* _tmp234_;
1029 ValaNamespace* _tmp235_;
1030 ValaScope* _tmp236_;
1031 ValaScope* _tmp237_;
1032 ValaDelegate* _tmp238_;
1033 ValaDelegateType* _tmp239_;
1034 _tmp219_ = vala_void_type_new (NULL);
1035 _tmp220_ = _tmp219_;
1036 _tmp221_ = vala_pointer_type_new ((ValaDataType*) _tmp220_, NULL);
1037 _vala_code_node_unref0 (self->delegate_target_type);
1038 self->delegate_target_type = (ValaDataType*) _tmp221_;
1039 _vala_code_node_unref0 (_tmp220_);
1040 _tmp222_ = vala_void_type_new (NULL);
1041 _tmp223_ = _tmp222_;
1042 _tmp224_ = vala_delegate_new ("ValaDestroyNotify", (ValaDataType*) _tmp223_, NULL, NULL);
1043 _vala_code_node_unref0 (self->priv->destroy_notify);
1044 self->priv->destroy_notify = _tmp224_;
1045 _vala_code_node_unref0 (_tmp223_);
1046 _tmp225_ = self->priv->destroy_notify;
1047 _tmp226_ = vala_void_type_new (NULL);
1048 _tmp227_ = _tmp226_;
1049 _tmp228_ = vala_pointer_type_new ((ValaDataType*) _tmp227_, NULL);
1050 _tmp229_ = _tmp228_;
1051 _tmp230_ = vala_parameter_new ("data", (ValaDataType*) _tmp229_, NULL);
1052 _tmp231_ = _tmp230_;
1053 vala_callable_add_parameter ((ValaCallable*) _tmp225_, _tmp231_);
1054 _vala_code_node_unref0 (_tmp231_);
1055 _vala_code_node_unref0 (_tmp229_);
1056 _vala_code_node_unref0 (_tmp227_);
1057 _tmp232_ = self->priv->destroy_notify;
1058 vala_delegate_set_has_target (_tmp232_, FALSE);
1059 _tmp233_ = self->priv->destroy_notify;
1060 _tmp234_ = vala_code_context_get_root (context);
1061 _tmp235_ = _tmp234_;
1062 _tmp236_ = vala_symbol_get_scope ((ValaSymbol*) _tmp235_);
1063 _tmp237_ = _tmp236_;
1064 vala_symbol_set_owner ((ValaSymbol*) _tmp233_, _tmp237_);
1065 _tmp238_ = self->priv->destroy_notify;
1066 _tmp239_ = vala_delegate_type_new (_tmp238_);
1067 _vala_code_node_unref0 (self->delegate_target_destroy_type);
1068 self->delegate_target_destroy_type = _tmp239_;
1069 }
1070 _tmp240_ = root_symbol;
1071 vala_semantic_analyzer_set_current_symbol (self, (ValaSymbol*) _tmp240_);
1072 _tmp241_ = vala_code_context_get_root (context);
1073 _tmp242_ = _tmp241_;
1074 vala_code_node_check ((ValaCodeNode*) _tmp242_, context);
1075 vala_code_context_accept (context, (ValaCodeVisitor*) self);
1076 _vala_code_context_unref0 (self->priv->context);
1077 self->priv->context = NULL;
1078 _vala_code_node_unref0 (unichar_struct);
1079 _vala_code_node_unref0 (root_symbol);
1080 }
1081
1082 static void
vala_semantic_analyzer_real_visit_source_file(ValaCodeVisitor * base,ValaSourceFile * file)1083 vala_semantic_analyzer_real_visit_source_file (ValaCodeVisitor* base,
1084 ValaSourceFile* file)
1085 {
1086 ValaSemanticAnalyzer * self;
1087 ValaCodeContext* _tmp0_;
1088 self = (ValaSemanticAnalyzer*) base;
1089 g_return_if_fail (file != NULL);
1090 vala_semantic_analyzer_set_current_source_file (self, file);
1091 _tmp0_ = self->priv->context;
1092 vala_source_file_check (file, _tmp0_);
1093 }
1094
1095 gboolean
vala_semantic_analyzer_is_type_accessible(ValaSemanticAnalyzer * self,ValaSymbol * sym,ValaDataType * type)1096 vala_semantic_analyzer_is_type_accessible (ValaSemanticAnalyzer* self,
1097 ValaSymbol* sym,
1098 ValaDataType* type)
1099 {
1100 gboolean result = FALSE;
1101 g_return_val_if_fail (self != NULL, FALSE);
1102 g_return_val_if_fail (sym != NULL, FALSE);
1103 g_return_val_if_fail (type != NULL, FALSE);
1104 result = vala_data_type_is_accessible (type, sym);
1105 return result;
1106 }
1107
1108 ValaDataType*
vala_semantic_analyzer_get_value_type_for_symbol(ValaSemanticAnalyzer * self,ValaSymbol * sym,gboolean lvalue)1109 vala_semantic_analyzer_get_value_type_for_symbol (ValaSemanticAnalyzer* self,
1110 ValaSymbol* sym,
1111 gboolean lvalue)
1112 {
1113 ValaDataType* result = NULL;
1114 g_return_val_if_fail (self != NULL, NULL);
1115 g_return_val_if_fail (sym != NULL, NULL);
1116 if (VALA_IS_FIELD (sym)) {
1117 ValaField* f = NULL;
1118 ValaDataType* type = NULL;
1119 ValaField* _tmp0_;
1120 ValaDataType* _tmp1_;
1121 ValaDataType* _tmp2_;
1122 ValaDataType* _tmp3_;
1123 f = G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_FIELD, ValaField);
1124 _tmp0_ = f;
1125 _tmp1_ = vala_variable_get_variable_type ((ValaVariable*) _tmp0_);
1126 _tmp2_ = _tmp1_;
1127 _tmp3_ = vala_data_type_copy (_tmp2_);
1128 type = _tmp3_;
1129 if (!lvalue) {
1130 ValaDataType* _tmp4_;
1131 _tmp4_ = type;
1132 vala_data_type_set_value_owned (_tmp4_, FALSE);
1133 }
1134 result = type;
1135 return result;
1136 } else {
1137 if (VALA_IS_ENUM_VALUE (sym)) {
1138 ValaSymbol* _tmp5_;
1139 ValaSymbol* _tmp6_;
1140 ValaEnumValueType* _tmp7_;
1141 _tmp5_ = vala_symbol_get_parent_symbol (sym);
1142 _tmp6_ = _tmp5_;
1143 _tmp7_ = vala_enum_value_type_new (G_TYPE_CHECK_INSTANCE_CAST (_tmp6_, VALA_TYPE_ENUM, ValaEnum));
1144 result = (ValaDataType*) _tmp7_;
1145 return result;
1146 } else {
1147 if (VALA_IS_CONSTANT (sym)) {
1148 ValaConstant* c = NULL;
1149 ValaConstant* _tmp8_;
1150 ValaDataType* _tmp9_;
1151 ValaDataType* _tmp10_;
1152 ValaDataType* _tmp11_;
1153 c = G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_CONSTANT, ValaConstant);
1154 _tmp8_ = c;
1155 _tmp9_ = vala_constant_get_type_reference (_tmp8_);
1156 _tmp10_ = _tmp9_;
1157 _tmp11_ = vala_data_type_copy (_tmp10_);
1158 result = _tmp11_;
1159 return result;
1160 } else {
1161 if (VALA_IS_PROPERTY (sym)) {
1162 ValaProperty* prop = NULL;
1163 prop = G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_PROPERTY, ValaProperty);
1164 if (lvalue) {
1165 gboolean _tmp12_ = FALSE;
1166 ValaProperty* _tmp13_;
1167 ValaPropertyAccessor* _tmp14_;
1168 ValaPropertyAccessor* _tmp15_;
1169 _tmp13_ = prop;
1170 _tmp14_ = vala_property_get_set_accessor (_tmp13_);
1171 _tmp15_ = _tmp14_;
1172 if (_tmp15_ != NULL) {
1173 ValaProperty* _tmp16_;
1174 ValaPropertyAccessor* _tmp17_;
1175 ValaPropertyAccessor* _tmp18_;
1176 ValaDataType* _tmp19_;
1177 ValaDataType* _tmp20_;
1178 _tmp16_ = prop;
1179 _tmp17_ = vala_property_get_set_accessor (_tmp16_);
1180 _tmp18_ = _tmp17_;
1181 _tmp19_ = vala_property_accessor_get_value_type (_tmp18_);
1182 _tmp20_ = _tmp19_;
1183 _tmp12_ = _tmp20_ != NULL;
1184 } else {
1185 _tmp12_ = FALSE;
1186 }
1187 if (_tmp12_) {
1188 ValaProperty* _tmp21_;
1189 ValaPropertyAccessor* _tmp22_;
1190 ValaPropertyAccessor* _tmp23_;
1191 ValaDataType* _tmp24_;
1192 ValaDataType* _tmp25_;
1193 ValaDataType* _tmp26_;
1194 _tmp21_ = prop;
1195 _tmp22_ = vala_property_get_set_accessor (_tmp21_);
1196 _tmp23_ = _tmp22_;
1197 _tmp24_ = vala_property_accessor_get_value_type (_tmp23_);
1198 _tmp25_ = _tmp24_;
1199 _tmp26_ = vala_data_type_copy (_tmp25_);
1200 result = _tmp26_;
1201 return result;
1202 }
1203 } else {
1204 gboolean _tmp27_ = FALSE;
1205 ValaProperty* _tmp28_;
1206 ValaPropertyAccessor* _tmp29_;
1207 ValaPropertyAccessor* _tmp30_;
1208 _tmp28_ = prop;
1209 _tmp29_ = vala_property_get_get_accessor (_tmp28_);
1210 _tmp30_ = _tmp29_;
1211 if (_tmp30_ != NULL) {
1212 ValaProperty* _tmp31_;
1213 ValaPropertyAccessor* _tmp32_;
1214 ValaPropertyAccessor* _tmp33_;
1215 ValaDataType* _tmp34_;
1216 ValaDataType* _tmp35_;
1217 _tmp31_ = prop;
1218 _tmp32_ = vala_property_get_get_accessor (_tmp31_);
1219 _tmp33_ = _tmp32_;
1220 _tmp34_ = vala_property_accessor_get_value_type (_tmp33_);
1221 _tmp35_ = _tmp34_;
1222 _tmp27_ = _tmp35_ != NULL;
1223 } else {
1224 _tmp27_ = FALSE;
1225 }
1226 if (_tmp27_) {
1227 ValaProperty* _tmp36_;
1228 ValaPropertyAccessor* _tmp37_;
1229 ValaPropertyAccessor* _tmp38_;
1230 ValaDataType* _tmp39_;
1231 ValaDataType* _tmp40_;
1232 ValaDataType* _tmp41_;
1233 _tmp36_ = prop;
1234 _tmp37_ = vala_property_get_get_accessor (_tmp36_);
1235 _tmp38_ = _tmp37_;
1236 _tmp39_ = vala_property_accessor_get_value_type (_tmp38_);
1237 _tmp40_ = _tmp39_;
1238 _tmp41_ = vala_data_type_copy (_tmp40_);
1239 result = _tmp41_;
1240 return result;
1241 }
1242 }
1243 } else {
1244 if (VALA_IS_PARAMETER (sym)) {
1245 ValaParameter* p = NULL;
1246 ValaDataType* type = NULL;
1247 ValaParameter* _tmp42_;
1248 ValaDataType* _tmp43_;
1249 ValaDataType* _tmp44_;
1250 ValaDataType* _tmp45_;
1251 p = G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_PARAMETER, ValaParameter);
1252 _tmp42_ = p;
1253 _tmp43_ = vala_variable_get_variable_type ((ValaVariable*) _tmp42_);
1254 _tmp44_ = _tmp43_;
1255 _tmp45_ = vala_data_type_copy (_tmp44_);
1256 type = _tmp45_;
1257 if (!lvalue) {
1258 ValaDataType* _tmp46_;
1259 _tmp46_ = type;
1260 vala_data_type_set_value_owned (_tmp46_, FALSE);
1261 }
1262 result = type;
1263 return result;
1264 } else {
1265 if (VALA_IS_LOCAL_VARIABLE (sym)) {
1266 ValaLocalVariable* local = NULL;
1267 ValaDataType* type = NULL;
1268 ValaLocalVariable* _tmp47_;
1269 ValaDataType* _tmp48_;
1270 ValaDataType* _tmp49_;
1271 ValaDataType* _tmp50_;
1272 local = G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_LOCAL_VARIABLE, ValaLocalVariable);
1273 _tmp47_ = local;
1274 _tmp48_ = vala_variable_get_variable_type ((ValaVariable*) _tmp47_);
1275 _tmp49_ = _tmp48_;
1276 _tmp50_ = vala_data_type_copy (_tmp49_);
1277 type = _tmp50_;
1278 if (!lvalue) {
1279 ValaDataType* _tmp51_;
1280 _tmp51_ = type;
1281 vala_data_type_set_value_owned (_tmp51_, FALSE);
1282 }
1283 result = type;
1284 return result;
1285 } else {
1286 if (VALA_IS_METHOD (sym)) {
1287 ValaMethodType* _tmp52_;
1288 _tmp52_ = vala_method_type_new (G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_METHOD, ValaMethod));
1289 result = (ValaDataType*) _tmp52_;
1290 return result;
1291 } else {
1292 if (VALA_IS_SIGNAL (sym)) {
1293 ValaSignalType* _tmp53_;
1294 _tmp53_ = vala_signal_type_new (G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_SIGNAL, ValaSignal));
1295 result = (ValaDataType*) _tmp53_;
1296 return result;
1297 }
1298 }
1299 }
1300 }
1301 }
1302 }
1303 }
1304 }
1305 result = NULL;
1306 return result;
1307 }
1308
1309 static gpointer
_vala_iterable_ref0(gpointer self)1310 _vala_iterable_ref0 (gpointer self)
1311 {
1312 return self ? vala_iterable_ref (self) : NULL;
1313 }
1314
1315 ValaSymbol*
vala_semantic_analyzer_symbol_lookup_inherited(ValaSymbol * sym,const gchar * name)1316 vala_semantic_analyzer_symbol_lookup_inherited (ValaSymbol* sym,
1317 const gchar* name)
1318 {
1319 ValaSymbol* _result_ = NULL;
1320 ValaScope* _tmp0_;
1321 ValaScope* _tmp1_;
1322 ValaSymbol* _tmp2_;
1323 ValaSymbol* _tmp3_;
1324 ValaSymbol* result = NULL;
1325 g_return_val_if_fail (sym != NULL, NULL);
1326 g_return_val_if_fail (name != NULL, NULL);
1327 _tmp0_ = vala_symbol_get_scope (sym);
1328 _tmp1_ = _tmp0_;
1329 _tmp2_ = vala_scope_lookup (_tmp1_, name);
1330 _result_ = _tmp2_;
1331 _tmp3_ = _result_;
1332 if (_tmp3_ != NULL) {
1333 result = _result_;
1334 return result;
1335 }
1336 if (VALA_IS_CLASS (sym)) {
1337 ValaClass* cl = NULL;
1338 ValaClass* _tmp24_;
1339 ValaClass* _tmp25_;
1340 ValaClass* _tmp26_;
1341 cl = G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_CLASS, ValaClass);
1342 {
1343 ValaList* _base_type_list = NULL;
1344 ValaClass* _tmp4_;
1345 ValaList* _tmp5_;
1346 ValaList* _tmp6_;
1347 gint _base_type_size = 0;
1348 ValaList* _tmp7_;
1349 gint _tmp8_;
1350 gint _tmp9_;
1351 gint _base_type_index = 0;
1352 _tmp4_ = cl;
1353 _tmp5_ = vala_class_get_base_types (_tmp4_);
1354 _tmp6_ = _vala_iterable_ref0 (_tmp5_);
1355 _base_type_list = _tmp6_;
1356 _tmp7_ = _base_type_list;
1357 _tmp8_ = vala_collection_get_size ((ValaCollection*) _tmp7_);
1358 _tmp9_ = _tmp8_;
1359 _base_type_size = _tmp9_;
1360 _base_type_index = -1;
1361 while (TRUE) {
1362 gint _tmp10_;
1363 gint _tmp11_;
1364 ValaDataType* base_type = NULL;
1365 ValaList* _tmp12_;
1366 gpointer _tmp13_;
1367 ValaDataType* _tmp14_;
1368 ValaTypeSymbol* _tmp15_;
1369 ValaTypeSymbol* _tmp16_;
1370 _base_type_index = _base_type_index + 1;
1371 _tmp10_ = _base_type_index;
1372 _tmp11_ = _base_type_size;
1373 if (!(_tmp10_ < _tmp11_)) {
1374 break;
1375 }
1376 _tmp12_ = _base_type_list;
1377 _tmp13_ = vala_list_get (_tmp12_, _base_type_index);
1378 base_type = (ValaDataType*) _tmp13_;
1379 _tmp14_ = base_type;
1380 _tmp15_ = vala_data_type_get_type_symbol (_tmp14_);
1381 _tmp16_ = _tmp15_;
1382 if (VALA_IS_INTERFACE (_tmp16_)) {
1383 ValaDataType* _tmp17_;
1384 ValaTypeSymbol* _tmp18_;
1385 ValaTypeSymbol* _tmp19_;
1386 ValaScope* _tmp20_;
1387 ValaScope* _tmp21_;
1388 ValaSymbol* _tmp22_;
1389 ValaSymbol* _tmp23_;
1390 _tmp17_ = base_type;
1391 _tmp18_ = vala_data_type_get_type_symbol (_tmp17_);
1392 _tmp19_ = _tmp18_;
1393 _tmp20_ = vala_symbol_get_scope ((ValaSymbol*) _tmp19_);
1394 _tmp21_ = _tmp20_;
1395 _tmp22_ = vala_scope_lookup (_tmp21_, name);
1396 _vala_code_node_unref0 (_result_);
1397 _result_ = _tmp22_;
1398 _tmp23_ = _result_;
1399 if (_tmp23_ != NULL) {
1400 result = _result_;
1401 _vala_code_node_unref0 (base_type);
1402 _vala_iterable_unref0 (_base_type_list);
1403 return result;
1404 }
1405 }
1406 _vala_code_node_unref0 (base_type);
1407 }
1408 _vala_iterable_unref0 (_base_type_list);
1409 }
1410 _tmp24_ = cl;
1411 _tmp25_ = vala_class_get_base_class (_tmp24_);
1412 _tmp26_ = _tmp25_;
1413 if (_tmp26_ != NULL) {
1414 ValaClass* _tmp27_;
1415 ValaClass* _tmp28_;
1416 ValaClass* _tmp29_;
1417 ValaSymbol* _tmp30_;
1418 _tmp27_ = cl;
1419 _tmp28_ = vala_class_get_base_class (_tmp27_);
1420 _tmp29_ = _tmp28_;
1421 _tmp30_ = vala_semantic_analyzer_symbol_lookup_inherited ((ValaSymbol*) _tmp29_, name);
1422 result = _tmp30_;
1423 _vala_code_node_unref0 (_result_);
1424 return result;
1425 }
1426 } else {
1427 if (VALA_IS_STRUCT (sym)) {
1428 ValaStruct* st = NULL;
1429 ValaStruct* _tmp31_;
1430 ValaDataType* _tmp32_;
1431 ValaDataType* _tmp33_;
1432 st = G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_STRUCT, ValaStruct);
1433 _tmp31_ = st;
1434 _tmp32_ = vala_struct_get_base_type (_tmp31_);
1435 _tmp33_ = _tmp32_;
1436 if (_tmp33_ != NULL) {
1437 ValaStruct* _tmp34_;
1438 ValaDataType* _tmp35_;
1439 ValaDataType* _tmp36_;
1440 ValaTypeSymbol* _tmp37_;
1441 ValaTypeSymbol* _tmp38_;
1442 ValaSymbol* _tmp39_;
1443 ValaSymbol* _tmp40_;
1444 _tmp34_ = st;
1445 _tmp35_ = vala_struct_get_base_type (_tmp34_);
1446 _tmp36_ = _tmp35_;
1447 _tmp37_ = vala_data_type_get_type_symbol (_tmp36_);
1448 _tmp38_ = _tmp37_;
1449 _tmp39_ = vala_semantic_analyzer_symbol_lookup_inherited ((ValaSymbol*) _tmp38_, name);
1450 _vala_code_node_unref0 (_result_);
1451 _result_ = _tmp39_;
1452 _tmp40_ = _result_;
1453 if (_tmp40_ != NULL) {
1454 result = _result_;
1455 return result;
1456 }
1457 }
1458 } else {
1459 if (VALA_IS_INTERFACE (sym)) {
1460 ValaInterface* iface = NULL;
1461 iface = G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_INTERFACE, ValaInterface);
1462 {
1463 ValaList* _prerequisite_list = NULL;
1464 ValaInterface* _tmp41_;
1465 ValaList* _tmp42_;
1466 ValaList* _tmp43_;
1467 gint _prerequisite_size = 0;
1468 ValaList* _tmp44_;
1469 gint _tmp45_;
1470 gint _tmp46_;
1471 gint _prerequisite_index = 0;
1472 _tmp41_ = iface;
1473 _tmp42_ = vala_interface_get_prerequisites (_tmp41_);
1474 _tmp43_ = _vala_iterable_ref0 (_tmp42_);
1475 _prerequisite_list = _tmp43_;
1476 _tmp44_ = _prerequisite_list;
1477 _tmp45_ = vala_collection_get_size ((ValaCollection*) _tmp44_);
1478 _tmp46_ = _tmp45_;
1479 _prerequisite_size = _tmp46_;
1480 _prerequisite_index = -1;
1481 while (TRUE) {
1482 gint _tmp47_;
1483 gint _tmp48_;
1484 ValaDataType* prerequisite = NULL;
1485 ValaList* _tmp49_;
1486 gpointer _tmp50_;
1487 ValaDataType* _tmp51_;
1488 ValaTypeSymbol* _tmp52_;
1489 ValaTypeSymbol* _tmp53_;
1490 _prerequisite_index = _prerequisite_index + 1;
1491 _tmp47_ = _prerequisite_index;
1492 _tmp48_ = _prerequisite_size;
1493 if (!(_tmp47_ < _tmp48_)) {
1494 break;
1495 }
1496 _tmp49_ = _prerequisite_list;
1497 _tmp50_ = vala_list_get (_tmp49_, _prerequisite_index);
1498 prerequisite = (ValaDataType*) _tmp50_;
1499 _tmp51_ = prerequisite;
1500 _tmp52_ = vala_data_type_get_type_symbol (_tmp51_);
1501 _tmp53_ = _tmp52_;
1502 if (VALA_IS_INTERFACE (_tmp53_)) {
1503 ValaDataType* _tmp54_;
1504 ValaTypeSymbol* _tmp55_;
1505 ValaTypeSymbol* _tmp56_;
1506 ValaSymbol* _tmp57_;
1507 ValaSymbol* _tmp58_;
1508 _tmp54_ = prerequisite;
1509 _tmp55_ = vala_data_type_get_type_symbol (_tmp54_);
1510 _tmp56_ = _tmp55_;
1511 _tmp57_ = vala_semantic_analyzer_symbol_lookup_inherited ((ValaSymbol*) _tmp56_, name);
1512 _vala_code_node_unref0 (_result_);
1513 _result_ = _tmp57_;
1514 _tmp58_ = _result_;
1515 if (_tmp58_ != NULL) {
1516 result = _result_;
1517 _vala_code_node_unref0 (prerequisite);
1518 _vala_iterable_unref0 (_prerequisite_list);
1519 return result;
1520 }
1521 }
1522 _vala_code_node_unref0 (prerequisite);
1523 }
1524 _vala_iterable_unref0 (_prerequisite_list);
1525 }
1526 {
1527 ValaList* _prerequisite_list = NULL;
1528 ValaInterface* _tmp59_;
1529 ValaList* _tmp60_;
1530 ValaList* _tmp61_;
1531 gint _prerequisite_size = 0;
1532 ValaList* _tmp62_;
1533 gint _tmp63_;
1534 gint _tmp64_;
1535 gint _prerequisite_index = 0;
1536 _tmp59_ = iface;
1537 _tmp60_ = vala_interface_get_prerequisites (_tmp59_);
1538 _tmp61_ = _vala_iterable_ref0 (_tmp60_);
1539 _prerequisite_list = _tmp61_;
1540 _tmp62_ = _prerequisite_list;
1541 _tmp63_ = vala_collection_get_size ((ValaCollection*) _tmp62_);
1542 _tmp64_ = _tmp63_;
1543 _prerequisite_size = _tmp64_;
1544 _prerequisite_index = -1;
1545 while (TRUE) {
1546 gint _tmp65_;
1547 gint _tmp66_;
1548 ValaDataType* prerequisite = NULL;
1549 ValaList* _tmp67_;
1550 gpointer _tmp68_;
1551 ValaDataType* _tmp69_;
1552 ValaTypeSymbol* _tmp70_;
1553 ValaTypeSymbol* _tmp71_;
1554 _prerequisite_index = _prerequisite_index + 1;
1555 _tmp65_ = _prerequisite_index;
1556 _tmp66_ = _prerequisite_size;
1557 if (!(_tmp65_ < _tmp66_)) {
1558 break;
1559 }
1560 _tmp67_ = _prerequisite_list;
1561 _tmp68_ = vala_list_get (_tmp67_, _prerequisite_index);
1562 prerequisite = (ValaDataType*) _tmp68_;
1563 _tmp69_ = prerequisite;
1564 _tmp70_ = vala_data_type_get_type_symbol (_tmp69_);
1565 _tmp71_ = _tmp70_;
1566 if (VALA_IS_CLASS (_tmp71_)) {
1567 ValaDataType* _tmp72_;
1568 ValaTypeSymbol* _tmp73_;
1569 ValaTypeSymbol* _tmp74_;
1570 ValaSymbol* _tmp75_;
1571 ValaSymbol* _tmp76_;
1572 _tmp72_ = prerequisite;
1573 _tmp73_ = vala_data_type_get_type_symbol (_tmp72_);
1574 _tmp74_ = _tmp73_;
1575 _tmp75_ = vala_semantic_analyzer_symbol_lookup_inherited ((ValaSymbol*) _tmp74_, name);
1576 _vala_code_node_unref0 (_result_);
1577 _result_ = _tmp75_;
1578 _tmp76_ = _result_;
1579 if (_tmp76_ != NULL) {
1580 result = _result_;
1581 _vala_code_node_unref0 (prerequisite);
1582 _vala_iterable_unref0 (_prerequisite_list);
1583 return result;
1584 }
1585 }
1586 _vala_code_node_unref0 (prerequisite);
1587 }
1588 _vala_iterable_unref0 (_prerequisite_list);
1589 }
1590 }
1591 }
1592 }
1593 result = NULL;
1594 _vala_code_node_unref0 (_result_);
1595 return result;
1596 }
1597
1598 ValaDataType*
vala_semantic_analyzer_get_data_type_for_symbol(ValaSymbol * sym)1599 vala_semantic_analyzer_get_data_type_for_symbol (ValaSymbol* sym)
1600 {
1601 ValaDataType* type = NULL;
1602 ValaList* type_parameters = NULL;
1603 ValaList* _tmp33_;
1604 ValaDataType* result = NULL;
1605 g_return_val_if_fail (sym != NULL, NULL);
1606 type_parameters = NULL;
1607 if (VALA_IS_OBJECT_TYPE_SYMBOL (sym)) {
1608 ValaClass* cl = NULL;
1609 gboolean _tmp0_ = FALSE;
1610 ValaClass* _tmp1_;
1611 cl = VALA_IS_CLASS (sym) ? ((ValaClass*) sym) : NULL;
1612 _tmp1_ = cl;
1613 if (_tmp1_ != NULL) {
1614 ValaClass* _tmp2_;
1615 gboolean _tmp3_;
1616 gboolean _tmp4_;
1617 _tmp2_ = cl;
1618 _tmp3_ = vala_class_get_is_error_base (_tmp2_);
1619 _tmp4_ = _tmp3_;
1620 _tmp0_ = _tmp4_;
1621 } else {
1622 _tmp0_ = FALSE;
1623 }
1624 if (_tmp0_) {
1625 ValaErrorType* _tmp5_;
1626 _tmp5_ = vala_error_type_new (NULL, NULL, NULL);
1627 _vala_code_node_unref0 (type);
1628 type = (ValaDataType*) _tmp5_;
1629 } else {
1630 ValaObjectType* _tmp6_;
1631 ValaList* _tmp7_;
1632 ValaList* _tmp8_;
1633 _tmp6_ = vala_object_type_new (G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_OBJECT_TYPE_SYMBOL, ValaObjectTypeSymbol));
1634 _vala_code_node_unref0 (type);
1635 type = (ValaDataType*) _tmp6_;
1636 _tmp7_ = vala_object_type_symbol_get_type_parameters (G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_OBJECT_TYPE_SYMBOL, ValaObjectTypeSymbol));
1637 _tmp8_ = _vala_iterable_ref0 (_tmp7_);
1638 _vala_iterable_unref0 (type_parameters);
1639 type_parameters = _tmp8_;
1640 }
1641 } else {
1642 if (VALA_IS_STRUCT (sym)) {
1643 ValaStruct* st = NULL;
1644 ValaStruct* _tmp9_;
1645 ValaStruct* _tmp20_;
1646 ValaList* _tmp21_;
1647 ValaList* _tmp22_;
1648 st = G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_STRUCT, ValaStruct);
1649 _tmp9_ = st;
1650 if (vala_struct_is_boolean_type (_tmp9_)) {
1651 ValaStruct* _tmp10_;
1652 ValaBooleanType* _tmp11_;
1653 _tmp10_ = st;
1654 _tmp11_ = vala_boolean_type_new (_tmp10_);
1655 _vala_code_node_unref0 (type);
1656 type = (ValaDataType*) _tmp11_;
1657 } else {
1658 ValaStruct* _tmp12_;
1659 _tmp12_ = st;
1660 if (vala_struct_is_integer_type (_tmp12_)) {
1661 ValaStruct* _tmp13_;
1662 ValaIntegerType* _tmp14_;
1663 _tmp13_ = st;
1664 _tmp14_ = vala_integer_type_new (_tmp13_, NULL, NULL);
1665 _vala_code_node_unref0 (type);
1666 type = (ValaDataType*) _tmp14_;
1667 } else {
1668 ValaStruct* _tmp15_;
1669 _tmp15_ = st;
1670 if (vala_struct_is_floating_type (_tmp15_)) {
1671 ValaStruct* _tmp16_;
1672 ValaFloatingType* _tmp17_;
1673 _tmp16_ = st;
1674 _tmp17_ = vala_floating_type_new (_tmp16_);
1675 _vala_code_node_unref0 (type);
1676 type = (ValaDataType*) _tmp17_;
1677 } else {
1678 ValaStruct* _tmp18_;
1679 ValaStructValueType* _tmp19_;
1680 _tmp18_ = st;
1681 _tmp19_ = vala_struct_value_type_new (_tmp18_);
1682 _vala_code_node_unref0 (type);
1683 type = (ValaDataType*) _tmp19_;
1684 }
1685 }
1686 }
1687 _tmp20_ = st;
1688 _tmp21_ = vala_struct_get_type_parameters (_tmp20_);
1689 _tmp22_ = _vala_iterable_ref0 (_tmp21_);
1690 _vala_iterable_unref0 (type_parameters);
1691 type_parameters = _tmp22_;
1692 } else {
1693 if (VALA_IS_ENUM (sym)) {
1694 ValaEnumValueType* _tmp23_;
1695 _tmp23_ = vala_enum_value_type_new (G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_ENUM, ValaEnum));
1696 _vala_code_node_unref0 (type);
1697 type = (ValaDataType*) _tmp23_;
1698 } else {
1699 if (VALA_IS_ERROR_DOMAIN (sym)) {
1700 ValaErrorType* _tmp24_;
1701 _tmp24_ = vala_error_type_new (G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_ERROR_DOMAIN, ValaErrorDomain), NULL, NULL);
1702 _vala_code_node_unref0 (type);
1703 type = (ValaDataType*) _tmp24_;
1704 } else {
1705 if (VALA_IS_ERROR_CODE (sym)) {
1706 ValaSymbol* _tmp25_;
1707 ValaSymbol* _tmp26_;
1708 ValaErrorType* _tmp27_;
1709 _tmp25_ = vala_symbol_get_parent_symbol (sym);
1710 _tmp26_ = _tmp25_;
1711 _tmp27_ = vala_error_type_new (G_TYPE_CHECK_INSTANCE_CAST (_tmp26_, VALA_TYPE_ERROR_DOMAIN, ValaErrorDomain), G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_ERROR_CODE, ValaErrorCode), NULL);
1712 _vala_code_node_unref0 (type);
1713 type = (ValaDataType*) _tmp27_;
1714 } else {
1715 gchar* _tmp28_;
1716 gchar* _tmp29_;
1717 gchar* _tmp30_;
1718 gchar* _tmp31_;
1719 ValaInvalidType* _tmp32_;
1720 _tmp28_ = vala_symbol_get_full_name (sym);
1721 _tmp29_ = _tmp28_;
1722 _tmp30_ = g_strdup_printf ("internal error: `%s' is not a supported type", _tmp29_);
1723 _tmp31_ = _tmp30_;
1724 vala_report_error (NULL, _tmp31_);
1725 _g_free0 (_tmp31_);
1726 _g_free0 (_tmp29_);
1727 _tmp32_ = vala_invalid_type_new ();
1728 result = (ValaDataType*) _tmp32_;
1729 _vala_iterable_unref0 (type_parameters);
1730 _vala_code_node_unref0 (type);
1731 return result;
1732 }
1733 }
1734 }
1735 }
1736 }
1737 _tmp33_ = type_parameters;
1738 if (_tmp33_ != NULL) {
1739 {
1740 ValaList* _type_param_list = NULL;
1741 ValaList* _tmp34_;
1742 ValaList* _tmp35_;
1743 gint _type_param_size = 0;
1744 ValaList* _tmp36_;
1745 gint _tmp37_;
1746 gint _tmp38_;
1747 gint _type_param_index = 0;
1748 _tmp34_ = type_parameters;
1749 _tmp35_ = _vala_iterable_ref0 (_tmp34_);
1750 _type_param_list = _tmp35_;
1751 _tmp36_ = _type_param_list;
1752 _tmp37_ = vala_collection_get_size ((ValaCollection*) _tmp36_);
1753 _tmp38_ = _tmp37_;
1754 _type_param_size = _tmp38_;
1755 _type_param_index = -1;
1756 while (TRUE) {
1757 gint _tmp39_;
1758 gint _tmp40_;
1759 ValaTypeParameter* type_param = NULL;
1760 ValaList* _tmp41_;
1761 gpointer _tmp42_;
1762 ValaGenericType* type_arg = NULL;
1763 ValaTypeParameter* _tmp43_;
1764 ValaGenericType* _tmp44_;
1765 ValaGenericType* _tmp45_;
1766 ValaDataType* _tmp46_;
1767 ValaGenericType* _tmp47_;
1768 _type_param_index = _type_param_index + 1;
1769 _tmp39_ = _type_param_index;
1770 _tmp40_ = _type_param_size;
1771 if (!(_tmp39_ < _tmp40_)) {
1772 break;
1773 }
1774 _tmp41_ = _type_param_list;
1775 _tmp42_ = vala_list_get (_tmp41_, _type_param_index);
1776 type_param = (ValaTypeParameter*) _tmp42_;
1777 _tmp43_ = type_param;
1778 _tmp44_ = vala_generic_type_new (_tmp43_);
1779 type_arg = _tmp44_;
1780 _tmp45_ = type_arg;
1781 vala_data_type_set_value_owned ((ValaDataType*) _tmp45_, TRUE);
1782 _tmp46_ = type;
1783 _tmp47_ = type_arg;
1784 vala_data_type_add_type_argument (_tmp46_, (ValaDataType*) _tmp47_);
1785 _vala_code_node_unref0 (type_arg);
1786 _vala_code_node_unref0 (type_param);
1787 }
1788 _vala_iterable_unref0 (_type_param_list);
1789 }
1790 }
1791 result = type;
1792 _vala_iterable_unref0 (type_parameters);
1793 return result;
1794 }
1795
1796 ValaSymbol*
vala_semantic_analyzer_get_symbol_for_data_type(ValaDataType * type)1797 vala_semantic_analyzer_get_symbol_for_data_type (ValaDataType* type)
1798 {
1799 ValaSymbol* sym = NULL;
1800 ValaSymbol* _tmp14_;
1801 ValaSymbol* result = NULL;
1802 g_return_val_if_fail (type != NULL, NULL);
1803 sym = NULL;
1804 if (VALA_IS_OBJECT_TYPE (type)) {
1805 ValaTypeSymbol* _tmp0_;
1806 ValaTypeSymbol* _tmp1_;
1807 _tmp0_ = vala_data_type_get_type_symbol ((ValaDataType*) G_TYPE_CHECK_INSTANCE_CAST (type, VALA_TYPE_OBJECT_TYPE, ValaObjectType));
1808 _tmp1_ = _tmp0_;
1809 sym = (ValaSymbol*) _tmp1_;
1810 } else {
1811 if (VALA_IS_CLASS_TYPE (type)) {
1812 ValaClass* _tmp2_;
1813 ValaClass* _tmp3_;
1814 _tmp2_ = vala_class_type_get_class_symbol (G_TYPE_CHECK_INSTANCE_CAST (type, VALA_TYPE_CLASS_TYPE, ValaClassType));
1815 _tmp3_ = _tmp2_;
1816 sym = (ValaSymbol*) _tmp3_;
1817 } else {
1818 if (VALA_IS_INTERFACE_TYPE (type)) {
1819 ValaInterface* _tmp4_;
1820 ValaInterface* _tmp5_;
1821 _tmp4_ = vala_interface_type_get_interface_symbol (G_TYPE_CHECK_INSTANCE_CAST (type, VALA_TYPE_INTERFACE_TYPE, ValaInterfaceType));
1822 _tmp5_ = _tmp4_;
1823 sym = (ValaSymbol*) _tmp5_;
1824 } else {
1825 if (VALA_IS_METHOD_TYPE (type)) {
1826 ValaMethod* _tmp6_;
1827 ValaMethod* _tmp7_;
1828 _tmp6_ = vala_method_type_get_method_symbol (G_TYPE_CHECK_INSTANCE_CAST (type, VALA_TYPE_METHOD_TYPE, ValaMethodType));
1829 _tmp7_ = _tmp6_;
1830 sym = (ValaSymbol*) _tmp7_;
1831 } else {
1832 if (VALA_IS_SIGNAL_TYPE (type)) {
1833 ValaSignal* _tmp8_;
1834 ValaSignal* _tmp9_;
1835 _tmp8_ = vala_signal_type_get_signal_symbol (G_TYPE_CHECK_INSTANCE_CAST (type, VALA_TYPE_SIGNAL_TYPE, ValaSignalType));
1836 _tmp9_ = _tmp8_;
1837 sym = (ValaSymbol*) _tmp9_;
1838 } else {
1839 if (VALA_IS_DELEGATE_TYPE (type)) {
1840 ValaDelegate* _tmp10_;
1841 ValaDelegate* _tmp11_;
1842 _tmp10_ = vala_delegate_type_get_delegate_symbol (G_TYPE_CHECK_INSTANCE_CAST (type, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));
1843 _tmp11_ = _tmp10_;
1844 sym = (ValaSymbol*) _tmp11_;
1845 } else {
1846 if (VALA_IS_VALUE_TYPE (type)) {
1847 ValaTypeSymbol* _tmp12_;
1848 ValaTypeSymbol* _tmp13_;
1849 _tmp12_ = vala_data_type_get_type_symbol ((ValaDataType*) G_TYPE_CHECK_INSTANCE_CAST (type, VALA_TYPE_VALUE_TYPE, ValaValueType));
1850 _tmp13_ = _tmp12_;
1851 sym = (ValaSymbol*) _tmp13_;
1852 }
1853 }
1854 }
1855 }
1856 }
1857 }
1858 }
1859 _tmp14_ = sym;
1860 result = _tmp14_;
1861 return result;
1862 }
1863
1864 static gchar
string_get(const gchar * self,glong index)1865 string_get (const gchar* self,
1866 glong index)
1867 {
1868 gchar _tmp0_;
1869 gchar result = '\0';
1870 g_return_val_if_fail (self != NULL, '\0');
1871 _tmp0_ = ((gchar*) self)[index];
1872 result = _tmp0_;
1873 return result;
1874 }
1875
1876 gboolean
vala_semantic_analyzer_is_gobject_property(ValaSemanticAnalyzer * self,ValaProperty * prop)1877 vala_semantic_analyzer_is_gobject_property (ValaSemanticAnalyzer* self,
1878 ValaProperty* prop)
1879 {
1880 ValaObjectTypeSymbol* type_sym = NULL;
1881 ValaSymbol* _tmp0_;
1882 ValaSymbol* _tmp1_;
1883 gboolean _tmp2_ = FALSE;
1884 ValaObjectTypeSymbol* _tmp3_;
1885 ValaMemberBinding _tmp6_;
1886 ValaMemberBinding _tmp7_;
1887 ValaSymbolAccessibility _tmp8_;
1888 ValaSymbolAccessibility _tmp9_;
1889 ValaDataType* _tmp10_;
1890 ValaDataType* _tmp11_;
1891 gboolean _tmp19_ = FALSE;
1892 gboolean _tmp20_ = FALSE;
1893 ValaObjectTypeSymbol* _tmp21_;
1894 const gchar* _tmp26_;
1895 const gchar* _tmp27_;
1896 gboolean _tmp28_ = FALSE;
1897 gboolean _tmp29_ = FALSE;
1898 gboolean _tmp30_ = FALSE;
1899 ValaObjectTypeSymbol* _tmp31_;
1900 gboolean _tmp38_ = FALSE;
1901 ValaObjectTypeSymbol* _tmp39_;
1902 gboolean result = FALSE;
1903 g_return_val_if_fail (self != NULL, FALSE);
1904 g_return_val_if_fail (prop != NULL, FALSE);
1905 _tmp0_ = vala_symbol_get_parent_symbol ((ValaSymbol*) prop);
1906 _tmp1_ = _tmp0_;
1907 type_sym = VALA_IS_OBJECT_TYPE_SYMBOL (_tmp1_) ? ((ValaObjectTypeSymbol*) _tmp1_) : NULL;
1908 _tmp3_ = type_sym;
1909 if (_tmp3_ == NULL) {
1910 _tmp2_ = TRUE;
1911 } else {
1912 ValaObjectTypeSymbol* _tmp4_;
1913 ValaClass* _tmp5_;
1914 _tmp4_ = type_sym;
1915 _tmp5_ = self->object_type;
1916 _tmp2_ = !vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp4_, (ValaTypeSymbol*) _tmp5_);
1917 }
1918 if (_tmp2_) {
1919 result = FALSE;
1920 return result;
1921 }
1922 _tmp6_ = vala_property_get_binding (prop);
1923 _tmp7_ = _tmp6_;
1924 if (_tmp7_ != VALA_MEMBER_BINDING_INSTANCE) {
1925 result = FALSE;
1926 return result;
1927 }
1928 _tmp8_ = vala_symbol_get_access ((ValaSymbol*) prop);
1929 _tmp9_ = _tmp8_;
1930 if (_tmp9_ == VALA_SYMBOL_ACCESSIBILITY_PRIVATE) {
1931 result = FALSE;
1932 return result;
1933 }
1934 _tmp10_ = vala_property_get_property_type (prop);
1935 _tmp11_ = _tmp10_;
1936 if (!vala_semantic_analyzer_is_gobject_property_type (self, _tmp11_)) {
1937 gboolean _tmp12_ = FALSE;
1938 ValaDataType* _tmp13_;
1939 ValaDataType* _tmp14_;
1940 _tmp13_ = vala_property_get_property_type (prop);
1941 _tmp14_ = _tmp13_;
1942 if (VALA_IS_ARRAY_TYPE (_tmp14_)) {
1943 gboolean _tmp15_ = FALSE;
1944 if (!vala_code_node_get_attribute_bool ((ValaCodeNode*) prop, "CCode", "array_length", TRUE)) {
1945 _tmp15_ = vala_code_node_get_attribute_bool ((ValaCodeNode*) prop, "CCode", "array_null_terminated", FALSE);
1946 } else {
1947 _tmp15_ = FALSE;
1948 }
1949 _tmp12_ = _tmp15_;
1950 } else {
1951 _tmp12_ = FALSE;
1952 }
1953 if (_tmp12_) {
1954 } else {
1955 gboolean _tmp16_ = FALSE;
1956 ValaDataType* _tmp17_;
1957 ValaDataType* _tmp18_;
1958 _tmp17_ = vala_property_get_property_type (prop);
1959 _tmp18_ = _tmp17_;
1960 if (VALA_IS_DELEGATE_TYPE (_tmp18_)) {
1961 _tmp16_ = !vala_code_node_get_attribute_bool ((ValaCodeNode*) prop, "CCode", "delegate_target", TRUE);
1962 } else {
1963 _tmp16_ = FALSE;
1964 }
1965 if (_tmp16_) {
1966 } else {
1967 result = FALSE;
1968 return result;
1969 }
1970 }
1971 }
1972 _tmp21_ = type_sym;
1973 if (VALA_IS_CLASS (_tmp21_)) {
1974 ValaProperty* _tmp22_;
1975 ValaProperty* _tmp23_;
1976 _tmp22_ = vala_property_get_base_interface_property (prop);
1977 _tmp23_ = _tmp22_;
1978 _tmp20_ = _tmp23_ != NULL;
1979 } else {
1980 _tmp20_ = FALSE;
1981 }
1982 if (_tmp20_) {
1983 ValaProperty* _tmp24_;
1984 ValaProperty* _tmp25_;
1985 _tmp24_ = vala_property_get_base_interface_property (prop);
1986 _tmp25_ = _tmp24_;
1987 _tmp19_ = !vala_semantic_analyzer_is_gobject_property (self, _tmp25_);
1988 } else {
1989 _tmp19_ = FALSE;
1990 }
1991 if (_tmp19_) {
1992 result = FALSE;
1993 return result;
1994 }
1995 _tmp26_ = vala_symbol_get_name ((ValaSymbol*) prop);
1996 _tmp27_ = _tmp26_;
1997 if (!g_ascii_isalpha (string_get (_tmp27_, (glong) 0))) {
1998 result = FALSE;
1999 return result;
2000 }
2001 _tmp31_ = type_sym;
2002 if (VALA_IS_INTERFACE (_tmp31_)) {
2003 gboolean _tmp32_;
2004 gboolean _tmp33_;
2005 _tmp32_ = vala_property_get_is_abstract (prop);
2006 _tmp33_ = _tmp32_;
2007 _tmp30_ = !_tmp33_;
2008 } else {
2009 _tmp30_ = FALSE;
2010 }
2011 if (_tmp30_) {
2012 gboolean _tmp34_;
2013 gboolean _tmp35_;
2014 _tmp34_ = vala_symbol_get_external ((ValaSymbol*) prop);
2015 _tmp35_ = _tmp34_;
2016 _tmp29_ = !_tmp35_;
2017 } else {
2018 _tmp29_ = FALSE;
2019 }
2020 if (_tmp29_) {
2021 gboolean _tmp36_;
2022 gboolean _tmp37_;
2023 _tmp36_ = vala_symbol_get_external_package ((ValaSymbol*) prop);
2024 _tmp37_ = _tmp36_;
2025 _tmp28_ = !_tmp37_;
2026 } else {
2027 _tmp28_ = FALSE;
2028 }
2029 if (_tmp28_) {
2030 result = FALSE;
2031 return result;
2032 }
2033 _tmp39_ = type_sym;
2034 if (VALA_IS_INTERFACE (_tmp39_)) {
2035 ValaObjectTypeSymbol* _tmp40_;
2036 ValaAttribute* _tmp41_;
2037 _tmp40_ = type_sym;
2038 _tmp41_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp40_, "DBus");
2039 _tmp38_ = _tmp41_ != NULL;
2040 } else {
2041 _tmp38_ = FALSE;
2042 }
2043 if (_tmp38_) {
2044 result = FALSE;
2045 return result;
2046 }
2047 result = TRUE;
2048 return result;
2049 }
2050
2051 gboolean
vala_semantic_analyzer_is_gobject_property_type(ValaSemanticAnalyzer * self,ValaDataType * property_type)2052 vala_semantic_analyzer_is_gobject_property_type (ValaSemanticAnalyzer* self,
2053 ValaDataType* property_type)
2054 {
2055 ValaStruct* st = NULL;
2056 ValaTypeSymbol* _tmp0_;
2057 ValaTypeSymbol* _tmp1_;
2058 ValaStruct* _tmp2_;
2059 gboolean _tmp9_ = FALSE;
2060 ValaDelegateType* d = NULL;
2061 gboolean _tmp17_ = FALSE;
2062 ValaDelegateType* _tmp18_;
2063 gboolean result = FALSE;
2064 g_return_val_if_fail (self != NULL, FALSE);
2065 g_return_val_if_fail (property_type != NULL, FALSE);
2066 _tmp0_ = vala_data_type_get_type_symbol (property_type);
2067 _tmp1_ = _tmp0_;
2068 st = VALA_IS_STRUCT (_tmp1_) ? ((ValaStruct*) _tmp1_) : NULL;
2069 _tmp2_ = st;
2070 if (_tmp2_ != NULL) {
2071 gboolean _tmp3_ = FALSE;
2072 ValaStruct* _tmp4_;
2073 _tmp4_ = st;
2074 if (!vala_struct_is_simple_type (_tmp4_)) {
2075 ValaStruct* _tmp5_;
2076 _tmp5_ = st;
2077 _tmp3_ = vala_code_node_get_attribute_bool ((ValaCodeNode*) _tmp5_, "CCode", "has_type_id", TRUE);
2078 } else {
2079 _tmp3_ = FALSE;
2080 }
2081 if (_tmp3_) {
2082 } else {
2083 gboolean _tmp6_;
2084 gboolean _tmp7_;
2085 _tmp6_ = vala_data_type_get_nullable (property_type);
2086 _tmp7_ = _tmp6_;
2087 if (_tmp7_) {
2088 result = FALSE;
2089 return result;
2090 } else {
2091 ValaStruct* _tmp8_;
2092 _tmp8_ = st;
2093 if (!vala_code_node_get_attribute_bool ((ValaCodeNode*) _tmp8_, "CCode", "has_type_id", TRUE)) {
2094 result = FALSE;
2095 return result;
2096 }
2097 }
2098 }
2099 }
2100 if (VALA_IS_ARRAY_TYPE (property_type)) {
2101 ValaDataType* _tmp10_;
2102 ValaDataType* _tmp11_;
2103 ValaTypeSymbol* _tmp12_;
2104 ValaTypeSymbol* _tmp13_;
2105 ValaDataType* _tmp14_;
2106 ValaTypeSymbol* _tmp15_;
2107 ValaTypeSymbol* _tmp16_;
2108 _tmp10_ = vala_array_type_get_element_type (G_TYPE_CHECK_INSTANCE_CAST (property_type, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
2109 _tmp11_ = _tmp10_;
2110 _tmp12_ = vala_data_type_get_type_symbol (_tmp11_);
2111 _tmp13_ = _tmp12_;
2112 _tmp14_ = self->string_type;
2113 _tmp15_ = vala_data_type_get_type_symbol (_tmp14_);
2114 _tmp16_ = _tmp15_;
2115 _tmp9_ = _tmp13_ != _tmp16_;
2116 } else {
2117 _tmp9_ = FALSE;
2118 }
2119 if (_tmp9_) {
2120 result = FALSE;
2121 return result;
2122 }
2123 d = VALA_IS_DELEGATE_TYPE (property_type) ? ((ValaDelegateType*) property_type) : NULL;
2124 _tmp18_ = d;
2125 if (_tmp18_ != NULL) {
2126 ValaDelegateType* _tmp19_;
2127 ValaDelegate* _tmp20_;
2128 ValaDelegate* _tmp21_;
2129 gboolean _tmp22_;
2130 gboolean _tmp23_;
2131 _tmp19_ = d;
2132 _tmp20_ = vala_delegate_type_get_delegate_symbol (_tmp19_);
2133 _tmp21_ = _tmp20_;
2134 _tmp22_ = vala_delegate_get_has_target (_tmp21_);
2135 _tmp23_ = _tmp22_;
2136 _tmp17_ = _tmp23_;
2137 } else {
2138 _tmp17_ = FALSE;
2139 }
2140 if (_tmp17_) {
2141 result = FALSE;
2142 return result;
2143 }
2144 result = TRUE;
2145 return result;
2146 }
2147
2148 static glong
string_strnlen(gchar * str,glong maxlen)2149 string_strnlen (gchar* str,
2150 glong maxlen)
2151 {
2152 gchar* end = NULL;
2153 gchar* _tmp0_;
2154 gchar* _tmp1_;
2155 glong result = 0L;
2156 _tmp0_ = memchr (str, 0, (gsize) maxlen);
2157 end = _tmp0_;
2158 _tmp1_ = end;
2159 if (_tmp1_ == NULL) {
2160 result = maxlen;
2161 return result;
2162 } else {
2163 gchar* _tmp2_;
2164 _tmp2_ = end;
2165 result = (glong) (_tmp2_ - str);
2166 return result;
2167 }
2168 }
2169
2170 static gchar*
string_substring(const gchar * self,glong offset,glong len)2171 string_substring (const gchar* self,
2172 glong offset,
2173 glong len)
2174 {
2175 glong string_length = 0L;
2176 gboolean _tmp0_ = FALSE;
2177 gchar* _tmp3_;
2178 gchar* result = NULL;
2179 g_return_val_if_fail (self != NULL, NULL);
2180 if (offset >= ((glong) 0)) {
2181 _tmp0_ = len >= ((glong) 0);
2182 } else {
2183 _tmp0_ = FALSE;
2184 }
2185 if (_tmp0_) {
2186 string_length = string_strnlen ((gchar*) self, offset + len);
2187 } else {
2188 gint _tmp1_;
2189 gint _tmp2_;
2190 _tmp1_ = strlen (self);
2191 _tmp2_ = _tmp1_;
2192 string_length = (glong) _tmp2_;
2193 }
2194 if (offset < ((glong) 0)) {
2195 offset = string_length + offset;
2196 g_return_val_if_fail (offset >= ((glong) 0), NULL);
2197 } else {
2198 g_return_val_if_fail (offset <= string_length, NULL);
2199 }
2200 if (len < ((glong) 0)) {
2201 len = string_length - offset;
2202 }
2203 g_return_val_if_fail ((offset + len) <= string_length, NULL);
2204 _tmp3_ = g_strndup (((gchar*) self) + offset, (gsize) len);
2205 result = _tmp3_;
2206 return result;
2207 }
2208
2209 gboolean
vala_semantic_analyzer_check_arguments(ValaSemanticAnalyzer * self,ValaExpression * expr,ValaDataType * mtype,ValaList * params,ValaList * args)2210 vala_semantic_analyzer_check_arguments (ValaSemanticAnalyzer* self,
2211 ValaExpression* expr,
2212 ValaDataType* mtype,
2213 ValaList* params,
2214 ValaList* args)
2215 {
2216 gboolean _error_ = FALSE;
2217 ValaExpression* prev_arg = NULL;
2218 ValaIterator* arg_it = NULL;
2219 ValaIterator* _tmp0_;
2220 gboolean _tmp1_ = FALSE;
2221 gboolean diag = FALSE;
2222 gboolean ellipsis = FALSE;
2223 gint i = 0;
2224 gboolean _tmp74_ = FALSE;
2225 gboolean _tmp104_ = FALSE;
2226 gboolean result = FALSE;
2227 g_return_val_if_fail (self != NULL, FALSE);
2228 g_return_val_if_fail (expr != NULL, FALSE);
2229 g_return_val_if_fail (mtype != NULL, FALSE);
2230 g_return_val_if_fail (params != NULL, FALSE);
2231 g_return_val_if_fail (args != NULL, FALSE);
2232 _error_ = FALSE;
2233 prev_arg = NULL;
2234 _tmp0_ = vala_iterable_iterator ((ValaIterable*) args);
2235 arg_it = _tmp0_;
2236 if (VALA_IS_METHOD_TYPE (mtype)) {
2237 ValaMethod* _tmp2_;
2238 ValaMethod* _tmp3_;
2239 ValaAttribute* _tmp4_;
2240 _tmp2_ = vala_method_type_get_method_symbol (G_TYPE_CHECK_INSTANCE_CAST (mtype, VALA_TYPE_METHOD_TYPE, ValaMethodType));
2241 _tmp3_ = _tmp2_;
2242 _tmp4_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp3_, "Diagnostics");
2243 _tmp1_ = _tmp4_ != NULL;
2244 } else {
2245 _tmp1_ = FALSE;
2246 }
2247 diag = _tmp1_;
2248 ellipsis = FALSE;
2249 i = 0;
2250 {
2251 ValaList* _param_list = NULL;
2252 ValaList* _tmp5_;
2253 gint _param_size = 0;
2254 ValaList* _tmp6_;
2255 gint _tmp7_;
2256 gint _tmp8_;
2257 gint _param_index = 0;
2258 _tmp5_ = _vala_iterable_ref0 (params);
2259 _param_list = _tmp5_;
2260 _tmp6_ = _param_list;
2261 _tmp7_ = vala_collection_get_size ((ValaCollection*) _tmp6_);
2262 _tmp8_ = _tmp7_;
2263 _param_size = _tmp8_;
2264 _param_index = -1;
2265 while (TRUE) {
2266 gint _tmp9_;
2267 gint _tmp10_;
2268 ValaParameter* param = NULL;
2269 ValaList* _tmp11_;
2270 gpointer _tmp12_;
2271 ValaParameter* _tmp13_;
2272 gboolean _tmp14_;
2273 gboolean _tmp15_;
2274 ValaParameter* _tmp16_;
2275 gboolean _tmp17_;
2276 gboolean _tmp18_;
2277 gboolean _tmp27_ = FALSE;
2278 ValaIterator* _tmp28_;
2279 _param_index = _param_index + 1;
2280 _tmp9_ = _param_index;
2281 _tmp10_ = _param_size;
2282 if (!(_tmp9_ < _tmp10_)) {
2283 break;
2284 }
2285 _tmp11_ = _param_list;
2286 _tmp12_ = vala_list_get (_tmp11_, _param_index);
2287 param = (ValaParameter*) _tmp12_;
2288 _tmp13_ = param;
2289 _tmp14_ = vala_parameter_get_ellipsis (_tmp13_);
2290 _tmp15_ = _tmp14_;
2291 if (_tmp15_) {
2292 ellipsis = TRUE;
2293 _vala_code_node_unref0 (param);
2294 break;
2295 }
2296 _tmp16_ = param;
2297 _tmp17_ = vala_parameter_get_params_array (_tmp16_);
2298 _tmp18_ = _tmp17_;
2299 if (_tmp18_) {
2300 while (TRUE) {
2301 ValaIterator* _tmp19_;
2302 ValaExpression* arg = NULL;
2303 ValaIterator* _tmp20_;
2304 gpointer _tmp21_;
2305 ValaExpression* _tmp22_;
2306 ValaParameter* _tmp23_;
2307 ValaParameterDirection _tmp24_;
2308 ValaParameterDirection _tmp25_;
2309 gint _tmp26_;
2310 _tmp19_ = arg_it;
2311 if (!vala_iterator_next (_tmp19_)) {
2312 break;
2313 }
2314 _tmp20_ = arg_it;
2315 _tmp21_ = vala_iterator_get (_tmp20_);
2316 arg = (ValaExpression*) _tmp21_;
2317 _tmp22_ = arg;
2318 _tmp23_ = param;
2319 _tmp24_ = vala_parameter_get_direction (_tmp23_);
2320 _tmp25_ = _tmp24_;
2321 if (!vala_semantic_analyzer_check_argument (self, _tmp22_, i, _tmp25_)) {
2322 vala_code_node_set_error ((ValaCodeNode*) expr, TRUE);
2323 _error_ = TRUE;
2324 }
2325 _tmp26_ = i;
2326 i = _tmp26_ + 1;
2327 _vala_code_node_unref0 (arg);
2328 }
2329 _vala_code_node_unref0 (param);
2330 break;
2331 }
2332 _tmp28_ = arg_it;
2333 if (_tmp28_ == NULL) {
2334 _tmp27_ = TRUE;
2335 } else {
2336 ValaIterator* _tmp29_;
2337 _tmp29_ = arg_it;
2338 _tmp27_ = !vala_iterator_next (_tmp29_);
2339 }
2340 if (_tmp27_) {
2341 ValaParameter* _tmp30_;
2342 ValaExpression* _tmp31_;
2343 ValaExpression* _tmp32_;
2344 _tmp30_ = param;
2345 _tmp31_ = vala_variable_get_initializer ((ValaVariable*) _tmp30_);
2346 _tmp32_ = _tmp31_;
2347 if (_tmp32_ == NULL) {
2348 ValaMethodType* m = NULL;
2349 ValaMethodType* _tmp33_;
2350 vala_code_node_set_error ((ValaCodeNode*) expr, TRUE);
2351 m = VALA_IS_METHOD_TYPE (mtype) ? ((ValaMethodType*) mtype) : NULL;
2352 _tmp33_ = m;
2353 if (_tmp33_ != NULL) {
2354 ValaSourceReference* _tmp34_;
2355 ValaSourceReference* _tmp35_;
2356 ValaMethodType* _tmp36_;
2357 ValaList* _tmp37_;
2358 gint _tmp38_;
2359 gint _tmp39_;
2360 gint _tmp40_;
2361 gint _tmp41_;
2362 ValaMethodType* _tmp42_;
2363 gchar* _tmp43_;
2364 gchar* _tmp44_;
2365 gchar* _tmp45_;
2366 gchar* _tmp46_;
2367 _tmp34_ = vala_code_node_get_source_reference ((ValaCodeNode*) expr);
2368 _tmp35_ = _tmp34_;
2369 _tmp36_ = m;
2370 _tmp37_ = vala_data_type_get_parameters ((ValaDataType*) _tmp36_);
2371 _tmp38_ = vala_collection_get_size ((ValaCollection*) _tmp37_);
2372 _tmp39_ = _tmp38_;
2373 _tmp40_ = vala_collection_get_size ((ValaCollection*) args);
2374 _tmp41_ = _tmp40_;
2375 _tmp42_ = m;
2376 _tmp43_ = vala_data_type_to_prototype_string ((ValaDataType*) _tmp42_, NULL);
2377 _tmp44_ = _tmp43_;
2378 _tmp45_ = g_strdup_printf ("%d missing arguments for `%s'", _tmp39_ - _tmp41_, _tmp44_);
2379 _tmp46_ = _tmp45_;
2380 vala_report_error (_tmp35_, _tmp46_);
2381 _g_free0 (_tmp46_);
2382 _g_free0 (_tmp44_);
2383 } else {
2384 ValaSourceReference* _tmp47_;
2385 ValaSourceReference* _tmp48_;
2386 gchar* _tmp49_;
2387 gchar* _tmp50_;
2388 gint _tmp51_;
2389 gint _tmp52_;
2390 gchar* _tmp53_;
2391 gchar* _tmp54_;
2392 _tmp47_ = vala_code_node_get_source_reference ((ValaCodeNode*) expr);
2393 _tmp48_ = _tmp47_;
2394 _tmp49_ = vala_code_node_to_string ((ValaCodeNode*) mtype);
2395 _tmp50_ = _tmp49_;
2396 _tmp51_ = vala_collection_get_size ((ValaCollection*) args);
2397 _tmp52_ = _tmp51_;
2398 _tmp53_ = g_strdup_printf ("Too few arguments, method `%s' does not take %d arguments", _tmp50_, _tmp52_);
2399 _tmp54_ = _tmp53_;
2400 vala_report_error (_tmp48_, _tmp54_);
2401 _g_free0 (_tmp54_);
2402 _g_free0 (_tmp50_);
2403 }
2404 _error_ = TRUE;
2405 } else {
2406 ValaMethodCall* invocation_expr = NULL;
2407 ValaObjectCreationExpression* object_creation_expr = NULL;
2408 ValaMethodCall* _tmp55_;
2409 invocation_expr = VALA_IS_METHOD_CALL (expr) ? ((ValaMethodCall*) expr) : NULL;
2410 object_creation_expr = VALA_IS_OBJECT_CREATION_EXPRESSION (expr) ? ((ValaObjectCreationExpression*) expr) : NULL;
2411 _tmp55_ = invocation_expr;
2412 if (_tmp55_ != NULL) {
2413 ValaMethodCall* _tmp56_;
2414 ValaParameter* _tmp57_;
2415 ValaExpression* _tmp58_;
2416 ValaExpression* _tmp59_;
2417 _tmp56_ = invocation_expr;
2418 _tmp57_ = param;
2419 _tmp58_ = vala_variable_get_initializer ((ValaVariable*) _tmp57_);
2420 _tmp59_ = _tmp58_;
2421 vala_method_call_add_argument (_tmp56_, _tmp59_);
2422 } else {
2423 ValaObjectCreationExpression* _tmp60_;
2424 _tmp60_ = object_creation_expr;
2425 if (_tmp60_ != NULL) {
2426 ValaObjectCreationExpression* _tmp61_;
2427 ValaParameter* _tmp62_;
2428 ValaExpression* _tmp63_;
2429 ValaExpression* _tmp64_;
2430 _tmp61_ = object_creation_expr;
2431 _tmp62_ = param;
2432 _tmp63_ = vala_variable_get_initializer ((ValaVariable*) _tmp62_);
2433 _tmp64_ = _tmp63_;
2434 vala_object_creation_expression_add_argument (_tmp61_, _tmp64_);
2435 } else {
2436 g_assert_not_reached ();
2437 }
2438 }
2439 _vala_iterator_unref0 (arg_it);
2440 arg_it = NULL;
2441 }
2442 } else {
2443 ValaExpression* arg = NULL;
2444 ValaIterator* _tmp65_;
2445 gpointer _tmp66_;
2446 ValaExpression* _tmp67_;
2447 ValaParameter* _tmp68_;
2448 ValaParameterDirection _tmp69_;
2449 ValaParameterDirection _tmp70_;
2450 ValaExpression* _tmp71_;
2451 ValaExpression* _tmp72_;
2452 gint _tmp73_;
2453 _tmp65_ = arg_it;
2454 _tmp66_ = vala_iterator_get (_tmp65_);
2455 arg = (ValaExpression*) _tmp66_;
2456 _tmp67_ = arg;
2457 _tmp68_ = param;
2458 _tmp69_ = vala_parameter_get_direction (_tmp68_);
2459 _tmp70_ = _tmp69_;
2460 if (!vala_semantic_analyzer_check_argument (self, _tmp67_, i, _tmp70_)) {
2461 vala_code_node_set_error ((ValaCodeNode*) expr, TRUE);
2462 _error_ = TRUE;
2463 }
2464 _tmp71_ = arg;
2465 _tmp72_ = _vala_code_node_ref0 (_tmp71_);
2466 _vala_code_node_unref0 (prev_arg);
2467 prev_arg = _tmp72_;
2468 _tmp73_ = i;
2469 i = _tmp73_ + 1;
2470 _vala_code_node_unref0 (arg);
2471 }
2472 _vala_code_node_unref0 (param);
2473 }
2474 _vala_iterable_unref0 (_param_list);
2475 }
2476 if (ellipsis) {
2477 ValaIterator* _tmp75_;
2478 ValaSourceReference* _tmp76_;
2479 ValaSourceReference* _tmp77_;
2480 _tmp75_ = arg_it;
2481 _tmp76_ = vala_code_node_get_source_reference ((ValaCodeNode*) expr);
2482 _tmp77_ = _tmp76_;
2483 _tmp74_ = !vala_semantic_analyzer_check_variadic_arguments (self, _tmp75_, i, _tmp77_);
2484 } else {
2485 _tmp74_ = FALSE;
2486 }
2487 if (_tmp74_) {
2488 vala_code_node_set_error ((ValaCodeNode*) expr, TRUE);
2489 _error_ = TRUE;
2490 } else {
2491 gboolean _tmp78_ = FALSE;
2492 gboolean _tmp79_ = FALSE;
2493 if (!ellipsis) {
2494 ValaIterator* _tmp80_;
2495 _tmp80_ = arg_it;
2496 _tmp79_ = _tmp80_ != NULL;
2497 } else {
2498 _tmp79_ = FALSE;
2499 }
2500 if (_tmp79_) {
2501 ValaIterator* _tmp81_;
2502 _tmp81_ = arg_it;
2503 _tmp78_ = vala_iterator_next (_tmp81_);
2504 } else {
2505 _tmp78_ = FALSE;
2506 }
2507 if (_tmp78_) {
2508 ValaMethodType* m = NULL;
2509 ValaMethodType* _tmp82_;
2510 vala_code_node_set_error ((ValaCodeNode*) expr, TRUE);
2511 m = VALA_IS_METHOD_TYPE (mtype) ? ((ValaMethodType*) mtype) : NULL;
2512 _tmp82_ = m;
2513 if (_tmp82_ != NULL) {
2514 ValaSourceReference* _tmp83_;
2515 ValaSourceReference* _tmp84_;
2516 gint _tmp85_;
2517 gint _tmp86_;
2518 ValaMethodType* _tmp87_;
2519 ValaList* _tmp88_;
2520 gint _tmp89_;
2521 gint _tmp90_;
2522 ValaMethodType* _tmp91_;
2523 gchar* _tmp92_;
2524 gchar* _tmp93_;
2525 gchar* _tmp94_;
2526 gchar* _tmp95_;
2527 _tmp83_ = vala_code_node_get_source_reference ((ValaCodeNode*) expr);
2528 _tmp84_ = _tmp83_;
2529 _tmp85_ = vala_collection_get_size ((ValaCollection*) args);
2530 _tmp86_ = _tmp85_;
2531 _tmp87_ = m;
2532 _tmp88_ = vala_data_type_get_parameters ((ValaDataType*) _tmp87_);
2533 _tmp89_ = vala_collection_get_size ((ValaCollection*) _tmp88_);
2534 _tmp90_ = _tmp89_;
2535 _tmp91_ = m;
2536 _tmp92_ = vala_data_type_to_prototype_string ((ValaDataType*) _tmp91_, NULL);
2537 _tmp93_ = _tmp92_;
2538 _tmp94_ = g_strdup_printf ("%d extra arguments for `%s'", _tmp86_ - _tmp90_, _tmp93_);
2539 _tmp95_ = _tmp94_;
2540 vala_report_error (_tmp84_, _tmp95_);
2541 _g_free0 (_tmp95_);
2542 _g_free0 (_tmp93_);
2543 } else {
2544 ValaSourceReference* _tmp96_;
2545 ValaSourceReference* _tmp97_;
2546 gchar* _tmp98_;
2547 gchar* _tmp99_;
2548 gint _tmp100_;
2549 gint _tmp101_;
2550 gchar* _tmp102_;
2551 gchar* _tmp103_;
2552 _tmp96_ = vala_code_node_get_source_reference ((ValaCodeNode*) expr);
2553 _tmp97_ = _tmp96_;
2554 _tmp98_ = vala_code_node_to_string ((ValaCodeNode*) mtype);
2555 _tmp99_ = _tmp98_;
2556 _tmp100_ = vala_collection_get_size ((ValaCollection*) args);
2557 _tmp101_ = _tmp100_;
2558 _tmp102_ = g_strdup_printf ("Too many arguments, method `%s' does not take %d arguments", _tmp99_, _tmp101_);
2559 _tmp103_ = _tmp102_;
2560 vala_report_error (_tmp97_, _tmp103_);
2561 _g_free0 (_tmp103_);
2562 _g_free0 (_tmp99_);
2563 }
2564 _error_ = TRUE;
2565 }
2566 }
2567 if (diag) {
2568 ValaExpression* _tmp105_;
2569 _tmp105_ = prev_arg;
2570 _tmp104_ = _tmp105_ != NULL;
2571 } else {
2572 _tmp104_ = FALSE;
2573 }
2574 if (_tmp104_) {
2575 ValaStringLiteral* format_arg = NULL;
2576 ValaExpression* _tmp106_;
2577 ValaStringLiteral* _tmp107_;
2578 _tmp106_ = prev_arg;
2579 format_arg = VALA_IS_STRING_LITERAL (_tmp106_) ? ((ValaStringLiteral*) _tmp106_) : NULL;
2580 _tmp107_ = format_arg;
2581 if (_tmp107_ != NULL) {
2582 ValaStringLiteral* _tmp108_;
2583 ValaSourceReference* _tmp109_;
2584 ValaSourceReference* _tmp110_;
2585 ValaSourceFile* _tmp111_;
2586 ValaSourceFile* _tmp112_;
2587 const gchar* _tmp113_;
2588 const gchar* _tmp114_;
2589 gchar* _tmp115_;
2590 gchar* _tmp116_;
2591 ValaSourceReference* _tmp117_;
2592 ValaSourceReference* _tmp118_;
2593 ValaSourceLocation _tmp119_ = {0};
2594 ValaSourceLocation _tmp120_;
2595 ValaStringLiteral* _tmp121_;
2596 const gchar* _tmp122_;
2597 const gchar* _tmp123_;
2598 gchar* _tmp124_;
2599 gchar* _tmp125_;
2600 gchar* _tmp126_;
2601 gchar* _tmp127_;
2602 _tmp108_ = format_arg;
2603 _tmp109_ = vala_code_node_get_source_reference ((ValaCodeNode*) expr);
2604 _tmp110_ = _tmp109_;
2605 _tmp111_ = vala_source_reference_get_file (_tmp110_);
2606 _tmp112_ = _tmp111_;
2607 _tmp113_ = vala_source_file_get_filename (_tmp112_);
2608 _tmp114_ = _tmp113_;
2609 _tmp115_ = g_path_get_basename (_tmp114_);
2610 _tmp116_ = _tmp115_;
2611 _tmp117_ = vala_code_node_get_source_reference ((ValaCodeNode*) expr);
2612 _tmp118_ = _tmp117_;
2613 vala_source_reference_get_begin (_tmp118_, &_tmp119_);
2614 _tmp120_ = _tmp119_;
2615 _tmp121_ = format_arg;
2616 _tmp122_ = vala_string_literal_get_value (_tmp121_);
2617 _tmp123_ = _tmp122_;
2618 _tmp124_ = string_substring (_tmp123_, (glong) 1, (glong) -1);
2619 _tmp125_ = _tmp124_;
2620 _tmp126_ = g_strdup_printf ("\"%s:%d: %s", _tmp116_, _tmp120_.line, _tmp125_);
2621 _tmp127_ = _tmp126_;
2622 vala_string_literal_set_value (_tmp108_, _tmp127_);
2623 _g_free0 (_tmp127_);
2624 _g_free0 (_tmp125_);
2625 _g_free0 (_tmp116_);
2626 }
2627 }
2628 result = !_error_;
2629 _vala_iterator_unref0 (arg_it);
2630 _vala_code_node_unref0 (prev_arg);
2631 return result;
2632 }
2633
2634 static gboolean
vala_semantic_analyzer_check_argument(ValaSemanticAnalyzer * self,ValaExpression * arg,gint i,ValaParameterDirection direction)2635 vala_semantic_analyzer_check_argument (ValaSemanticAnalyzer* self,
2636 ValaExpression* arg,
2637 gint i,
2638 ValaParameterDirection direction)
2639 {
2640 gboolean _tmp0_;
2641 gboolean _tmp1_;
2642 ValaDataType* _tmp83_;
2643 ValaDataType* _tmp84_;
2644 ValaMemberAccess* ma = NULL;
2645 gboolean _tmp122_ = FALSE;
2646 ValaMemberAccess* _tmp123_;
2647 gboolean result = FALSE;
2648 g_return_val_if_fail (self != NULL, FALSE);
2649 g_return_val_if_fail (arg != NULL, FALSE);
2650 _tmp0_ = vala_code_node_get_error ((ValaCodeNode*) arg);
2651 _tmp1_ = _tmp0_;
2652 if (_tmp1_) {
2653 result = FALSE;
2654 return result;
2655 } else {
2656 if (VALA_IS_NAMED_ARGUMENT (arg)) {
2657 ValaSourceReference* _tmp2_;
2658 ValaSourceReference* _tmp3_;
2659 _tmp2_ = vala_code_node_get_source_reference ((ValaCodeNode*) arg);
2660 _tmp3_ = _tmp2_;
2661 vala_report_error (_tmp3_, "Named arguments are not supported yet");
2662 result = FALSE;
2663 return result;
2664 } else {
2665 ValaDataType* _tmp4_;
2666 ValaDataType* _tmp5_;
2667 _tmp4_ = vala_expression_get_value_type (arg);
2668 _tmp5_ = _tmp4_;
2669 if (_tmp5_ == NULL) {
2670 gboolean _tmp6_ = FALSE;
2671 ValaDataType* _tmp7_;
2672 ValaDataType* _tmp8_;
2673 _tmp7_ = vala_expression_get_target_type (arg);
2674 _tmp8_ = _tmp7_;
2675 if (!VALA_IS_DELEGATE_TYPE (_tmp8_)) {
2676 _tmp6_ = TRUE;
2677 } else {
2678 ValaSymbol* _tmp9_;
2679 ValaSymbol* _tmp10_;
2680 _tmp9_ = vala_expression_get_symbol_reference (arg);
2681 _tmp10_ = _tmp9_;
2682 _tmp6_ = !VALA_IS_METHOD (_tmp10_);
2683 }
2684 if (_tmp6_) {
2685 ValaSourceReference* _tmp11_;
2686 ValaSourceReference* _tmp12_;
2687 gchar* _tmp13_;
2688 gchar* _tmp14_;
2689 _tmp11_ = vala_code_node_get_source_reference ((ValaCodeNode*) arg);
2690 _tmp12_ = _tmp11_;
2691 _tmp13_ = g_strdup_printf ("Invalid type for argument %d", i + 1);
2692 _tmp14_ = _tmp13_;
2693 vala_report_error (_tmp12_, _tmp14_);
2694 _g_free0 (_tmp14_);
2695 result = FALSE;
2696 return result;
2697 }
2698 } else {
2699 gint arg_type = 0;
2700 ValaDataType* _tmp15_;
2701 ValaDataType* _tmp16_;
2702 arg_type = 1;
2703 _tmp15_ = vala_expression_get_value_type (arg);
2704 _tmp16_ = _tmp15_;
2705 if (VALA_IS_NULL_TYPE (_tmp16_)) {
2706 arg_type = 0;
2707 } else {
2708 if (VALA_IS_UNARY_EXPRESSION (arg)) {
2709 ValaUnaryExpression* unary = NULL;
2710 ValaUnaryExpression* _tmp17_;
2711 ValaUnaryExpression* _tmp18_;
2712 ValaUnaryOperator _tmp19_;
2713 ValaUnaryOperator _tmp20_;
2714 _tmp17_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (arg, VALA_TYPE_UNARY_EXPRESSION, ValaUnaryExpression));
2715 unary = _tmp17_;
2716 _tmp18_ = unary;
2717 _tmp19_ = vala_unary_expression_get_operator (_tmp18_);
2718 _tmp20_ = _tmp19_;
2719 if (_tmp20_ == VALA_UNARY_OPERATOR_REF) {
2720 arg_type = 2;
2721 } else {
2722 ValaUnaryExpression* _tmp21_;
2723 ValaUnaryOperator _tmp22_;
2724 ValaUnaryOperator _tmp23_;
2725 _tmp21_ = unary;
2726 _tmp22_ = vala_unary_expression_get_operator (_tmp21_);
2727 _tmp23_ = _tmp22_;
2728 if (_tmp23_ == VALA_UNARY_OPERATOR_OUT) {
2729 arg_type = 3;
2730 }
2731 }
2732 _vala_code_node_unref0 (unary);
2733 }
2734 }
2735 if (arg_type == 0) {
2736 if (direction == VALA_PARAMETER_DIRECTION_REF) {
2737 ValaSourceReference* _tmp24_;
2738 ValaSourceReference* _tmp25_;
2739 gchar* _tmp26_;
2740 gchar* _tmp27_;
2741 _tmp24_ = vala_code_node_get_source_reference ((ValaCodeNode*) arg);
2742 _tmp25_ = _tmp24_;
2743 _tmp26_ = g_strdup_printf ("Argument %d: Cannot pass null to reference parameter", i + 1);
2744 _tmp27_ = _tmp26_;
2745 vala_report_error (_tmp25_, _tmp27_);
2746 _g_free0 (_tmp27_);
2747 result = FALSE;
2748 return result;
2749 } else {
2750 gboolean _tmp28_ = FALSE;
2751 if (direction != VALA_PARAMETER_DIRECTION_OUT) {
2752 ValaDataType* _tmp29_;
2753 ValaDataType* _tmp30_;
2754 gboolean _tmp31_;
2755 gboolean _tmp32_;
2756 _tmp29_ = vala_expression_get_target_type (arg);
2757 _tmp30_ = _tmp29_;
2758 _tmp31_ = vala_data_type_get_nullable (_tmp30_);
2759 _tmp32_ = _tmp31_;
2760 _tmp28_ = !_tmp32_;
2761 } else {
2762 _tmp28_ = FALSE;
2763 }
2764 if (_tmp28_) {
2765 ValaSourceReference* _tmp33_;
2766 ValaSourceReference* _tmp34_;
2767 gchar* _tmp35_;
2768 gchar* _tmp36_;
2769 _tmp33_ = vala_code_node_get_source_reference ((ValaCodeNode*) arg);
2770 _tmp34_ = _tmp33_;
2771 _tmp35_ = g_strdup_printf ("Argument %d: Cannot pass null to non-null parameter type", i + 1);
2772 _tmp36_ = _tmp35_;
2773 vala_report_warning (_tmp34_, _tmp36_);
2774 _g_free0 (_tmp36_);
2775 }
2776 }
2777 } else {
2778 if (arg_type == 1) {
2779 if (direction != VALA_PARAMETER_DIRECTION_IN) {
2780 ValaSourceReference* _tmp37_;
2781 ValaSourceReference* _tmp38_;
2782 gchar* _tmp39_;
2783 gchar* _tmp40_;
2784 _tmp37_ = vala_code_node_get_source_reference ((ValaCodeNode*) arg);
2785 _tmp38_ = _tmp37_;
2786 _tmp39_ = g_strdup_printf ("Argument %d: Cannot pass value to reference or output parameter", i + 1);
2787 _tmp40_ = _tmp39_;
2788 vala_report_error (_tmp38_, _tmp40_);
2789 _g_free0 (_tmp40_);
2790 result = FALSE;
2791 return result;
2792 }
2793 } else {
2794 if (arg_type == 2) {
2795 ValaDataType* _tmp45_;
2796 ValaDataType* _tmp46_;
2797 ValaDataType* _tmp58_;
2798 ValaDataType* _tmp59_;
2799 if (direction != VALA_PARAMETER_DIRECTION_REF) {
2800 ValaSourceReference* _tmp41_;
2801 ValaSourceReference* _tmp42_;
2802 gchar* _tmp43_;
2803 gchar* _tmp44_;
2804 _tmp41_ = vala_code_node_get_source_reference ((ValaCodeNode*) arg);
2805 _tmp42_ = _tmp41_;
2806 _tmp43_ = g_strdup_printf ("Argument %d: Cannot pass ref argument to non-reference parameter", i + 1);
2807 _tmp44_ = _tmp43_;
2808 vala_report_error (_tmp42_, _tmp44_);
2809 _g_free0 (_tmp44_);
2810 result = FALSE;
2811 return result;
2812 }
2813 _tmp45_ = vala_expression_get_target_type (arg);
2814 _tmp46_ = _tmp45_;
2815 if (vala_data_type_is_disposable (_tmp46_)) {
2816 gboolean _tmp47_ = FALSE;
2817 ValaDataType* _tmp48_;
2818 ValaDataType* _tmp49_;
2819 _tmp48_ = vala_expression_get_value_type (arg);
2820 _tmp49_ = _tmp48_;
2821 if (!VALA_IS_POINTER_TYPE (_tmp49_)) {
2822 ValaDataType* _tmp50_;
2823 ValaDataType* _tmp51_;
2824 gboolean _tmp52_;
2825 gboolean _tmp53_;
2826 _tmp50_ = vala_expression_get_value_type (arg);
2827 _tmp51_ = _tmp50_;
2828 _tmp52_ = vala_data_type_get_value_owned (_tmp51_);
2829 _tmp53_ = _tmp52_;
2830 _tmp47_ = !_tmp53_;
2831 } else {
2832 _tmp47_ = FALSE;
2833 }
2834 if (_tmp47_) {
2835 ValaSourceReference* _tmp54_;
2836 ValaSourceReference* _tmp55_;
2837 gchar* _tmp56_;
2838 gchar* _tmp57_;
2839 _tmp54_ = vala_code_node_get_source_reference ((ValaCodeNode*) arg);
2840 _tmp55_ = _tmp54_;
2841 _tmp56_ = g_strdup_printf ("Argument %d: Cannot pass unowned ref argument to owned reference param" \
2842 "eter", i + 1);
2843 _tmp57_ = _tmp56_;
2844 vala_report_error (_tmp55_, _tmp57_);
2845 _g_free0 (_tmp57_);
2846 result = FALSE;
2847 return result;
2848 }
2849 }
2850 _tmp58_ = vala_expression_get_value_type (arg);
2851 _tmp59_ = _tmp58_;
2852 if (vala_data_type_is_disposable (_tmp59_)) {
2853 ValaDataType* _tmp60_;
2854 ValaDataType* _tmp61_;
2855 gboolean _tmp62_;
2856 gboolean _tmp63_;
2857 _tmp60_ = vala_expression_get_target_type (arg);
2858 _tmp61_ = _tmp60_;
2859 _tmp62_ = vala_data_type_get_value_owned (_tmp61_);
2860 _tmp63_ = _tmp62_;
2861 if (!_tmp63_) {
2862 ValaSourceReference* _tmp64_;
2863 ValaSourceReference* _tmp65_;
2864 gchar* _tmp66_;
2865 gchar* _tmp67_;
2866 _tmp64_ = vala_code_node_get_source_reference ((ValaCodeNode*) arg);
2867 _tmp65_ = _tmp64_;
2868 _tmp66_ = g_strdup_printf ("Argument %d: Cannot pass owned ref argument to unowned reference param" \
2869 "eter", i + 1);
2870 _tmp67_ = _tmp66_;
2871 vala_report_error (_tmp65_, _tmp67_);
2872 _g_free0 (_tmp67_);
2873 result = FALSE;
2874 return result;
2875 }
2876 }
2877 } else {
2878 if (arg_type == 3) {
2879 ValaDataType* _tmp72_;
2880 ValaDataType* _tmp73_;
2881 if (direction != VALA_PARAMETER_DIRECTION_OUT) {
2882 ValaSourceReference* _tmp68_;
2883 ValaSourceReference* _tmp69_;
2884 gchar* _tmp70_;
2885 gchar* _tmp71_;
2886 _tmp68_ = vala_code_node_get_source_reference ((ValaCodeNode*) arg);
2887 _tmp69_ = _tmp68_;
2888 _tmp70_ = g_strdup_printf ("Argument %d: Cannot pass out argument to non-output parameter", i + 1);
2889 _tmp71_ = _tmp70_;
2890 vala_report_error (_tmp69_, _tmp71_);
2891 _g_free0 (_tmp71_);
2892 result = FALSE;
2893 return result;
2894 }
2895 _tmp72_ = vala_expression_get_target_type (arg);
2896 _tmp73_ = _tmp72_;
2897 if (vala_data_type_is_disposable (_tmp73_)) {
2898 gboolean _tmp74_ = FALSE;
2899 ValaDataType* _tmp75_;
2900 ValaDataType* _tmp76_;
2901 _tmp75_ = vala_expression_get_value_type (arg);
2902 _tmp76_ = _tmp75_;
2903 if (!VALA_IS_POINTER_TYPE (_tmp76_)) {
2904 ValaDataType* _tmp77_;
2905 ValaDataType* _tmp78_;
2906 gboolean _tmp79_;
2907 gboolean _tmp80_;
2908 _tmp77_ = vala_expression_get_value_type (arg);
2909 _tmp78_ = _tmp77_;
2910 _tmp79_ = vala_data_type_get_value_owned (_tmp78_);
2911 _tmp80_ = _tmp79_;
2912 _tmp74_ = !_tmp80_;
2913 } else {
2914 _tmp74_ = FALSE;
2915 }
2916 if (_tmp74_) {
2917 ValaSourceReference* _tmp81_;
2918 ValaSourceReference* _tmp82_;
2919 _tmp81_ = vala_code_node_get_source_reference ((ValaCodeNode*) arg);
2920 _tmp82_ = _tmp81_;
2921 vala_report_error (_tmp82_, "Invalid assignment from owned expression to unowned variable");
2922 result = FALSE;
2923 return result;
2924 }
2925 }
2926 }
2927 }
2928 }
2929 }
2930 }
2931 }
2932 }
2933 _tmp83_ = vala_expression_get_target_type (arg);
2934 _tmp84_ = _tmp83_;
2935 if (_tmp84_ != NULL) {
2936 gboolean _tmp85_ = FALSE;
2937 gboolean _tmp86_ = FALSE;
2938 if (direction == VALA_PARAMETER_DIRECTION_IN) {
2939 _tmp86_ = TRUE;
2940 } else {
2941 _tmp86_ = direction == VALA_PARAMETER_DIRECTION_REF;
2942 }
2943 if (_tmp86_) {
2944 ValaDataType* _tmp87_;
2945 ValaDataType* _tmp88_;
2946 ValaDataType* _tmp89_;
2947 ValaDataType* _tmp90_;
2948 _tmp87_ = vala_expression_get_value_type (arg);
2949 _tmp88_ = _tmp87_;
2950 _tmp89_ = vala_expression_get_target_type (arg);
2951 _tmp90_ = _tmp89_;
2952 _tmp85_ = !vala_data_type_compatible (_tmp88_, _tmp90_);
2953 } else {
2954 _tmp85_ = FALSE;
2955 }
2956 if (_tmp85_) {
2957 ValaSourceReference* _tmp91_;
2958 ValaSourceReference* _tmp92_;
2959 ValaDataType* _tmp93_;
2960 ValaDataType* _tmp94_;
2961 gchar* _tmp95_;
2962 gchar* _tmp96_;
2963 ValaDataType* _tmp97_;
2964 ValaDataType* _tmp98_;
2965 gchar* _tmp99_;
2966 gchar* _tmp100_;
2967 gchar* _tmp101_;
2968 gchar* _tmp102_;
2969 _tmp91_ = vala_code_node_get_source_reference ((ValaCodeNode*) arg);
2970 _tmp92_ = _tmp91_;
2971 _tmp93_ = vala_expression_get_value_type (arg);
2972 _tmp94_ = _tmp93_;
2973 _tmp95_ = vala_data_type_to_prototype_string (_tmp94_, NULL);
2974 _tmp96_ = _tmp95_;
2975 _tmp97_ = vala_expression_get_target_type (arg);
2976 _tmp98_ = _tmp97_;
2977 _tmp99_ = vala_data_type_to_prototype_string (_tmp98_, NULL);
2978 _tmp100_ = _tmp99_;
2979 _tmp101_ = g_strdup_printf ("Argument %d: Cannot convert from `%s' to `%s'", i + 1, _tmp96_, _tmp100_);
2980 _tmp102_ = _tmp101_;
2981 vala_report_error (_tmp92_, _tmp102_);
2982 _g_free0 (_tmp102_);
2983 _g_free0 (_tmp100_);
2984 _g_free0 (_tmp96_);
2985 result = FALSE;
2986 return result;
2987 } else {
2988 gboolean _tmp103_ = FALSE;
2989 gboolean _tmp104_ = FALSE;
2990 gboolean _tmp105_ = FALSE;
2991 if (direction == VALA_PARAMETER_DIRECTION_REF) {
2992 _tmp105_ = TRUE;
2993 } else {
2994 _tmp105_ = direction == VALA_PARAMETER_DIRECTION_OUT;
2995 }
2996 if (_tmp105_) {
2997 ValaDataType* _tmp106_;
2998 ValaDataType* _tmp107_;
2999 ValaDataType* _tmp108_;
3000 ValaDataType* _tmp109_;
3001 _tmp106_ = vala_expression_get_target_type (arg);
3002 _tmp107_ = _tmp106_;
3003 _tmp108_ = vala_expression_get_value_type (arg);
3004 _tmp109_ = _tmp108_;
3005 _tmp104_ = !vala_data_type_compatible (_tmp107_, _tmp109_);
3006 } else {
3007 _tmp104_ = FALSE;
3008 }
3009 if (_tmp104_) {
3010 _tmp103_ = !VALA_IS_NULL_LITERAL (arg);
3011 } else {
3012 _tmp103_ = FALSE;
3013 }
3014 if (_tmp103_) {
3015 ValaSourceReference* _tmp110_;
3016 ValaSourceReference* _tmp111_;
3017 ValaDataType* _tmp112_;
3018 ValaDataType* _tmp113_;
3019 gchar* _tmp114_;
3020 gchar* _tmp115_;
3021 ValaDataType* _tmp116_;
3022 ValaDataType* _tmp117_;
3023 gchar* _tmp118_;
3024 gchar* _tmp119_;
3025 gchar* _tmp120_;
3026 gchar* _tmp121_;
3027 _tmp110_ = vala_code_node_get_source_reference ((ValaCodeNode*) arg);
3028 _tmp111_ = _tmp110_;
3029 _tmp112_ = vala_expression_get_target_type (arg);
3030 _tmp113_ = _tmp112_;
3031 _tmp114_ = vala_data_type_to_prototype_string (_tmp113_, NULL);
3032 _tmp115_ = _tmp114_;
3033 _tmp116_ = vala_expression_get_value_type (arg);
3034 _tmp117_ = _tmp116_;
3035 _tmp118_ = vala_data_type_to_prototype_string (_tmp117_, NULL);
3036 _tmp119_ = _tmp118_;
3037 _tmp120_ = g_strdup_printf ("Argument %d: Cannot convert from `%s' to `%s'", i + 1, _tmp115_, _tmp119_);
3038 _tmp121_ = _tmp120_;
3039 vala_report_error (_tmp111_, _tmp121_);
3040 _g_free0 (_tmp121_);
3041 _g_free0 (_tmp119_);
3042 _g_free0 (_tmp115_);
3043 result = FALSE;
3044 return result;
3045 }
3046 }
3047 }
3048 ma = VALA_IS_MEMBER_ACCESS (arg) ? ((ValaMemberAccess*) arg) : NULL;
3049 _tmp123_ = ma;
3050 if (_tmp123_ != NULL) {
3051 ValaMemberAccess* _tmp124_;
3052 gboolean _tmp125_;
3053 gboolean _tmp126_;
3054 _tmp124_ = ma;
3055 _tmp125_ = vala_member_access_get_prototype_access (_tmp124_);
3056 _tmp126_ = _tmp125_;
3057 _tmp122_ = _tmp126_;
3058 } else {
3059 _tmp122_ = FALSE;
3060 }
3061 if (_tmp122_) {
3062 ValaDelegateType* deleg_type = NULL;
3063 ValaDataType* _tmp127_;
3064 ValaDataType* _tmp128_;
3065 gboolean _tmp129_ = FALSE;
3066 ValaDelegateType* _tmp130_;
3067 _tmp127_ = vala_expression_get_target_type (arg);
3068 _tmp128_ = _tmp127_;
3069 deleg_type = VALA_IS_DELEGATE_TYPE (_tmp128_) ? ((ValaDelegateType*) _tmp128_) : NULL;
3070 _tmp130_ = deleg_type;
3071 if (_tmp130_ == NULL) {
3072 _tmp129_ = TRUE;
3073 } else {
3074 ValaDelegateType* _tmp131_;
3075 ValaDelegate* _tmp132_;
3076 ValaDelegate* _tmp133_;
3077 gboolean _tmp134_;
3078 gboolean _tmp135_;
3079 _tmp131_ = deleg_type;
3080 _tmp132_ = vala_delegate_type_get_delegate_symbol (_tmp131_);
3081 _tmp133_ = _tmp132_;
3082 _tmp134_ = vala_delegate_get_has_target (_tmp133_);
3083 _tmp135_ = _tmp134_;
3084 _tmp129_ = _tmp135_;
3085 }
3086 if (_tmp129_) {
3087 ValaSourceReference* _tmp136_;
3088 ValaSourceReference* _tmp137_;
3089 ValaSymbol* _tmp138_;
3090 ValaSymbol* _tmp139_;
3091 gchar* _tmp140_;
3092 gchar* _tmp141_;
3093 gchar* _tmp142_;
3094 gchar* _tmp143_;
3095 _tmp136_ = vala_code_node_get_source_reference ((ValaCodeNode*) arg);
3096 _tmp137_ = _tmp136_;
3097 _tmp138_ = vala_expression_get_symbol_reference (arg);
3098 _tmp139_ = _tmp138_;
3099 _tmp140_ = vala_symbol_get_full_name (_tmp139_);
3100 _tmp141_ = _tmp140_;
3101 _tmp142_ = g_strdup_printf ("Access to instance member `%s' denied", _tmp141_);
3102 _tmp143_ = _tmp142_;
3103 vala_report_error (_tmp137_, _tmp143_);
3104 _g_free0 (_tmp143_);
3105 _g_free0 (_tmp141_);
3106 result = FALSE;
3107 return result;
3108 }
3109 }
3110 result = TRUE;
3111 return result;
3112 }
3113
3114 gboolean
vala_semantic_analyzer_check_variadic_arguments(ValaSemanticAnalyzer * self,ValaIterator * arg_it,gint i,ValaSourceReference * source_reference)3115 vala_semantic_analyzer_check_variadic_arguments (ValaSemanticAnalyzer* self,
3116 ValaIterator* arg_it,
3117 gint i,
3118 ValaSourceReference* source_reference)
3119 {
3120 gboolean result = FALSE;
3121 g_return_val_if_fail (self != NULL, FALSE);
3122 while (TRUE) {
3123 gboolean _tmp0_ = FALSE;
3124 ValaExpression* arg = NULL;
3125 gpointer _tmp1_;
3126 ValaExpression* _tmp2_;
3127 gboolean _tmp3_;
3128 gboolean _tmp4_;
3129 gint _tmp45_;
3130 if (arg_it != NULL) {
3131 _tmp0_ = vala_iterator_next (arg_it);
3132 } else {
3133 _tmp0_ = FALSE;
3134 }
3135 if (!_tmp0_) {
3136 break;
3137 }
3138 _tmp1_ = vala_iterator_get (arg_it);
3139 arg = (ValaExpression*) _tmp1_;
3140 _tmp2_ = arg;
3141 _tmp3_ = vala_code_node_get_error ((ValaCodeNode*) _tmp2_);
3142 _tmp4_ = _tmp3_;
3143 if (_tmp4_) {
3144 result = FALSE;
3145 _vala_code_node_unref0 (arg);
3146 return result;
3147 } else {
3148 ValaExpression* _tmp5_;
3149 ValaDataType* _tmp6_;
3150 ValaDataType* _tmp7_;
3151 _tmp5_ = arg;
3152 _tmp6_ = vala_expression_get_value_type (_tmp5_);
3153 _tmp7_ = _tmp6_;
3154 if (VALA_IS_SIGNAL_TYPE (_tmp7_)) {
3155 ValaExpression* _tmp8_;
3156 ValaExpression* _tmp9_;
3157 ValaSourceReference* _tmp10_;
3158 ValaSourceReference* _tmp11_;
3159 _tmp8_ = arg;
3160 vala_code_node_set_error ((ValaCodeNode*) _tmp8_, TRUE);
3161 _tmp9_ = arg;
3162 _tmp10_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp9_);
3163 _tmp11_ = _tmp10_;
3164 vala_report_error (_tmp11_, "Cannot pass signals as arguments");
3165 result = FALSE;
3166 _vala_code_node_unref0 (arg);
3167 return result;
3168 } else {
3169 ValaExpression* _tmp12_;
3170 ValaDataType* _tmp13_;
3171 ValaDataType* _tmp14_;
3172 _tmp12_ = arg;
3173 _tmp13_ = vala_expression_get_value_type (_tmp12_);
3174 _tmp14_ = _tmp13_;
3175 if (_tmp14_ == NULL) {
3176 ValaExpression* _tmp15_;
3177 ValaSymbol* _tmp16_;
3178 ValaSymbol* _tmp17_;
3179 _tmp15_ = arg;
3180 _tmp16_ = vala_expression_get_symbol_reference (_tmp15_);
3181 _tmp17_ = _tmp16_;
3182 if (!VALA_IS_METHOD (_tmp17_)) {
3183 gchar* _tmp18_;
3184 gchar* _tmp19_;
3185 _tmp18_ = g_strdup_printf ("Invalid type for argument %d", i + 1);
3186 _tmp19_ = _tmp18_;
3187 vala_report_error (source_reference, _tmp19_);
3188 _g_free0 (_tmp19_);
3189 result = FALSE;
3190 _vala_code_node_unref0 (arg);
3191 return result;
3192 }
3193 } else {
3194 gboolean _tmp20_ = FALSE;
3195 ValaExpression* _tmp21_;
3196 ValaDataType* _tmp22_;
3197 ValaDataType* _tmp23_;
3198 _tmp21_ = arg;
3199 _tmp22_ = vala_expression_get_target_type (_tmp21_);
3200 _tmp23_ = _tmp22_;
3201 if (_tmp23_ != NULL) {
3202 ValaExpression* _tmp24_;
3203 ValaDataType* _tmp25_;
3204 ValaDataType* _tmp26_;
3205 ValaExpression* _tmp27_;
3206 ValaDataType* _tmp28_;
3207 ValaDataType* _tmp29_;
3208 _tmp24_ = arg;
3209 _tmp25_ = vala_expression_get_value_type (_tmp24_);
3210 _tmp26_ = _tmp25_;
3211 _tmp27_ = arg;
3212 _tmp28_ = vala_expression_get_target_type (_tmp27_);
3213 _tmp29_ = _tmp28_;
3214 _tmp20_ = !vala_data_type_compatible (_tmp26_, _tmp29_);
3215 } else {
3216 _tmp20_ = FALSE;
3217 }
3218 if (_tmp20_) {
3219 ValaExpression* _tmp30_;
3220 ValaSourceReference* _tmp31_;
3221 ValaSourceReference* _tmp32_;
3222 ValaExpression* _tmp33_;
3223 ValaDataType* _tmp34_;
3224 ValaDataType* _tmp35_;
3225 gchar* _tmp36_;
3226 gchar* _tmp37_;
3227 ValaExpression* _tmp38_;
3228 ValaDataType* _tmp39_;
3229 ValaDataType* _tmp40_;
3230 gchar* _tmp41_;
3231 gchar* _tmp42_;
3232 gchar* _tmp43_;
3233 gchar* _tmp44_;
3234 _tmp30_ = arg;
3235 _tmp31_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp30_);
3236 _tmp32_ = _tmp31_;
3237 _tmp33_ = arg;
3238 _tmp34_ = vala_expression_get_value_type (_tmp33_);
3239 _tmp35_ = _tmp34_;
3240 _tmp36_ = vala_code_node_to_string ((ValaCodeNode*) _tmp35_);
3241 _tmp37_ = _tmp36_;
3242 _tmp38_ = arg;
3243 _tmp39_ = vala_expression_get_target_type (_tmp38_);
3244 _tmp40_ = _tmp39_;
3245 _tmp41_ = vala_code_node_to_string ((ValaCodeNode*) _tmp40_);
3246 _tmp42_ = _tmp41_;
3247 _tmp43_ = g_strdup_printf ("Argument %d: Cannot convert from `%s' to `%s'", i + 1, _tmp37_, _tmp42_);
3248 _tmp44_ = _tmp43_;
3249 vala_report_error (_tmp32_, _tmp44_);
3250 _g_free0 (_tmp44_);
3251 _g_free0 (_tmp42_);
3252 _g_free0 (_tmp37_);
3253 result = FALSE;
3254 _vala_code_node_unref0 (arg);
3255 return result;
3256 }
3257 }
3258 }
3259 }
3260 _tmp45_ = i;
3261 i = _tmp45_ + 1;
3262 _vala_code_node_unref0 (arg);
3263 }
3264 result = TRUE;
3265 return result;
3266 }
3267
3268 static gunichar
string_get_char(const gchar * self,glong index)3269 string_get_char (const gchar* self,
3270 glong index)
3271 {
3272 gunichar result = 0U;
3273 g_return_val_if_fail (self != NULL, 0U);
3274 result = g_utf8_get_char (((gchar*) self) + index);
3275 return result;
3276 }
3277
3278 gboolean
vala_semantic_analyzer_check_print_format(ValaSemanticAnalyzer * self,const gchar * format,ValaIterator * arg_it,ValaSourceReference * source_reference)3279 vala_semantic_analyzer_check_print_format (ValaSemanticAnalyzer* self,
3280 const gchar* format,
3281 ValaIterator* arg_it,
3282 ValaSourceReference* source_reference)
3283 {
3284 gboolean unsupported_format = FALSE;
3285 const gchar* format_it = NULL;
3286 gunichar c = 0U;
3287 const gchar* _tmp0_;
3288 gboolean _tmp83_ = FALSE;
3289 gboolean result = FALSE;
3290 g_return_val_if_fail (self != NULL, FALSE);
3291 g_return_val_if_fail (format != NULL, FALSE);
3292 g_return_val_if_fail (arg_it != NULL, FALSE);
3293 unsupported_format = FALSE;
3294 format_it = format;
3295 _tmp0_ = format_it;
3296 c = string_get_char (_tmp0_, (glong) 0);
3297 while (TRUE) {
3298 const gchar* _tmp4_;
3299 const gchar* _tmp5_;
3300 const gchar* _tmp6_;
3301 gint length = 0;
3302 ValaDataType* param_type = NULL;
3303 gboolean _tmp37_ = FALSE;
3304 gboolean _tmp38_ = FALSE;
3305 ValaDataType* _tmp79_;
3306 if (!(c != ((gunichar) '\0'))) {
3307 break;
3308 }
3309 if (c != ((gunichar) '%')) {
3310 const gchar* _tmp1_;
3311 const gchar* _tmp2_;
3312 const gchar* _tmp3_;
3313 _tmp1_ = format_it;
3314 _tmp2_ = g_utf8_next_char (_tmp1_);
3315 format_it = _tmp2_;
3316 _tmp3_ = format_it;
3317 c = string_get_char (_tmp3_, (glong) 0);
3318 continue;
3319 }
3320 _tmp4_ = format_it;
3321 _tmp5_ = g_utf8_next_char (_tmp4_);
3322 format_it = _tmp5_;
3323 _tmp6_ = format_it;
3324 c = string_get_char (_tmp6_, (glong) 0);
3325 while (TRUE) {
3326 gboolean _tmp7_ = FALSE;
3327 gboolean _tmp8_ = FALSE;
3328 gboolean _tmp9_ = FALSE;
3329 gboolean _tmp10_ = FALSE;
3330 const gchar* _tmp11_;
3331 const gchar* _tmp12_;
3332 const gchar* _tmp13_;
3333 if (c == ((gunichar) '#')) {
3334 _tmp10_ = TRUE;
3335 } else {
3336 _tmp10_ = c == ((gunichar) '0');
3337 }
3338 if (_tmp10_) {
3339 _tmp9_ = TRUE;
3340 } else {
3341 _tmp9_ = c == ((gunichar) '-');
3342 }
3343 if (_tmp9_) {
3344 _tmp8_ = TRUE;
3345 } else {
3346 _tmp8_ = c == ((gunichar) ' ');
3347 }
3348 if (_tmp8_) {
3349 _tmp7_ = TRUE;
3350 } else {
3351 _tmp7_ = c == ((gunichar) '+');
3352 }
3353 if (!_tmp7_) {
3354 break;
3355 }
3356 _tmp11_ = format_it;
3357 _tmp12_ = g_utf8_next_char (_tmp11_);
3358 format_it = _tmp12_;
3359 _tmp13_ = format_it;
3360 c = string_get_char (_tmp13_, (glong) 0);
3361 }
3362 while (TRUE) {
3363 gboolean _tmp14_ = FALSE;
3364 const gchar* _tmp15_;
3365 const gchar* _tmp16_;
3366 const gchar* _tmp17_;
3367 if (c >= ((gunichar) '0')) {
3368 _tmp14_ = c <= ((gunichar) '9');
3369 } else {
3370 _tmp14_ = FALSE;
3371 }
3372 if (!_tmp14_) {
3373 break;
3374 }
3375 _tmp15_ = format_it;
3376 _tmp16_ = g_utf8_next_char (_tmp15_);
3377 format_it = _tmp16_;
3378 _tmp17_ = format_it;
3379 c = string_get_char (_tmp17_, (glong) 0);
3380 }
3381 if (c == ((gunichar) '.')) {
3382 const gchar* _tmp18_;
3383 const gchar* _tmp19_;
3384 const gchar* _tmp20_;
3385 _tmp18_ = format_it;
3386 _tmp19_ = g_utf8_next_char (_tmp18_);
3387 format_it = _tmp19_;
3388 _tmp20_ = format_it;
3389 c = string_get_char (_tmp20_, (glong) 0);
3390 while (TRUE) {
3391 gboolean _tmp21_ = FALSE;
3392 const gchar* _tmp22_;
3393 const gchar* _tmp23_;
3394 const gchar* _tmp24_;
3395 if (c >= ((gunichar) '0')) {
3396 _tmp21_ = c <= ((gunichar) '9');
3397 } else {
3398 _tmp21_ = FALSE;
3399 }
3400 if (!_tmp21_) {
3401 break;
3402 }
3403 _tmp22_ = format_it;
3404 _tmp23_ = g_utf8_next_char (_tmp22_);
3405 format_it = _tmp23_;
3406 _tmp24_ = format_it;
3407 c = string_get_char (_tmp24_, (glong) 0);
3408 }
3409 }
3410 length = 0;
3411 if (c == ((gunichar) 'h')) {
3412 const gchar* _tmp25_;
3413 const gchar* _tmp26_;
3414 const gchar* _tmp27_;
3415 length = -1;
3416 _tmp25_ = format_it;
3417 _tmp26_ = g_utf8_next_char (_tmp25_);
3418 format_it = _tmp26_;
3419 _tmp27_ = format_it;
3420 c = string_get_char (_tmp27_, (glong) 0);
3421 if (c == ((gunichar) 'h')) {
3422 const gchar* _tmp28_;
3423 const gchar* _tmp29_;
3424 const gchar* _tmp30_;
3425 length = -2;
3426 _tmp28_ = format_it;
3427 _tmp29_ = g_utf8_next_char (_tmp28_);
3428 format_it = _tmp29_;
3429 _tmp30_ = format_it;
3430 c = string_get_char (_tmp30_, (glong) 0);
3431 }
3432 } else {
3433 if (c == ((gunichar) 'l')) {
3434 const gchar* _tmp31_;
3435 const gchar* _tmp32_;
3436 const gchar* _tmp33_;
3437 length = 1;
3438 _tmp31_ = format_it;
3439 _tmp32_ = g_utf8_next_char (_tmp31_);
3440 format_it = _tmp32_;
3441 _tmp33_ = format_it;
3442 c = string_get_char (_tmp33_, (glong) 0);
3443 } else {
3444 if (c == ((gunichar) 'z')) {
3445 const gchar* _tmp34_;
3446 const gchar* _tmp35_;
3447 const gchar* _tmp36_;
3448 length = 2;
3449 _tmp34_ = format_it;
3450 _tmp35_ = g_utf8_next_char (_tmp34_);
3451 format_it = _tmp35_;
3452 _tmp36_ = format_it;
3453 c = string_get_char (_tmp36_, (glong) 0);
3454 }
3455 }
3456 }
3457 param_type = NULL;
3458 if (c == ((gunichar) 'd')) {
3459 _tmp38_ = TRUE;
3460 } else {
3461 _tmp38_ = c == ((gunichar) 'i');
3462 }
3463 if (_tmp38_) {
3464 _tmp37_ = TRUE;
3465 } else {
3466 _tmp37_ = c == ((gunichar) 'c');
3467 }
3468 if (_tmp37_) {
3469 if (length == -2) {
3470 ValaDataType* _tmp39_;
3471 ValaDataType* _tmp40_;
3472 _tmp39_ = self->int8_type;
3473 _tmp40_ = _vala_code_node_ref0 (_tmp39_);
3474 _vala_code_node_unref0 (param_type);
3475 param_type = _tmp40_;
3476 } else {
3477 if (length == -1) {
3478 ValaDataType* _tmp41_;
3479 ValaDataType* _tmp42_;
3480 _tmp41_ = self->short_type;
3481 _tmp42_ = _vala_code_node_ref0 (_tmp41_);
3482 _vala_code_node_unref0 (param_type);
3483 param_type = _tmp42_;
3484 } else {
3485 if (length == 0) {
3486 ValaDataType* _tmp43_;
3487 ValaDataType* _tmp44_;
3488 _tmp43_ = self->int_type;
3489 _tmp44_ = _vala_code_node_ref0 (_tmp43_);
3490 _vala_code_node_unref0 (param_type);
3491 param_type = _tmp44_;
3492 } else {
3493 if (length == 1) {
3494 ValaDataType* _tmp45_;
3495 ValaDataType* _tmp46_;
3496 _tmp45_ = self->long_type;
3497 _tmp46_ = _vala_code_node_ref0 (_tmp45_);
3498 _vala_code_node_unref0 (param_type);
3499 param_type = _tmp46_;
3500 } else {
3501 if (length == 2) {
3502 ValaDataType* _tmp47_;
3503 ValaDataType* _tmp48_;
3504 _tmp47_ = self->ssize_t_type;
3505 _tmp48_ = _vala_code_node_ref0 (_tmp47_);
3506 _vala_code_node_unref0 (param_type);
3507 param_type = _tmp48_;
3508 }
3509 }
3510 }
3511 }
3512 }
3513 } else {
3514 gboolean _tmp49_ = FALSE;
3515 gboolean _tmp50_ = FALSE;
3516 gboolean _tmp51_ = FALSE;
3517 if (c == ((gunichar) 'o')) {
3518 _tmp51_ = TRUE;
3519 } else {
3520 _tmp51_ = c == ((gunichar) 'u');
3521 }
3522 if (_tmp51_) {
3523 _tmp50_ = TRUE;
3524 } else {
3525 _tmp50_ = c == ((gunichar) 'x');
3526 }
3527 if (_tmp50_) {
3528 _tmp49_ = TRUE;
3529 } else {
3530 _tmp49_ = c == ((gunichar) 'X');
3531 }
3532 if (_tmp49_) {
3533 if (length == -2) {
3534 ValaDataType* _tmp52_;
3535 ValaDataType* _tmp53_;
3536 _tmp52_ = self->uchar_type;
3537 _tmp53_ = _vala_code_node_ref0 (_tmp52_);
3538 _vala_code_node_unref0 (param_type);
3539 param_type = _tmp53_;
3540 } else {
3541 if (length == -1) {
3542 ValaDataType* _tmp54_;
3543 ValaDataType* _tmp55_;
3544 _tmp54_ = self->ushort_type;
3545 _tmp55_ = _vala_code_node_ref0 (_tmp54_);
3546 _vala_code_node_unref0 (param_type);
3547 param_type = _tmp55_;
3548 } else {
3549 if (length == 0) {
3550 ValaDataType* _tmp56_;
3551 ValaDataType* _tmp57_;
3552 _tmp56_ = self->uint_type;
3553 _tmp57_ = _vala_code_node_ref0 (_tmp56_);
3554 _vala_code_node_unref0 (param_type);
3555 param_type = _tmp57_;
3556 } else {
3557 if (length == 1) {
3558 ValaDataType* _tmp58_;
3559 ValaDataType* _tmp59_;
3560 _tmp58_ = self->ulong_type;
3561 _tmp59_ = _vala_code_node_ref0 (_tmp58_);
3562 _vala_code_node_unref0 (param_type);
3563 param_type = _tmp59_;
3564 } else {
3565 if (length == 2) {
3566 ValaDataType* _tmp60_;
3567 ValaDataType* _tmp61_;
3568 _tmp60_ = self->size_t_type;
3569 _tmp61_ = _vala_code_node_ref0 (_tmp60_);
3570 _vala_code_node_unref0 (param_type);
3571 param_type = _tmp61_;
3572 }
3573 }
3574 }
3575 }
3576 }
3577 } else {
3578 gboolean _tmp62_ = FALSE;
3579 gboolean _tmp63_ = FALSE;
3580 gboolean _tmp64_ = FALSE;
3581 gboolean _tmp65_ = FALSE;
3582 gboolean _tmp66_ = FALSE;
3583 gboolean _tmp67_ = FALSE;
3584 gboolean _tmp68_ = FALSE;
3585 if (c == ((gunichar) 'e')) {
3586 _tmp68_ = TRUE;
3587 } else {
3588 _tmp68_ = c == ((gunichar) 'E');
3589 }
3590 if (_tmp68_) {
3591 _tmp67_ = TRUE;
3592 } else {
3593 _tmp67_ = c == ((gunichar) 'f');
3594 }
3595 if (_tmp67_) {
3596 _tmp66_ = TRUE;
3597 } else {
3598 _tmp66_ = c == ((gunichar) 'F');
3599 }
3600 if (_tmp66_) {
3601 _tmp65_ = TRUE;
3602 } else {
3603 _tmp65_ = c == ((gunichar) 'g');
3604 }
3605 if (_tmp65_) {
3606 _tmp64_ = TRUE;
3607 } else {
3608 _tmp64_ = c == ((gunichar) 'G');
3609 }
3610 if (_tmp64_) {
3611 _tmp63_ = TRUE;
3612 } else {
3613 _tmp63_ = c == ((gunichar) 'a');
3614 }
3615 if (_tmp63_) {
3616 _tmp62_ = TRUE;
3617 } else {
3618 _tmp62_ = c == ((gunichar) 'A');
3619 }
3620 if (_tmp62_) {
3621 ValaDataType* _tmp69_;
3622 ValaDataType* _tmp70_;
3623 _tmp69_ = self->double_type;
3624 _tmp70_ = _vala_code_node_ref0 (_tmp69_);
3625 _vala_code_node_unref0 (param_type);
3626 param_type = _tmp70_;
3627 } else {
3628 if (c == ((gunichar) 's')) {
3629 ValaDataType* _tmp71_;
3630 ValaDataType* _tmp72_;
3631 _tmp71_ = self->string_type;
3632 _tmp72_ = _vala_code_node_ref0 (_tmp71_);
3633 _vala_code_node_unref0 (param_type);
3634 param_type = _tmp72_;
3635 } else {
3636 if (c == ((gunichar) 'p')) {
3637 ValaVoidType* _tmp73_;
3638 ValaVoidType* _tmp74_;
3639 ValaPointerType* _tmp75_;
3640 _tmp73_ = vala_void_type_new (NULL);
3641 _tmp74_ = _tmp73_;
3642 _tmp75_ = vala_pointer_type_new ((ValaDataType*) _tmp74_, NULL);
3643 _vala_code_node_unref0 (param_type);
3644 param_type = (ValaDataType*) _tmp75_;
3645 _vala_code_node_unref0 (_tmp74_);
3646 } else {
3647 if (c == ((gunichar) '%')) {
3648 } else {
3649 unsupported_format = TRUE;
3650 _vala_code_node_unref0 (param_type);
3651 break;
3652 }
3653 }
3654 }
3655 }
3656 }
3657 }
3658 if (c != ((gunichar) '\0')) {
3659 const gchar* _tmp76_;
3660 const gchar* _tmp77_;
3661 const gchar* _tmp78_;
3662 _tmp76_ = format_it;
3663 _tmp77_ = g_utf8_next_char (_tmp76_);
3664 format_it = _tmp77_;
3665 _tmp78_ = format_it;
3666 c = string_get_char (_tmp78_, (glong) 0);
3667 }
3668 _tmp79_ = param_type;
3669 if (_tmp79_ != NULL) {
3670 if (vala_iterator_next (arg_it)) {
3671 ValaExpression* arg = NULL;
3672 gpointer _tmp80_;
3673 ValaExpression* _tmp81_;
3674 ValaDataType* _tmp82_;
3675 _tmp80_ = vala_iterator_get (arg_it);
3676 arg = (ValaExpression*) _tmp80_;
3677 _tmp81_ = arg;
3678 _tmp82_ = param_type;
3679 vala_expression_set_target_type (_tmp81_, _tmp82_);
3680 _vala_code_node_unref0 (arg);
3681 } else {
3682 vala_report_error (source_reference, "Too few arguments for specified format");
3683 result = FALSE;
3684 _vala_code_node_unref0 (param_type);
3685 return result;
3686 }
3687 }
3688 _vala_code_node_unref0 (param_type);
3689 }
3690 if (!unsupported_format) {
3691 _tmp83_ = vala_iterator_next (arg_it);
3692 } else {
3693 _tmp83_ = FALSE;
3694 }
3695 if (_tmp83_) {
3696 vala_report_error (source_reference, "Too many arguments for specified format");
3697 result = FALSE;
3698 return result;
3699 }
3700 result = TRUE;
3701 return result;
3702 }
3703
3704 static ValaDataType*
vala_semantic_analyzer_get_instance_base_type(ValaDataType * instance_type,ValaDataType * base_type,ValaCodeNode * node_reference)3705 vala_semantic_analyzer_get_instance_base_type (ValaDataType* instance_type,
3706 ValaDataType* base_type,
3707 ValaCodeNode* node_reference)
3708 {
3709 ValaDataType* instance_base_type = NULL;
3710 ValaTypeSymbol* _tmp0_;
3711 ValaTypeSymbol* _tmp1_;
3712 ValaDataType* result = NULL;
3713 g_return_val_if_fail (instance_type != NULL, NULL);
3714 g_return_val_if_fail (base_type != NULL, NULL);
3715 _tmp0_ = vala_data_type_get_type_symbol (base_type);
3716 _tmp1_ = _tmp0_;
3717 if (VALA_IS_OBJECT_TYPE_SYMBOL (_tmp1_)) {
3718 ValaTypeSymbol* _tmp2_;
3719 ValaTypeSymbol* _tmp3_;
3720 ValaObjectType* _tmp4_;
3721 _tmp2_ = vala_data_type_get_type_symbol (base_type);
3722 _tmp3_ = _tmp2_;
3723 _tmp4_ = vala_object_type_new (G_TYPE_CHECK_INSTANCE_CAST (_tmp3_, VALA_TYPE_OBJECT_TYPE_SYMBOL, ValaObjectTypeSymbol));
3724 _vala_code_node_unref0 (instance_base_type);
3725 instance_base_type = (ValaDataType*) _tmp4_;
3726 } else {
3727 ValaTypeSymbol* _tmp5_;
3728 ValaTypeSymbol* _tmp6_;
3729 _tmp5_ = vala_data_type_get_type_symbol (base_type);
3730 _tmp6_ = _tmp5_;
3731 if (VALA_IS_STRUCT (_tmp6_)) {
3732 ValaTypeSymbol* _tmp7_;
3733 ValaTypeSymbol* _tmp8_;
3734 ValaStructValueType* _tmp9_;
3735 _tmp7_ = vala_data_type_get_type_symbol (base_type);
3736 _tmp8_ = _tmp7_;
3737 _tmp9_ = vala_struct_value_type_new (G_TYPE_CHECK_INSTANCE_CAST (_tmp8_, VALA_TYPE_STRUCT, ValaStruct));
3738 _vala_code_node_unref0 (instance_base_type);
3739 instance_base_type = (ValaDataType*) _tmp9_;
3740 } else {
3741 g_assert_not_reached ();
3742 }
3743 }
3744 {
3745 ValaList* _type_arg_list = NULL;
3746 ValaList* _tmp10_;
3747 ValaList* _tmp11_;
3748 gint _type_arg_size = 0;
3749 ValaList* _tmp12_;
3750 gint _tmp13_;
3751 gint _tmp14_;
3752 gint _type_arg_index = 0;
3753 _tmp10_ = vala_data_type_get_type_arguments (base_type);
3754 _tmp11_ = _vala_iterable_ref0 (_tmp10_);
3755 _type_arg_list = _tmp11_;
3756 _tmp12_ = _type_arg_list;
3757 _tmp13_ = vala_collection_get_size ((ValaCollection*) _tmp12_);
3758 _tmp14_ = _tmp13_;
3759 _type_arg_size = _tmp14_;
3760 _type_arg_index = -1;
3761 while (TRUE) {
3762 gint _tmp15_;
3763 gint _tmp16_;
3764 ValaDataType* type_arg = NULL;
3765 ValaList* _tmp17_;
3766 gpointer _tmp18_;
3767 ValaDataType* _tmp19_;
3768 ValaDataType* _tmp20_;
3769 ValaDataType* _tmp21_;
3770 ValaDataType* _tmp22_;
3771 _type_arg_index = _type_arg_index + 1;
3772 _tmp15_ = _type_arg_index;
3773 _tmp16_ = _type_arg_size;
3774 if (!(_tmp15_ < _tmp16_)) {
3775 break;
3776 }
3777 _tmp17_ = _type_arg_list;
3778 _tmp18_ = vala_list_get (_tmp17_, _type_arg_index);
3779 type_arg = (ValaDataType*) _tmp18_;
3780 _tmp19_ = type_arg;
3781 _tmp20_ = vala_data_type_get_actual_type (_tmp19_, instance_type, NULL, node_reference);
3782 _vala_code_node_unref0 (type_arg);
3783 type_arg = _tmp20_;
3784 _tmp21_ = instance_base_type;
3785 _tmp22_ = type_arg;
3786 vala_data_type_add_type_argument (_tmp21_, _tmp22_);
3787 _vala_code_node_unref0 (type_arg);
3788 }
3789 _vala_iterable_unref0 (_type_arg_list);
3790 }
3791 result = instance_base_type;
3792 return result;
3793 }
3794
3795 G_GNUC_INTERNAL ValaDataType*
vala_semantic_analyzer_get_instance_base_type_for_member(ValaDataType * derived_instance_type,ValaTypeSymbol * type_symbol,ValaCodeNode * node_reference)3796 vala_semantic_analyzer_get_instance_base_type_for_member (ValaDataType* derived_instance_type,
3797 ValaTypeSymbol* type_symbol,
3798 ValaCodeNode* node_reference)
3799 {
3800 ValaDataType* instance_type = NULL;
3801 ValaDataType* _tmp0_;
3802 gboolean _tmp7_ = FALSE;
3803 ValaDataType* _tmp8_;
3804 ValaDataType* instance_base_type = NULL;
3805 ValaDataType* _tmp15_;
3806 ValaTypeSymbol* _tmp16_;
3807 ValaTypeSymbol* _tmp17_;
3808 ValaDataType* result = NULL;
3809 g_return_val_if_fail (derived_instance_type != NULL, NULL);
3810 g_return_val_if_fail (type_symbol != NULL, NULL);
3811 _tmp0_ = _vala_code_node_ref0 (derived_instance_type);
3812 instance_type = _tmp0_;
3813 while (TRUE) {
3814 ValaDataType* _tmp1_;
3815 ValaPointerType* instance_pointer_type = NULL;
3816 ValaDataType* _tmp2_;
3817 ValaPointerType* _tmp3_;
3818 ValaDataType* _tmp4_;
3819 ValaDataType* _tmp5_;
3820 ValaDataType* _tmp6_;
3821 _tmp1_ = instance_type;
3822 if (!VALA_IS_POINTER_TYPE (_tmp1_)) {
3823 break;
3824 }
3825 _tmp2_ = instance_type;
3826 instance_pointer_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp2_, VALA_TYPE_POINTER_TYPE, ValaPointerType);
3827 _tmp3_ = instance_pointer_type;
3828 _tmp4_ = vala_pointer_type_get_base_type (_tmp3_);
3829 _tmp5_ = _tmp4_;
3830 _tmp6_ = _vala_code_node_ref0 (_tmp5_);
3831 _vala_code_node_unref0 (instance_type);
3832 instance_type = _tmp6_;
3833 }
3834 _tmp8_ = instance_type;
3835 if (VALA_IS_DELEGATE_TYPE (_tmp8_)) {
3836 ValaDataType* _tmp9_;
3837 ValaDelegate* _tmp10_;
3838 ValaDelegate* _tmp11_;
3839 _tmp9_ = instance_type;
3840 _tmp10_ = vala_delegate_type_get_delegate_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp9_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));
3841 _tmp11_ = _tmp10_;
3842 _tmp7_ = G_TYPE_CHECK_INSTANCE_CAST (_tmp11_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol) == type_symbol;
3843 } else {
3844 _tmp7_ = FALSE;
3845 }
3846 if (_tmp7_) {
3847 result = instance_type;
3848 return result;
3849 } else {
3850 ValaDataType* _tmp12_;
3851 ValaTypeSymbol* _tmp13_;
3852 ValaTypeSymbol* _tmp14_;
3853 _tmp12_ = instance_type;
3854 _tmp13_ = vala_data_type_get_type_symbol (_tmp12_);
3855 _tmp14_ = _tmp13_;
3856 if (_tmp14_ == type_symbol) {
3857 result = instance_type;
3858 return result;
3859 }
3860 }
3861 instance_base_type = NULL;
3862 _tmp15_ = instance_type;
3863 _tmp16_ = vala_data_type_get_type_symbol (_tmp15_);
3864 _tmp17_ = _tmp16_;
3865 if (VALA_IS_CLASS (_tmp17_)) {
3866 ValaClass* cl = NULL;
3867 ValaDataType* _tmp18_;
3868 ValaTypeSymbol* _tmp19_;
3869 ValaTypeSymbol* _tmp20_;
3870 ValaDataType* _tmp40_;
3871 _tmp18_ = instance_type;
3872 _tmp19_ = vala_data_type_get_type_symbol (_tmp18_);
3873 _tmp20_ = _tmp19_;
3874 cl = G_TYPE_CHECK_INSTANCE_CAST (_tmp20_, VALA_TYPE_CLASS, ValaClass);
3875 {
3876 ValaList* _base_type_list = NULL;
3877 ValaClass* _tmp21_;
3878 ValaList* _tmp22_;
3879 ValaList* _tmp23_;
3880 gint _base_type_size = 0;
3881 ValaList* _tmp24_;
3882 gint _tmp25_;
3883 gint _tmp26_;
3884 gint _base_type_index = 0;
3885 _tmp21_ = cl;
3886 _tmp22_ = vala_class_get_base_types (_tmp21_);
3887 _tmp23_ = _vala_iterable_ref0 (_tmp22_);
3888 _base_type_list = _tmp23_;
3889 _tmp24_ = _base_type_list;
3890 _tmp25_ = vala_collection_get_size ((ValaCollection*) _tmp24_);
3891 _tmp26_ = _tmp25_;
3892 _base_type_size = _tmp26_;
3893 _base_type_index = -1;
3894 while (TRUE) {
3895 gint _tmp27_;
3896 gint _tmp28_;
3897 ValaDataType* base_type = NULL;
3898 ValaList* _tmp29_;
3899 gpointer _tmp30_;
3900 ValaDataType* _tmp31_;
3901 ValaTypeSymbol* _tmp32_;
3902 ValaTypeSymbol* _tmp33_;
3903 _base_type_index = _base_type_index + 1;
3904 _tmp27_ = _base_type_index;
3905 _tmp28_ = _base_type_size;
3906 if (!(_tmp27_ < _tmp28_)) {
3907 break;
3908 }
3909 _tmp29_ = _base_type_list;
3910 _tmp30_ = vala_list_get (_tmp29_, _base_type_index);
3911 base_type = (ValaDataType*) _tmp30_;
3912 _tmp31_ = base_type;
3913 _tmp32_ = vala_data_type_get_type_symbol (_tmp31_);
3914 _tmp33_ = _tmp32_;
3915 if (VALA_IS_INTERFACE (_tmp33_)) {
3916 ValaDataType* _tmp34_;
3917 ValaDataType* _tmp35_;
3918 ValaDataType* _tmp36_;
3919 ValaDataType* _tmp37_;
3920 ValaDataType* _tmp38_;
3921 ValaDataType* _tmp39_;
3922 _tmp34_ = instance_type;
3923 _tmp35_ = base_type;
3924 _tmp36_ = vala_semantic_analyzer_get_instance_base_type (_tmp34_, _tmp35_, node_reference);
3925 _tmp37_ = _tmp36_;
3926 _tmp38_ = vala_semantic_analyzer_get_instance_base_type_for_member (_tmp37_, type_symbol, node_reference);
3927 _vala_code_node_unref0 (instance_base_type);
3928 instance_base_type = _tmp38_;
3929 _vala_code_node_unref0 (_tmp37_);
3930 _tmp39_ = instance_base_type;
3931 if (_tmp39_ != NULL) {
3932 result = instance_base_type;
3933 _vala_code_node_unref0 (base_type);
3934 _vala_iterable_unref0 (_base_type_list);
3935 _vala_code_node_unref0 (instance_type);
3936 return result;
3937 }
3938 }
3939 _vala_code_node_unref0 (base_type);
3940 }
3941 _vala_iterable_unref0 (_base_type_list);
3942 }
3943 _tmp40_ = instance_base_type;
3944 if (_tmp40_ == NULL) {
3945 {
3946 ValaList* _base_type_list = NULL;
3947 ValaClass* _tmp41_;
3948 ValaList* _tmp42_;
3949 ValaList* _tmp43_;
3950 gint _base_type_size = 0;
3951 ValaList* _tmp44_;
3952 gint _tmp45_;
3953 gint _tmp46_;
3954 gint _base_type_index = 0;
3955 _tmp41_ = cl;
3956 _tmp42_ = vala_class_get_base_types (_tmp41_);
3957 _tmp43_ = _vala_iterable_ref0 (_tmp42_);
3958 _base_type_list = _tmp43_;
3959 _tmp44_ = _base_type_list;
3960 _tmp45_ = vala_collection_get_size ((ValaCollection*) _tmp44_);
3961 _tmp46_ = _tmp45_;
3962 _base_type_size = _tmp46_;
3963 _base_type_index = -1;
3964 while (TRUE) {
3965 gint _tmp47_;
3966 gint _tmp48_;
3967 ValaDataType* base_type = NULL;
3968 ValaList* _tmp49_;
3969 gpointer _tmp50_;
3970 ValaDataType* _tmp51_;
3971 ValaTypeSymbol* _tmp52_;
3972 ValaTypeSymbol* _tmp53_;
3973 _base_type_index = _base_type_index + 1;
3974 _tmp47_ = _base_type_index;
3975 _tmp48_ = _base_type_size;
3976 if (!(_tmp47_ < _tmp48_)) {
3977 break;
3978 }
3979 _tmp49_ = _base_type_list;
3980 _tmp50_ = vala_list_get (_tmp49_, _base_type_index);
3981 base_type = (ValaDataType*) _tmp50_;
3982 _tmp51_ = base_type;
3983 _tmp52_ = vala_data_type_get_type_symbol (_tmp51_);
3984 _tmp53_ = _tmp52_;
3985 if (VALA_IS_CLASS (_tmp53_)) {
3986 ValaDataType* _tmp54_;
3987 ValaDataType* _tmp55_;
3988 ValaDataType* _tmp56_;
3989 ValaDataType* _tmp57_;
3990 ValaDataType* _tmp58_;
3991 ValaDataType* _tmp59_;
3992 _tmp54_ = instance_type;
3993 _tmp55_ = base_type;
3994 _tmp56_ = vala_semantic_analyzer_get_instance_base_type (_tmp54_, _tmp55_, node_reference);
3995 _tmp57_ = _tmp56_;
3996 _tmp58_ = vala_semantic_analyzer_get_instance_base_type_for_member (_tmp57_, type_symbol, node_reference);
3997 _vala_code_node_unref0 (instance_base_type);
3998 instance_base_type = _tmp58_;
3999 _vala_code_node_unref0 (_tmp57_);
4000 _tmp59_ = instance_base_type;
4001 if (_tmp59_ != NULL) {
4002 result = instance_base_type;
4003 _vala_code_node_unref0 (base_type);
4004 _vala_iterable_unref0 (_base_type_list);
4005 _vala_code_node_unref0 (instance_type);
4006 return result;
4007 }
4008 }
4009 _vala_code_node_unref0 (base_type);
4010 }
4011 _vala_iterable_unref0 (_base_type_list);
4012 }
4013 }
4014 } else {
4015 ValaDataType* _tmp60_;
4016 ValaTypeSymbol* _tmp61_;
4017 ValaTypeSymbol* _tmp62_;
4018 _tmp60_ = instance_type;
4019 _tmp61_ = vala_data_type_get_type_symbol (_tmp60_);
4020 _tmp62_ = _tmp61_;
4021 if (VALA_IS_STRUCT (_tmp62_)) {
4022 ValaStruct* st = NULL;
4023 ValaDataType* _tmp63_;
4024 ValaTypeSymbol* _tmp64_;
4025 ValaTypeSymbol* _tmp65_;
4026 ValaStruct* _tmp66_;
4027 ValaDataType* _tmp67_;
4028 ValaDataType* _tmp68_;
4029 _tmp63_ = instance_type;
4030 _tmp64_ = vala_data_type_get_type_symbol (_tmp63_);
4031 _tmp65_ = _tmp64_;
4032 st = G_TYPE_CHECK_INSTANCE_CAST (_tmp65_, VALA_TYPE_STRUCT, ValaStruct);
4033 _tmp66_ = st;
4034 _tmp67_ = vala_struct_get_base_type (_tmp66_);
4035 _tmp68_ = _tmp67_;
4036 if (_tmp68_ != NULL) {
4037 ValaDataType* _tmp69_;
4038 ValaStruct* _tmp70_;
4039 ValaDataType* _tmp71_;
4040 ValaDataType* _tmp72_;
4041 ValaDataType* _tmp73_;
4042 ValaDataType* _tmp74_;
4043 ValaDataType* _tmp75_;
4044 ValaDataType* _tmp76_;
4045 _tmp69_ = instance_type;
4046 _tmp70_ = st;
4047 _tmp71_ = vala_struct_get_base_type (_tmp70_);
4048 _tmp72_ = _tmp71_;
4049 _tmp73_ = vala_semantic_analyzer_get_instance_base_type (_tmp69_, _tmp72_, node_reference);
4050 _tmp74_ = _tmp73_;
4051 _tmp75_ = vala_semantic_analyzer_get_instance_base_type_for_member (_tmp74_, type_symbol, node_reference);
4052 _vala_code_node_unref0 (instance_base_type);
4053 instance_base_type = _tmp75_;
4054 _vala_code_node_unref0 (_tmp74_);
4055 _tmp76_ = instance_base_type;
4056 if (_tmp76_ != NULL) {
4057 result = instance_base_type;
4058 _vala_code_node_unref0 (instance_type);
4059 return result;
4060 }
4061 }
4062 } else {
4063 ValaDataType* _tmp77_;
4064 ValaTypeSymbol* _tmp78_;
4065 ValaTypeSymbol* _tmp79_;
4066 _tmp77_ = instance_type;
4067 _tmp78_ = vala_data_type_get_type_symbol (_tmp77_);
4068 _tmp79_ = _tmp78_;
4069 if (VALA_IS_INTERFACE (_tmp79_)) {
4070 ValaInterface* iface = NULL;
4071 ValaDataType* _tmp80_;
4072 ValaTypeSymbol* _tmp81_;
4073 ValaTypeSymbol* _tmp82_;
4074 ValaDataType* _tmp102_;
4075 _tmp80_ = instance_type;
4076 _tmp81_ = vala_data_type_get_type_symbol (_tmp80_);
4077 _tmp82_ = _tmp81_;
4078 iface = G_TYPE_CHECK_INSTANCE_CAST (_tmp82_, VALA_TYPE_INTERFACE, ValaInterface);
4079 {
4080 ValaList* _prerequisite_list = NULL;
4081 ValaInterface* _tmp83_;
4082 ValaList* _tmp84_;
4083 ValaList* _tmp85_;
4084 gint _prerequisite_size = 0;
4085 ValaList* _tmp86_;
4086 gint _tmp87_;
4087 gint _tmp88_;
4088 gint _prerequisite_index = 0;
4089 _tmp83_ = iface;
4090 _tmp84_ = vala_interface_get_prerequisites (_tmp83_);
4091 _tmp85_ = _vala_iterable_ref0 (_tmp84_);
4092 _prerequisite_list = _tmp85_;
4093 _tmp86_ = _prerequisite_list;
4094 _tmp87_ = vala_collection_get_size ((ValaCollection*) _tmp86_);
4095 _tmp88_ = _tmp87_;
4096 _prerequisite_size = _tmp88_;
4097 _prerequisite_index = -1;
4098 while (TRUE) {
4099 gint _tmp89_;
4100 gint _tmp90_;
4101 ValaDataType* prerequisite = NULL;
4102 ValaList* _tmp91_;
4103 gpointer _tmp92_;
4104 ValaDataType* _tmp93_;
4105 ValaTypeSymbol* _tmp94_;
4106 ValaTypeSymbol* _tmp95_;
4107 _prerequisite_index = _prerequisite_index + 1;
4108 _tmp89_ = _prerequisite_index;
4109 _tmp90_ = _prerequisite_size;
4110 if (!(_tmp89_ < _tmp90_)) {
4111 break;
4112 }
4113 _tmp91_ = _prerequisite_list;
4114 _tmp92_ = vala_list_get (_tmp91_, _prerequisite_index);
4115 prerequisite = (ValaDataType*) _tmp92_;
4116 _tmp93_ = prerequisite;
4117 _tmp94_ = vala_data_type_get_type_symbol (_tmp93_);
4118 _tmp95_ = _tmp94_;
4119 if (VALA_IS_INTERFACE (_tmp95_)) {
4120 ValaDataType* _tmp96_;
4121 ValaDataType* _tmp97_;
4122 ValaDataType* _tmp98_;
4123 ValaDataType* _tmp99_;
4124 ValaDataType* _tmp100_;
4125 ValaDataType* _tmp101_;
4126 _tmp96_ = instance_type;
4127 _tmp97_ = prerequisite;
4128 _tmp98_ = vala_semantic_analyzer_get_instance_base_type (_tmp96_, _tmp97_, node_reference);
4129 _tmp99_ = _tmp98_;
4130 _tmp100_ = vala_semantic_analyzer_get_instance_base_type_for_member (_tmp99_, type_symbol, node_reference);
4131 _vala_code_node_unref0 (instance_base_type);
4132 instance_base_type = _tmp100_;
4133 _vala_code_node_unref0 (_tmp99_);
4134 _tmp101_ = instance_base_type;
4135 if (_tmp101_ != NULL) {
4136 result = instance_base_type;
4137 _vala_code_node_unref0 (prerequisite);
4138 _vala_iterable_unref0 (_prerequisite_list);
4139 _vala_code_node_unref0 (instance_type);
4140 return result;
4141 }
4142 }
4143 _vala_code_node_unref0 (prerequisite);
4144 }
4145 _vala_iterable_unref0 (_prerequisite_list);
4146 }
4147 _tmp102_ = instance_base_type;
4148 if (_tmp102_ == NULL) {
4149 {
4150 ValaList* _prerequisite_list = NULL;
4151 ValaInterface* _tmp103_;
4152 ValaList* _tmp104_;
4153 ValaList* _tmp105_;
4154 gint _prerequisite_size = 0;
4155 ValaList* _tmp106_;
4156 gint _tmp107_;
4157 gint _tmp108_;
4158 gint _prerequisite_index = 0;
4159 _tmp103_ = iface;
4160 _tmp104_ = vala_interface_get_prerequisites (_tmp103_);
4161 _tmp105_ = _vala_iterable_ref0 (_tmp104_);
4162 _prerequisite_list = _tmp105_;
4163 _tmp106_ = _prerequisite_list;
4164 _tmp107_ = vala_collection_get_size ((ValaCollection*) _tmp106_);
4165 _tmp108_ = _tmp107_;
4166 _prerequisite_size = _tmp108_;
4167 _prerequisite_index = -1;
4168 while (TRUE) {
4169 gint _tmp109_;
4170 gint _tmp110_;
4171 ValaDataType* prerequisite = NULL;
4172 ValaList* _tmp111_;
4173 gpointer _tmp112_;
4174 ValaDataType* _tmp113_;
4175 ValaTypeSymbol* _tmp114_;
4176 ValaTypeSymbol* _tmp115_;
4177 _prerequisite_index = _prerequisite_index + 1;
4178 _tmp109_ = _prerequisite_index;
4179 _tmp110_ = _prerequisite_size;
4180 if (!(_tmp109_ < _tmp110_)) {
4181 break;
4182 }
4183 _tmp111_ = _prerequisite_list;
4184 _tmp112_ = vala_list_get (_tmp111_, _prerequisite_index);
4185 prerequisite = (ValaDataType*) _tmp112_;
4186 _tmp113_ = prerequisite;
4187 _tmp114_ = vala_data_type_get_type_symbol (_tmp113_);
4188 _tmp115_ = _tmp114_;
4189 if (VALA_IS_CLASS (_tmp115_)) {
4190 ValaDataType* _tmp116_;
4191 ValaDataType* _tmp117_;
4192 ValaDataType* _tmp118_;
4193 ValaDataType* _tmp119_;
4194 ValaDataType* _tmp120_;
4195 ValaDataType* _tmp121_;
4196 _tmp116_ = instance_type;
4197 _tmp117_ = prerequisite;
4198 _tmp118_ = vala_semantic_analyzer_get_instance_base_type (_tmp116_, _tmp117_, node_reference);
4199 _tmp119_ = _tmp118_;
4200 _tmp120_ = vala_semantic_analyzer_get_instance_base_type_for_member (_tmp119_, type_symbol, node_reference);
4201 _vala_code_node_unref0 (instance_base_type);
4202 instance_base_type = _tmp120_;
4203 _vala_code_node_unref0 (_tmp119_);
4204 _tmp121_ = instance_base_type;
4205 if (_tmp121_ != NULL) {
4206 result = instance_base_type;
4207 _vala_code_node_unref0 (prerequisite);
4208 _vala_iterable_unref0 (_prerequisite_list);
4209 _vala_code_node_unref0 (instance_type);
4210 return result;
4211 }
4212 }
4213 _vala_code_node_unref0 (prerequisite);
4214 }
4215 _vala_iterable_unref0 (_prerequisite_list);
4216 }
4217 }
4218 }
4219 }
4220 }
4221 result = NULL;
4222 _vala_code_node_unref0 (instance_base_type);
4223 _vala_code_node_unref0 (instance_type);
4224 return result;
4225 }
4226
4227 ValaDataType*
vala_semantic_analyzer_get_actual_type(ValaDataType * derived_instance_type,ValaList * method_type_arguments,ValaGenericType * generic_type,ValaCodeNode * node_reference)4228 vala_semantic_analyzer_get_actual_type (ValaDataType* derived_instance_type,
4229 ValaList* method_type_arguments,
4230 ValaGenericType* generic_type,
4231 ValaCodeNode* node_reference)
4232 {
4233 ValaDataType* actual_type = NULL;
4234 ValaTypeParameter* _tmp0_;
4235 ValaTypeParameter* _tmp1_;
4236 ValaSymbol* _tmp2_;
4237 ValaSymbol* _tmp3_;
4238 ValaDataType* _tmp73_;
4239 ValaDataType* _tmp75_;
4240 ValaDataType* _tmp76_;
4241 gboolean _tmp77_ = FALSE;
4242 ValaDataType* _tmp78_;
4243 gboolean _tmp79_;
4244 gboolean _tmp80_;
4245 ValaDataType* _tmp83_;
4246 ValaDataType* result = NULL;
4247 g_return_val_if_fail (generic_type != NULL, NULL);
4248 actual_type = NULL;
4249 _tmp0_ = vala_generic_type_get_type_parameter (generic_type);
4250 _tmp1_ = _tmp0_;
4251 _tmp2_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp1_);
4252 _tmp3_ = _tmp2_;
4253 if (VALA_IS_TYPESYMBOL (_tmp3_)) {
4254 if (derived_instance_type != NULL) {
4255 ValaDataType* instance_type = NULL;
4256 ValaTypeParameter* _tmp4_;
4257 ValaTypeParameter* _tmp5_;
4258 ValaSymbol* _tmp6_;
4259 ValaSymbol* _tmp7_;
4260 ValaDataType* _tmp8_;
4261 ValaDataType* _tmp9_;
4262 gint param_index = 0;
4263 ValaDataType* _tmp21_;
4264 ValaDataType* _tmp45_;
4265 ValaList* _tmp46_;
4266 gint _tmp47_;
4267 gint _tmp48_;
4268 _tmp4_ = vala_generic_type_get_type_parameter (generic_type);
4269 _tmp5_ = _tmp4_;
4270 _tmp6_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp5_);
4271 _tmp7_ = _tmp6_;
4272 _tmp8_ = vala_semantic_analyzer_get_instance_base_type_for_member (derived_instance_type, G_TYPE_CHECK_INSTANCE_CAST (_tmp7_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol), node_reference);
4273 instance_type = _tmp8_;
4274 _tmp9_ = instance_type;
4275 if (_tmp9_ == NULL) {
4276 ValaInvalidType* _tmp20_;
4277 if (node_reference != NULL) {
4278 ValaCodeNode* reference = NULL;
4279 ValaSymbol* _tmp10_;
4280 ValaCodeNode* _tmp11_;
4281 ValaCodeNode* _tmp12_ = NULL;
4282 ValaCodeNode* _tmp13_;
4283 ValaSourceReference* _tmp14_;
4284 ValaSourceReference* _tmp15_;
4285 gchar* _tmp16_;
4286 gchar* _tmp17_;
4287 gchar* _tmp18_;
4288 gchar* _tmp19_;
4289 _tmp10_ = vala_semantic_analyzer_get_symbol_for_data_type (derived_instance_type);
4290 _tmp11_ = _vala_code_node_ref0 ((ValaCodeNode*) _tmp10_);
4291 reference = _tmp11_;
4292 _tmp13_ = reference;
4293 _tmp12_ = _tmp13_;
4294 if (_tmp12_ == NULL) {
4295 _tmp12_ = node_reference;
4296 }
4297 _tmp14_ = vala_code_node_get_source_reference (_tmp12_);
4298 _tmp15_ = _tmp14_;
4299 _tmp16_ = vala_code_node_to_string ((ValaCodeNode*) generic_type);
4300 _tmp17_ = _tmp16_;
4301 _tmp18_ = g_strdup_printf ("The type-parameter `%s' is missing", _tmp17_);
4302 _tmp19_ = _tmp18_;
4303 vala_report_error (_tmp15_, _tmp19_);
4304 _g_free0 (_tmp19_);
4305 _g_free0 (_tmp17_);
4306 vala_code_node_set_error (node_reference, TRUE);
4307 _vala_code_node_unref0 (reference);
4308 }
4309 _tmp20_ = vala_invalid_type_new ();
4310 result = (ValaDataType*) _tmp20_;
4311 _vala_code_node_unref0 (instance_type);
4312 _vala_code_node_unref0 (actual_type);
4313 return result;
4314 }
4315 _tmp21_ = instance_type;
4316 if (VALA_IS_DELEGATE_TYPE (_tmp21_)) {
4317 ValaDataType* _tmp22_;
4318 ValaDelegate* _tmp23_;
4319 ValaDelegate* _tmp24_;
4320 ValaTypeParameter* _tmp25_;
4321 ValaTypeParameter* _tmp26_;
4322 const gchar* _tmp27_;
4323 const gchar* _tmp28_;
4324 _tmp22_ = instance_type;
4325 _tmp23_ = vala_delegate_type_get_delegate_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp22_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));
4326 _tmp24_ = _tmp23_;
4327 _tmp25_ = vala_generic_type_get_type_parameter (generic_type);
4328 _tmp26_ = _tmp25_;
4329 _tmp27_ = vala_symbol_get_name ((ValaSymbol*) _tmp26_);
4330 _tmp28_ = _tmp27_;
4331 param_index = vala_typesymbol_get_type_parameter_index ((ValaTypeSymbol*) _tmp24_, _tmp28_);
4332 } else {
4333 ValaDataType* _tmp29_;
4334 ValaTypeSymbol* _tmp30_;
4335 ValaTypeSymbol* _tmp31_;
4336 ValaTypeParameter* _tmp32_;
4337 ValaTypeParameter* _tmp33_;
4338 const gchar* _tmp34_;
4339 const gchar* _tmp35_;
4340 _tmp29_ = instance_type;
4341 _tmp30_ = vala_data_type_get_type_symbol (_tmp29_);
4342 _tmp31_ = _tmp30_;
4343 _tmp32_ = vala_generic_type_get_type_parameter (generic_type);
4344 _tmp33_ = _tmp32_;
4345 _tmp34_ = vala_symbol_get_name ((ValaSymbol*) _tmp33_);
4346 _tmp35_ = _tmp34_;
4347 param_index = vala_typesymbol_get_type_parameter_index (_tmp31_, _tmp35_);
4348 }
4349 if (param_index == -1) {
4350 ValaInvalidType* _tmp44_;
4351 if (node_reference != NULL) {
4352 ValaSourceReference* _tmp36_;
4353 ValaSourceReference* _tmp37_;
4354 ValaTypeParameter* _tmp38_;
4355 ValaTypeParameter* _tmp39_;
4356 const gchar* _tmp40_;
4357 const gchar* _tmp41_;
4358 gchar* _tmp42_;
4359 gchar* _tmp43_;
4360 _tmp36_ = vala_code_node_get_source_reference (node_reference);
4361 _tmp37_ = _tmp36_;
4362 _tmp38_ = vala_generic_type_get_type_parameter (generic_type);
4363 _tmp39_ = _tmp38_;
4364 _tmp40_ = vala_symbol_get_name ((ValaSymbol*) _tmp39_);
4365 _tmp41_ = _tmp40_;
4366 _tmp42_ = g_strdup_printf ("internal error: unknown type parameter %s", _tmp41_);
4367 _tmp43_ = _tmp42_;
4368 vala_report_error (_tmp37_, _tmp43_);
4369 _g_free0 (_tmp43_);
4370 vala_code_node_set_error (node_reference, TRUE);
4371 }
4372 _tmp44_ = vala_invalid_type_new ();
4373 result = (ValaDataType*) _tmp44_;
4374 _vala_code_node_unref0 (instance_type);
4375 _vala_code_node_unref0 (actual_type);
4376 return result;
4377 }
4378 _tmp45_ = instance_type;
4379 _tmp46_ = vala_data_type_get_type_arguments (_tmp45_);
4380 _tmp47_ = vala_collection_get_size ((ValaCollection*) _tmp46_);
4381 _tmp48_ = _tmp47_;
4382 if (param_index < _tmp48_) {
4383 ValaDataType* _tmp49_;
4384 ValaList* _tmp50_;
4385 gpointer _tmp51_;
4386 _tmp49_ = instance_type;
4387 _tmp50_ = vala_data_type_get_type_arguments (_tmp49_);
4388 _tmp51_ = vala_list_get (_tmp50_, param_index);
4389 _vala_code_node_unref0 (actual_type);
4390 actual_type = G_TYPE_CHECK_INSTANCE_CAST ((ValaDataType*) _tmp51_, VALA_TYPE_DATA_TYPE, ValaDataType);
4391 }
4392 _vala_code_node_unref0 (instance_type);
4393 }
4394 } else {
4395 ValaMethod* m = NULL;
4396 ValaTypeParameter* _tmp52_;
4397 ValaTypeParameter* _tmp53_;
4398 ValaSymbol* _tmp54_;
4399 ValaSymbol* _tmp55_;
4400 gint param_index = 0;
4401 ValaMethod* _tmp56_;
4402 ValaTypeParameter* _tmp57_;
4403 ValaTypeParameter* _tmp58_;
4404 const gchar* _tmp59_;
4405 const gchar* _tmp60_;
4406 _tmp52_ = vala_generic_type_get_type_parameter (generic_type);
4407 _tmp53_ = _tmp52_;
4408 _tmp54_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp53_);
4409 _tmp55_ = _tmp54_;
4410 m = G_TYPE_CHECK_INSTANCE_CAST (_tmp55_, VALA_TYPE_METHOD, ValaMethod);
4411 _tmp56_ = m;
4412 _tmp57_ = vala_generic_type_get_type_parameter (generic_type);
4413 _tmp58_ = _tmp57_;
4414 _tmp59_ = vala_symbol_get_name ((ValaSymbol*) _tmp58_);
4415 _tmp60_ = _tmp59_;
4416 param_index = vala_method_get_type_parameter_index (_tmp56_, _tmp60_);
4417 if (param_index == -1) {
4418 ValaInvalidType* _tmp69_;
4419 if (node_reference != NULL) {
4420 ValaSourceReference* _tmp61_;
4421 ValaSourceReference* _tmp62_;
4422 ValaTypeParameter* _tmp63_;
4423 ValaTypeParameter* _tmp64_;
4424 const gchar* _tmp65_;
4425 const gchar* _tmp66_;
4426 gchar* _tmp67_;
4427 gchar* _tmp68_;
4428 _tmp61_ = vala_code_node_get_source_reference (node_reference);
4429 _tmp62_ = _tmp61_;
4430 _tmp63_ = vala_generic_type_get_type_parameter (generic_type);
4431 _tmp64_ = _tmp63_;
4432 _tmp65_ = vala_symbol_get_name ((ValaSymbol*) _tmp64_);
4433 _tmp66_ = _tmp65_;
4434 _tmp67_ = g_strdup_printf ("internal error: unknown type parameter %s", _tmp66_);
4435 _tmp68_ = _tmp67_;
4436 vala_report_error (_tmp62_, _tmp68_);
4437 _g_free0 (_tmp68_);
4438 vala_code_node_set_error (node_reference, TRUE);
4439 }
4440 _tmp69_ = vala_invalid_type_new ();
4441 result = (ValaDataType*) _tmp69_;
4442 _vala_code_node_unref0 (actual_type);
4443 return result;
4444 }
4445 if (method_type_arguments != NULL) {
4446 gint _tmp70_;
4447 gint _tmp71_;
4448 _tmp70_ = vala_collection_get_size ((ValaCollection*) method_type_arguments);
4449 _tmp71_ = _tmp70_;
4450 if (param_index < _tmp71_) {
4451 gpointer _tmp72_;
4452 _tmp72_ = vala_list_get (method_type_arguments, param_index);
4453 _vala_code_node_unref0 (actual_type);
4454 actual_type = G_TYPE_CHECK_INSTANCE_CAST ((ValaDataType*) _tmp72_, VALA_TYPE_DATA_TYPE, ValaDataType);
4455 }
4456 }
4457 }
4458 _tmp73_ = actual_type;
4459 if (_tmp73_ == NULL) {
4460 ValaDataType* _tmp74_;
4461 _tmp74_ = _vala_code_node_ref0 ((ValaDataType*) generic_type);
4462 result = _tmp74_;
4463 _vala_code_node_unref0 (actual_type);
4464 return result;
4465 }
4466 _tmp75_ = actual_type;
4467 _tmp76_ = vala_data_type_copy (_tmp75_);
4468 _vala_code_node_unref0 (actual_type);
4469 actual_type = _tmp76_;
4470 _tmp78_ = actual_type;
4471 _tmp79_ = vala_data_type_get_value_owned (_tmp78_);
4472 _tmp80_ = _tmp79_;
4473 if (_tmp80_) {
4474 gboolean _tmp81_;
4475 gboolean _tmp82_;
4476 _tmp81_ = vala_data_type_get_value_owned ((ValaDataType*) generic_type);
4477 _tmp82_ = _tmp81_;
4478 _tmp77_ = _tmp82_;
4479 } else {
4480 _tmp77_ = FALSE;
4481 }
4482 _tmp83_ = actual_type;
4483 vala_data_type_set_value_owned (_tmp83_, _tmp77_);
4484 result = actual_type;
4485 return result;
4486 }
4487
4488 gboolean
vala_semantic_analyzer_is_in_instance_method(ValaSemanticAnalyzer * self)4489 vala_semantic_analyzer_is_in_instance_method (ValaSemanticAnalyzer* self)
4490 {
4491 ValaSymbol* sym = NULL;
4492 ValaSymbol* _tmp0_;
4493 gboolean result = FALSE;
4494 g_return_val_if_fail (self != NULL, FALSE);
4495 _tmp0_ = self->priv->_current_symbol;
4496 sym = _tmp0_;
4497 while (TRUE) {
4498 ValaSymbol* _tmp1_;
4499 ValaSymbol* _tmp2_;
4500 ValaSymbol* _tmp23_;
4501 ValaSymbol* _tmp24_;
4502 ValaSymbol* _tmp25_;
4503 _tmp1_ = sym;
4504 if (!(_tmp1_ != NULL)) {
4505 break;
4506 }
4507 _tmp2_ = sym;
4508 if (VALA_IS_CREATION_METHOD (_tmp2_)) {
4509 result = TRUE;
4510 return result;
4511 } else {
4512 ValaSymbol* _tmp3_;
4513 _tmp3_ = sym;
4514 if (VALA_IS_METHOD (_tmp3_)) {
4515 ValaMethod* m = NULL;
4516 ValaSymbol* _tmp4_;
4517 ValaMethod* _tmp5_;
4518 ValaMemberBinding _tmp6_;
4519 ValaMemberBinding _tmp7_;
4520 _tmp4_ = sym;
4521 m = G_TYPE_CHECK_INSTANCE_CAST (_tmp4_, VALA_TYPE_METHOD, ValaMethod);
4522 _tmp5_ = m;
4523 _tmp6_ = vala_method_get_binding (_tmp5_);
4524 _tmp7_ = _tmp6_;
4525 result = _tmp7_ == VALA_MEMBER_BINDING_INSTANCE;
4526 return result;
4527 } else {
4528 ValaSymbol* _tmp8_;
4529 _tmp8_ = sym;
4530 if (VALA_IS_CONSTRUCTOR (_tmp8_)) {
4531 ValaConstructor* c = NULL;
4532 ValaSymbol* _tmp9_;
4533 ValaConstructor* _tmp10_;
4534 ValaMemberBinding _tmp11_;
4535 ValaMemberBinding _tmp12_;
4536 _tmp9_ = sym;
4537 c = G_TYPE_CHECK_INSTANCE_CAST (_tmp9_, VALA_TYPE_CONSTRUCTOR, ValaConstructor);
4538 _tmp10_ = c;
4539 _tmp11_ = vala_constructor_get_binding (_tmp10_);
4540 _tmp12_ = _tmp11_;
4541 result = _tmp12_ == VALA_MEMBER_BINDING_INSTANCE;
4542 return result;
4543 } else {
4544 ValaSymbol* _tmp13_;
4545 _tmp13_ = sym;
4546 if (VALA_IS_DESTRUCTOR (_tmp13_)) {
4547 ValaDestructor* d = NULL;
4548 ValaSymbol* _tmp14_;
4549 ValaDestructor* _tmp15_;
4550 ValaMemberBinding _tmp16_;
4551 ValaMemberBinding _tmp17_;
4552 _tmp14_ = sym;
4553 d = G_TYPE_CHECK_INSTANCE_CAST (_tmp14_, VALA_TYPE_DESTRUCTOR, ValaDestructor);
4554 _tmp15_ = d;
4555 _tmp16_ = vala_destructor_get_binding (_tmp15_);
4556 _tmp17_ = _tmp16_;
4557 result = _tmp17_ == VALA_MEMBER_BINDING_INSTANCE;
4558 return result;
4559 } else {
4560 ValaSymbol* _tmp18_;
4561 _tmp18_ = sym;
4562 if (VALA_IS_PROPERTY (_tmp18_)) {
4563 ValaProperty* p = NULL;
4564 ValaSymbol* _tmp19_;
4565 ValaProperty* _tmp20_;
4566 ValaMemberBinding _tmp21_;
4567 ValaMemberBinding _tmp22_;
4568 _tmp19_ = sym;
4569 p = G_TYPE_CHECK_INSTANCE_CAST (_tmp19_, VALA_TYPE_PROPERTY, ValaProperty);
4570 _tmp20_ = p;
4571 _tmp21_ = vala_property_get_binding (_tmp20_);
4572 _tmp22_ = _tmp21_;
4573 result = _tmp22_ == VALA_MEMBER_BINDING_INSTANCE;
4574 return result;
4575 }
4576 }
4577 }
4578 }
4579 }
4580 _tmp23_ = sym;
4581 _tmp24_ = vala_symbol_get_parent_symbol (_tmp23_);
4582 _tmp25_ = _tmp24_;
4583 sym = _tmp25_;
4584 }
4585 result = FALSE;
4586 return result;
4587 }
4588
4589 ValaExpression*
vala_semantic_analyzer_create_temp_access(ValaLocalVariable * local,ValaDataType * target_type)4590 vala_semantic_analyzer_create_temp_access (ValaLocalVariable* local,
4591 ValaDataType* target_type)
4592 {
4593 ValaExpression* temp_access = NULL;
4594 const gchar* _tmp0_;
4595 const gchar* _tmp1_;
4596 ValaSourceReference* _tmp2_;
4597 ValaSourceReference* _tmp3_;
4598 ValaMemberAccess* _tmp4_;
4599 gboolean _tmp5_ = FALSE;
4600 gboolean target_owned = FALSE;
4601 gboolean _tmp8_ = FALSE;
4602 ValaExpression* result = NULL;
4603 g_return_val_if_fail (local != NULL, NULL);
4604 _tmp0_ = vala_symbol_get_name ((ValaSymbol*) local);
4605 _tmp1_ = _tmp0_;
4606 _tmp2_ = vala_code_node_get_source_reference ((ValaCodeNode*) local);
4607 _tmp3_ = _tmp2_;
4608 _tmp4_ = vala_member_access_new_simple (_tmp1_, _tmp3_);
4609 temp_access = (ValaExpression*) _tmp4_;
4610 if (target_type != NULL) {
4611 gboolean _tmp6_;
4612 gboolean _tmp7_;
4613 _tmp6_ = vala_data_type_get_value_owned (target_type);
4614 _tmp7_ = _tmp6_;
4615 _tmp5_ = _tmp7_;
4616 } else {
4617 _tmp5_ = FALSE;
4618 }
4619 target_owned = _tmp5_;
4620 if (target_owned) {
4621 ValaDataType* _tmp9_;
4622 ValaDataType* _tmp10_;
4623 _tmp9_ = vala_variable_get_variable_type ((ValaVariable*) local);
4624 _tmp10_ = _tmp9_;
4625 _tmp8_ = vala_data_type_is_disposable (_tmp10_);
4626 } else {
4627 _tmp8_ = FALSE;
4628 }
4629 if (_tmp8_) {
4630 ValaExpression* _tmp11_;
4631 ValaSourceReference* _tmp12_;
4632 ValaSourceReference* _tmp13_;
4633 ValaReferenceTransferExpression* _tmp14_;
4634 ValaDataType* _tmp15_ = NULL;
4635 ValaExpression* _tmp20_;
4636 ValaExpression* _tmp21_;
4637 ValaDataType* _tmp22_;
4638 ValaDataType* _tmp23_;
4639 _tmp11_ = temp_access;
4640 _tmp12_ = vala_code_node_get_source_reference ((ValaCodeNode*) local);
4641 _tmp13_ = _tmp12_;
4642 _tmp14_ = vala_reference_transfer_expression_new (_tmp11_, _tmp13_);
4643 _vala_code_node_unref0 (temp_access);
4644 temp_access = (ValaExpression*) _tmp14_;
4645 if (target_type != NULL) {
4646 ValaDataType* _tmp16_;
4647 _tmp16_ = vala_data_type_copy (target_type);
4648 _vala_code_node_unref0 (_tmp15_);
4649 _tmp15_ = _tmp16_;
4650 } else {
4651 ValaDataType* _tmp17_;
4652 ValaDataType* _tmp18_;
4653 ValaDataType* _tmp19_;
4654 _tmp17_ = vala_variable_get_variable_type ((ValaVariable*) local);
4655 _tmp18_ = _tmp17_;
4656 _tmp19_ = vala_data_type_copy (_tmp18_);
4657 _vala_code_node_unref0 (_tmp15_);
4658 _tmp15_ = _tmp19_;
4659 }
4660 _tmp20_ = temp_access;
4661 vala_expression_set_target_type (_tmp20_, _tmp15_);
4662 _tmp21_ = temp_access;
4663 _tmp22_ = vala_expression_get_target_type (_tmp21_);
4664 _tmp23_ = _tmp22_;
4665 vala_data_type_set_value_owned (_tmp23_, TRUE);
4666 _vala_code_node_unref0 (_tmp15_);
4667 } else {
4668 ValaDataType* _tmp24_ = NULL;
4669 ValaExpression* _tmp26_;
4670 if (target_type != NULL) {
4671 ValaDataType* _tmp25_;
4672 _tmp25_ = vala_data_type_copy (target_type);
4673 _vala_code_node_unref0 (_tmp24_);
4674 _tmp24_ = _tmp25_;
4675 } else {
4676 _vala_code_node_unref0 (_tmp24_);
4677 _tmp24_ = NULL;
4678 }
4679 _tmp26_ = temp_access;
4680 vala_expression_set_target_type (_tmp26_, _tmp24_);
4681 _vala_code_node_unref0 (_tmp24_);
4682 }
4683 result = temp_access;
4684 return result;
4685 }
4686
4687 void
vala_semantic_analyzer_visit_member_initializer(ValaSemanticAnalyzer * self,ValaMemberInitializer * init,ValaDataType * type)4688 vala_semantic_analyzer_visit_member_initializer (ValaSemanticAnalyzer* self,
4689 ValaMemberInitializer* init,
4690 ValaDataType* type)
4691 {
4692 ValaTypeSymbol* _tmp0_;
4693 ValaTypeSymbol* _tmp1_;
4694 const gchar* _tmp2_;
4695 const gchar* _tmp3_;
4696 ValaSymbol* _tmp4_;
4697 ValaSymbol* _tmp5_;
4698 gboolean _tmp6_ = FALSE;
4699 ValaSymbol* _tmp7_;
4700 ValaSymbol* _tmp8_;
4701 ValaSymbol* _tmp21_;
4702 ValaSymbol* _tmp22_;
4703 ValaSymbolAccessibility _tmp23_;
4704 ValaSymbolAccessibility _tmp24_;
4705 ValaDataType* member_type = NULL;
4706 ValaSymbol* _tmp33_;
4707 ValaSymbol* _tmp34_;
4708 ValaExpression* _tmp65_;
4709 ValaExpression* _tmp66_;
4710 ValaDataType* _tmp67_;
4711 ValaExpression* _tmp68_;
4712 ValaExpression* _tmp69_;
4713 ValaExpression* _tmp70_;
4714 ValaExpression* _tmp71_;
4715 ValaDataType* _tmp72_;
4716 ValaDataType* _tmp73_;
4717 ValaDataType* _tmp74_;
4718 ValaDataType* _tmp75_;
4719 ValaCodeContext* _tmp76_;
4720 gboolean _tmp77_ = FALSE;
4721 ValaExpression* _tmp78_;
4722 ValaExpression* _tmp79_;
4723 ValaDataType* _tmp80_;
4724 ValaDataType* _tmp81_;
4725 g_return_if_fail (self != NULL);
4726 g_return_if_fail (init != NULL);
4727 g_return_if_fail (type != NULL);
4728 _tmp0_ = vala_data_type_get_type_symbol (type);
4729 _tmp1_ = _tmp0_;
4730 _tmp2_ = vala_member_initializer_get_name (init);
4731 _tmp3_ = _tmp2_;
4732 _tmp4_ = vala_semantic_analyzer_symbol_lookup_inherited ((ValaSymbol*) _tmp1_, _tmp3_);
4733 _tmp5_ = _tmp4_;
4734 vala_member_initializer_set_symbol_reference (init, _tmp5_);
4735 _vala_code_node_unref0 (_tmp5_);
4736 _tmp7_ = vala_member_initializer_get_symbol_reference (init);
4737 _tmp8_ = _tmp7_;
4738 if (VALA_IS_FIELD (_tmp8_)) {
4739 _tmp6_ = TRUE;
4740 } else {
4741 ValaSymbol* _tmp9_;
4742 ValaSymbol* _tmp10_;
4743 _tmp9_ = vala_member_initializer_get_symbol_reference (init);
4744 _tmp10_ = _tmp9_;
4745 _tmp6_ = VALA_IS_PROPERTY (_tmp10_);
4746 }
4747 if (!_tmp6_) {
4748 ValaSourceReference* _tmp11_;
4749 ValaSourceReference* _tmp12_;
4750 const gchar* _tmp13_;
4751 const gchar* _tmp14_;
4752 ValaTypeSymbol* _tmp15_;
4753 ValaTypeSymbol* _tmp16_;
4754 gchar* _tmp17_;
4755 gchar* _tmp18_;
4756 gchar* _tmp19_;
4757 gchar* _tmp20_;
4758 vala_code_node_set_error ((ValaCodeNode*) init, TRUE);
4759 _tmp11_ = vala_code_node_get_source_reference ((ValaCodeNode*) init);
4760 _tmp12_ = _tmp11_;
4761 _tmp13_ = vala_member_initializer_get_name (init);
4762 _tmp14_ = _tmp13_;
4763 _tmp15_ = vala_data_type_get_type_symbol (type);
4764 _tmp16_ = _tmp15_;
4765 _tmp17_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp16_);
4766 _tmp18_ = _tmp17_;
4767 _tmp19_ = g_strdup_printf ("Invalid member `%s' in `%s'", _tmp14_, _tmp18_);
4768 _tmp20_ = _tmp19_;
4769 vala_report_error (_tmp12_, _tmp20_);
4770 _g_free0 (_tmp20_);
4771 _g_free0 (_tmp18_);
4772 return;
4773 }
4774 _tmp21_ = vala_member_initializer_get_symbol_reference (init);
4775 _tmp22_ = _tmp21_;
4776 _tmp23_ = vala_symbol_get_access (_tmp22_);
4777 _tmp24_ = _tmp23_;
4778 if (_tmp24_ != VALA_SYMBOL_ACCESSIBILITY_PUBLIC) {
4779 ValaSourceReference* _tmp25_;
4780 ValaSourceReference* _tmp26_;
4781 ValaSymbol* _tmp27_;
4782 ValaSymbol* _tmp28_;
4783 gchar* _tmp29_;
4784 gchar* _tmp30_;
4785 gchar* _tmp31_;
4786 gchar* _tmp32_;
4787 vala_code_node_set_error ((ValaCodeNode*) init, TRUE);
4788 _tmp25_ = vala_code_node_get_source_reference ((ValaCodeNode*) init);
4789 _tmp26_ = _tmp25_;
4790 _tmp27_ = vala_member_initializer_get_symbol_reference (init);
4791 _tmp28_ = _tmp27_;
4792 _tmp29_ = vala_symbol_get_full_name (_tmp28_);
4793 _tmp30_ = _tmp29_;
4794 _tmp31_ = g_strdup_printf ("Access to private member `%s' denied", _tmp30_);
4795 _tmp32_ = _tmp31_;
4796 vala_report_error (_tmp26_, _tmp32_);
4797 _g_free0 (_tmp32_);
4798 _g_free0 (_tmp30_);
4799 return;
4800 }
4801 member_type = NULL;
4802 _tmp33_ = vala_member_initializer_get_symbol_reference (init);
4803 _tmp34_ = _tmp33_;
4804 if (VALA_IS_FIELD (_tmp34_)) {
4805 ValaField* f = NULL;
4806 ValaSymbol* _tmp35_;
4807 ValaSymbol* _tmp36_;
4808 ValaField* _tmp37_;
4809 ValaDataType* _tmp38_;
4810 ValaDataType* _tmp39_;
4811 ValaDataType* _tmp40_;
4812 _tmp35_ = vala_member_initializer_get_symbol_reference (init);
4813 _tmp36_ = _tmp35_;
4814 f = G_TYPE_CHECK_INSTANCE_CAST (_tmp36_, VALA_TYPE_FIELD, ValaField);
4815 _tmp37_ = f;
4816 _tmp38_ = vala_variable_get_variable_type ((ValaVariable*) _tmp37_);
4817 _tmp39_ = _tmp38_;
4818 _tmp40_ = _vala_code_node_ref0 (_tmp39_);
4819 _vala_code_node_unref0 (member_type);
4820 member_type = _tmp40_;
4821 } else {
4822 ValaSymbol* _tmp41_;
4823 ValaSymbol* _tmp42_;
4824 _tmp41_ = vala_member_initializer_get_symbol_reference (init);
4825 _tmp42_ = _tmp41_;
4826 if (VALA_IS_PROPERTY (_tmp42_)) {
4827 ValaProperty* prop = NULL;
4828 ValaSymbol* _tmp43_;
4829 ValaSymbol* _tmp44_;
4830 ValaProperty* _tmp45_;
4831 ValaDataType* _tmp46_;
4832 ValaDataType* _tmp47_;
4833 ValaDataType* _tmp48_;
4834 gboolean _tmp49_ = FALSE;
4835 ValaProperty* _tmp50_;
4836 ValaPropertyAccessor* _tmp51_;
4837 ValaPropertyAccessor* _tmp52_;
4838 _tmp43_ = vala_member_initializer_get_symbol_reference (init);
4839 _tmp44_ = _tmp43_;
4840 prop = G_TYPE_CHECK_INSTANCE_CAST (_tmp44_, VALA_TYPE_PROPERTY, ValaProperty);
4841 _tmp45_ = prop;
4842 _tmp46_ = vala_property_get_property_type (_tmp45_);
4843 _tmp47_ = _tmp46_;
4844 _tmp48_ = _vala_code_node_ref0 (_tmp47_);
4845 _vala_code_node_unref0 (member_type);
4846 member_type = _tmp48_;
4847 _tmp50_ = prop;
4848 _tmp51_ = vala_property_get_set_accessor (_tmp50_);
4849 _tmp52_ = _tmp51_;
4850 if (_tmp52_ == NULL) {
4851 _tmp49_ = TRUE;
4852 } else {
4853 ValaProperty* _tmp53_;
4854 ValaPropertyAccessor* _tmp54_;
4855 ValaPropertyAccessor* _tmp55_;
4856 gboolean _tmp56_;
4857 gboolean _tmp57_;
4858 _tmp53_ = prop;
4859 _tmp54_ = vala_property_get_set_accessor (_tmp53_);
4860 _tmp55_ = _tmp54_;
4861 _tmp56_ = vala_property_accessor_get_writable (_tmp55_);
4862 _tmp57_ = _tmp56_;
4863 _tmp49_ = !_tmp57_;
4864 }
4865 if (_tmp49_) {
4866 ValaSourceReference* _tmp58_;
4867 ValaSourceReference* _tmp59_;
4868 ValaProperty* _tmp60_;
4869 gchar* _tmp61_;
4870 gchar* _tmp62_;
4871 gchar* _tmp63_;
4872 gchar* _tmp64_;
4873 vala_code_node_set_error ((ValaCodeNode*) init, TRUE);
4874 _tmp58_ = vala_code_node_get_source_reference ((ValaCodeNode*) init);
4875 _tmp59_ = _tmp58_;
4876 _tmp60_ = prop;
4877 _tmp61_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp60_);
4878 _tmp62_ = _tmp61_;
4879 _tmp63_ = g_strdup_printf ("Property `%s' is read-only", _tmp62_);
4880 _tmp64_ = _tmp63_;
4881 vala_report_error (_tmp59_, _tmp64_);
4882 _g_free0 (_tmp64_);
4883 _g_free0 (_tmp62_);
4884 _vala_code_node_unref0 (member_type);
4885 return;
4886 }
4887 }
4888 }
4889 _tmp65_ = vala_member_initializer_get_initializer (init);
4890 _tmp66_ = _tmp65_;
4891 _tmp67_ = member_type;
4892 vala_expression_set_formal_target_type (_tmp66_, _tmp67_);
4893 _tmp68_ = vala_member_initializer_get_initializer (init);
4894 _tmp69_ = _tmp68_;
4895 _tmp70_ = vala_member_initializer_get_initializer (init);
4896 _tmp71_ = _tmp70_;
4897 _tmp72_ = vala_expression_get_formal_target_type (_tmp71_);
4898 _tmp73_ = _tmp72_;
4899 _tmp74_ = vala_data_type_get_actual_type (_tmp73_, type, NULL, (ValaCodeNode*) init);
4900 _tmp75_ = _tmp74_;
4901 vala_expression_set_target_type (_tmp69_, _tmp75_);
4902 _vala_code_node_unref0 (_tmp75_);
4903 _tmp76_ = self->priv->context;
4904 if (!vala_code_node_check ((ValaCodeNode*) init, _tmp76_)) {
4905 _vala_code_node_unref0 (member_type);
4906 return;
4907 }
4908 _tmp78_ = vala_member_initializer_get_initializer (init);
4909 _tmp79_ = _tmp78_;
4910 _tmp80_ = vala_expression_get_value_type (_tmp79_);
4911 _tmp81_ = _tmp80_;
4912 if (_tmp81_ == NULL) {
4913 _tmp77_ = TRUE;
4914 } else {
4915 ValaExpression* _tmp82_;
4916 ValaExpression* _tmp83_;
4917 ValaDataType* _tmp84_;
4918 ValaDataType* _tmp85_;
4919 ValaExpression* _tmp86_;
4920 ValaExpression* _tmp87_;
4921 ValaDataType* _tmp88_;
4922 ValaDataType* _tmp89_;
4923 _tmp82_ = vala_member_initializer_get_initializer (init);
4924 _tmp83_ = _tmp82_;
4925 _tmp84_ = vala_expression_get_value_type (_tmp83_);
4926 _tmp85_ = _tmp84_;
4927 _tmp86_ = vala_member_initializer_get_initializer (init);
4928 _tmp87_ = _tmp86_;
4929 _tmp88_ = vala_expression_get_target_type (_tmp87_);
4930 _tmp89_ = _tmp88_;
4931 _tmp77_ = !vala_data_type_compatible (_tmp85_, _tmp89_);
4932 }
4933 if (_tmp77_) {
4934 ValaSourceReference* _tmp90_;
4935 ValaSourceReference* _tmp91_;
4936 const gchar* _tmp92_;
4937 const gchar* _tmp93_;
4938 gchar* _tmp94_;
4939 gchar* _tmp95_;
4940 vala_code_node_set_error ((ValaCodeNode*) init, TRUE);
4941 _tmp90_ = vala_code_node_get_source_reference ((ValaCodeNode*) init);
4942 _tmp91_ = _tmp90_;
4943 _tmp92_ = vala_member_initializer_get_name (init);
4944 _tmp93_ = _tmp92_;
4945 _tmp94_ = g_strdup_printf ("Invalid type for member `%s'", _tmp93_);
4946 _tmp95_ = _tmp94_;
4947 vala_report_error (_tmp91_, _tmp95_);
4948 _g_free0 (_tmp95_);
4949 _vala_code_node_unref0 (member_type);
4950 return;
4951 }
4952 _vala_code_node_unref0 (member_type);
4953 }
4954
4955 static ValaStruct*
vala_semantic_analyzer_get_arithmetic_struct(ValaSemanticAnalyzer * self,ValaDataType * type)4956 vala_semantic_analyzer_get_arithmetic_struct (ValaSemanticAnalyzer* self,
4957 ValaDataType* type)
4958 {
4959 ValaStruct* _result_ = NULL;
4960 ValaTypeSymbol* _tmp0_;
4961 ValaTypeSymbol* _tmp1_;
4962 gboolean _tmp2_ = FALSE;
4963 ValaStruct* _tmp3_;
4964 ValaStruct* _tmp7_;
4965 ValaStruct* result = NULL;
4966 g_return_val_if_fail (self != NULL, NULL);
4967 g_return_val_if_fail (type != NULL, NULL);
4968 _tmp0_ = vala_data_type_get_type_symbol (type);
4969 _tmp1_ = _tmp0_;
4970 _result_ = VALA_IS_STRUCT (_tmp1_) ? ((ValaStruct*) _tmp1_) : NULL;
4971 _tmp3_ = _result_;
4972 if (_tmp3_ == NULL) {
4973 _tmp2_ = VALA_IS_ENUM_VALUE_TYPE (type);
4974 } else {
4975 _tmp2_ = FALSE;
4976 }
4977 if (_tmp2_) {
4978 ValaDataType* _tmp4_;
4979 ValaTypeSymbol* _tmp5_;
4980 ValaTypeSymbol* _tmp6_;
4981 _tmp4_ = self->int_type;
4982 _tmp5_ = vala_data_type_get_type_symbol (_tmp4_);
4983 _tmp6_ = _tmp5_;
4984 result = G_TYPE_CHECK_INSTANCE_CAST (_tmp6_, VALA_TYPE_STRUCT, ValaStruct);
4985 return result;
4986 }
4987 _tmp7_ = _result_;
4988 result = _tmp7_;
4989 return result;
4990 }
4991
4992 ValaDataType*
vala_semantic_analyzer_get_arithmetic_result_type(ValaSemanticAnalyzer * self,ValaDataType * left_type,ValaDataType * right_type)4993 vala_semantic_analyzer_get_arithmetic_result_type (ValaSemanticAnalyzer* self,
4994 ValaDataType* left_type,
4995 ValaDataType* right_type)
4996 {
4997 ValaStruct* left = NULL;
4998 ValaStruct* _tmp0_;
4999 ValaStruct* right = NULL;
5000 ValaStruct* _tmp1_;
5001 gboolean _tmp2_ = FALSE;
5002 ValaStruct* _tmp3_;
5003 gboolean _tmp5_ = FALSE;
5004 gboolean _tmp6_ = FALSE;
5005 ValaStruct* _tmp7_;
5006 ValaStruct* _tmp12_;
5007 ValaStruct* _tmp13_;
5008 ValaDataType* result = NULL;
5009 g_return_val_if_fail (self != NULL, NULL);
5010 g_return_val_if_fail (left_type != NULL, NULL);
5011 g_return_val_if_fail (right_type != NULL, NULL);
5012 _tmp0_ = vala_semantic_analyzer_get_arithmetic_struct (self, left_type);
5013 left = _tmp0_;
5014 _tmp1_ = vala_semantic_analyzer_get_arithmetic_struct (self, right_type);
5015 right = _tmp1_;
5016 _tmp3_ = left;
5017 if (_tmp3_ == NULL) {
5018 _tmp2_ = TRUE;
5019 } else {
5020 ValaStruct* _tmp4_;
5021 _tmp4_ = right;
5022 _tmp2_ = _tmp4_ == NULL;
5023 }
5024 if (_tmp2_) {
5025 result = NULL;
5026 return result;
5027 }
5028 _tmp7_ = left;
5029 if (!vala_struct_is_floating_type (_tmp7_)) {
5030 ValaStruct* _tmp8_;
5031 _tmp8_ = left;
5032 _tmp6_ = !vala_struct_is_integer_type (_tmp8_);
5033 } else {
5034 _tmp6_ = FALSE;
5035 }
5036 if (_tmp6_) {
5037 _tmp5_ = TRUE;
5038 } else {
5039 gboolean _tmp9_ = FALSE;
5040 ValaStruct* _tmp10_;
5041 _tmp10_ = right;
5042 if (!vala_struct_is_floating_type (_tmp10_)) {
5043 ValaStruct* _tmp11_;
5044 _tmp11_ = right;
5045 _tmp9_ = !vala_struct_is_integer_type (_tmp11_);
5046 } else {
5047 _tmp9_ = FALSE;
5048 }
5049 _tmp5_ = _tmp9_;
5050 }
5051 if (_tmp5_) {
5052 result = NULL;
5053 return result;
5054 }
5055 _tmp12_ = left;
5056 _tmp13_ = right;
5057 if (vala_struct_is_floating_type (_tmp12_) == vala_struct_is_floating_type (_tmp13_)) {
5058 ValaStruct* _tmp14_;
5059 gint _tmp15_;
5060 gint _tmp16_;
5061 ValaStruct* _tmp17_;
5062 gint _tmp18_;
5063 gint _tmp19_;
5064 _tmp14_ = left;
5065 _tmp15_ = vala_struct_get_rank (_tmp14_);
5066 _tmp16_ = _tmp15_;
5067 _tmp17_ = right;
5068 _tmp18_ = vala_struct_get_rank (_tmp17_);
5069 _tmp19_ = _tmp18_;
5070 if (_tmp16_ >= _tmp19_) {
5071 result = left_type;
5072 return result;
5073 } else {
5074 result = right_type;
5075 return result;
5076 }
5077 } else {
5078 ValaStruct* _tmp20_;
5079 _tmp20_ = left;
5080 if (vala_struct_is_floating_type (_tmp20_)) {
5081 result = left_type;
5082 return result;
5083 } else {
5084 result = right_type;
5085 return result;
5086 }
5087 }
5088 }
5089
5090 ValaMethod*
vala_semantic_analyzer_find_current_method(ValaSemanticAnalyzer * self)5091 vala_semantic_analyzer_find_current_method (ValaSemanticAnalyzer* self)
5092 {
5093 ValaSymbol* sym = NULL;
5094 ValaSymbol* _tmp0_;
5095 ValaMethod* result = NULL;
5096 g_return_val_if_fail (self != NULL, NULL);
5097 _tmp0_ = self->priv->_current_symbol;
5098 sym = _tmp0_;
5099 while (TRUE) {
5100 ValaSymbol* _tmp1_;
5101 ValaSymbol* _tmp2_;
5102 ValaSymbol* _tmp4_;
5103 ValaSymbol* _tmp5_;
5104 ValaSymbol* _tmp6_;
5105 _tmp1_ = sym;
5106 if (!(_tmp1_ != NULL)) {
5107 break;
5108 }
5109 _tmp2_ = sym;
5110 if (VALA_IS_METHOD (_tmp2_)) {
5111 ValaSymbol* _tmp3_;
5112 _tmp3_ = sym;
5113 result = G_TYPE_CHECK_INSTANCE_CAST (_tmp3_, VALA_TYPE_METHOD, ValaMethod);
5114 return result;
5115 }
5116 _tmp4_ = sym;
5117 _tmp5_ = vala_symbol_get_parent_symbol (_tmp4_);
5118 _tmp6_ = _tmp5_;
5119 sym = _tmp6_;
5120 }
5121 result = NULL;
5122 return result;
5123 }
5124
5125 ValaMethod*
vala_semantic_analyzer_find_parent_method(ValaSymbol * sym)5126 vala_semantic_analyzer_find_parent_method (ValaSymbol* sym)
5127 {
5128 ValaMethod* result = NULL;
5129 g_return_val_if_fail (sym != NULL, NULL);
5130 while (TRUE) {
5131 ValaSymbol* _tmp0_;
5132 ValaSymbol* _tmp1_;
5133 if (!VALA_IS_BLOCK (sym)) {
5134 break;
5135 }
5136 _tmp0_ = vala_symbol_get_parent_symbol (sym);
5137 _tmp1_ = _tmp0_;
5138 sym = _tmp1_;
5139 }
5140 result = VALA_IS_METHOD (sym) ? ((ValaMethod*) sym) : NULL;
5141 return result;
5142 }
5143
5144 ValaSymbol*
vala_semantic_analyzer_find_parent_method_or_property_accessor(ValaSymbol * sym)5145 vala_semantic_analyzer_find_parent_method_or_property_accessor (ValaSymbol* sym)
5146 {
5147 ValaSymbol* result = NULL;
5148 g_return_val_if_fail (sym != NULL, NULL);
5149 while (TRUE) {
5150 ValaSymbol* _tmp0_;
5151 ValaSymbol* _tmp1_;
5152 if (!VALA_IS_BLOCK (sym)) {
5153 break;
5154 }
5155 _tmp0_ = vala_symbol_get_parent_symbol (sym);
5156 _tmp1_ = _tmp0_;
5157 sym = _tmp1_;
5158 }
5159 if (VALA_IS_METHOD (sym)) {
5160 result = sym;
5161 return result;
5162 } else {
5163 if (VALA_IS_PROPERTY_ACCESSOR (sym)) {
5164 result = sym;
5165 return result;
5166 } else {
5167 result = NULL;
5168 return result;
5169 }
5170 }
5171 }
5172
5173 ValaTypeSymbol*
vala_semantic_analyzer_find_parent_type_symbol(ValaSymbol * sym)5174 vala_semantic_analyzer_find_parent_type_symbol (ValaSymbol* sym)
5175 {
5176 ValaTypeSymbol* result = NULL;
5177 g_return_val_if_fail (sym != NULL, NULL);
5178 while (TRUE) {
5179 ValaSymbol* _tmp0_;
5180 ValaSymbol* _tmp1_;
5181 if (!(sym != NULL)) {
5182 break;
5183 }
5184 if (VALA_IS_TYPESYMBOL (sym)) {
5185 result = G_TYPE_CHECK_INSTANCE_CAST (sym, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol);
5186 return result;
5187 }
5188 _tmp0_ = vala_symbol_get_parent_symbol (sym);
5189 _tmp1_ = _tmp0_;
5190 sym = _tmp1_;
5191 }
5192 result = NULL;
5193 return result;
5194 }
5195
5196 ValaDataType*
vala_semantic_analyzer_get_this_type(ValaSymbol * s,ValaTypeSymbol * parent)5197 vala_semantic_analyzer_get_this_type (ValaSymbol* s,
5198 ValaTypeSymbol* parent)
5199 {
5200 ValaTypeSymbol* _tmp0_ = NULL;
5201 ValaTypeSymbol* parent_type = NULL;
5202 ValaTypeSymbol* _tmp2_;
5203 ValaMemberBinding binding = 0;
5204 ValaDataType* this_type = NULL;
5205 ValaList* type_parameters = NULL;
5206 ValaMemberBinding _tmp18_;
5207 ValaList* _tmp57_;
5208 ValaDataType* result = NULL;
5209 g_return_val_if_fail (s != NULL, NULL);
5210 _tmp0_ = parent;
5211 if (_tmp0_ == NULL) {
5212 ValaTypeSymbol* _tmp1_;
5213 _tmp1_ = vala_semantic_analyzer_find_parent_type_symbol (s);
5214 _tmp0_ = _tmp1_;
5215 }
5216 parent_type = _tmp0_;
5217 _tmp2_ = parent_type;
5218 if (_tmp2_ == NULL) {
5219 ValaTypeSymbol* _tmp3_;
5220 ValaSourceReference* _tmp4_;
5221 ValaSourceReference* _tmp5_;
5222 ValaInvalidType* _tmp6_;
5223 _tmp3_ = parent_type;
5224 _tmp4_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp3_);
5225 _tmp5_ = _tmp4_;
5226 vala_report_error (_tmp5_, "internal: Unsupported symbol type");
5227 _tmp6_ = vala_invalid_type_new ();
5228 result = (ValaDataType*) _tmp6_;
5229 return result;
5230 }
5231 if (VALA_IS_METHOD (s)) {
5232 ValaMemberBinding _tmp7_;
5233 ValaMemberBinding _tmp8_;
5234 _tmp7_ = vala_method_get_binding (G_TYPE_CHECK_INSTANCE_CAST (s, VALA_TYPE_METHOD, ValaMethod));
5235 _tmp8_ = _tmp7_;
5236 binding = _tmp8_;
5237 } else {
5238 if (VALA_IS_CONSTRUCTOR (s)) {
5239 ValaMemberBinding _tmp9_;
5240 ValaMemberBinding _tmp10_;
5241 _tmp9_ = vala_constructor_get_binding (G_TYPE_CHECK_INSTANCE_CAST (s, VALA_TYPE_CONSTRUCTOR, ValaConstructor));
5242 _tmp10_ = _tmp9_;
5243 binding = _tmp10_;
5244 } else {
5245 if (VALA_IS_DESTRUCTOR (s)) {
5246 ValaMemberBinding _tmp11_;
5247 ValaMemberBinding _tmp12_;
5248 _tmp11_ = vala_destructor_get_binding (G_TYPE_CHECK_INSTANCE_CAST (s, VALA_TYPE_DESTRUCTOR, ValaDestructor));
5249 _tmp12_ = _tmp11_;
5250 binding = _tmp12_;
5251 } else {
5252 if (VALA_IS_PROPERTY (s)) {
5253 ValaMemberBinding _tmp13_;
5254 ValaMemberBinding _tmp14_;
5255 _tmp13_ = vala_property_get_binding (G_TYPE_CHECK_INSTANCE_CAST (s, VALA_TYPE_PROPERTY, ValaProperty));
5256 _tmp14_ = _tmp13_;
5257 binding = _tmp14_;
5258 } else {
5259 ValaSourceReference* _tmp15_;
5260 ValaSourceReference* _tmp16_;
5261 ValaInvalidType* _tmp17_;
5262 _tmp15_ = vala_code_node_get_source_reference ((ValaCodeNode*) s);
5263 _tmp16_ = _tmp15_;
5264 vala_report_error (_tmp16_, "internal: Unsupported symbol type");
5265 _tmp17_ = vala_invalid_type_new ();
5266 result = (ValaDataType*) _tmp17_;
5267 return result;
5268 }
5269 }
5270 }
5271 }
5272 this_type = NULL;
5273 type_parameters = NULL;
5274 _tmp18_ = binding;
5275 switch (_tmp18_) {
5276 case VALA_MEMBER_BINDING_INSTANCE:
5277 {
5278 ValaTypeSymbol* _tmp19_;
5279 _tmp19_ = parent_type;
5280 if (VALA_IS_CLASS (_tmp19_)) {
5281 ValaTypeSymbol* _tmp20_;
5282 ValaObjectType* _tmp21_;
5283 ValaTypeSymbol* _tmp22_;
5284 ValaList* _tmp23_;
5285 ValaList* _tmp24_;
5286 _tmp20_ = parent_type;
5287 _tmp21_ = vala_object_type_new ((ValaObjectTypeSymbol*) G_TYPE_CHECK_INSTANCE_CAST (_tmp20_, VALA_TYPE_CLASS, ValaClass));
5288 _vala_code_node_unref0 (this_type);
5289 this_type = (ValaDataType*) _tmp21_;
5290 _tmp22_ = parent_type;
5291 _tmp23_ = vala_object_type_symbol_get_type_parameters ((ValaObjectTypeSymbol*) G_TYPE_CHECK_INSTANCE_CAST (_tmp22_, VALA_TYPE_CLASS, ValaClass));
5292 _tmp24_ = _vala_iterable_ref0 (_tmp23_);
5293 _vala_iterable_unref0 (type_parameters);
5294 type_parameters = _tmp24_;
5295 } else {
5296 ValaTypeSymbol* _tmp25_;
5297 _tmp25_ = parent_type;
5298 if (VALA_IS_INTERFACE (_tmp25_)) {
5299 ValaTypeSymbol* _tmp26_;
5300 ValaObjectType* _tmp27_;
5301 ValaTypeSymbol* _tmp28_;
5302 ValaList* _tmp29_;
5303 ValaList* _tmp30_;
5304 _tmp26_ = parent_type;
5305 _tmp27_ = vala_object_type_new ((ValaObjectTypeSymbol*) G_TYPE_CHECK_INSTANCE_CAST (_tmp26_, VALA_TYPE_INTERFACE, ValaInterface));
5306 _vala_code_node_unref0 (this_type);
5307 this_type = (ValaDataType*) _tmp27_;
5308 _tmp28_ = parent_type;
5309 _tmp29_ = vala_object_type_symbol_get_type_parameters ((ValaObjectTypeSymbol*) G_TYPE_CHECK_INSTANCE_CAST (_tmp28_, VALA_TYPE_INTERFACE, ValaInterface));
5310 _tmp30_ = _vala_iterable_ref0 (_tmp29_);
5311 _vala_iterable_unref0 (type_parameters);
5312 type_parameters = _tmp30_;
5313 } else {
5314 ValaTypeSymbol* _tmp31_;
5315 _tmp31_ = parent_type;
5316 if (VALA_IS_STRUCT (_tmp31_)) {
5317 ValaTypeSymbol* _tmp32_;
5318 ValaStructValueType* _tmp33_;
5319 ValaTypeSymbol* _tmp34_;
5320 ValaList* _tmp35_;
5321 ValaList* _tmp36_;
5322 _tmp32_ = parent_type;
5323 _tmp33_ = vala_struct_value_type_new (G_TYPE_CHECK_INSTANCE_CAST (_tmp32_, VALA_TYPE_STRUCT, ValaStruct));
5324 _vala_code_node_unref0 (this_type);
5325 this_type = (ValaDataType*) _tmp33_;
5326 _tmp34_ = parent_type;
5327 _tmp35_ = vala_struct_get_type_parameters (G_TYPE_CHECK_INSTANCE_CAST (_tmp34_, VALA_TYPE_STRUCT, ValaStruct));
5328 _tmp36_ = _vala_iterable_ref0 (_tmp35_);
5329 _vala_iterable_unref0 (type_parameters);
5330 type_parameters = _tmp36_;
5331 } else {
5332 ValaTypeSymbol* _tmp37_;
5333 _tmp37_ = parent_type;
5334 if (VALA_IS_ENUM (_tmp37_)) {
5335 ValaTypeSymbol* _tmp38_;
5336 ValaEnumValueType* _tmp39_;
5337 _tmp38_ = parent_type;
5338 _tmp39_ = vala_enum_value_type_new (G_TYPE_CHECK_INSTANCE_CAST (_tmp38_, VALA_TYPE_ENUM, ValaEnum));
5339 _vala_code_node_unref0 (this_type);
5340 this_type = (ValaDataType*) _tmp39_;
5341 } else {
5342 ValaTypeSymbol* _tmp40_;
5343 ValaSourceReference* _tmp41_;
5344 ValaSourceReference* _tmp42_;
5345 ValaInvalidType* _tmp43_;
5346 _tmp40_ = parent_type;
5347 _tmp41_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp40_);
5348 _tmp42_ = _tmp41_;
5349 vala_report_error (_tmp42_, "internal: Unsupported symbol type");
5350 _tmp43_ = vala_invalid_type_new ();
5351 _vala_code_node_unref0 (this_type);
5352 this_type = (ValaDataType*) _tmp43_;
5353 }
5354 }
5355 }
5356 }
5357 break;
5358 }
5359 case VALA_MEMBER_BINDING_CLASS:
5360 {
5361 ValaTypeSymbol* _tmp44_;
5362 _tmp44_ = parent_type;
5363 if (VALA_IS_CLASS (_tmp44_)) {
5364 ValaTypeSymbol* _tmp45_;
5365 ValaClassType* _tmp46_;
5366 _tmp45_ = parent_type;
5367 _tmp46_ = vala_class_type_new (G_TYPE_CHECK_INSTANCE_CAST (_tmp45_, VALA_TYPE_CLASS, ValaClass));
5368 _vala_code_node_unref0 (this_type);
5369 this_type = (ValaDataType*) _tmp46_;
5370 } else {
5371 ValaTypeSymbol* _tmp47_;
5372 _tmp47_ = parent_type;
5373 if (VALA_IS_INTERFACE (_tmp47_)) {
5374 ValaTypeSymbol* _tmp48_;
5375 ValaInterfaceType* _tmp49_;
5376 _tmp48_ = parent_type;
5377 _tmp49_ = vala_interface_type_new (G_TYPE_CHECK_INSTANCE_CAST (_tmp48_, VALA_TYPE_INTERFACE, ValaInterface));
5378 _vala_code_node_unref0 (this_type);
5379 this_type = (ValaDataType*) _tmp49_;
5380 } else {
5381 ValaTypeSymbol* _tmp50_;
5382 ValaSourceReference* _tmp51_;
5383 ValaSourceReference* _tmp52_;
5384 ValaInvalidType* _tmp53_;
5385 _tmp50_ = parent_type;
5386 _tmp51_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp50_);
5387 _tmp52_ = _tmp51_;
5388 vala_report_error (_tmp52_, "internal: Unsupported symbol type");
5389 _tmp53_ = vala_invalid_type_new ();
5390 _vala_code_node_unref0 (this_type);
5391 this_type = (ValaDataType*) _tmp53_;
5392 }
5393 }
5394 break;
5395 }
5396 default:
5397 case VALA_MEMBER_BINDING_STATIC:
5398 {
5399 ValaSourceReference* _tmp54_;
5400 ValaSourceReference* _tmp55_;
5401 ValaInvalidType* _tmp56_;
5402 _tmp54_ = vala_code_node_get_source_reference ((ValaCodeNode*) s);
5403 _tmp55_ = _tmp54_;
5404 vala_report_error (_tmp55_, "internal: Does not support a parent instance");
5405 _tmp56_ = vala_invalid_type_new ();
5406 _vala_code_node_unref0 (this_type);
5407 this_type = (ValaDataType*) _tmp56_;
5408 break;
5409 }
5410 }
5411 _tmp57_ = type_parameters;
5412 if (_tmp57_ != NULL) {
5413 {
5414 ValaList* _type_param_list = NULL;
5415 ValaList* _tmp58_;
5416 ValaList* _tmp59_;
5417 gint _type_param_size = 0;
5418 ValaList* _tmp60_;
5419 gint _tmp61_;
5420 gint _tmp62_;
5421 gint _type_param_index = 0;
5422 _tmp58_ = type_parameters;
5423 _tmp59_ = _vala_iterable_ref0 (_tmp58_);
5424 _type_param_list = _tmp59_;
5425 _tmp60_ = _type_param_list;
5426 _tmp61_ = vala_collection_get_size ((ValaCollection*) _tmp60_);
5427 _tmp62_ = _tmp61_;
5428 _type_param_size = _tmp62_;
5429 _type_param_index = -1;
5430 while (TRUE) {
5431 gint _tmp63_;
5432 gint _tmp64_;
5433 ValaTypeParameter* type_param = NULL;
5434 ValaList* _tmp65_;
5435 gpointer _tmp66_;
5436 ValaGenericType* type_arg = NULL;
5437 ValaTypeParameter* _tmp67_;
5438 ValaGenericType* _tmp68_;
5439 ValaGenericType* _tmp69_;
5440 ValaDataType* _tmp70_;
5441 ValaGenericType* _tmp71_;
5442 _type_param_index = _type_param_index + 1;
5443 _tmp63_ = _type_param_index;
5444 _tmp64_ = _type_param_size;
5445 if (!(_tmp63_ < _tmp64_)) {
5446 break;
5447 }
5448 _tmp65_ = _type_param_list;
5449 _tmp66_ = vala_list_get (_tmp65_, _type_param_index);
5450 type_param = (ValaTypeParameter*) _tmp66_;
5451 _tmp67_ = type_param;
5452 _tmp68_ = vala_generic_type_new (_tmp67_);
5453 type_arg = _tmp68_;
5454 _tmp69_ = type_arg;
5455 vala_data_type_set_value_owned ((ValaDataType*) _tmp69_, TRUE);
5456 _tmp70_ = this_type;
5457 _tmp71_ = type_arg;
5458 vala_data_type_add_type_argument (_tmp70_, (ValaDataType*) _tmp71_);
5459 _vala_code_node_unref0 (type_arg);
5460 _vala_code_node_unref0 (type_param);
5461 }
5462 _vala_iterable_unref0 (_type_param_list);
5463 }
5464 }
5465 result = this_type;
5466 _vala_iterable_unref0 (type_parameters);
5467 return result;
5468 }
5469
5470 gboolean
vala_semantic_analyzer_is_in_constructor(ValaSemanticAnalyzer * self)5471 vala_semantic_analyzer_is_in_constructor (ValaSemanticAnalyzer* self)
5472 {
5473 ValaSymbol* sym = NULL;
5474 ValaSymbol* _tmp0_;
5475 gboolean result = FALSE;
5476 g_return_val_if_fail (self != NULL, FALSE);
5477 _tmp0_ = self->priv->_current_symbol;
5478 sym = _tmp0_;
5479 while (TRUE) {
5480 ValaSymbol* _tmp1_;
5481 ValaSymbol* _tmp2_;
5482 ValaSymbol* _tmp3_;
5483 ValaSymbol* _tmp4_;
5484 ValaSymbol* _tmp5_;
5485 _tmp1_ = sym;
5486 if (!(_tmp1_ != NULL)) {
5487 break;
5488 }
5489 _tmp2_ = sym;
5490 if (VALA_IS_CONSTRUCTOR (_tmp2_)) {
5491 result = TRUE;
5492 return result;
5493 }
5494 _tmp3_ = sym;
5495 _tmp4_ = vala_symbol_get_parent_symbol (_tmp3_);
5496 _tmp5_ = _tmp4_;
5497 sym = _tmp5_;
5498 }
5499 result = FALSE;
5500 return result;
5501 }
5502
5503 gboolean
vala_semantic_analyzer_is_in_destructor(ValaSemanticAnalyzer * self)5504 vala_semantic_analyzer_is_in_destructor (ValaSemanticAnalyzer* self)
5505 {
5506 ValaSymbol* sym = NULL;
5507 ValaSymbol* _tmp0_;
5508 gboolean result = FALSE;
5509 g_return_val_if_fail (self != NULL, FALSE);
5510 _tmp0_ = self->priv->_current_symbol;
5511 sym = _tmp0_;
5512 while (TRUE) {
5513 ValaSymbol* _tmp1_;
5514 ValaSymbol* _tmp2_;
5515 ValaSymbol* _tmp3_;
5516 ValaSymbol* _tmp4_;
5517 ValaSymbol* _tmp5_;
5518 _tmp1_ = sym;
5519 if (!(_tmp1_ != NULL)) {
5520 break;
5521 }
5522 _tmp2_ = sym;
5523 if (VALA_IS_DESTRUCTOR (_tmp2_)) {
5524 result = TRUE;
5525 return result;
5526 }
5527 _tmp3_ = sym;
5528 _tmp4_ = vala_symbol_get_parent_symbol (_tmp3_);
5529 _tmp5_ = _tmp4_;
5530 sym = _tmp5_;
5531 }
5532 result = FALSE;
5533 return result;
5534 }
5535
5536 gboolean
vala_semantic_analyzer_is_reference_type_argument(ValaSemanticAnalyzer * self,ValaDataType * type_arg)5537 vala_semantic_analyzer_is_reference_type_argument (ValaSemanticAnalyzer* self,
5538 ValaDataType* type_arg)
5539 {
5540 gboolean _tmp0_ = FALSE;
5541 gboolean result = FALSE;
5542 g_return_val_if_fail (self != NULL, FALSE);
5543 g_return_val_if_fail (type_arg != NULL, FALSE);
5544 if (VALA_IS_ERROR_TYPE (type_arg)) {
5545 _tmp0_ = TRUE;
5546 } else {
5547 gboolean _tmp1_ = FALSE;
5548 ValaTypeSymbol* _tmp2_;
5549 ValaTypeSymbol* _tmp3_;
5550 _tmp2_ = vala_data_type_get_type_symbol (type_arg);
5551 _tmp3_ = _tmp2_;
5552 if (_tmp3_ != NULL) {
5553 ValaTypeSymbol* _tmp4_;
5554 ValaTypeSymbol* _tmp5_;
5555 _tmp4_ = vala_data_type_get_type_symbol (type_arg);
5556 _tmp5_ = _tmp4_;
5557 _tmp1_ = vala_typesymbol_is_reference_type (_tmp5_);
5558 } else {
5559 _tmp1_ = FALSE;
5560 }
5561 _tmp0_ = _tmp1_;
5562 }
5563 if (_tmp0_) {
5564 result = TRUE;
5565 return result;
5566 } else {
5567 result = FALSE;
5568 return result;
5569 }
5570 }
5571
5572 gboolean
vala_semantic_analyzer_is_nullable_value_type_argument(ValaSemanticAnalyzer * self,ValaDataType * type_arg)5573 vala_semantic_analyzer_is_nullable_value_type_argument (ValaSemanticAnalyzer* self,
5574 ValaDataType* type_arg)
5575 {
5576 gboolean _tmp0_ = FALSE;
5577 gboolean result = FALSE;
5578 g_return_val_if_fail (self != NULL, FALSE);
5579 g_return_val_if_fail (type_arg != NULL, FALSE);
5580 if (VALA_IS_VALUE_TYPE (type_arg)) {
5581 gboolean _tmp1_;
5582 gboolean _tmp2_;
5583 _tmp1_ = vala_data_type_get_nullable (type_arg);
5584 _tmp2_ = _tmp1_;
5585 _tmp0_ = _tmp2_;
5586 } else {
5587 _tmp0_ = FALSE;
5588 }
5589 if (_tmp0_) {
5590 result = TRUE;
5591 return result;
5592 } else {
5593 result = FALSE;
5594 return result;
5595 }
5596 }
5597
5598 gboolean
vala_semantic_analyzer_is_signed_integer_type_argument(ValaSemanticAnalyzer * self,ValaDataType * type_arg)5599 vala_semantic_analyzer_is_signed_integer_type_argument (ValaSemanticAnalyzer* self,
5600 ValaDataType* type_arg)
5601 {
5602 ValaStruct* st = NULL;
5603 ValaTypeSymbol* _tmp0_;
5604 ValaTypeSymbol* _tmp1_;
5605 gboolean result = FALSE;
5606 g_return_val_if_fail (self != NULL, FALSE);
5607 g_return_val_if_fail (type_arg != NULL, FALSE);
5608 _tmp0_ = vala_data_type_get_type_symbol (type_arg);
5609 _tmp1_ = _tmp0_;
5610 st = VALA_IS_STRUCT (_tmp1_) ? ((ValaStruct*) _tmp1_) : NULL;
5611 if (VALA_IS_ENUM_VALUE_TYPE (type_arg)) {
5612 result = TRUE;
5613 return result;
5614 } else {
5615 gboolean _tmp2_;
5616 gboolean _tmp3_;
5617 _tmp2_ = vala_data_type_get_nullable (type_arg);
5618 _tmp3_ = _tmp2_;
5619 if (_tmp3_) {
5620 result = FALSE;
5621 return result;
5622 } else {
5623 ValaStruct* _tmp4_;
5624 _tmp4_ = st;
5625 if (_tmp4_ == NULL) {
5626 result = FALSE;
5627 return result;
5628 } else {
5629 ValaStruct* _tmp5_;
5630 ValaDataType* _tmp6_;
5631 ValaTypeSymbol* _tmp7_;
5632 ValaTypeSymbol* _tmp8_;
5633 _tmp5_ = st;
5634 _tmp6_ = self->bool_type;
5635 _tmp7_ = vala_data_type_get_type_symbol (_tmp6_);
5636 _tmp8_ = _tmp7_;
5637 if (vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp5_, _tmp8_)) {
5638 result = TRUE;
5639 return result;
5640 } else {
5641 ValaStruct* _tmp9_;
5642 ValaDataType* _tmp10_;
5643 ValaTypeSymbol* _tmp11_;
5644 ValaTypeSymbol* _tmp12_;
5645 _tmp9_ = st;
5646 _tmp10_ = self->char_type;
5647 _tmp11_ = vala_data_type_get_type_symbol (_tmp10_);
5648 _tmp12_ = _tmp11_;
5649 if (vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp9_, _tmp12_)) {
5650 result = TRUE;
5651 return result;
5652 } else {
5653 gboolean _tmp13_ = FALSE;
5654 ValaDataType* _tmp14_;
5655 _tmp14_ = self->unichar_type;
5656 if (_tmp14_ != NULL) {
5657 ValaStruct* _tmp15_;
5658 ValaDataType* _tmp16_;
5659 ValaTypeSymbol* _tmp17_;
5660 ValaTypeSymbol* _tmp18_;
5661 _tmp15_ = st;
5662 _tmp16_ = self->unichar_type;
5663 _tmp17_ = vala_data_type_get_type_symbol (_tmp16_);
5664 _tmp18_ = _tmp17_;
5665 _tmp13_ = vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp15_, _tmp18_);
5666 } else {
5667 _tmp13_ = FALSE;
5668 }
5669 if (_tmp13_) {
5670 result = TRUE;
5671 return result;
5672 } else {
5673 ValaStruct* _tmp19_;
5674 ValaDataType* _tmp20_;
5675 ValaTypeSymbol* _tmp21_;
5676 ValaTypeSymbol* _tmp22_;
5677 _tmp19_ = st;
5678 _tmp20_ = self->short_type;
5679 _tmp21_ = vala_data_type_get_type_symbol (_tmp20_);
5680 _tmp22_ = _tmp21_;
5681 if (vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp19_, _tmp22_)) {
5682 result = TRUE;
5683 return result;
5684 } else {
5685 ValaStruct* _tmp23_;
5686 ValaDataType* _tmp24_;
5687 ValaTypeSymbol* _tmp25_;
5688 ValaTypeSymbol* _tmp26_;
5689 _tmp23_ = st;
5690 _tmp24_ = self->int_type;
5691 _tmp25_ = vala_data_type_get_type_symbol (_tmp24_);
5692 _tmp26_ = _tmp25_;
5693 if (vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp23_, _tmp26_)) {
5694 result = TRUE;
5695 return result;
5696 } else {
5697 ValaStruct* _tmp27_;
5698 ValaDataType* _tmp28_;
5699 ValaTypeSymbol* _tmp29_;
5700 ValaTypeSymbol* _tmp30_;
5701 _tmp27_ = st;
5702 _tmp28_ = self->long_type;
5703 _tmp29_ = vala_data_type_get_type_symbol (_tmp28_);
5704 _tmp30_ = _tmp29_;
5705 if (vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp27_, _tmp30_)) {
5706 result = TRUE;
5707 return result;
5708 } else {
5709 ValaStruct* _tmp31_;
5710 ValaDataType* _tmp32_;
5711 ValaTypeSymbol* _tmp33_;
5712 ValaTypeSymbol* _tmp34_;
5713 _tmp31_ = st;
5714 _tmp32_ = self->int8_type;
5715 _tmp33_ = vala_data_type_get_type_symbol (_tmp32_);
5716 _tmp34_ = _tmp33_;
5717 if (vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp31_, _tmp34_)) {
5718 result = TRUE;
5719 return result;
5720 } else {
5721 ValaStruct* _tmp35_;
5722 ValaDataType* _tmp36_;
5723 ValaTypeSymbol* _tmp37_;
5724 ValaTypeSymbol* _tmp38_;
5725 _tmp35_ = st;
5726 _tmp36_ = self->int16_type;
5727 _tmp37_ = vala_data_type_get_type_symbol (_tmp36_);
5728 _tmp38_ = _tmp37_;
5729 if (vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp35_, _tmp38_)) {
5730 result = TRUE;
5731 return result;
5732 } else {
5733 ValaStruct* _tmp39_;
5734 ValaDataType* _tmp40_;
5735 ValaTypeSymbol* _tmp41_;
5736 ValaTypeSymbol* _tmp42_;
5737 _tmp39_ = st;
5738 _tmp40_ = self->int32_type;
5739 _tmp41_ = vala_data_type_get_type_symbol (_tmp40_);
5740 _tmp42_ = _tmp41_;
5741 if (vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp39_, _tmp42_)) {
5742 result = TRUE;
5743 return result;
5744 } else {
5745 ValaStruct* _tmp43_;
5746 ValaDataType* _tmp44_;
5747 ValaTypeSymbol* _tmp45_;
5748 ValaTypeSymbol* _tmp46_;
5749 _tmp43_ = st;
5750 _tmp44_ = self->type_type;
5751 _tmp45_ = vala_data_type_get_type_symbol (_tmp44_);
5752 _tmp46_ = _tmp45_;
5753 if (vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp43_, _tmp46_)) {
5754 result = TRUE;
5755 return result;
5756 } else {
5757 result = FALSE;
5758 return result;
5759 }
5760 }
5761 }
5762 }
5763 }
5764 }
5765 }
5766 }
5767 }
5768 }
5769 }
5770 }
5771 }
5772 }
5773
5774 gboolean
vala_semantic_analyzer_is_unsigned_integer_type_argument(ValaSemanticAnalyzer * self,ValaDataType * type_arg)5775 vala_semantic_analyzer_is_unsigned_integer_type_argument (ValaSemanticAnalyzer* self,
5776 ValaDataType* type_arg)
5777 {
5778 ValaStruct* st = NULL;
5779 ValaTypeSymbol* _tmp0_;
5780 ValaTypeSymbol* _tmp1_;
5781 ValaStruct* _tmp2_;
5782 gboolean result = FALSE;
5783 g_return_val_if_fail (self != NULL, FALSE);
5784 g_return_val_if_fail (type_arg != NULL, FALSE);
5785 _tmp0_ = vala_data_type_get_type_symbol (type_arg);
5786 _tmp1_ = _tmp0_;
5787 st = VALA_IS_STRUCT (_tmp1_) ? ((ValaStruct*) _tmp1_) : NULL;
5788 _tmp2_ = st;
5789 if (_tmp2_ == NULL) {
5790 result = FALSE;
5791 return result;
5792 } else {
5793 gboolean _tmp3_;
5794 gboolean _tmp4_;
5795 _tmp3_ = vala_data_type_get_nullable (type_arg);
5796 _tmp4_ = _tmp3_;
5797 if (_tmp4_) {
5798 result = FALSE;
5799 return result;
5800 } else {
5801 ValaStruct* _tmp5_;
5802 ValaDataType* _tmp6_;
5803 ValaTypeSymbol* _tmp7_;
5804 ValaTypeSymbol* _tmp8_;
5805 _tmp5_ = st;
5806 _tmp6_ = self->uchar_type;
5807 _tmp7_ = vala_data_type_get_type_symbol (_tmp6_);
5808 _tmp8_ = _tmp7_;
5809 if (vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp5_, _tmp8_)) {
5810 result = TRUE;
5811 return result;
5812 } else {
5813 ValaStruct* _tmp9_;
5814 ValaDataType* _tmp10_;
5815 ValaTypeSymbol* _tmp11_;
5816 ValaTypeSymbol* _tmp12_;
5817 _tmp9_ = st;
5818 _tmp10_ = self->ushort_type;
5819 _tmp11_ = vala_data_type_get_type_symbol (_tmp10_);
5820 _tmp12_ = _tmp11_;
5821 if (vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp9_, _tmp12_)) {
5822 result = TRUE;
5823 return result;
5824 } else {
5825 ValaStruct* _tmp13_;
5826 ValaDataType* _tmp14_;
5827 ValaTypeSymbol* _tmp15_;
5828 ValaTypeSymbol* _tmp16_;
5829 _tmp13_ = st;
5830 _tmp14_ = self->uint_type;
5831 _tmp15_ = vala_data_type_get_type_symbol (_tmp14_);
5832 _tmp16_ = _tmp15_;
5833 if (vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp13_, _tmp16_)) {
5834 result = TRUE;
5835 return result;
5836 } else {
5837 ValaStruct* _tmp17_;
5838 ValaDataType* _tmp18_;
5839 ValaTypeSymbol* _tmp19_;
5840 ValaTypeSymbol* _tmp20_;
5841 _tmp17_ = st;
5842 _tmp18_ = self->ulong_type;
5843 _tmp19_ = vala_data_type_get_type_symbol (_tmp18_);
5844 _tmp20_ = _tmp19_;
5845 if (vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp17_, _tmp20_)) {
5846 result = TRUE;
5847 return result;
5848 } else {
5849 ValaStruct* _tmp21_;
5850 ValaDataType* _tmp22_;
5851 ValaTypeSymbol* _tmp23_;
5852 ValaTypeSymbol* _tmp24_;
5853 _tmp21_ = st;
5854 _tmp22_ = self->uint8_type;
5855 _tmp23_ = vala_data_type_get_type_symbol (_tmp22_);
5856 _tmp24_ = _tmp23_;
5857 if (vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp21_, _tmp24_)) {
5858 result = TRUE;
5859 return result;
5860 } else {
5861 ValaStruct* _tmp25_;
5862 ValaDataType* _tmp26_;
5863 ValaTypeSymbol* _tmp27_;
5864 ValaTypeSymbol* _tmp28_;
5865 _tmp25_ = st;
5866 _tmp26_ = self->uint16_type;
5867 _tmp27_ = vala_data_type_get_type_symbol (_tmp26_);
5868 _tmp28_ = _tmp27_;
5869 if (vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp25_, _tmp28_)) {
5870 result = TRUE;
5871 return result;
5872 } else {
5873 ValaStruct* _tmp29_;
5874 ValaDataType* _tmp30_;
5875 ValaTypeSymbol* _tmp31_;
5876 ValaTypeSymbol* _tmp32_;
5877 _tmp29_ = st;
5878 _tmp30_ = self->uint32_type;
5879 _tmp31_ = vala_data_type_get_type_symbol (_tmp30_);
5880 _tmp32_ = _tmp31_;
5881 if (vala_typesymbol_is_subtype_of ((ValaTypeSymbol*) _tmp29_, _tmp32_)) {
5882 result = TRUE;
5883 return result;
5884 } else {
5885 result = FALSE;
5886 return result;
5887 }
5888 }
5889 }
5890 }
5891 }
5892 }
5893 }
5894 }
5895 }
5896 }
5897
5898 void
vala_semantic_analyzer_check_type(ValaSemanticAnalyzer * self,ValaDataType * type)5899 vala_semantic_analyzer_check_type (ValaSemanticAnalyzer* self,
5900 ValaDataType* type)
5901 {
5902 g_return_if_fail (self != NULL);
5903 g_return_if_fail (type != NULL);
5904 {
5905 ValaList* _type_arg_list = NULL;
5906 ValaList* _tmp0_;
5907 ValaList* _tmp1_;
5908 gint _type_arg_size = 0;
5909 ValaList* _tmp2_;
5910 gint _tmp3_;
5911 gint _tmp4_;
5912 gint _type_arg_index = 0;
5913 _tmp0_ = vala_data_type_get_type_arguments (type);
5914 _tmp1_ = _vala_iterable_ref0 (_tmp0_);
5915 _type_arg_list = _tmp1_;
5916 _tmp2_ = _type_arg_list;
5917 _tmp3_ = vala_collection_get_size ((ValaCollection*) _tmp2_);
5918 _tmp4_ = _tmp3_;
5919 _type_arg_size = _tmp4_;
5920 _type_arg_index = -1;
5921 while (TRUE) {
5922 gint _tmp5_;
5923 gint _tmp6_;
5924 ValaDataType* type_arg = NULL;
5925 ValaList* _tmp7_;
5926 gpointer _tmp8_;
5927 ValaDataType* _tmp9_;
5928 ValaDataType* _tmp10_;
5929 _type_arg_index = _type_arg_index + 1;
5930 _tmp5_ = _type_arg_index;
5931 _tmp6_ = _type_arg_size;
5932 if (!(_tmp5_ < _tmp6_)) {
5933 break;
5934 }
5935 _tmp7_ = _type_arg_list;
5936 _tmp8_ = vala_list_get (_tmp7_, _type_arg_index);
5937 type_arg = (ValaDataType*) _tmp8_;
5938 _tmp9_ = type_arg;
5939 vala_semantic_analyzer_check_type (self, _tmp9_);
5940 _tmp10_ = type_arg;
5941 vala_semantic_analyzer_check_type_argument (self, _tmp10_);
5942 _vala_code_node_unref0 (type_arg);
5943 }
5944 _vala_iterable_unref0 (_type_arg_list);
5945 }
5946 }
5947
5948 void
vala_semantic_analyzer_check_type_arguments(ValaSemanticAnalyzer * self,ValaMemberAccess * access)5949 vala_semantic_analyzer_check_type_arguments (ValaSemanticAnalyzer* self,
5950 ValaMemberAccess* access)
5951 {
5952 g_return_if_fail (self != NULL);
5953 g_return_if_fail (access != NULL);
5954 {
5955 ValaList* _type_arg_list = NULL;
5956 ValaList* _tmp0_;
5957 ValaList* _tmp1_;
5958 gint _type_arg_size = 0;
5959 ValaList* _tmp2_;
5960 gint _tmp3_;
5961 gint _tmp4_;
5962 gint _type_arg_index = 0;
5963 _tmp0_ = vala_member_access_get_type_arguments (access);
5964 _tmp1_ = _vala_iterable_ref0 (_tmp0_);
5965 _type_arg_list = _tmp1_;
5966 _tmp2_ = _type_arg_list;
5967 _tmp3_ = vala_collection_get_size ((ValaCollection*) _tmp2_);
5968 _tmp4_ = _tmp3_;
5969 _type_arg_size = _tmp4_;
5970 _type_arg_index = -1;
5971 while (TRUE) {
5972 gint _tmp5_;
5973 gint _tmp6_;
5974 ValaDataType* type_arg = NULL;
5975 ValaList* _tmp7_;
5976 gpointer _tmp8_;
5977 ValaDataType* _tmp9_;
5978 ValaDataType* _tmp10_;
5979 _type_arg_index = _type_arg_index + 1;
5980 _tmp5_ = _type_arg_index;
5981 _tmp6_ = _type_arg_size;
5982 if (!(_tmp5_ < _tmp6_)) {
5983 break;
5984 }
5985 _tmp7_ = _type_arg_list;
5986 _tmp8_ = vala_list_get (_tmp7_, _type_arg_index);
5987 type_arg = (ValaDataType*) _tmp8_;
5988 _tmp9_ = type_arg;
5989 vala_semantic_analyzer_check_type (self, _tmp9_);
5990 _tmp10_ = type_arg;
5991 vala_semantic_analyzer_check_type_argument (self, _tmp10_);
5992 _vala_code_node_unref0 (type_arg);
5993 }
5994 _vala_iterable_unref0 (_type_arg_list);
5995 }
5996 }
5997
5998 static void
vala_semantic_analyzer_check_type_argument(ValaSemanticAnalyzer * self,ValaDataType * type_arg)5999 vala_semantic_analyzer_check_type_argument (ValaSemanticAnalyzer* self,
6000 ValaDataType* type_arg)
6001 {
6002 gboolean _tmp0_ = FALSE;
6003 gboolean _tmp1_ = FALSE;
6004 gboolean _tmp2_ = FALSE;
6005 gboolean _tmp3_ = FALSE;
6006 gboolean _tmp4_ = FALSE;
6007 gboolean _tmp5_ = FALSE;
6008 g_return_if_fail (self != NULL);
6009 g_return_if_fail (type_arg != NULL);
6010 if (VALA_IS_GENERIC_TYPE (type_arg)) {
6011 _tmp5_ = TRUE;
6012 } else {
6013 _tmp5_ = VALA_IS_POINTER_TYPE (type_arg);
6014 }
6015 if (_tmp5_) {
6016 _tmp4_ = TRUE;
6017 } else {
6018 _tmp4_ = VALA_IS_VOID_TYPE (type_arg);
6019 }
6020 if (_tmp4_) {
6021 _tmp3_ = TRUE;
6022 } else {
6023 _tmp3_ = vala_semantic_analyzer_is_reference_type_argument (self, type_arg);
6024 }
6025 if (_tmp3_) {
6026 _tmp2_ = TRUE;
6027 } else {
6028 _tmp2_ = vala_semantic_analyzer_is_nullable_value_type_argument (self, type_arg);
6029 }
6030 if (_tmp2_) {
6031 _tmp1_ = TRUE;
6032 } else {
6033 _tmp1_ = vala_semantic_analyzer_is_signed_integer_type_argument (self, type_arg);
6034 }
6035 if (_tmp1_) {
6036 _tmp0_ = TRUE;
6037 } else {
6038 _tmp0_ = vala_semantic_analyzer_is_unsigned_integer_type_argument (self, type_arg);
6039 }
6040 if (_tmp0_) {
6041 } else {
6042 if (VALA_IS_DELEGATE_TYPE (type_arg)) {
6043 ValaDelegateType* delegate_type = NULL;
6044 ValaDelegateType* _tmp6_;
6045 ValaDelegateType* _tmp7_;
6046 ValaDelegate* _tmp8_;
6047 ValaDelegate* _tmp9_;
6048 gboolean _tmp10_;
6049 gboolean _tmp11_;
6050 _tmp6_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (type_arg, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));
6051 delegate_type = _tmp6_;
6052 _tmp7_ = delegate_type;
6053 _tmp8_ = vala_delegate_type_get_delegate_symbol (_tmp7_);
6054 _tmp9_ = _tmp8_;
6055 _tmp10_ = vala_delegate_get_has_target (_tmp9_);
6056 _tmp11_ = _tmp10_;
6057 if (_tmp11_) {
6058 ValaSourceReference* _tmp12_;
6059 ValaSourceReference* _tmp13_;
6060 _tmp12_ = vala_code_node_get_source_reference ((ValaCodeNode*) type_arg);
6061 _tmp13_ = _tmp12_;
6062 vala_report_error (_tmp13_, "Delegates with target are not supported as generic type arguments");
6063 }
6064 _vala_code_node_unref0 (delegate_type);
6065 } else {
6066 if (VALA_IS_ARRAY_TYPE (type_arg)) {
6067 ValaSourceReference* _tmp14_;
6068 ValaSourceReference* _tmp15_;
6069 _tmp14_ = vala_code_node_get_source_reference ((ValaCodeNode*) type_arg);
6070 _tmp15_ = _tmp14_;
6071 vala_report_error (_tmp15_, "Arrays are not supported as generic type arguments");
6072 } else {
6073 ValaSourceReference* _tmp16_;
6074 ValaSourceReference* _tmp17_;
6075 gchar* _tmp18_;
6076 gchar* _tmp19_;
6077 gchar* _tmp20_;
6078 gchar* _tmp21_;
6079 _tmp16_ = vala_code_node_get_source_reference ((ValaCodeNode*) type_arg);
6080 _tmp17_ = _tmp16_;
6081 _tmp18_ = vala_code_node_to_string ((ValaCodeNode*) type_arg);
6082 _tmp19_ = _tmp18_;
6083 _tmp20_ = g_strdup_printf ("`%s' is not a supported generic type argument, use `?' to box value ty" \
6084 "pes", _tmp19_);
6085 _tmp21_ = _tmp20_;
6086 vala_report_error (_tmp17_, _tmp21_);
6087 _g_free0 (_tmp21_);
6088 _g_free0 (_tmp19_);
6089 }
6090 }
6091 }
6092 }
6093
6094 static void
vala_semantic_analyzer_class_init(ValaSemanticAnalyzerClass * klass,gpointer klass_data)6095 vala_semantic_analyzer_class_init (ValaSemanticAnalyzerClass * klass,
6096 gpointer klass_data)
6097 {
6098 vala_semantic_analyzer_parent_class = g_type_class_peek_parent (klass);
6099 ((ValaCodeVisitorClass *) klass)->finalize = vala_semantic_analyzer_finalize;
6100 g_type_class_adjust_private_offset (klass, &ValaSemanticAnalyzer_private_offset);
6101 ((ValaCodeVisitorClass *) klass)->visit_source_file = (void (*) (ValaCodeVisitor*, ValaSourceFile*)) vala_semantic_analyzer_real_visit_source_file;
6102 }
6103
6104 static void
vala_semantic_analyzer_instance_init(ValaSemanticAnalyzer * self,gpointer klass)6105 vala_semantic_analyzer_instance_init (ValaSemanticAnalyzer * self,
6106 gpointer klass)
6107 {
6108 ValaVoidType* _tmp0_;
6109 GEqualFunc _tmp1_;
6110 ValaArrayList* _tmp2_;
6111 self->priv = vala_semantic_analyzer_get_instance_private (self);
6112 _tmp0_ = vala_void_type_new (NULL);
6113 self->void_type = (ValaDataType*) _tmp0_;
6114 _tmp1_ = g_direct_equal;
6115 _tmp2_ = vala_array_list_new (VALA_TYPE_CODE_NODE, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp1_);
6116 self->replaced_nodes = (ValaList*) _tmp2_;
6117 }
6118
6119 static void
vala_semantic_analyzer_finalize(ValaCodeVisitor * obj)6120 vala_semantic_analyzer_finalize (ValaCodeVisitor * obj)
6121 {
6122 ValaSemanticAnalyzer * self;
6123 self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALA_TYPE_SEMANTIC_ANALYZER, ValaSemanticAnalyzer);
6124 _vala_code_context_unref0 (self->priv->context);
6125 _vala_code_node_unref0 (self->priv->_current_symbol);
6126 _vala_source_file_unref0 (self->priv->_current_source_file);
6127 _vala_code_node_unref0 (self->insert_block);
6128 _vala_code_node_unref0 (self->void_type);
6129 _vala_code_node_unref0 (self->bool_type);
6130 _vala_code_node_unref0 (self->char_type);
6131 _vala_code_node_unref0 (self->uchar_type);
6132 _vala_code_node_unref0 (self->short_type);
6133 _vala_code_node_unref0 (self->ushort_type);
6134 _vala_code_node_unref0 (self->int_type);
6135 _vala_code_node_unref0 (self->uint_type);
6136 _vala_code_node_unref0 (self->long_type);
6137 _vala_code_node_unref0 (self->ulong_type);
6138 _vala_code_node_unref0 (self->int8_type);
6139 _vala_code_node_unref0 (self->uint8_type);
6140 _vala_code_node_unref0 (self->int16_type);
6141 _vala_code_node_unref0 (self->uint16_type);
6142 _vala_code_node_unref0 (self->int32_type);
6143 _vala_code_node_unref0 (self->uint32_type);
6144 _vala_code_node_unref0 (self->size_t_type);
6145 _vala_code_node_unref0 (self->ssize_t_type);
6146 _vala_code_node_unref0 (self->unichar_type);
6147 _vala_code_node_unref0 (self->double_type);
6148 _vala_code_node_unref0 (self->string_type);
6149 _vala_code_node_unref0 (self->regex_type);
6150 _vala_code_node_unref0 (self->type_type);
6151 _vala_code_node_unref0 (self->va_list_type);
6152 _vala_code_node_unref0 (self->object_type);
6153 _vala_code_node_unref0 (self->gvalue_type);
6154 _vala_code_node_unref0 (self->gvariant_type);
6155 _vala_code_node_unref0 (self->glist_type);
6156 _vala_code_node_unref0 (self->gslist_type);
6157 _vala_code_node_unref0 (self->garray_type);
6158 _vala_code_node_unref0 (self->gvaluearray_type);
6159 _vala_code_node_unref0 (self->gerror_type);
6160 _vala_code_node_unref0 (self->list_type);
6161 _vala_code_node_unref0 (self->tuple_type);
6162 _vala_code_node_unref0 (self->gsource_type);
6163 _vala_code_node_unref0 (self->delegate_target_type);
6164 _vala_code_node_unref0 (self->delegate_target_destroy_type);
6165 _vala_code_node_unref0 (self->generics_dup_func_type);
6166 _vala_code_node_unref0 (self->priv->destroy_notify);
6167 _vala_iterable_unref0 (self->replaced_nodes);
6168 VALA_CODE_VISITOR_CLASS (vala_semantic_analyzer_parent_class)->finalize (obj);
6169 }
6170
6171 /**
6172 * Code visitor analyzing and checking code.
6173 */
6174 static GType
vala_semantic_analyzer_get_type_once(void)6175 vala_semantic_analyzer_get_type_once (void)
6176 {
6177 static const GTypeInfo g_define_type_info = { sizeof (ValaSemanticAnalyzerClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_semantic_analyzer_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaSemanticAnalyzer), 0, (GInstanceInitFunc) vala_semantic_analyzer_instance_init, NULL };
6178 GType vala_semantic_analyzer_type_id;
6179 vala_semantic_analyzer_type_id = g_type_register_static (VALA_TYPE_CODE_VISITOR, "ValaSemanticAnalyzer", &g_define_type_info, 0);
6180 ValaSemanticAnalyzer_private_offset = g_type_add_instance_private (vala_semantic_analyzer_type_id, sizeof (ValaSemanticAnalyzerPrivate));
6181 return vala_semantic_analyzer_type_id;
6182 }
6183
6184 GType
vala_semantic_analyzer_get_type(void)6185 vala_semantic_analyzer_get_type (void)
6186 {
6187 static volatile gsize vala_semantic_analyzer_type_id__volatile = 0;
6188 if (g_once_init_enter (&vala_semantic_analyzer_type_id__volatile)) {
6189 GType vala_semantic_analyzer_type_id;
6190 vala_semantic_analyzer_type_id = vala_semantic_analyzer_get_type_once ();
6191 g_once_init_leave (&vala_semantic_analyzer_type_id__volatile, vala_semantic_analyzer_type_id);
6192 }
6193 return vala_semantic_analyzer_type_id__volatile;
6194 }
6195
6196