1 /* valastruct.c generated by valac, the Vala compiler
2 * generated from valastruct.vala, do not modify */
3
4 /* valastruct.vala
5 *
6 * Copyright (C) 2006-2010 Jürg Billeter
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 *
22 * Author:
23 * Jürg Billeter <j@bitron.ch>
24 */
25
26 #include "vala.h"
27 #include <valagee.h>
28 #include <glib-object.h>
29 #include <glib.h>
30 #include <stdlib.h>
31 #include <string.h>
32
33 #define _vala_iterable_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterable_unref (var), NULL)))
34 #define _vala_code_node_unref0(var) ((var == NULL) ? NULL : (var = (vala_code_node_unref (var), NULL)))
35 #define _g_free0(var) ((var == NULL) ? NULL : (var = (g_free (var), NULL)))
36 #define _vala_source_file_unref0(var) ((var == NULL) ? NULL : (var = (vala_source_file_unref (var), NULL)))
37
38 struct _ValaStructPrivate {
39 ValaList* type_parameters;
40 ValaList* constants;
41 ValaList* fields;
42 ValaList* methods;
43 ValaList* properties;
44 ValaSet* property_fields;
45 ValaDataType* _base_type;
46 gboolean* boolean_type;
47 gboolean* integer_type;
48 gboolean* floating_type;
49 gboolean* decimal_floating_type;
50 gboolean* simple_type;
51 gint* _rank;
52 gint* _width;
53 gboolean* _signed;
54 gboolean* _is_immutable;
55 ValaCreationMethod* _default_construction_method;
56 };
57
58 static gint ValaStruct_private_offset;
59 static gpointer vala_struct_parent_class = NULL;
60
61 static void vala_struct_set_default_construction_method (ValaStruct* self,
62 ValaCreationMethod* value);
63 static gboolean* _bool_dup (gboolean* self);
64 static gint* _int_dup (gint* self);
65 static void vala_struct_real_add_constant (ValaSymbol* base,
66 ValaConstant* c);
67 static void vala_struct_real_add_field (ValaSymbol* base,
68 ValaField* f);
69 static void vala_struct_real_add_method (ValaSymbol* base,
70 ValaMethod* m);
71 static void vala_struct_real_add_property (ValaSymbol* base,
72 ValaProperty* prop);
73 static void vala_struct_real_accept (ValaCodeNode* base,
74 ValaCodeVisitor* visitor);
75 static void vala_struct_real_accept_children (ValaCodeNode* base,
76 ValaCodeVisitor* visitor);
77 static gint vala_struct_real_get_type_parameter_index (ValaTypeSymbol* base,
78 const gchar* name);
79 static void vala_struct_real_replace_type (ValaCodeNode* base,
80 ValaDataType* old_type,
81 ValaDataType* new_type);
82 static gboolean vala_struct_real_is_subtype_of (ValaTypeSymbol* base,
83 ValaTypeSymbol* t);
84 static gboolean vala_struct_is_recursive_value_type (ValaStruct* self,
85 ValaCodeContext* context,
86 ValaDataType* type);
87 static gboolean vala_struct_real_check (ValaCodeNode* base,
88 ValaCodeContext* context);
89 static void vala_struct_finalize (ValaCodeNode * obj);
90 static GType vala_struct_get_type_once (void);
91
92 static inline gpointer
vala_struct_get_instance_private(ValaStruct * self)93 vala_struct_get_instance_private (ValaStruct* self)
94 {
95 return G_STRUCT_MEMBER_P (self, ValaStruct_private_offset);
96 }
97
98 ValaDataType*
vala_struct_get_base_type(ValaStruct * self)99 vala_struct_get_base_type (ValaStruct* self)
100 {
101 ValaDataType* result;
102 ValaDataType* _tmp0_;
103 g_return_val_if_fail (self != NULL, NULL);
104 _tmp0_ = self->priv->_base_type;
105 result = _tmp0_;
106 return result;
107 }
108
109 static gpointer
_vala_code_node_ref0(gpointer self)110 _vala_code_node_ref0 (gpointer self)
111 {
112 return self ? vala_code_node_ref (self) : NULL;
113 }
114
115 void
vala_struct_set_base_type(ValaStruct * self,ValaDataType * value)116 vala_struct_set_base_type (ValaStruct* self,
117 ValaDataType* value)
118 {
119 ValaDataType* _tmp0_;
120 g_return_if_fail (self != NULL);
121 vala_code_node_set_parent_node ((ValaCodeNode*) value, (ValaCodeNode*) self);
122 _tmp0_ = _vala_code_node_ref0 (value);
123 _vala_code_node_unref0 (self->priv->_base_type);
124 self->priv->_base_type = _tmp0_;
125 }
126
127 ValaStruct*
vala_struct_get_base_struct(ValaStruct * self)128 vala_struct_get_base_struct (ValaStruct* self)
129 {
130 ValaStruct* result;
131 ValaDataType* _tmp0_;
132 g_return_val_if_fail (self != NULL, NULL);
133 _tmp0_ = self->priv->_base_type;
134 if (_tmp0_ != NULL) {
135 ValaDataType* _tmp1_;
136 ValaTypeSymbol* _tmp2_;
137 ValaTypeSymbol* _tmp3_;
138 _tmp1_ = self->priv->_base_type;
139 _tmp2_ = vala_data_type_get_type_symbol (_tmp1_);
140 _tmp3_ = _tmp2_;
141 result = VALA_IS_STRUCT (_tmp3_) ? ((ValaStruct*) _tmp3_) : NULL;
142 return result;
143 }
144 result = NULL;
145 return result;
146 }
147
148 ValaCreationMethod*
vala_struct_get_default_construction_method(ValaStruct * self)149 vala_struct_get_default_construction_method (ValaStruct* self)
150 {
151 ValaCreationMethod* result;
152 ValaCreationMethod* _tmp0_;
153 g_return_val_if_fail (self != NULL, NULL);
154 _tmp0_ = self->priv->_default_construction_method;
155 result = _tmp0_;
156 return result;
157 }
158
159 static void
vala_struct_set_default_construction_method(ValaStruct * self,ValaCreationMethod * value)160 vala_struct_set_default_construction_method (ValaStruct* self,
161 ValaCreationMethod* value)
162 {
163 ValaCreationMethod* _tmp0_;
164 g_return_if_fail (self != NULL);
165 _tmp0_ = _vala_code_node_ref0 (value);
166 _vala_code_node_unref0 (self->priv->_default_construction_method);
167 self->priv->_default_construction_method = _tmp0_;
168 }
169
170 static gboolean*
_bool_dup(gboolean * self)171 _bool_dup (gboolean* self)
172 {
173 gboolean* dup;
174 dup = g_new0 (gboolean, 1);
175 memcpy (dup, self, sizeof (gboolean));
176 return dup;
177 }
178
179 static gpointer
__bool_dup0(gpointer self)180 __bool_dup0 (gpointer self)
181 {
182 return self ? _bool_dup (self) : NULL;
183 }
184
185 gboolean
vala_struct_get_is_immutable(ValaStruct * self)186 vala_struct_get_is_immutable (ValaStruct* self)
187 {
188 gboolean result;
189 gboolean* _tmp0_;
190 gboolean* _tmp4_;
191 g_return_val_if_fail (self != NULL, FALSE);
192 _tmp0_ = self->priv->_is_immutable;
193 if (_tmp0_ == NULL) {
194 ValaAttribute* _tmp1_;
195 gboolean _tmp2_;
196 gboolean* _tmp3_;
197 _tmp1_ = vala_code_node_get_attribute ((ValaCodeNode*) self, "Immutable");
198 _tmp2_ = _tmp1_ != NULL;
199 _tmp3_ = __bool_dup0 (&_tmp2_);
200 _g_free0 (self->priv->_is_immutable);
201 self->priv->_is_immutable = _tmp3_;
202 }
203 _tmp4_ = self->priv->_is_immutable;
204 result = *_tmp4_;
205 return result;
206 }
207
208 void
vala_struct_set_is_immutable(ValaStruct * self,gboolean value)209 vala_struct_set_is_immutable (ValaStruct* self,
210 gboolean value)
211 {
212 gboolean* _tmp0_;
213 g_return_if_fail (self != NULL);
214 _tmp0_ = __bool_dup0 (&value);
215 _g_free0 (self->priv->_is_immutable);
216 self->priv->_is_immutable = _tmp0_;
217 vala_code_node_set_attribute ((ValaCodeNode*) self, "Immutable", value, NULL);
218 }
219
220 static gint*
_int_dup(gint * self)221 _int_dup (gint* self)
222 {
223 gint* dup;
224 dup = g_new0 (gint, 1);
225 memcpy (dup, self, sizeof (gint));
226 return dup;
227 }
228
229 static gpointer
__int_dup0(gpointer self)230 __int_dup0 (gpointer self)
231 {
232 return self ? _int_dup (self) : NULL;
233 }
234
235 gint
vala_struct_get_width(ValaStruct * self)236 vala_struct_get_width (ValaStruct* self)
237 {
238 gint result;
239 gint* _tmp0_;
240 gint* _tmp5_;
241 g_return_val_if_fail (self != NULL, 0);
242 _tmp0_ = self->priv->_width;
243 if (_tmp0_ == NULL) {
244 if (vala_struct_is_integer_type (self)) {
245 gint _tmp1_;
246 gint* _tmp2_;
247 _tmp1_ = vala_code_node_get_attribute_integer ((ValaCodeNode*) self, "IntegerType", "width", 32);
248 _tmp2_ = __int_dup0 (&_tmp1_);
249 _g_free0 (self->priv->_width);
250 self->priv->_width = _tmp2_;
251 } else {
252 gint _tmp3_;
253 gint* _tmp4_;
254 _tmp3_ = vala_code_node_get_attribute_integer ((ValaCodeNode*) self, "FloatingType", "width", 32);
255 _tmp4_ = __int_dup0 (&_tmp3_);
256 _g_free0 (self->priv->_width);
257 self->priv->_width = _tmp4_;
258 }
259 }
260 _tmp5_ = self->priv->_width;
261 result = *_tmp5_;
262 return result;
263 }
264
265 void
vala_struct_set_width(ValaStruct * self,gint value)266 vala_struct_set_width (ValaStruct* self,
267 gint value)
268 {
269 gint* _tmp0_;
270 g_return_if_fail (self != NULL);
271 _tmp0_ = __int_dup0 (&value);
272 _g_free0 (self->priv->_width);
273 self->priv->_width = _tmp0_;
274 if (vala_struct_is_integer_type (self)) {
275 vala_code_node_set_attribute_integer ((ValaCodeNode*) self, "IntegerType", "width", value, NULL);
276 } else {
277 vala_code_node_set_attribute_integer ((ValaCodeNode*) self, "FloatingType", "width", value, NULL);
278 }
279 }
280
281 gboolean
vala_struct_get_signed(ValaStruct * self)282 vala_struct_get_signed (ValaStruct* self)
283 {
284 gboolean result;
285 gboolean* _tmp0_;
286 gboolean* _tmp3_;
287 g_return_val_if_fail (self != NULL, FALSE);
288 _tmp0_ = self->priv->_signed;
289 if (_tmp0_ == NULL) {
290 gboolean _tmp1_;
291 gboolean* _tmp2_;
292 _tmp1_ = vala_code_node_get_attribute_bool ((ValaCodeNode*) self, "IntegerType", "signed", TRUE);
293 _tmp2_ = __bool_dup0 (&_tmp1_);
294 _g_free0 (self->priv->_signed);
295 self->priv->_signed = _tmp2_;
296 }
297 _tmp3_ = self->priv->_signed;
298 result = *_tmp3_;
299 return result;
300 }
301
302 void
vala_struct_set_signed(ValaStruct * self,gboolean value)303 vala_struct_set_signed (ValaStruct* self,
304 gboolean value)
305 {
306 gboolean* _tmp0_;
307 g_return_if_fail (self != NULL);
308 _tmp0_ = __bool_dup0 (&value);
309 _g_free0 (self->priv->_signed);
310 self->priv->_signed = _tmp0_;
311 vala_code_node_set_attribute_bool ((ValaCodeNode*) self, "IntegerType", "signed", value, NULL);
312 }
313
314 gint
vala_struct_get_rank(ValaStruct * self)315 vala_struct_get_rank (ValaStruct* self)
316 {
317 gint result;
318 gint* _tmp0_;
319 gint* _tmp16_;
320 g_return_val_if_fail (self != NULL, 0);
321 _tmp0_ = self->priv->_rank;
322 if (_tmp0_ == NULL) {
323 gboolean _tmp1_ = FALSE;
324 if (vala_struct_is_integer_type (self)) {
325 _tmp1_ = vala_code_node_has_attribute_argument ((ValaCodeNode*) self, "IntegerType", "rank");
326 } else {
327 _tmp1_ = FALSE;
328 }
329 if (_tmp1_) {
330 gint _tmp2_;
331 gint* _tmp3_;
332 _tmp2_ = vala_code_node_get_attribute_integer ((ValaCodeNode*) self, "IntegerType", "rank", 0);
333 _tmp3_ = __int_dup0 (&_tmp2_);
334 _g_free0 (self->priv->_rank);
335 self->priv->_rank = _tmp3_;
336 } else {
337 if (vala_code_node_has_attribute_argument ((ValaCodeNode*) self, "FloatingType", "rank")) {
338 gint _tmp4_;
339 gint* _tmp5_;
340 _tmp4_ = vala_code_node_get_attribute_integer ((ValaCodeNode*) self, "FloatingType", "rank", 0);
341 _tmp5_ = __int_dup0 (&_tmp4_);
342 _g_free0 (self->priv->_rank);
343 self->priv->_rank = _tmp5_;
344 } else {
345 ValaStruct* st = NULL;
346 ValaStruct* _tmp6_;
347 ValaStruct* _tmp7_;
348 ValaStruct* _tmp8_;
349 ValaStruct* _tmp9_;
350 _tmp6_ = vala_struct_get_base_struct (self);
351 _tmp7_ = _tmp6_;
352 _tmp8_ = _vala_code_node_ref0 (_tmp7_);
353 st = _tmp8_;
354 _tmp9_ = st;
355 if (_tmp9_ != NULL) {
356 ValaStruct* _tmp10_;
357 gint _tmp11_;
358 gint _tmp12_;
359 gint* _tmp13_;
360 _tmp10_ = st;
361 _tmp11_ = vala_struct_get_rank (_tmp10_);
362 _tmp12_ = _tmp11_;
363 _tmp13_ = __int_dup0 (&_tmp12_);
364 _g_free0 (self->priv->_rank);
365 self->priv->_rank = _tmp13_;
366 } else {
367 ValaSourceReference* _tmp14_;
368 ValaSourceReference* _tmp15_;
369 _tmp14_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
370 _tmp15_ = _tmp14_;
371 vala_report_error (_tmp15_, "internal error: struct has no rank");
372 result = 0;
373 _vala_code_node_unref0 (st);
374 return result;
375 }
376 _vala_code_node_unref0 (st);
377 }
378 }
379 }
380 _tmp16_ = self->priv->_rank;
381 result = *_tmp16_;
382 return result;
383 }
384
385 void
vala_struct_set_rank(ValaStruct * self,gint value)386 vala_struct_set_rank (ValaStruct* self,
387 gint value)
388 {
389 gint* _tmp0_;
390 g_return_if_fail (self != NULL);
391 _tmp0_ = __int_dup0 (&value);
392 _g_free0 (self->priv->_rank);
393 self->priv->_rank = _tmp0_;
394 if (vala_struct_is_integer_type (self)) {
395 gint* _tmp1_;
396 _tmp1_ = self->priv->_rank;
397 vala_code_node_set_attribute_integer ((ValaCodeNode*) self, "IntegerType", "rank", *_tmp1_, NULL);
398 } else {
399 gint* _tmp2_;
400 _tmp2_ = self->priv->_rank;
401 vala_code_node_set_attribute_integer ((ValaCodeNode*) self, "FloatingType", "rank", *_tmp2_, NULL);
402 }
403 }
404
405 /**
406 * Creates a new struct.
407 *
408 * @param name type name
409 * @param source_reference reference to source code
410 * @return newly created struct
411 */
412 ValaStruct*
vala_struct_construct(GType object_type,const gchar * name,ValaSourceReference * source_reference,ValaComment * comment)413 vala_struct_construct (GType object_type,
414 const gchar* name,
415 ValaSourceReference* source_reference,
416 ValaComment* comment)
417 {
418 ValaStruct* self = NULL;
419 g_return_val_if_fail (name != NULL, NULL);
420 self = (ValaStruct*) vala_typesymbol_construct (object_type, name, source_reference, comment);
421 return self;
422 }
423
424 ValaStruct*
vala_struct_new(const gchar * name,ValaSourceReference * source_reference,ValaComment * comment)425 vala_struct_new (const gchar* name,
426 ValaSourceReference* source_reference,
427 ValaComment* comment)
428 {
429 return vala_struct_construct (VALA_TYPE_STRUCT, name, source_reference, comment);
430 }
431
432 /**
433 * Appends the specified parameter to the list of type parameters.
434 *
435 * @param p a type parameter
436 */
437 void
vala_struct_add_type_parameter(ValaStruct * self,ValaTypeParameter * p)438 vala_struct_add_type_parameter (ValaStruct* self,
439 ValaTypeParameter* p)
440 {
441 ValaList* _tmp0_;
442 ValaScope* _tmp1_;
443 ValaScope* _tmp2_;
444 const gchar* _tmp3_;
445 const gchar* _tmp4_;
446 g_return_if_fail (self != NULL);
447 g_return_if_fail (p != NULL);
448 _tmp0_ = self->priv->type_parameters;
449 vala_collection_add ((ValaCollection*) _tmp0_, p);
450 _tmp1_ = vala_symbol_get_scope ((ValaSymbol*) self);
451 _tmp2_ = _tmp1_;
452 _tmp3_ = vala_symbol_get_name ((ValaSymbol*) p);
453 _tmp4_ = _tmp3_;
454 vala_scope_add (_tmp2_, _tmp4_, (ValaSymbol*) p);
455 }
456
457 /**
458 * Returns the type parameter list.
459 *
460 * @return list of type parameters
461 */
462 ValaList*
vala_struct_get_type_parameters(ValaStruct * self)463 vala_struct_get_type_parameters (ValaStruct* self)
464 {
465 ValaList* _tmp0_;
466 ValaList* result = NULL;
467 g_return_val_if_fail (self != NULL, NULL);
468 _tmp0_ = self->priv->type_parameters;
469 result = _tmp0_;
470 return result;
471 }
472
473 /**
474 * Adds the specified constant as a member to this struct.
475 *
476 * @param c a constant
477 */
478 static void
vala_struct_real_add_constant(ValaSymbol * base,ValaConstant * c)479 vala_struct_real_add_constant (ValaSymbol* base,
480 ValaConstant* c)
481 {
482 ValaStruct * self;
483 ValaList* _tmp0_;
484 ValaScope* _tmp1_;
485 ValaScope* _tmp2_;
486 const gchar* _tmp3_;
487 const gchar* _tmp4_;
488 self = (ValaStruct*) base;
489 g_return_if_fail (c != NULL);
490 _tmp0_ = self->priv->constants;
491 vala_collection_add ((ValaCollection*) _tmp0_, c);
492 _tmp1_ = vala_symbol_get_scope ((ValaSymbol*) self);
493 _tmp2_ = _tmp1_;
494 _tmp3_ = vala_symbol_get_name ((ValaSymbol*) c);
495 _tmp4_ = _tmp3_;
496 vala_scope_add (_tmp2_, _tmp4_, (ValaSymbol*) c);
497 }
498
499 /**
500 * Adds the specified field as a member to this struct.
501 *
502 * @param f a field
503 */
504 static void
vala_struct_real_add_field(ValaSymbol * base,ValaField * f)505 vala_struct_real_add_field (ValaSymbol* base,
506 ValaField* f)
507 {
508 ValaStruct * self;
509 ValaList* _tmp0_;
510 ValaScope* _tmp1_;
511 ValaScope* _tmp2_;
512 const gchar* _tmp3_;
513 const gchar* _tmp4_;
514 self = (ValaStruct*) base;
515 g_return_if_fail (f != NULL);
516 vala_symbol_set_access ((ValaSymbol*) f, VALA_SYMBOL_ACCESSIBILITY_PUBLIC);
517 _tmp0_ = self->priv->fields;
518 vala_collection_add ((ValaCollection*) _tmp0_, f);
519 _tmp1_ = vala_symbol_get_scope ((ValaSymbol*) self);
520 _tmp2_ = _tmp1_;
521 _tmp3_ = vala_symbol_get_name ((ValaSymbol*) f);
522 _tmp4_ = _tmp3_;
523 vala_scope_add (_tmp2_, _tmp4_, (ValaSymbol*) f);
524 }
525
526 /**
527 * Returns the list of fields.
528 *
529 * @return list of fields
530 */
531 ValaList*
vala_struct_get_fields(ValaStruct * self)532 vala_struct_get_fields (ValaStruct* self)
533 {
534 ValaList* _tmp0_;
535 ValaList* result = NULL;
536 g_return_val_if_fail (self != NULL, NULL);
537 _tmp0_ = self->priv->fields;
538 result = _tmp0_;
539 return result;
540 }
541
542 /**
543 * Returns the list of constants.
544 *
545 * @return list of constants
546 */
547 ValaList*
vala_struct_get_constants(ValaStruct * self)548 vala_struct_get_constants (ValaStruct* self)
549 {
550 ValaList* _tmp0_;
551 ValaList* result = NULL;
552 g_return_val_if_fail (self != NULL, NULL);
553 _tmp0_ = self->priv->constants;
554 result = _tmp0_;
555 return result;
556 }
557
558 /**
559 * Adds the specified method as a member to this struct.
560 *
561 * @param m a method
562 */
563 static void
vala_struct_real_add_method(ValaSymbol * base,ValaMethod * m)564 vala_struct_real_add_method (ValaSymbol* base,
565 ValaMethod* m)
566 {
567 ValaStruct * self;
568 gboolean _tmp0_ = FALSE;
569 ValaMemberBinding _tmp1_;
570 ValaMemberBinding _tmp2_;
571 gboolean _tmp17_ = FALSE;
572 ValaDataType* _tmp18_;
573 ValaDataType* _tmp19_;
574 ValaList* _tmp54_;
575 ValaScope* _tmp55_;
576 ValaScope* _tmp56_;
577 const gchar* _tmp57_;
578 const gchar* _tmp58_;
579 self = (ValaStruct*) base;
580 g_return_if_fail (m != NULL);
581 _tmp1_ = vala_method_get_binding (m);
582 _tmp2_ = _tmp1_;
583 if (_tmp2_ == VALA_MEMBER_BINDING_INSTANCE) {
584 _tmp0_ = TRUE;
585 } else {
586 _tmp0_ = VALA_IS_CREATION_METHOD (m);
587 }
588 if (_tmp0_) {
589 ValaDataType* _tmp3_;
590 ValaDataType* _tmp4_;
591 ValaSourceReference* _tmp5_;
592 ValaSourceReference* _tmp6_;
593 ValaParameter* _tmp7_;
594 ValaParameter* _tmp8_;
595 ValaScope* _tmp9_;
596 ValaScope* _tmp10_;
597 ValaParameter* _tmp11_;
598 ValaParameter* _tmp12_;
599 const gchar* _tmp13_;
600 const gchar* _tmp14_;
601 ValaParameter* _tmp15_;
602 ValaParameter* _tmp16_;
603 _tmp3_ = vala_semantic_analyzer_get_this_type ((ValaSymbol*) m, (ValaTypeSymbol*) self);
604 _tmp4_ = _tmp3_;
605 _tmp5_ = vala_code_node_get_source_reference ((ValaCodeNode*) m);
606 _tmp6_ = _tmp5_;
607 _tmp7_ = vala_parameter_new ("this", _tmp4_, _tmp6_);
608 _tmp8_ = _tmp7_;
609 vala_method_set_this_parameter (m, _tmp8_);
610 _vala_code_node_unref0 (_tmp8_);
611 _vala_code_node_unref0 (_tmp4_);
612 _tmp9_ = vala_symbol_get_scope ((ValaSymbol*) m);
613 _tmp10_ = _tmp9_;
614 _tmp11_ = vala_method_get_this_parameter (m);
615 _tmp12_ = _tmp11_;
616 _tmp13_ = vala_symbol_get_name ((ValaSymbol*) _tmp12_);
617 _tmp14_ = _tmp13_;
618 _tmp15_ = vala_method_get_this_parameter (m);
619 _tmp16_ = _tmp15_;
620 vala_scope_add (_tmp10_, _tmp14_, (ValaSymbol*) _tmp16_);
621 }
622 _tmp18_ = vala_callable_get_return_type ((ValaCallable*) m);
623 _tmp19_ = _tmp18_;
624 if (!VALA_IS_VOID_TYPE (_tmp19_)) {
625 ValaList* _tmp20_;
626 gint _tmp21_;
627 gint _tmp22_;
628 _tmp20_ = vala_method_get_postconditions (m);
629 _tmp21_ = vala_collection_get_size ((ValaCollection*) _tmp20_);
630 _tmp22_ = _tmp21_;
631 _tmp17_ = _tmp22_ > 0;
632 } else {
633 _tmp17_ = FALSE;
634 }
635 if (_tmp17_) {
636 ValaDataType* _tmp23_;
637 ValaDataType* _tmp24_;
638 ValaDataType* _tmp25_;
639 ValaDataType* _tmp26_;
640 ValaSourceReference* _tmp27_;
641 ValaSourceReference* _tmp28_;
642 ValaLocalVariable* _tmp29_;
643 ValaLocalVariable* _tmp30_;
644 ValaLocalVariable* _tmp31_;
645 ValaLocalVariable* _tmp32_;
646 _tmp23_ = vala_callable_get_return_type ((ValaCallable*) m);
647 _tmp24_ = _tmp23_;
648 _tmp25_ = vala_data_type_copy (_tmp24_);
649 _tmp26_ = _tmp25_;
650 _tmp27_ = vala_code_node_get_source_reference ((ValaCodeNode*) m);
651 _tmp28_ = _tmp27_;
652 _tmp29_ = vala_local_variable_new (_tmp26_, "result", NULL, _tmp28_);
653 _tmp30_ = _tmp29_;
654 vala_subroutine_set_result_var ((ValaSubroutine*) m, _tmp30_);
655 _vala_code_node_unref0 (_tmp30_);
656 _vala_code_node_unref0 (_tmp26_);
657 _tmp31_ = vala_subroutine_get_result_var ((ValaSubroutine*) m);
658 _tmp32_ = _tmp31_;
659 vala_local_variable_set_is_result (_tmp32_, TRUE);
660 }
661 if (VALA_IS_CREATION_METHOD (m)) {
662 const gchar* _tmp33_;
663 const gchar* _tmp34_;
664 ValaCreationMethod* cm = NULL;
665 ValaCreationMethod* _tmp35_;
666 gboolean _tmp36_ = FALSE;
667 ValaCreationMethod* _tmp37_;
668 const gchar* _tmp38_;
669 const gchar* _tmp39_;
670 _tmp33_ = vala_symbol_get_name ((ValaSymbol*) m);
671 _tmp34_ = _tmp33_;
672 if (_tmp34_ == NULL) {
673 vala_struct_set_default_construction_method (self, G_TYPE_CHECK_INSTANCE_CAST (m, VALA_TYPE_CREATION_METHOD, ValaCreationMethod));
674 vala_symbol_set_name ((ValaSymbol*) m, ".new");
675 }
676 _tmp35_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (m, VALA_TYPE_CREATION_METHOD, ValaCreationMethod));
677 cm = _tmp35_;
678 _tmp37_ = cm;
679 _tmp38_ = vala_creation_method_get_class_name (_tmp37_);
680 _tmp39_ = _tmp38_;
681 if (_tmp39_ != NULL) {
682 ValaCreationMethod* _tmp40_;
683 const gchar* _tmp41_;
684 const gchar* _tmp42_;
685 const gchar* _tmp43_;
686 const gchar* _tmp44_;
687 _tmp40_ = cm;
688 _tmp41_ = vala_creation_method_get_class_name (_tmp40_);
689 _tmp42_ = _tmp41_;
690 _tmp43_ = vala_symbol_get_name ((ValaSymbol*) self);
691 _tmp44_ = _tmp43_;
692 _tmp36_ = g_strcmp0 (_tmp42_, _tmp44_) != 0;
693 } else {
694 _tmp36_ = FALSE;
695 }
696 if (_tmp36_) {
697 ValaSourceReference* _tmp45_;
698 ValaSourceReference* _tmp46_;
699 gchar* _tmp47_;
700 gchar* _tmp48_;
701 ValaCreationMethod* _tmp49_;
702 const gchar* _tmp50_;
703 const gchar* _tmp51_;
704 gchar* _tmp52_;
705 gchar* _tmp53_;
706 _tmp45_ = vala_code_node_get_source_reference ((ValaCodeNode*) m);
707 _tmp46_ = _tmp45_;
708 _tmp47_ = vala_symbol_get_full_name ((ValaSymbol*) self);
709 _tmp48_ = _tmp47_;
710 _tmp49_ = cm;
711 _tmp50_ = vala_creation_method_get_class_name (_tmp49_);
712 _tmp51_ = _tmp50_;
713 _tmp52_ = g_strdup_printf ("missing return type in method `%s.%s´", _tmp48_, _tmp51_);
714 _tmp53_ = _tmp52_;
715 vala_report_error (_tmp46_, _tmp53_);
716 _g_free0 (_tmp53_);
717 _g_free0 (_tmp48_);
718 vala_code_node_set_error ((ValaCodeNode*) m, TRUE);
719 _vala_code_node_unref0 (cm);
720 return;
721 }
722 _vala_code_node_unref0 (cm);
723 }
724 _tmp54_ = self->priv->methods;
725 vala_collection_add ((ValaCollection*) _tmp54_, m);
726 _tmp55_ = vala_symbol_get_scope ((ValaSymbol*) self);
727 _tmp56_ = _tmp55_;
728 _tmp57_ = vala_symbol_get_name ((ValaSymbol*) m);
729 _tmp58_ = _tmp57_;
730 vala_scope_add (_tmp56_, _tmp58_, (ValaSymbol*) m);
731 }
732
733 /**
734 * Returns the list of methods.
735 *
736 * @return list of methods
737 */
738 ValaList*
vala_struct_get_methods(ValaStruct * self)739 vala_struct_get_methods (ValaStruct* self)
740 {
741 ValaList* _tmp0_;
742 ValaList* result = NULL;
743 g_return_val_if_fail (self != NULL, NULL);
744 _tmp0_ = self->priv->methods;
745 result = _tmp0_;
746 return result;
747 }
748
749 /**
750 * Adds the specified property as a member to this struct.
751 *
752 * @param prop a property
753 */
754 static void
vala_struct_real_add_property(ValaSymbol * base,ValaProperty * prop)755 vala_struct_real_add_property (ValaSymbol* base,
756 ValaProperty* prop)
757 {
758 ValaStruct * self;
759 ValaList* _tmp0_;
760 ValaScope* _tmp1_;
761 ValaScope* _tmp2_;
762 const gchar* _tmp3_;
763 const gchar* _tmp4_;
764 ValaMemberBinding _tmp5_;
765 ValaMemberBinding _tmp6_;
766 ValaField* _tmp21_;
767 ValaField* _tmp22_;
768 self = (ValaStruct*) base;
769 g_return_if_fail (prop != NULL);
770 _tmp0_ = self->priv->properties;
771 vala_collection_add ((ValaCollection*) _tmp0_, prop);
772 _tmp1_ = vala_symbol_get_scope ((ValaSymbol*) self);
773 _tmp2_ = _tmp1_;
774 _tmp3_ = vala_symbol_get_name ((ValaSymbol*) prop);
775 _tmp4_ = _tmp3_;
776 vala_scope_add (_tmp2_, _tmp4_, (ValaSymbol*) prop);
777 _tmp5_ = vala_property_get_binding (prop);
778 _tmp6_ = _tmp5_;
779 if (_tmp6_ == VALA_MEMBER_BINDING_INSTANCE) {
780 ValaDataType* _tmp7_;
781 ValaDataType* _tmp8_;
782 ValaSourceReference* _tmp9_;
783 ValaSourceReference* _tmp10_;
784 ValaParameter* _tmp11_;
785 ValaParameter* _tmp12_;
786 ValaScope* _tmp13_;
787 ValaScope* _tmp14_;
788 ValaParameter* _tmp15_;
789 ValaParameter* _tmp16_;
790 const gchar* _tmp17_;
791 const gchar* _tmp18_;
792 ValaParameter* _tmp19_;
793 ValaParameter* _tmp20_;
794 _tmp7_ = vala_semantic_analyzer_get_this_type ((ValaSymbol*) prop, (ValaTypeSymbol*) self);
795 _tmp8_ = _tmp7_;
796 _tmp9_ = vala_code_node_get_source_reference ((ValaCodeNode*) prop);
797 _tmp10_ = _tmp9_;
798 _tmp11_ = vala_parameter_new ("this", _tmp8_, _tmp10_);
799 _tmp12_ = _tmp11_;
800 vala_property_set_this_parameter (prop, _tmp12_);
801 _vala_code_node_unref0 (_tmp12_);
802 _vala_code_node_unref0 (_tmp8_);
803 _tmp13_ = vala_symbol_get_scope ((ValaSymbol*) prop);
804 _tmp14_ = _tmp13_;
805 _tmp15_ = vala_property_get_this_parameter (prop);
806 _tmp16_ = _tmp15_;
807 _tmp17_ = vala_symbol_get_name ((ValaSymbol*) _tmp16_);
808 _tmp18_ = _tmp17_;
809 _tmp19_ = vala_property_get_this_parameter (prop);
810 _tmp20_ = _tmp19_;
811 vala_scope_add (_tmp14_, _tmp18_, (ValaSymbol*) _tmp20_);
812 }
813 _tmp21_ = vala_property_get_field (prop);
814 _tmp22_ = _tmp21_;
815 if (_tmp22_ != NULL) {
816 ValaField* _tmp23_;
817 ValaField* _tmp24_;
818 ValaSet* _tmp25_;
819 ValaField* _tmp26_;
820 ValaField* _tmp27_;
821 _tmp23_ = vala_property_get_field (prop);
822 _tmp24_ = _tmp23_;
823 vala_symbol_add_field ((ValaSymbol*) self, _tmp24_);
824 _tmp25_ = self->priv->property_fields;
825 _tmp26_ = vala_property_get_field (prop);
826 _tmp27_ = _tmp26_;
827 vala_collection_add ((ValaCollection*) _tmp25_, _tmp27_);
828 }
829 }
830
831 /**
832 * Returns the list of properties.
833 *
834 * @return list of properties
835 */
836 ValaList*
vala_struct_get_properties(ValaStruct * self)837 vala_struct_get_properties (ValaStruct* self)
838 {
839 ValaList* _tmp0_;
840 ValaList* result = NULL;
841 g_return_val_if_fail (self != NULL, NULL);
842 _tmp0_ = self->priv->properties;
843 result = _tmp0_;
844 return result;
845 }
846
847 static void
vala_struct_real_accept(ValaCodeNode * base,ValaCodeVisitor * visitor)848 vala_struct_real_accept (ValaCodeNode* base,
849 ValaCodeVisitor* visitor)
850 {
851 ValaStruct * self;
852 self = (ValaStruct*) base;
853 g_return_if_fail (visitor != NULL);
854 vala_code_visitor_visit_struct (visitor, self);
855 }
856
857 static gpointer
_vala_iterable_ref0(gpointer self)858 _vala_iterable_ref0 (gpointer self)
859 {
860 return self ? vala_iterable_ref (self) : NULL;
861 }
862
863 static void
vala_struct_real_accept_children(ValaCodeNode * base,ValaCodeVisitor * visitor)864 vala_struct_real_accept_children (ValaCodeNode* base,
865 ValaCodeVisitor* visitor)
866 {
867 ValaStruct * self;
868 ValaDataType* _tmp0_;
869 ValaDataType* _tmp1_;
870 self = (ValaStruct*) base;
871 g_return_if_fail (visitor != NULL);
872 _tmp0_ = vala_struct_get_base_type (self);
873 _tmp1_ = _tmp0_;
874 if (_tmp1_ != NULL) {
875 ValaDataType* _tmp2_;
876 ValaDataType* _tmp3_;
877 _tmp2_ = vala_struct_get_base_type (self);
878 _tmp3_ = _tmp2_;
879 vala_code_node_accept ((ValaCodeNode*) _tmp3_, visitor);
880 }
881 {
882 ValaList* _p_list = NULL;
883 ValaList* _tmp4_;
884 ValaList* _tmp5_;
885 gint _p_size = 0;
886 ValaList* _tmp6_;
887 gint _tmp7_;
888 gint _tmp8_;
889 gint _p_index = 0;
890 _tmp4_ = self->priv->type_parameters;
891 _tmp5_ = _vala_iterable_ref0 (_tmp4_);
892 _p_list = _tmp5_;
893 _tmp6_ = _p_list;
894 _tmp7_ = vala_collection_get_size ((ValaCollection*) _tmp6_);
895 _tmp8_ = _tmp7_;
896 _p_size = _tmp8_;
897 _p_index = -1;
898 while (TRUE) {
899 gint _tmp9_;
900 gint _tmp10_;
901 ValaTypeParameter* p = NULL;
902 ValaList* _tmp11_;
903 gpointer _tmp12_;
904 ValaTypeParameter* _tmp13_;
905 _p_index = _p_index + 1;
906 _tmp9_ = _p_index;
907 _tmp10_ = _p_size;
908 if (!(_tmp9_ < _tmp10_)) {
909 break;
910 }
911 _tmp11_ = _p_list;
912 _tmp12_ = vala_list_get (_tmp11_, _p_index);
913 p = (ValaTypeParameter*) _tmp12_;
914 _tmp13_ = p;
915 vala_code_node_accept ((ValaCodeNode*) _tmp13_, visitor);
916 _vala_code_node_unref0 (p);
917 }
918 _vala_iterable_unref0 (_p_list);
919 }
920 {
921 ValaList* _f_list = NULL;
922 ValaList* _tmp14_;
923 ValaList* _tmp15_;
924 gint _f_size = 0;
925 ValaList* _tmp16_;
926 gint _tmp17_;
927 gint _tmp18_;
928 gint _f_index = 0;
929 _tmp14_ = self->priv->fields;
930 _tmp15_ = _vala_iterable_ref0 (_tmp14_);
931 _f_list = _tmp15_;
932 _tmp16_ = _f_list;
933 _tmp17_ = vala_collection_get_size ((ValaCollection*) _tmp16_);
934 _tmp18_ = _tmp17_;
935 _f_size = _tmp18_;
936 _f_index = -1;
937 while (TRUE) {
938 gint _tmp19_;
939 gint _tmp20_;
940 ValaField* f = NULL;
941 ValaList* _tmp21_;
942 gpointer _tmp22_;
943 ValaField* _tmp23_;
944 _f_index = _f_index + 1;
945 _tmp19_ = _f_index;
946 _tmp20_ = _f_size;
947 if (!(_tmp19_ < _tmp20_)) {
948 break;
949 }
950 _tmp21_ = _f_list;
951 _tmp22_ = vala_list_get (_tmp21_, _f_index);
952 f = (ValaField*) _tmp22_;
953 _tmp23_ = f;
954 vala_code_node_accept ((ValaCodeNode*) _tmp23_, visitor);
955 _vala_code_node_unref0 (f);
956 }
957 _vala_iterable_unref0 (_f_list);
958 }
959 {
960 ValaList* _c_list = NULL;
961 ValaList* _tmp24_;
962 ValaList* _tmp25_;
963 gint _c_size = 0;
964 ValaList* _tmp26_;
965 gint _tmp27_;
966 gint _tmp28_;
967 gint _c_index = 0;
968 _tmp24_ = self->priv->constants;
969 _tmp25_ = _vala_iterable_ref0 (_tmp24_);
970 _c_list = _tmp25_;
971 _tmp26_ = _c_list;
972 _tmp27_ = vala_collection_get_size ((ValaCollection*) _tmp26_);
973 _tmp28_ = _tmp27_;
974 _c_size = _tmp28_;
975 _c_index = -1;
976 while (TRUE) {
977 gint _tmp29_;
978 gint _tmp30_;
979 ValaConstant* c = NULL;
980 ValaList* _tmp31_;
981 gpointer _tmp32_;
982 ValaConstant* _tmp33_;
983 _c_index = _c_index + 1;
984 _tmp29_ = _c_index;
985 _tmp30_ = _c_size;
986 if (!(_tmp29_ < _tmp30_)) {
987 break;
988 }
989 _tmp31_ = _c_list;
990 _tmp32_ = vala_list_get (_tmp31_, _c_index);
991 c = (ValaConstant*) _tmp32_;
992 _tmp33_ = c;
993 vala_code_node_accept ((ValaCodeNode*) _tmp33_, visitor);
994 _vala_code_node_unref0 (c);
995 }
996 _vala_iterable_unref0 (_c_list);
997 }
998 {
999 ValaList* _m_list = NULL;
1000 ValaList* _tmp34_;
1001 ValaList* _tmp35_;
1002 gint _m_size = 0;
1003 ValaList* _tmp36_;
1004 gint _tmp37_;
1005 gint _tmp38_;
1006 gint _m_index = 0;
1007 _tmp34_ = self->priv->methods;
1008 _tmp35_ = _vala_iterable_ref0 (_tmp34_);
1009 _m_list = _tmp35_;
1010 _tmp36_ = _m_list;
1011 _tmp37_ = vala_collection_get_size ((ValaCollection*) _tmp36_);
1012 _tmp38_ = _tmp37_;
1013 _m_size = _tmp38_;
1014 _m_index = -1;
1015 while (TRUE) {
1016 gint _tmp39_;
1017 gint _tmp40_;
1018 ValaMethod* m = NULL;
1019 ValaList* _tmp41_;
1020 gpointer _tmp42_;
1021 ValaMethod* _tmp43_;
1022 _m_index = _m_index + 1;
1023 _tmp39_ = _m_index;
1024 _tmp40_ = _m_size;
1025 if (!(_tmp39_ < _tmp40_)) {
1026 break;
1027 }
1028 _tmp41_ = _m_list;
1029 _tmp42_ = vala_list_get (_tmp41_, _m_index);
1030 m = (ValaMethod*) _tmp42_;
1031 _tmp43_ = m;
1032 vala_code_node_accept ((ValaCodeNode*) _tmp43_, visitor);
1033 _vala_code_node_unref0 (m);
1034 }
1035 _vala_iterable_unref0 (_m_list);
1036 }
1037 {
1038 ValaList* _prop_list = NULL;
1039 ValaList* _tmp44_;
1040 ValaList* _tmp45_;
1041 gint _prop_size = 0;
1042 ValaList* _tmp46_;
1043 gint _tmp47_;
1044 gint _tmp48_;
1045 gint _prop_index = 0;
1046 _tmp44_ = self->priv->properties;
1047 _tmp45_ = _vala_iterable_ref0 (_tmp44_);
1048 _prop_list = _tmp45_;
1049 _tmp46_ = _prop_list;
1050 _tmp47_ = vala_collection_get_size ((ValaCollection*) _tmp46_);
1051 _tmp48_ = _tmp47_;
1052 _prop_size = _tmp48_;
1053 _prop_index = -1;
1054 while (TRUE) {
1055 gint _tmp49_;
1056 gint _tmp50_;
1057 ValaProperty* prop = NULL;
1058 ValaList* _tmp51_;
1059 gpointer _tmp52_;
1060 ValaProperty* _tmp53_;
1061 _prop_index = _prop_index + 1;
1062 _tmp49_ = _prop_index;
1063 _tmp50_ = _prop_size;
1064 if (!(_tmp49_ < _tmp50_)) {
1065 break;
1066 }
1067 _tmp51_ = _prop_list;
1068 _tmp52_ = vala_list_get (_tmp51_, _prop_index);
1069 prop = (ValaProperty*) _tmp52_;
1070 _tmp53_ = prop;
1071 vala_code_node_accept ((ValaCodeNode*) _tmp53_, visitor);
1072 _vala_code_node_unref0 (prop);
1073 }
1074 _vala_iterable_unref0 (_prop_list);
1075 }
1076 }
1077
1078 /**
1079 * Returns whether this is a boolean type.
1080 *
1081 * @return true if this is a boolean type, false otherwise
1082 */
1083 gboolean
vala_struct_is_boolean_type(ValaStruct * self)1084 vala_struct_is_boolean_type (ValaStruct* self)
1085 {
1086 ValaStruct* st = NULL;
1087 ValaStruct* _tmp0_;
1088 ValaStruct* _tmp1_;
1089 gboolean _tmp2_ = FALSE;
1090 ValaStruct* _tmp3_;
1091 gboolean* _tmp5_;
1092 gboolean* _tmp9_;
1093 gboolean result = FALSE;
1094 g_return_val_if_fail (self != NULL, FALSE);
1095 _tmp0_ = vala_struct_get_base_struct (self);
1096 _tmp1_ = _tmp0_;
1097 st = _tmp1_;
1098 _tmp3_ = st;
1099 if (_tmp3_ != NULL) {
1100 ValaStruct* _tmp4_;
1101 _tmp4_ = st;
1102 _tmp2_ = vala_struct_is_boolean_type (_tmp4_);
1103 } else {
1104 _tmp2_ = FALSE;
1105 }
1106 if (_tmp2_) {
1107 result = TRUE;
1108 return result;
1109 }
1110 _tmp5_ = self->priv->boolean_type;
1111 if (_tmp5_ == NULL) {
1112 ValaAttribute* _tmp6_;
1113 gboolean _tmp7_;
1114 gboolean* _tmp8_;
1115 _tmp6_ = vala_code_node_get_attribute ((ValaCodeNode*) self, "BooleanType");
1116 _tmp7_ = _tmp6_ != NULL;
1117 _tmp8_ = __bool_dup0 (&_tmp7_);
1118 _g_free0 (self->priv->boolean_type);
1119 self->priv->boolean_type = _tmp8_;
1120 }
1121 _tmp9_ = self->priv->boolean_type;
1122 result = *_tmp9_;
1123 return result;
1124 }
1125
1126 /**
1127 * Returns whether this is an integer type.
1128 *
1129 * @return true if this is an integer type, false otherwise
1130 */
1131 gboolean
vala_struct_is_integer_type(ValaStruct * self)1132 vala_struct_is_integer_type (ValaStruct* self)
1133 {
1134 ValaStruct* st = NULL;
1135 ValaStruct* _tmp0_;
1136 ValaStruct* _tmp1_;
1137 gboolean _tmp2_ = FALSE;
1138 ValaStruct* _tmp3_;
1139 gboolean* _tmp5_;
1140 gboolean* _tmp9_;
1141 gboolean result = FALSE;
1142 g_return_val_if_fail (self != NULL, FALSE);
1143 _tmp0_ = vala_struct_get_base_struct (self);
1144 _tmp1_ = _tmp0_;
1145 st = _tmp1_;
1146 _tmp3_ = st;
1147 if (_tmp3_ != NULL) {
1148 ValaStruct* _tmp4_;
1149 _tmp4_ = st;
1150 _tmp2_ = vala_struct_is_integer_type (_tmp4_);
1151 } else {
1152 _tmp2_ = FALSE;
1153 }
1154 if (_tmp2_) {
1155 result = TRUE;
1156 return result;
1157 }
1158 _tmp5_ = self->priv->integer_type;
1159 if (_tmp5_ == NULL) {
1160 ValaAttribute* _tmp6_;
1161 gboolean _tmp7_;
1162 gboolean* _tmp8_;
1163 _tmp6_ = vala_code_node_get_attribute ((ValaCodeNode*) self, "IntegerType");
1164 _tmp7_ = _tmp6_ != NULL;
1165 _tmp8_ = __bool_dup0 (&_tmp7_);
1166 _g_free0 (self->priv->integer_type);
1167 self->priv->integer_type = _tmp8_;
1168 }
1169 _tmp9_ = self->priv->integer_type;
1170 result = *_tmp9_;
1171 return result;
1172 }
1173
1174 /**
1175 * Returns whether this is a floating point type.
1176 *
1177 * @return true if this is a floating point type, false otherwise
1178 */
1179 gboolean
vala_struct_is_floating_type(ValaStruct * self)1180 vala_struct_is_floating_type (ValaStruct* self)
1181 {
1182 ValaStruct* st = NULL;
1183 ValaStruct* _tmp0_;
1184 ValaStruct* _tmp1_;
1185 gboolean _tmp2_ = FALSE;
1186 ValaStruct* _tmp3_;
1187 gboolean* _tmp5_;
1188 gboolean* _tmp9_;
1189 gboolean result = FALSE;
1190 g_return_val_if_fail (self != NULL, FALSE);
1191 _tmp0_ = vala_struct_get_base_struct (self);
1192 _tmp1_ = _tmp0_;
1193 st = _tmp1_;
1194 _tmp3_ = st;
1195 if (_tmp3_ != NULL) {
1196 ValaStruct* _tmp4_;
1197 _tmp4_ = st;
1198 _tmp2_ = vala_struct_is_floating_type (_tmp4_);
1199 } else {
1200 _tmp2_ = FALSE;
1201 }
1202 if (_tmp2_) {
1203 result = TRUE;
1204 return result;
1205 }
1206 _tmp5_ = self->priv->floating_type;
1207 if (_tmp5_ == NULL) {
1208 ValaAttribute* _tmp6_;
1209 gboolean _tmp7_;
1210 gboolean* _tmp8_;
1211 _tmp6_ = vala_code_node_get_attribute ((ValaCodeNode*) self, "FloatingType");
1212 _tmp7_ = _tmp6_ != NULL;
1213 _tmp8_ = __bool_dup0 (&_tmp7_);
1214 _g_free0 (self->priv->floating_type);
1215 self->priv->floating_type = _tmp8_;
1216 }
1217 _tmp9_ = self->priv->floating_type;
1218 result = *_tmp9_;
1219 return result;
1220 }
1221
1222 gboolean
vala_struct_is_decimal_floating_type(ValaStruct * self)1223 vala_struct_is_decimal_floating_type (ValaStruct* self)
1224 {
1225 ValaStruct* st = NULL;
1226 ValaStruct* _tmp0_;
1227 ValaStruct* _tmp1_;
1228 gboolean _tmp2_ = FALSE;
1229 ValaStruct* _tmp3_;
1230 gboolean* _tmp5_;
1231 gboolean* _tmp8_;
1232 gboolean result = FALSE;
1233 g_return_val_if_fail (self != NULL, FALSE);
1234 _tmp0_ = vala_struct_get_base_struct (self);
1235 _tmp1_ = _tmp0_;
1236 st = _tmp1_;
1237 _tmp3_ = st;
1238 if (_tmp3_ != NULL) {
1239 ValaStruct* _tmp4_;
1240 _tmp4_ = st;
1241 _tmp2_ = vala_struct_is_decimal_floating_type (_tmp4_);
1242 } else {
1243 _tmp2_ = FALSE;
1244 }
1245 if (_tmp2_) {
1246 result = TRUE;
1247 return result;
1248 }
1249 _tmp5_ = self->priv->decimal_floating_type;
1250 if (_tmp5_ == NULL) {
1251 gboolean _tmp6_;
1252 gboolean* _tmp7_;
1253 _tmp6_ = vala_code_node_get_attribute_bool ((ValaCodeNode*) self, "FloatingType", "decimal", FALSE);
1254 _tmp7_ = __bool_dup0 (&_tmp6_);
1255 _g_free0 (self->priv->decimal_floating_type);
1256 self->priv->decimal_floating_type = _tmp7_;
1257 }
1258 _tmp8_ = self->priv->decimal_floating_type;
1259 result = *_tmp8_;
1260 return result;
1261 }
1262
1263 static gint
vala_struct_real_get_type_parameter_index(ValaTypeSymbol * base,const gchar * name)1264 vala_struct_real_get_type_parameter_index (ValaTypeSymbol* base,
1265 const gchar* name)
1266 {
1267 ValaStruct * self;
1268 gint i = 0;
1269 gint result = 0;
1270 self = (ValaStruct*) base;
1271 g_return_val_if_fail (name != NULL, 0);
1272 i = 0;
1273 {
1274 ValaList* _p_list = NULL;
1275 ValaList* _tmp0_;
1276 ValaList* _tmp1_;
1277 gint _p_size = 0;
1278 ValaList* _tmp2_;
1279 gint _tmp3_;
1280 gint _tmp4_;
1281 gint _p_index = 0;
1282 _tmp0_ = self->priv->type_parameters;
1283 _tmp1_ = _vala_iterable_ref0 (_tmp0_);
1284 _p_list = _tmp1_;
1285 _tmp2_ = _p_list;
1286 _tmp3_ = vala_collection_get_size ((ValaCollection*) _tmp2_);
1287 _tmp4_ = _tmp3_;
1288 _p_size = _tmp4_;
1289 _p_index = -1;
1290 while (TRUE) {
1291 gint _tmp5_;
1292 gint _tmp6_;
1293 ValaTypeParameter* p = NULL;
1294 ValaList* _tmp7_;
1295 gpointer _tmp8_;
1296 ValaTypeParameter* _tmp9_;
1297 const gchar* _tmp10_;
1298 const gchar* _tmp11_;
1299 gint _tmp12_;
1300 _p_index = _p_index + 1;
1301 _tmp5_ = _p_index;
1302 _tmp6_ = _p_size;
1303 if (!(_tmp5_ < _tmp6_)) {
1304 break;
1305 }
1306 _tmp7_ = _p_list;
1307 _tmp8_ = vala_list_get (_tmp7_, _p_index);
1308 p = (ValaTypeParameter*) _tmp8_;
1309 _tmp9_ = p;
1310 _tmp10_ = vala_symbol_get_name ((ValaSymbol*) _tmp9_);
1311 _tmp11_ = _tmp10_;
1312 if (g_strcmp0 (_tmp11_, name) == 0) {
1313 result = i;
1314 _vala_code_node_unref0 (p);
1315 _vala_iterable_unref0 (_p_list);
1316 return result;
1317 }
1318 _tmp12_ = i;
1319 i = _tmp12_ + 1;
1320 _vala_code_node_unref0 (p);
1321 }
1322 _vala_iterable_unref0 (_p_list);
1323 }
1324 result = -1;
1325 return result;
1326 }
1327
1328 /**
1329 * Returns whether this struct is a simple type, i.e. whether
1330 * instances are passed by value.
1331 */
1332 gboolean
vala_struct_is_simple_type(ValaStruct * self)1333 vala_struct_is_simple_type (ValaStruct* self)
1334 {
1335 ValaStruct* st = NULL;
1336 ValaStruct* _tmp0_;
1337 ValaStruct* _tmp1_;
1338 gboolean _tmp2_ = FALSE;
1339 ValaStruct* _tmp3_;
1340 gboolean* _tmp5_;
1341 gboolean* _tmp14_;
1342 gboolean result = FALSE;
1343 g_return_val_if_fail (self != NULL, FALSE);
1344 _tmp0_ = vala_struct_get_base_struct (self);
1345 _tmp1_ = _tmp0_;
1346 st = _tmp1_;
1347 _tmp3_ = st;
1348 if (_tmp3_ != NULL) {
1349 ValaStruct* _tmp4_;
1350 _tmp4_ = st;
1351 _tmp2_ = vala_struct_is_simple_type (_tmp4_);
1352 } else {
1353 _tmp2_ = FALSE;
1354 }
1355 if (_tmp2_) {
1356 result = TRUE;
1357 return result;
1358 }
1359 _tmp5_ = self->priv->simple_type;
1360 if (_tmp5_ == NULL) {
1361 gboolean _tmp6_ = FALSE;
1362 gboolean _tmp7_ = FALSE;
1363 gboolean _tmp8_ = FALSE;
1364 ValaAttribute* _tmp9_;
1365 gboolean* _tmp13_;
1366 _tmp9_ = vala_code_node_get_attribute ((ValaCodeNode*) self, "SimpleType");
1367 if (_tmp9_ != NULL) {
1368 _tmp8_ = TRUE;
1369 } else {
1370 ValaAttribute* _tmp10_;
1371 _tmp10_ = vala_code_node_get_attribute ((ValaCodeNode*) self, "BooleanType");
1372 _tmp8_ = _tmp10_ != NULL;
1373 }
1374 if (_tmp8_) {
1375 _tmp7_ = TRUE;
1376 } else {
1377 ValaAttribute* _tmp11_;
1378 _tmp11_ = vala_code_node_get_attribute ((ValaCodeNode*) self, "IntegerType");
1379 _tmp7_ = _tmp11_ != NULL;
1380 }
1381 if (_tmp7_) {
1382 _tmp6_ = TRUE;
1383 } else {
1384 ValaAttribute* _tmp12_;
1385 _tmp12_ = vala_code_node_get_attribute ((ValaCodeNode*) self, "FloatingType");
1386 _tmp6_ = _tmp12_ != NULL;
1387 }
1388 _tmp13_ = __bool_dup0 (&_tmp6_);
1389 _g_free0 (self->priv->simple_type);
1390 self->priv->simple_type = _tmp13_;
1391 }
1392 _tmp14_ = self->priv->simple_type;
1393 result = *_tmp14_;
1394 return result;
1395 }
1396
1397 /**
1398 * Marks this struct as simple type, i.e. instances will be passed by
1399 * value.
1400 */
1401 void
vala_struct_set_simple_type(ValaStruct * self,gboolean simple_type)1402 vala_struct_set_simple_type (ValaStruct* self,
1403 gboolean simple_type)
1404 {
1405 gboolean* _tmp0_;
1406 g_return_if_fail (self != NULL);
1407 _tmp0_ = __bool_dup0 (&simple_type);
1408 _g_free0 (self->priv->simple_type);
1409 self->priv->simple_type = _tmp0_;
1410 vala_code_node_set_attribute ((ValaCodeNode*) self, "SimpleType", simple_type, NULL);
1411 }
1412
1413 static void
vala_struct_real_replace_type(ValaCodeNode * base,ValaDataType * old_type,ValaDataType * new_type)1414 vala_struct_real_replace_type (ValaCodeNode* base,
1415 ValaDataType* old_type,
1416 ValaDataType* new_type)
1417 {
1418 ValaStruct * self;
1419 ValaDataType* _tmp0_;
1420 ValaDataType* _tmp1_;
1421 self = (ValaStruct*) base;
1422 g_return_if_fail (old_type != NULL);
1423 g_return_if_fail (new_type != NULL);
1424 _tmp0_ = vala_struct_get_base_type (self);
1425 _tmp1_ = _tmp0_;
1426 if (_tmp1_ == old_type) {
1427 vala_struct_set_base_type (self, new_type);
1428 }
1429 }
1430
1431 static gboolean
vala_struct_real_is_subtype_of(ValaTypeSymbol * base,ValaTypeSymbol * t)1432 vala_struct_real_is_subtype_of (ValaTypeSymbol* base,
1433 ValaTypeSymbol* t)
1434 {
1435 ValaStruct * self;
1436 ValaDataType* _tmp0_;
1437 ValaDataType* _tmp1_;
1438 gboolean result = FALSE;
1439 self = (ValaStruct*) base;
1440 g_return_val_if_fail (t != NULL, FALSE);
1441 if (G_TYPE_CHECK_INSTANCE_CAST (self, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol) == t) {
1442 result = TRUE;
1443 return result;
1444 }
1445 _tmp0_ = vala_struct_get_base_type (self);
1446 _tmp1_ = _tmp0_;
1447 if (_tmp1_ != NULL) {
1448 gboolean _tmp2_ = FALSE;
1449 ValaDataType* _tmp3_;
1450 ValaDataType* _tmp4_;
1451 ValaTypeSymbol* _tmp5_;
1452 ValaTypeSymbol* _tmp6_;
1453 _tmp3_ = vala_struct_get_base_type (self);
1454 _tmp4_ = _tmp3_;
1455 _tmp5_ = vala_data_type_get_type_symbol (_tmp4_);
1456 _tmp6_ = _tmp5_;
1457 if (_tmp6_ != NULL) {
1458 ValaDataType* _tmp7_;
1459 ValaDataType* _tmp8_;
1460 ValaTypeSymbol* _tmp9_;
1461 ValaTypeSymbol* _tmp10_;
1462 _tmp7_ = vala_struct_get_base_type (self);
1463 _tmp8_ = _tmp7_;
1464 _tmp9_ = vala_data_type_get_type_symbol (_tmp8_);
1465 _tmp10_ = _tmp9_;
1466 _tmp2_ = vala_typesymbol_is_subtype_of (_tmp10_, t);
1467 } else {
1468 _tmp2_ = FALSE;
1469 }
1470 if (_tmp2_) {
1471 result = TRUE;
1472 return result;
1473 }
1474 }
1475 result = FALSE;
1476 return result;
1477 }
1478
1479 gboolean
vala_struct_is_disposable(ValaStruct * self)1480 vala_struct_is_disposable (ValaStruct* self)
1481 {
1482 gchar* _tmp0_;
1483 gchar* _tmp1_;
1484 gboolean _tmp2_;
1485 ValaStruct* _tmp3_;
1486 ValaStruct* _tmp4_;
1487 gboolean result = FALSE;
1488 g_return_val_if_fail (self != NULL, FALSE);
1489 _tmp0_ = vala_code_node_get_attribute_string ((ValaCodeNode*) self, "CCode", "destroy_function", NULL);
1490 _tmp1_ = _tmp0_;
1491 _tmp2_ = _tmp1_ != NULL;
1492 _g_free0 (_tmp1_);
1493 if (_tmp2_) {
1494 result = TRUE;
1495 return result;
1496 }
1497 _tmp3_ = vala_struct_get_base_struct (self);
1498 _tmp4_ = _tmp3_;
1499 if (_tmp4_ != NULL) {
1500 ValaStruct* _tmp5_;
1501 ValaStruct* _tmp6_;
1502 _tmp5_ = vala_struct_get_base_struct (self);
1503 _tmp6_ = _tmp5_;
1504 result = vala_struct_is_disposable (_tmp6_);
1505 return result;
1506 }
1507 {
1508 ValaList* _f_list = NULL;
1509 ValaList* _tmp7_;
1510 ValaList* _tmp8_;
1511 gint _f_size = 0;
1512 ValaList* _tmp9_;
1513 gint _tmp10_;
1514 gint _tmp11_;
1515 gint _f_index = 0;
1516 _tmp7_ = self->priv->fields;
1517 _tmp8_ = _vala_iterable_ref0 (_tmp7_);
1518 _f_list = _tmp8_;
1519 _tmp9_ = _f_list;
1520 _tmp10_ = vala_collection_get_size ((ValaCollection*) _tmp9_);
1521 _tmp11_ = _tmp10_;
1522 _f_size = _tmp11_;
1523 _f_index = -1;
1524 while (TRUE) {
1525 gint _tmp12_;
1526 gint _tmp13_;
1527 ValaField* f = NULL;
1528 ValaList* _tmp14_;
1529 gpointer _tmp15_;
1530 gboolean _tmp16_ = FALSE;
1531 gboolean _tmp17_ = FALSE;
1532 ValaField* _tmp18_;
1533 ValaMemberBinding _tmp19_;
1534 ValaMemberBinding _tmp20_;
1535 _f_index = _f_index + 1;
1536 _tmp12_ = _f_index;
1537 _tmp13_ = _f_size;
1538 if (!(_tmp12_ < _tmp13_)) {
1539 break;
1540 }
1541 _tmp14_ = _f_list;
1542 _tmp15_ = vala_list_get (_tmp14_, _f_index);
1543 f = (ValaField*) _tmp15_;
1544 _tmp18_ = f;
1545 _tmp19_ = vala_field_get_binding (_tmp18_);
1546 _tmp20_ = _tmp19_;
1547 if (_tmp20_ == VALA_MEMBER_BINDING_INSTANCE) {
1548 ValaField* _tmp21_;
1549 _tmp21_ = f;
1550 _tmp17_ = vala_code_node_get_attribute_bool ((ValaCodeNode*) _tmp21_, "CCode", "delegate_target", TRUE);
1551 } else {
1552 _tmp17_ = FALSE;
1553 }
1554 if (_tmp17_) {
1555 ValaField* _tmp22_;
1556 ValaDataType* _tmp23_;
1557 ValaDataType* _tmp24_;
1558 _tmp22_ = f;
1559 _tmp23_ = vala_variable_get_variable_type ((ValaVariable*) _tmp22_);
1560 _tmp24_ = _tmp23_;
1561 _tmp16_ = vala_data_type_is_disposable (_tmp24_);
1562 } else {
1563 _tmp16_ = FALSE;
1564 }
1565 if (_tmp16_) {
1566 if (vala_struct_is_simple_type (self)) {
1567 ValaField* _tmp25_;
1568 ValaSourceReference* _tmp26_;
1569 ValaSourceReference* _tmp27_;
1570 gchar* _tmp28_;
1571 gchar* _tmp29_;
1572 gchar* _tmp30_;
1573 gchar* _tmp31_;
1574 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
1575 _tmp25_ = f;
1576 _tmp26_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp25_);
1577 _tmp27_ = _tmp26_;
1578 _tmp28_ = vala_symbol_get_full_name ((ValaSymbol*) self);
1579 _tmp29_ = _tmp28_;
1580 _tmp30_ = g_strdup_printf ("[SimpleType] struct `%s' cannot have owned heap-allocated fields", _tmp29_);
1581 _tmp31_ = _tmp30_;
1582 vala_report_error (_tmp27_, _tmp31_);
1583 _g_free0 (_tmp31_);
1584 _g_free0 (_tmp29_);
1585 }
1586 result = TRUE;
1587 _vala_code_node_unref0 (f);
1588 _vala_iterable_unref0 (_f_list);
1589 return result;
1590 }
1591 _vala_code_node_unref0 (f);
1592 }
1593 _vala_iterable_unref0 (_f_list);
1594 }
1595 result = FALSE;
1596 return result;
1597 }
1598
1599 static gboolean
vala_struct_is_recursive_value_type(ValaStruct * self,ValaCodeContext * context,ValaDataType * type)1600 vala_struct_is_recursive_value_type (ValaStruct* self,
1601 ValaCodeContext* context,
1602 ValaDataType* type)
1603 {
1604 ValaStructValueType* struct_type = NULL;
1605 gboolean _tmp0_ = FALSE;
1606 ValaStructValueType* _tmp1_;
1607 gboolean result = FALSE;
1608 g_return_val_if_fail (self != NULL, FALSE);
1609 g_return_val_if_fail (context != NULL, FALSE);
1610 g_return_val_if_fail (type != NULL, FALSE);
1611 struct_type = VALA_IS_STRUCT_VALUE_TYPE (type) ? ((ValaStructValueType*) type) : NULL;
1612 _tmp1_ = struct_type;
1613 if (_tmp1_ != NULL) {
1614 ValaStructValueType* _tmp2_;
1615 gboolean _tmp3_;
1616 gboolean _tmp4_;
1617 _tmp2_ = struct_type;
1618 _tmp3_ = vala_data_type_get_nullable ((ValaDataType*) _tmp2_);
1619 _tmp4_ = _tmp3_;
1620 _tmp0_ = !_tmp4_;
1621 } else {
1622 _tmp0_ = FALSE;
1623 }
1624 if (_tmp0_) {
1625 ValaStruct* st = NULL;
1626 ValaStructValueType* _tmp5_;
1627 ValaTypeSymbol* _tmp6_;
1628 ValaTypeSymbol* _tmp7_;
1629 ValaStruct* _tmp8_;
1630 ValaStruct* _tmp9_;
1631 _tmp5_ = struct_type;
1632 _tmp6_ = vala_data_type_get_type_symbol ((ValaDataType*) _tmp5_);
1633 _tmp7_ = _tmp6_;
1634 st = G_TYPE_CHECK_INSTANCE_CAST (_tmp7_, VALA_TYPE_STRUCT, ValaStruct);
1635 _tmp8_ = st;
1636 if (_tmp8_ == self) {
1637 result = TRUE;
1638 return result;
1639 }
1640 _tmp9_ = st;
1641 if (!vala_code_node_check ((ValaCodeNode*) _tmp9_, context)) {
1642 result = FALSE;
1643 return result;
1644 }
1645 {
1646 ValaList* _f_list = NULL;
1647 ValaStruct* _tmp10_;
1648 ValaList* _tmp11_;
1649 ValaList* _tmp12_;
1650 gint _f_size = 0;
1651 ValaList* _tmp13_;
1652 gint _tmp14_;
1653 gint _tmp15_;
1654 gint _f_index = 0;
1655 _tmp10_ = st;
1656 _tmp11_ = _tmp10_->priv->fields;
1657 _tmp12_ = _vala_iterable_ref0 (_tmp11_);
1658 _f_list = _tmp12_;
1659 _tmp13_ = _f_list;
1660 _tmp14_ = vala_collection_get_size ((ValaCollection*) _tmp13_);
1661 _tmp15_ = _tmp14_;
1662 _f_size = _tmp15_;
1663 _f_index = -1;
1664 while (TRUE) {
1665 gint _tmp16_;
1666 gint _tmp17_;
1667 ValaField* f = NULL;
1668 ValaList* _tmp18_;
1669 gpointer _tmp19_;
1670 gboolean _tmp20_ = FALSE;
1671 ValaField* _tmp21_;
1672 ValaMemberBinding _tmp22_;
1673 ValaMemberBinding _tmp23_;
1674 _f_index = _f_index + 1;
1675 _tmp16_ = _f_index;
1676 _tmp17_ = _f_size;
1677 if (!(_tmp16_ < _tmp17_)) {
1678 break;
1679 }
1680 _tmp18_ = _f_list;
1681 _tmp19_ = vala_list_get (_tmp18_, _f_index);
1682 f = (ValaField*) _tmp19_;
1683 _tmp21_ = f;
1684 _tmp22_ = vala_field_get_binding (_tmp21_);
1685 _tmp23_ = _tmp22_;
1686 if (_tmp23_ == VALA_MEMBER_BINDING_INSTANCE) {
1687 ValaField* _tmp24_;
1688 ValaDataType* _tmp25_;
1689 ValaDataType* _tmp26_;
1690 _tmp24_ = f;
1691 _tmp25_ = vala_variable_get_variable_type ((ValaVariable*) _tmp24_);
1692 _tmp26_ = _tmp25_;
1693 _tmp20_ = vala_struct_is_recursive_value_type (self, context, _tmp26_);
1694 } else {
1695 _tmp20_ = FALSE;
1696 }
1697 if (_tmp20_) {
1698 result = TRUE;
1699 _vala_code_node_unref0 (f);
1700 _vala_iterable_unref0 (_f_list);
1701 return result;
1702 }
1703 _vala_code_node_unref0 (f);
1704 }
1705 _vala_iterable_unref0 (_f_list);
1706 }
1707 }
1708 result = FALSE;
1709 return result;
1710 }
1711
1712 static gpointer
_vala_source_file_ref0(gpointer self)1713 _vala_source_file_ref0 (gpointer self)
1714 {
1715 return self ? vala_source_file_ref (self) : NULL;
1716 }
1717
1718 static gboolean
vala_struct_real_check(ValaCodeNode * base,ValaCodeContext * context)1719 vala_struct_real_check (ValaCodeNode* base,
1720 ValaCodeContext* context)
1721 {
1722 ValaStruct * self;
1723 gboolean _tmp0_;
1724 gboolean _tmp1_;
1725 ValaSourceFile* old_source_file = NULL;
1726 ValaSemanticAnalyzer* _tmp4_;
1727 ValaSemanticAnalyzer* _tmp5_;
1728 ValaSourceFile* _tmp6_;
1729 ValaSourceFile* _tmp7_;
1730 ValaSourceFile* _tmp8_;
1731 ValaSymbol* old_symbol = NULL;
1732 ValaSemanticAnalyzer* _tmp9_;
1733 ValaSemanticAnalyzer* _tmp10_;
1734 ValaSymbol* _tmp11_;
1735 ValaSymbol* _tmp12_;
1736 ValaSymbol* _tmp13_;
1737 ValaSourceReference* _tmp14_;
1738 ValaSourceReference* _tmp15_;
1739 ValaSemanticAnalyzer* _tmp22_;
1740 ValaSemanticAnalyzer* _tmp23_;
1741 ValaDataType* _tmp24_;
1742 ValaDataType* _tmp25_;
1743 gboolean _tmp172_ = FALSE;
1744 gboolean _tmp173_;
1745 gboolean _tmp174_;
1746 ValaSemanticAnalyzer* _tmp210_;
1747 ValaSemanticAnalyzer* _tmp211_;
1748 ValaSourceFile* _tmp212_;
1749 ValaSemanticAnalyzer* _tmp213_;
1750 ValaSemanticAnalyzer* _tmp214_;
1751 ValaSymbol* _tmp215_;
1752 gboolean _tmp216_;
1753 gboolean _tmp217_;
1754 gboolean result = FALSE;
1755 self = (ValaStruct*) base;
1756 g_return_val_if_fail (context != NULL, FALSE);
1757 _tmp0_ = vala_code_node_get_checked ((ValaCodeNode*) self);
1758 _tmp1_ = _tmp0_;
1759 if (_tmp1_) {
1760 gboolean _tmp2_;
1761 gboolean _tmp3_;
1762 _tmp2_ = vala_code_node_get_error ((ValaCodeNode*) self);
1763 _tmp3_ = _tmp2_;
1764 result = !_tmp3_;
1765 return result;
1766 }
1767 vala_code_node_set_checked ((ValaCodeNode*) self, TRUE);
1768 _tmp4_ = vala_code_context_get_analyzer (context);
1769 _tmp5_ = _tmp4_;
1770 _tmp6_ = vala_semantic_analyzer_get_current_source_file (_tmp5_);
1771 _tmp7_ = _tmp6_;
1772 _tmp8_ = _vala_source_file_ref0 (_tmp7_);
1773 old_source_file = _tmp8_;
1774 _tmp9_ = vala_code_context_get_analyzer (context);
1775 _tmp10_ = _tmp9_;
1776 _tmp11_ = vala_semantic_analyzer_get_current_symbol (_tmp10_);
1777 _tmp12_ = _tmp11_;
1778 _tmp13_ = _vala_code_node_ref0 (_tmp12_);
1779 old_symbol = _tmp13_;
1780 _tmp14_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1781 _tmp15_ = _tmp14_;
1782 if (_tmp15_ != NULL) {
1783 ValaSemanticAnalyzer* _tmp16_;
1784 ValaSemanticAnalyzer* _tmp17_;
1785 ValaSourceReference* _tmp18_;
1786 ValaSourceReference* _tmp19_;
1787 ValaSourceFile* _tmp20_;
1788 ValaSourceFile* _tmp21_;
1789 _tmp16_ = vala_code_context_get_analyzer (context);
1790 _tmp17_ = _tmp16_;
1791 _tmp18_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1792 _tmp19_ = _tmp18_;
1793 _tmp20_ = vala_source_reference_get_file (_tmp19_);
1794 _tmp21_ = _tmp20_;
1795 vala_semantic_analyzer_set_current_source_file (_tmp17_, _tmp21_);
1796 }
1797 _tmp22_ = vala_code_context_get_analyzer (context);
1798 _tmp23_ = _tmp22_;
1799 vala_semantic_analyzer_set_current_symbol (_tmp23_, (ValaSymbol*) self);
1800 _tmp24_ = vala_struct_get_base_type (self);
1801 _tmp25_ = _tmp24_;
1802 if (_tmp25_ != NULL) {
1803 ValaDataType* _tmp26_;
1804 ValaDataType* _tmp27_;
1805 ValaDataType* _tmp28_;
1806 ValaDataType* _tmp29_;
1807 _tmp26_ = vala_struct_get_base_type (self);
1808 _tmp27_ = _tmp26_;
1809 vala_code_node_check ((ValaCodeNode*) _tmp27_, context);
1810 _tmp28_ = vala_struct_get_base_type (self);
1811 _tmp29_ = _tmp28_;
1812 if (!VALA_IS_VALUE_TYPE (_tmp29_)) {
1813 ValaSourceReference* _tmp30_;
1814 ValaSourceReference* _tmp31_;
1815 ValaDataType* _tmp32_;
1816 ValaDataType* _tmp33_;
1817 gchar* _tmp34_;
1818 gchar* _tmp35_;
1819 gchar* _tmp36_;
1820 gchar* _tmp37_;
1821 gchar* _tmp38_;
1822 gchar* _tmp39_;
1823 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
1824 _tmp30_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1825 _tmp31_ = _tmp30_;
1826 _tmp32_ = vala_struct_get_base_type (self);
1827 _tmp33_ = _tmp32_;
1828 _tmp34_ = vala_code_node_to_string ((ValaCodeNode*) _tmp33_);
1829 _tmp35_ = _tmp34_;
1830 _tmp36_ = vala_symbol_get_full_name ((ValaSymbol*) self);
1831 _tmp37_ = _tmp36_;
1832 _tmp38_ = g_strdup_printf ("The base type `%s' of struct `%s' is not a struct", _tmp35_, _tmp37_);
1833 _tmp39_ = _tmp38_;
1834 vala_report_error (_tmp31_, _tmp39_);
1835 _g_free0 (_tmp39_);
1836 _g_free0 (_tmp37_);
1837 _g_free0 (_tmp35_);
1838 result = FALSE;
1839 _vala_code_node_unref0 (old_symbol);
1840 _vala_source_file_unref0 (old_source_file);
1841 return result;
1842 }
1843 }
1844 {
1845 ValaList* _p_list = NULL;
1846 ValaList* _tmp40_;
1847 ValaList* _tmp41_;
1848 gint _p_size = 0;
1849 ValaList* _tmp42_;
1850 gint _tmp43_;
1851 gint _tmp44_;
1852 gint _p_index = 0;
1853 _tmp40_ = self->priv->type_parameters;
1854 _tmp41_ = _vala_iterable_ref0 (_tmp40_);
1855 _p_list = _tmp41_;
1856 _tmp42_ = _p_list;
1857 _tmp43_ = vala_collection_get_size ((ValaCollection*) _tmp42_);
1858 _tmp44_ = _tmp43_;
1859 _p_size = _tmp44_;
1860 _p_index = -1;
1861 while (TRUE) {
1862 gint _tmp45_;
1863 gint _tmp46_;
1864 ValaTypeParameter* p = NULL;
1865 ValaList* _tmp47_;
1866 gpointer _tmp48_;
1867 ValaTypeParameter* _tmp49_;
1868 _p_index = _p_index + 1;
1869 _tmp45_ = _p_index;
1870 _tmp46_ = _p_size;
1871 if (!(_tmp45_ < _tmp46_)) {
1872 break;
1873 }
1874 _tmp47_ = _p_list;
1875 _tmp48_ = vala_list_get (_tmp47_, _p_index);
1876 p = (ValaTypeParameter*) _tmp48_;
1877 _tmp49_ = p;
1878 vala_code_node_check ((ValaCodeNode*) _tmp49_, context);
1879 _vala_code_node_unref0 (p);
1880 }
1881 _vala_iterable_unref0 (_p_list);
1882 }
1883 {
1884 ValaList* _f_list = NULL;
1885 ValaList* _tmp50_;
1886 ValaList* _tmp51_;
1887 gint _f_size = 0;
1888 ValaList* _tmp52_;
1889 gint _tmp53_;
1890 gint _tmp54_;
1891 gint _f_index = 0;
1892 _tmp50_ = self->priv->fields;
1893 _tmp51_ = _vala_iterable_ref0 (_tmp50_);
1894 _f_list = _tmp51_;
1895 _tmp52_ = _f_list;
1896 _tmp53_ = vala_collection_get_size ((ValaCollection*) _tmp52_);
1897 _tmp54_ = _tmp53_;
1898 _f_size = _tmp54_;
1899 _f_index = -1;
1900 while (TRUE) {
1901 gint _tmp55_;
1902 gint _tmp56_;
1903 ValaField* f = NULL;
1904 ValaList* _tmp57_;
1905 gpointer _tmp58_;
1906 ValaField* _tmp59_;
1907 gboolean _tmp60_ = FALSE;
1908 ValaField* _tmp61_;
1909 ValaMemberBinding _tmp62_;
1910 ValaMemberBinding _tmp63_;
1911 gboolean _tmp70_ = FALSE;
1912 ValaField* _tmp71_;
1913 ValaMemberBinding _tmp72_;
1914 ValaMemberBinding _tmp73_;
1915 gboolean _tmp80_ = FALSE;
1916 ValaField* _tmp81_;
1917 ValaMemberBinding _tmp82_;
1918 ValaMemberBinding _tmp83_;
1919 _f_index = _f_index + 1;
1920 _tmp55_ = _f_index;
1921 _tmp56_ = _f_size;
1922 if (!(_tmp55_ < _tmp56_)) {
1923 break;
1924 }
1925 _tmp57_ = _f_list;
1926 _tmp58_ = vala_list_get (_tmp57_, _f_index);
1927 f = (ValaField*) _tmp58_;
1928 _tmp59_ = f;
1929 vala_code_node_check ((ValaCodeNode*) _tmp59_, context);
1930 _tmp61_ = f;
1931 _tmp62_ = vala_field_get_binding (_tmp61_);
1932 _tmp63_ = _tmp62_;
1933 if (_tmp63_ == VALA_MEMBER_BINDING_INSTANCE) {
1934 ValaField* _tmp64_;
1935 ValaDataType* _tmp65_;
1936 ValaDataType* _tmp66_;
1937 _tmp64_ = f;
1938 _tmp65_ = vala_variable_get_variable_type ((ValaVariable*) _tmp64_);
1939 _tmp66_ = _tmp65_;
1940 _tmp60_ = vala_struct_is_recursive_value_type (self, context, _tmp66_);
1941 } else {
1942 _tmp60_ = FALSE;
1943 }
1944 if (_tmp60_) {
1945 ValaField* _tmp67_;
1946 ValaSourceReference* _tmp68_;
1947 ValaSourceReference* _tmp69_;
1948 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
1949 _tmp67_ = f;
1950 _tmp68_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp67_);
1951 _tmp69_ = _tmp68_;
1952 vala_report_error (_tmp69_, "Recursive value types are not allowed");
1953 result = FALSE;
1954 _vala_code_node_unref0 (f);
1955 _vala_iterable_unref0 (_f_list);
1956 _vala_code_node_unref0 (old_symbol);
1957 _vala_source_file_unref0 (old_source_file);
1958 return result;
1959 }
1960 _tmp71_ = f;
1961 _tmp72_ = vala_field_get_binding (_tmp71_);
1962 _tmp73_ = _tmp72_;
1963 if (_tmp73_ == VALA_MEMBER_BINDING_INSTANCE) {
1964 ValaField* _tmp74_;
1965 ValaExpression* _tmp75_;
1966 ValaExpression* _tmp76_;
1967 _tmp74_ = f;
1968 _tmp75_ = vala_variable_get_initializer ((ValaVariable*) _tmp74_);
1969 _tmp76_ = _tmp75_;
1970 _tmp70_ = _tmp76_ != NULL;
1971 } else {
1972 _tmp70_ = FALSE;
1973 }
1974 if (_tmp70_) {
1975 ValaField* _tmp77_;
1976 ValaSourceReference* _tmp78_;
1977 ValaSourceReference* _tmp79_;
1978 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
1979 _tmp77_ = f;
1980 _tmp78_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp77_);
1981 _tmp79_ = _tmp78_;
1982 vala_report_error (_tmp79_, "Instance field initializers not supported");
1983 result = FALSE;
1984 _vala_code_node_unref0 (f);
1985 _vala_iterable_unref0 (_f_list);
1986 _vala_code_node_unref0 (old_symbol);
1987 _vala_source_file_unref0 (old_source_file);
1988 return result;
1989 }
1990 _tmp81_ = f;
1991 _tmp82_ = vala_field_get_binding (_tmp81_);
1992 _tmp83_ = _tmp82_;
1993 if (_tmp83_ == VALA_MEMBER_BINDING_STATIC) {
1994 ValaField* _tmp84_;
1995 ValaExpression* _tmp85_;
1996 ValaExpression* _tmp86_;
1997 _tmp84_ = f;
1998 _tmp85_ = vala_variable_get_initializer ((ValaVariable*) _tmp84_);
1999 _tmp86_ = _tmp85_;
2000 _tmp80_ = _tmp86_ != NULL;
2001 } else {
2002 _tmp80_ = FALSE;
2003 }
2004 if (_tmp80_) {
2005 gboolean _tmp87_ = FALSE;
2006 gboolean _tmp88_ = FALSE;
2007 gboolean _tmp89_ = FALSE;
2008 ValaSet* _tmp90_;
2009 ValaField* _tmp91_;
2010 _tmp90_ = self->priv->property_fields;
2011 _tmp91_ = f;
2012 if (!vala_collection_contains ((ValaCollection*) _tmp90_, _tmp91_)) {
2013 ValaField* _tmp92_;
2014 ValaExpression* _tmp93_;
2015 ValaExpression* _tmp94_;
2016 ValaDataType* _tmp95_;
2017 ValaDataType* _tmp96_;
2018 _tmp92_ = f;
2019 _tmp93_ = vala_variable_get_initializer ((ValaVariable*) _tmp92_);
2020 _tmp94_ = _tmp93_;
2021 _tmp95_ = vala_expression_get_value_type (_tmp94_);
2022 _tmp96_ = _tmp95_;
2023 _tmp89_ = !VALA_IS_NULL_TYPE (_tmp96_);
2024 } else {
2025 _tmp89_ = FALSE;
2026 }
2027 if (_tmp89_) {
2028 ValaField* _tmp97_;
2029 ValaDataType* _tmp98_;
2030 ValaDataType* _tmp99_;
2031 _tmp97_ = f;
2032 _tmp98_ = vala_variable_get_variable_type ((ValaVariable*) _tmp97_);
2033 _tmp99_ = _tmp98_;
2034 _tmp88_ = vala_data_type_is_disposable (_tmp99_);
2035 } else {
2036 _tmp88_ = FALSE;
2037 }
2038 if (_tmp88_) {
2039 ValaField* _tmp100_;
2040 ValaDataType* _tmp101_;
2041 ValaDataType* _tmp102_;
2042 gboolean _tmp103_;
2043 gboolean _tmp104_;
2044 _tmp100_ = f;
2045 _tmp101_ = vala_variable_get_variable_type ((ValaVariable*) _tmp100_);
2046 _tmp102_ = _tmp101_;
2047 _tmp103_ = vala_data_type_get_value_owned (_tmp102_);
2048 _tmp104_ = _tmp103_;
2049 _tmp87_ = _tmp104_;
2050 } else {
2051 _tmp87_ = FALSE;
2052 }
2053 if (_tmp87_) {
2054 ValaField* _tmp105_;
2055 ValaExpression* _tmp106_;
2056 ValaExpression* _tmp107_;
2057 ValaSourceReference* _tmp108_;
2058 ValaSourceReference* _tmp109_;
2059 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
2060 _tmp105_ = f;
2061 _tmp106_ = vala_variable_get_initializer ((ValaVariable*) _tmp105_);
2062 _tmp107_ = _tmp106_;
2063 _tmp108_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp107_);
2064 _tmp109_ = _tmp108_;
2065 vala_report_error (_tmp109_, "Owned static struct fields can only be initialized in a function or me" \
2066 "thod");
2067 }
2068 }
2069 _vala_code_node_unref0 (f);
2070 }
2071 _vala_iterable_unref0 (_f_list);
2072 }
2073 {
2074 ValaList* _c_list = NULL;
2075 ValaList* _tmp110_;
2076 ValaList* _tmp111_;
2077 gint _c_size = 0;
2078 ValaList* _tmp112_;
2079 gint _tmp113_;
2080 gint _tmp114_;
2081 gint _c_index = 0;
2082 _tmp110_ = self->priv->constants;
2083 _tmp111_ = _vala_iterable_ref0 (_tmp110_);
2084 _c_list = _tmp111_;
2085 _tmp112_ = _c_list;
2086 _tmp113_ = vala_collection_get_size ((ValaCollection*) _tmp112_);
2087 _tmp114_ = _tmp113_;
2088 _c_size = _tmp114_;
2089 _c_index = -1;
2090 while (TRUE) {
2091 gint _tmp115_;
2092 gint _tmp116_;
2093 ValaConstant* c = NULL;
2094 ValaList* _tmp117_;
2095 gpointer _tmp118_;
2096 ValaConstant* _tmp119_;
2097 _c_index = _c_index + 1;
2098 _tmp115_ = _c_index;
2099 _tmp116_ = _c_size;
2100 if (!(_tmp115_ < _tmp116_)) {
2101 break;
2102 }
2103 _tmp117_ = _c_list;
2104 _tmp118_ = vala_list_get (_tmp117_, _c_index);
2105 c = (ValaConstant*) _tmp118_;
2106 _tmp119_ = c;
2107 vala_code_node_check ((ValaCodeNode*) _tmp119_, context);
2108 _vala_code_node_unref0 (c);
2109 }
2110 _vala_iterable_unref0 (_c_list);
2111 }
2112 {
2113 ValaList* _m_list = NULL;
2114 ValaList* _tmp120_;
2115 ValaList* _tmp121_;
2116 gint _m_size = 0;
2117 ValaList* _tmp122_;
2118 gint _tmp123_;
2119 gint _tmp124_;
2120 gint _m_index = 0;
2121 _tmp120_ = self->priv->methods;
2122 _tmp121_ = _vala_iterable_ref0 (_tmp120_);
2123 _m_list = _tmp121_;
2124 _tmp122_ = _m_list;
2125 _tmp123_ = vala_collection_get_size ((ValaCollection*) _tmp122_);
2126 _tmp124_ = _tmp123_;
2127 _m_size = _tmp124_;
2128 _m_index = -1;
2129 while (TRUE) {
2130 gint _tmp125_;
2131 gint _tmp126_;
2132 ValaMethod* m = NULL;
2133 ValaList* _tmp127_;
2134 gpointer _tmp128_;
2135 ValaMethod* _tmp129_;
2136 _m_index = _m_index + 1;
2137 _tmp125_ = _m_index;
2138 _tmp126_ = _m_size;
2139 if (!(_tmp125_ < _tmp126_)) {
2140 break;
2141 }
2142 _tmp127_ = _m_list;
2143 _tmp128_ = vala_list_get (_tmp127_, _m_index);
2144 m = (ValaMethod*) _tmp128_;
2145 _tmp129_ = m;
2146 vala_code_node_check ((ValaCodeNode*) _tmp129_, context);
2147 _vala_code_node_unref0 (m);
2148 }
2149 _vala_iterable_unref0 (_m_list);
2150 }
2151 {
2152 ValaList* _prop_list = NULL;
2153 ValaList* _tmp130_;
2154 ValaList* _tmp131_;
2155 gint _prop_size = 0;
2156 ValaList* _tmp132_;
2157 gint _tmp133_;
2158 gint _tmp134_;
2159 gint _prop_index = 0;
2160 _tmp130_ = self->priv->properties;
2161 _tmp131_ = _vala_iterable_ref0 (_tmp130_);
2162 _prop_list = _tmp131_;
2163 _tmp132_ = _prop_list;
2164 _tmp133_ = vala_collection_get_size ((ValaCollection*) _tmp132_);
2165 _tmp134_ = _tmp133_;
2166 _prop_size = _tmp134_;
2167 _prop_index = -1;
2168 while (TRUE) {
2169 gint _tmp135_;
2170 gint _tmp136_;
2171 ValaProperty* prop = NULL;
2172 ValaList* _tmp137_;
2173 gpointer _tmp138_;
2174 ValaProperty* _tmp139_;
2175 ValaProperty* _tmp140_;
2176 ValaMemberBinding _tmp141_;
2177 ValaMemberBinding _tmp142_;
2178 _prop_index = _prop_index + 1;
2179 _tmp135_ = _prop_index;
2180 _tmp136_ = _prop_size;
2181 if (!(_tmp135_ < _tmp136_)) {
2182 break;
2183 }
2184 _tmp137_ = _prop_list;
2185 _tmp138_ = vala_list_get (_tmp137_, _prop_index);
2186 prop = (ValaProperty*) _tmp138_;
2187 _tmp139_ = prop;
2188 vala_code_node_check ((ValaCodeNode*) _tmp139_, context);
2189 _tmp140_ = prop;
2190 _tmp141_ = vala_property_get_binding (_tmp140_);
2191 _tmp142_ = _tmp141_;
2192 if (_tmp142_ == VALA_MEMBER_BINDING_STATIC) {
2193 ValaField* field = NULL;
2194 ValaProperty* _tmp143_;
2195 ValaField* _tmp144_;
2196 ValaField* _tmp145_;
2197 gboolean _tmp146_ = FALSE;
2198 gboolean _tmp147_ = FALSE;
2199 gboolean _tmp148_ = FALSE;
2200 gboolean _tmp149_ = FALSE;
2201 ValaField* _tmp150_;
2202 _tmp143_ = prop;
2203 _tmp144_ = vala_property_get_field (_tmp143_);
2204 _tmp145_ = _tmp144_;
2205 field = _tmp145_;
2206 _tmp150_ = field;
2207 if (_tmp150_ != NULL) {
2208 ValaField* _tmp151_;
2209 ValaExpression* _tmp152_;
2210 ValaExpression* _tmp153_;
2211 _tmp151_ = field;
2212 _tmp152_ = vala_variable_get_initializer ((ValaVariable*) _tmp151_);
2213 _tmp153_ = _tmp152_;
2214 _tmp149_ = _tmp153_ != NULL;
2215 } else {
2216 _tmp149_ = FALSE;
2217 }
2218 if (_tmp149_) {
2219 ValaField* _tmp154_;
2220 ValaExpression* _tmp155_;
2221 ValaExpression* _tmp156_;
2222 ValaDataType* _tmp157_;
2223 ValaDataType* _tmp158_;
2224 _tmp154_ = field;
2225 _tmp155_ = vala_variable_get_initializer ((ValaVariable*) _tmp154_);
2226 _tmp156_ = _tmp155_;
2227 _tmp157_ = vala_expression_get_value_type (_tmp156_);
2228 _tmp158_ = _tmp157_;
2229 _tmp148_ = !VALA_IS_NULL_TYPE (_tmp158_);
2230 } else {
2231 _tmp148_ = FALSE;
2232 }
2233 if (_tmp148_) {
2234 ValaField* _tmp159_;
2235 ValaDataType* _tmp160_;
2236 ValaDataType* _tmp161_;
2237 _tmp159_ = field;
2238 _tmp160_ = vala_variable_get_variable_type ((ValaVariable*) _tmp159_);
2239 _tmp161_ = _tmp160_;
2240 _tmp147_ = vala_data_type_is_disposable (_tmp161_);
2241 } else {
2242 _tmp147_ = FALSE;
2243 }
2244 if (_tmp147_) {
2245 ValaField* _tmp162_;
2246 ValaDataType* _tmp163_;
2247 ValaDataType* _tmp164_;
2248 gboolean _tmp165_;
2249 gboolean _tmp166_;
2250 _tmp162_ = field;
2251 _tmp163_ = vala_variable_get_variable_type ((ValaVariable*) _tmp162_);
2252 _tmp164_ = _tmp163_;
2253 _tmp165_ = vala_data_type_get_value_owned (_tmp164_);
2254 _tmp166_ = _tmp165_;
2255 _tmp146_ = _tmp166_;
2256 } else {
2257 _tmp146_ = FALSE;
2258 }
2259 if (_tmp146_) {
2260 ValaField* _tmp167_;
2261 ValaExpression* _tmp168_;
2262 ValaExpression* _tmp169_;
2263 ValaSourceReference* _tmp170_;
2264 ValaSourceReference* _tmp171_;
2265 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
2266 _tmp167_ = field;
2267 _tmp168_ = vala_variable_get_initializer ((ValaVariable*) _tmp167_);
2268 _tmp169_ = _tmp168_;
2269 _tmp170_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp169_);
2270 _tmp171_ = _tmp170_;
2271 vala_report_error (_tmp171_, "Owned static struct properties can only be initialized in a function o" \
2272 "r method");
2273 }
2274 }
2275 _vala_code_node_unref0 (prop);
2276 }
2277 _vala_iterable_unref0 (_prop_list);
2278 }
2279 _tmp173_ = vala_symbol_get_external ((ValaSymbol*) self);
2280 _tmp174_ = _tmp173_;
2281 if (!_tmp174_) {
2282 gboolean _tmp175_;
2283 gboolean _tmp176_;
2284 _tmp175_ = vala_symbol_get_external_package ((ValaSymbol*) self);
2285 _tmp176_ = _tmp175_;
2286 _tmp172_ = !_tmp176_;
2287 } else {
2288 _tmp172_ = FALSE;
2289 }
2290 if (_tmp172_) {
2291 gboolean has_instance_field = FALSE;
2292 gboolean _tmp189_ = FALSE;
2293 gboolean _tmp190_ = FALSE;
2294 gboolean _tmp191_ = FALSE;
2295 gboolean _tmp192_ = FALSE;
2296 ValaDataType* _tmp193_;
2297 ValaDataType* _tmp194_;
2298 has_instance_field = FALSE;
2299 {
2300 ValaList* _f_list = NULL;
2301 ValaList* _tmp177_;
2302 ValaList* _tmp178_;
2303 gint _f_size = 0;
2304 ValaList* _tmp179_;
2305 gint _tmp180_;
2306 gint _tmp181_;
2307 gint _f_index = 0;
2308 _tmp177_ = self->priv->fields;
2309 _tmp178_ = _vala_iterable_ref0 (_tmp177_);
2310 _f_list = _tmp178_;
2311 _tmp179_ = _f_list;
2312 _tmp180_ = vala_collection_get_size ((ValaCollection*) _tmp179_);
2313 _tmp181_ = _tmp180_;
2314 _f_size = _tmp181_;
2315 _f_index = -1;
2316 while (TRUE) {
2317 gint _tmp182_;
2318 gint _tmp183_;
2319 ValaField* f = NULL;
2320 ValaList* _tmp184_;
2321 gpointer _tmp185_;
2322 ValaField* _tmp186_;
2323 ValaMemberBinding _tmp187_;
2324 ValaMemberBinding _tmp188_;
2325 _f_index = _f_index + 1;
2326 _tmp182_ = _f_index;
2327 _tmp183_ = _f_size;
2328 if (!(_tmp182_ < _tmp183_)) {
2329 break;
2330 }
2331 _tmp184_ = _f_list;
2332 _tmp185_ = vala_list_get (_tmp184_, _f_index);
2333 f = (ValaField*) _tmp185_;
2334 _tmp186_ = f;
2335 _tmp187_ = vala_field_get_binding (_tmp186_);
2336 _tmp188_ = _tmp187_;
2337 if (_tmp188_ == VALA_MEMBER_BINDING_INSTANCE) {
2338 has_instance_field = TRUE;
2339 _vala_code_node_unref0 (f);
2340 break;
2341 }
2342 _vala_code_node_unref0 (f);
2343 }
2344 _vala_iterable_unref0 (_f_list);
2345 }
2346 _tmp193_ = vala_struct_get_base_type (self);
2347 _tmp194_ = _tmp193_;
2348 if (_tmp194_ == NULL) {
2349 _tmp192_ = !has_instance_field;
2350 } else {
2351 _tmp192_ = FALSE;
2352 }
2353 if (_tmp192_) {
2354 _tmp191_ = !vala_struct_is_boolean_type (self);
2355 } else {
2356 _tmp191_ = FALSE;
2357 }
2358 if (_tmp191_) {
2359 _tmp190_ = !vala_struct_is_integer_type (self);
2360 } else {
2361 _tmp190_ = FALSE;
2362 }
2363 if (_tmp190_) {
2364 _tmp189_ = !vala_struct_is_floating_type (self);
2365 } else {
2366 _tmp189_ = FALSE;
2367 }
2368 if (_tmp189_) {
2369 ValaSourceReference* _tmp195_;
2370 ValaSourceReference* _tmp196_;
2371 gchar* _tmp197_;
2372 gchar* _tmp198_;
2373 gchar* _tmp199_;
2374 gchar* _tmp200_;
2375 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
2376 _tmp195_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
2377 _tmp196_ = _tmp195_;
2378 _tmp197_ = vala_symbol_get_full_name ((ValaSymbol*) self);
2379 _tmp198_ = _tmp197_;
2380 _tmp199_ = g_strdup_printf ("struct `%s' cannot be empty", _tmp198_);
2381 _tmp200_ = _tmp199_;
2382 vala_report_error (_tmp196_, _tmp200_);
2383 _g_free0 (_tmp200_);
2384 _g_free0 (_tmp198_);
2385 } else {
2386 gboolean _tmp201_ = FALSE;
2387 ValaDataType* _tmp202_;
2388 ValaDataType* _tmp203_;
2389 _tmp202_ = vala_struct_get_base_type (self);
2390 _tmp203_ = _tmp202_;
2391 if (_tmp203_ != NULL) {
2392 _tmp201_ = has_instance_field;
2393 } else {
2394 _tmp201_ = FALSE;
2395 }
2396 if (_tmp201_) {
2397 ValaSourceReference* _tmp204_;
2398 ValaSourceReference* _tmp205_;
2399 gchar* _tmp206_;
2400 gchar* _tmp207_;
2401 gchar* _tmp208_;
2402 gchar* _tmp209_;
2403 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
2404 _tmp204_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
2405 _tmp205_ = _tmp204_;
2406 _tmp206_ = vala_symbol_get_full_name ((ValaSymbol*) self);
2407 _tmp207_ = _tmp206_;
2408 _tmp208_ = g_strdup_printf ("derived struct `%s' may not have instance fields", _tmp207_);
2409 _tmp209_ = _tmp208_;
2410 vala_report_error (_tmp205_, _tmp209_);
2411 _g_free0 (_tmp209_);
2412 _g_free0 (_tmp207_);
2413 }
2414 }
2415 }
2416 _tmp210_ = vala_code_context_get_analyzer (context);
2417 _tmp211_ = _tmp210_;
2418 _tmp212_ = old_source_file;
2419 vala_semantic_analyzer_set_current_source_file (_tmp211_, _tmp212_);
2420 _tmp213_ = vala_code_context_get_analyzer (context);
2421 _tmp214_ = _tmp213_;
2422 _tmp215_ = old_symbol;
2423 vala_semantic_analyzer_set_current_symbol (_tmp214_, _tmp215_);
2424 _tmp216_ = vala_code_node_get_error ((ValaCodeNode*) self);
2425 _tmp217_ = _tmp216_;
2426 result = !_tmp217_;
2427 _vala_code_node_unref0 (old_symbol);
2428 _vala_source_file_unref0 (old_source_file);
2429 return result;
2430 }
2431
2432 static void
vala_struct_class_init(ValaStructClass * klass,gpointer klass_data)2433 vala_struct_class_init (ValaStructClass * klass,
2434 gpointer klass_data)
2435 {
2436 vala_struct_parent_class = g_type_class_peek_parent (klass);
2437 ((ValaCodeNodeClass *) klass)->finalize = vala_struct_finalize;
2438 g_type_class_adjust_private_offset (klass, &ValaStruct_private_offset);
2439 ((ValaSymbolClass *) klass)->add_constant = (void (*) (ValaSymbol*, ValaConstant*)) vala_struct_real_add_constant;
2440 ((ValaSymbolClass *) klass)->add_field = (void (*) (ValaSymbol*, ValaField*)) vala_struct_real_add_field;
2441 ((ValaSymbolClass *) klass)->add_method = (void (*) (ValaSymbol*, ValaMethod*)) vala_struct_real_add_method;
2442 ((ValaSymbolClass *) klass)->add_property = (void (*) (ValaSymbol*, ValaProperty*)) vala_struct_real_add_property;
2443 ((ValaCodeNodeClass *) klass)->accept = (void (*) (ValaCodeNode*, ValaCodeVisitor*)) vala_struct_real_accept;
2444 ((ValaCodeNodeClass *) klass)->accept_children = (void (*) (ValaCodeNode*, ValaCodeVisitor*)) vala_struct_real_accept_children;
2445 ((ValaTypeSymbolClass *) klass)->get_type_parameter_index = (gint (*) (ValaTypeSymbol*, const gchar*)) vala_struct_real_get_type_parameter_index;
2446 ((ValaCodeNodeClass *) klass)->replace_type = (void (*) (ValaCodeNode*, ValaDataType*, ValaDataType*)) vala_struct_real_replace_type;
2447 ((ValaTypeSymbolClass *) klass)->is_subtype_of = (gboolean (*) (ValaTypeSymbol*, ValaTypeSymbol*)) vala_struct_real_is_subtype_of;
2448 ((ValaCodeNodeClass *) klass)->check = (gboolean (*) (ValaCodeNode*, ValaCodeContext*)) vala_struct_real_check;
2449 }
2450
2451 static void
vala_struct_instance_init(ValaStruct * self,gpointer klass)2452 vala_struct_instance_init (ValaStruct * self,
2453 gpointer klass)
2454 {
2455 GEqualFunc _tmp0_;
2456 ValaArrayList* _tmp1_;
2457 GEqualFunc _tmp2_;
2458 ValaArrayList* _tmp3_;
2459 GEqualFunc _tmp4_;
2460 ValaArrayList* _tmp5_;
2461 GEqualFunc _tmp6_;
2462 ValaArrayList* _tmp7_;
2463 GEqualFunc _tmp8_;
2464 ValaArrayList* _tmp9_;
2465 GHashFunc _tmp10_;
2466 GEqualFunc _tmp11_;
2467 ValaHashSet* _tmp12_;
2468 self->priv = vala_struct_get_instance_private (self);
2469 _tmp0_ = g_direct_equal;
2470 _tmp1_ = vala_array_list_new (VALA_TYPE_TYPEPARAMETER, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp0_);
2471 self->priv->type_parameters = (ValaList*) _tmp1_;
2472 _tmp2_ = g_direct_equal;
2473 _tmp3_ = vala_array_list_new (VALA_TYPE_CONSTANT, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp2_);
2474 self->priv->constants = (ValaList*) _tmp3_;
2475 _tmp4_ = g_direct_equal;
2476 _tmp5_ = vala_array_list_new (VALA_TYPE_FIELD, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp4_);
2477 self->priv->fields = (ValaList*) _tmp5_;
2478 _tmp6_ = g_direct_equal;
2479 _tmp7_ = vala_array_list_new (VALA_TYPE_METHOD, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp6_);
2480 self->priv->methods = (ValaList*) _tmp7_;
2481 _tmp8_ = g_direct_equal;
2482 _tmp9_ = vala_array_list_new (VALA_TYPE_PROPERTY, (GBoxedCopyFunc) vala_code_node_ref, (GDestroyNotify) vala_code_node_unref, _tmp8_);
2483 self->priv->properties = (ValaList*) _tmp9_;
2484 _tmp10_ = g_direct_hash;
2485 _tmp11_ = g_direct_equal;
2486 _tmp12_ = vala_hash_set_new (VALA_TYPE_FIELD, NULL, NULL, _tmp10_, _tmp11_);
2487 self->priv->property_fields = (ValaSet*) _tmp12_;
2488 self->priv->_base_type = NULL;
2489 }
2490
2491 static void
vala_struct_finalize(ValaCodeNode * obj)2492 vala_struct_finalize (ValaCodeNode * obj)
2493 {
2494 ValaStruct * self;
2495 self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALA_TYPE_STRUCT, ValaStruct);
2496 _vala_iterable_unref0 (self->priv->type_parameters);
2497 _vala_iterable_unref0 (self->priv->constants);
2498 _vala_iterable_unref0 (self->priv->fields);
2499 _vala_iterable_unref0 (self->priv->methods);
2500 _vala_iterable_unref0 (self->priv->properties);
2501 _vala_iterable_unref0 (self->priv->property_fields);
2502 _vala_code_node_unref0 (self->priv->_base_type);
2503 _g_free0 (self->priv->boolean_type);
2504 _g_free0 (self->priv->integer_type);
2505 _g_free0 (self->priv->floating_type);
2506 _g_free0 (self->priv->decimal_floating_type);
2507 _g_free0 (self->priv->simple_type);
2508 _g_free0 (self->priv->_rank);
2509 _g_free0 (self->priv->_width);
2510 _g_free0 (self->priv->_signed);
2511 _g_free0 (self->priv->_is_immutable);
2512 _vala_code_node_unref0 (self->priv->_default_construction_method);
2513 VALA_CODE_NODE_CLASS (vala_struct_parent_class)->finalize (obj);
2514 }
2515
2516 /**
2517 * Represents a struct declaration in the source code.
2518 */
2519 static GType
vala_struct_get_type_once(void)2520 vala_struct_get_type_once (void)
2521 {
2522 static const GTypeInfo g_define_type_info = { sizeof (ValaStructClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_struct_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaStruct), 0, (GInstanceInitFunc) vala_struct_instance_init, NULL };
2523 GType vala_struct_type_id;
2524 vala_struct_type_id = g_type_register_static (VALA_TYPE_TYPESYMBOL, "ValaStruct", &g_define_type_info, 0);
2525 ValaStruct_private_offset = g_type_add_instance_private (vala_struct_type_id, sizeof (ValaStructPrivate));
2526 return vala_struct_type_id;
2527 }
2528
2529 GType
vala_struct_get_type(void)2530 vala_struct_get_type (void)
2531 {
2532 static volatile gsize vala_struct_type_id__volatile = 0;
2533 if (g_once_init_enter (&vala_struct_type_id__volatile)) {
2534 GType vala_struct_type_id;
2535 vala_struct_type_id = vala_struct_get_type_once ();
2536 g_once_init_leave (&vala_struct_type_id__volatile, vala_struct_type_id);
2537 }
2538 return vala_struct_type_id__volatile;
2539 }
2540
2541