1 /* valaccodeattribute.c generated by valac, the Vala compiler
2 * generated from valaccodeattribute.vala, do not modify */
3
4 /* valaccodeattribute.vala
5 *
6 * Copyright (C) 2011 Luca Bruno
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 * Luca Bruno <lucabru@src.gnome.org>
24 */
25
26 #include "valacodegen.h"
27 #include <vala.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <glib.h>
31 #include <float.h>
32 #include <math.h>
33 #include <valagee.h>
34 #include <glib-object.h>
35
36 #define _vala_code_node_unref0(var) ((var == NULL) ? NULL : (var = (vala_code_node_unref (var), NULL)))
37 #define _g_free0(var) (var = (g_free (var), NULL))
38 #define _vala_iterable_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterable_unref (var), NULL)))
39 #define _g_regex_unref0(var) ((var == NULL) ? NULL : (var = (g_regex_unref (var), NULL)))
40 #define _vala_code_context_unref0(var) ((var == NULL) ? NULL : (var = (vala_code_context_unref (var), NULL)))
41
42 struct _ValaCCodeAttributePrivate {
43 ValaCodeNode* node;
44 ValaSymbol* sym;
45 ValaAttribute* ccode;
46 gchar* _array_length_name;
47 gchar* _array_length_expr;
48 gchar* _name;
49 gchar* _const_name;
50 gchar* _type_name;
51 gchar* _feature_test_macros;
52 gchar* _header_filenames;
53 gchar* _prefix;
54 gchar* _lower_case_prefix;
55 gchar* _lower_case_suffix;
56 gchar* _ref_function;
57 gboolean ref_function_set;
58 gboolean* _ref_function_void;
59 gchar* _unref_function;
60 gboolean unref_function_set;
61 gchar* _ref_sink_function;
62 gchar* _copy_function;
63 gboolean copy_function_set;
64 gchar* _destroy_function;
65 gboolean destroy_function_set;
66 gchar* _dup_function;
67 gboolean dup_function_set;
68 gchar* _free_function;
69 gboolean free_function_set;
70 gboolean* _free_function_address_of;
71 gchar* _type_id;
72 gchar* _marshaller_type_name;
73 gchar* _get_value_function;
74 gchar* _set_value_function;
75 gchar* _take_value_function;
76 gchar* _param_spec_function;
77 gchar* _default_value;
78 gchar* _default_value_on_error;
79 gdouble* _pos;
80 gchar* _vfunc_name;
81 gchar* _finish_name;
82 gchar* _finish_vfunc_name;
83 gchar* _finish_real_name;
84 gboolean* _finish_instance;
85 gchar* _real_name;
86 gboolean* _delegate_target;
87 gchar* _delegate_target_name;
88 gchar* _delegate_target_destroy_notify_name;
89 gchar* _ctype;
90 gboolean ctype_set;
91 gboolean* _array_length;
92 gchar* _array_length_type;
93 gboolean* _array_null_terminated;
94 gchar* _sentinel;
95 };
96
97 static gint ValaCCodeAttribute_private_offset;
98 static gpointer vala_ccode_attribute_parent_class = NULL;
99 static gint vala_ccode_attribute_dynamic_method_id;
100 static gint vala_ccode_attribute_dynamic_method_id = 0;
101
102 static gchar* vala_ccode_attribute_get_default_name (ValaCCodeAttribute* self);
103 static gchar* vala_ccode_attribute_get_default_const_name (ValaCCodeAttribute* self);
104 static gchar* vala_ccode_attribute_get_default_header_filenames (ValaCCodeAttribute* self);
105 static gchar* vala_ccode_attribute_get_default_prefix (ValaCCodeAttribute* self);
106 static gchar* vala_ccode_attribute_get_default_lower_case_prefix (ValaCCodeAttribute* self);
107 static gchar* vala_ccode_attribute_get_default_lower_case_suffix (ValaCCodeAttribute* self);
108 static gchar* vala_ccode_attribute_get_default_ref_function (ValaCCodeAttribute* self);
109 static gboolean* _bool_dup (gboolean* self);
110 static gchar* vala_ccode_attribute_get_default_unref_function (ValaCCodeAttribute* self);
111 static gchar* vala_ccode_attribute_get_default_ref_sink_function (ValaCCodeAttribute* self);
112 static gchar* vala_ccode_attribute_get_default_free_function (ValaCCodeAttribute* self);
113 static gchar* vala_ccode_attribute_get_default_type_id (ValaCCodeAttribute* self);
114 static gchar* vala_ccode_attribute_get_default_marshaller_type_name (ValaCCodeAttribute* self);
115 static gchar* vala_ccode_attribute_get_default_get_value_function (ValaCCodeAttribute* self);
116 static gchar* vala_ccode_attribute_get_default_set_value_function (ValaCCodeAttribute* self);
117 static gchar* vala_ccode_attribute_get_default_take_value_function (ValaCCodeAttribute* self);
118 static gchar* vala_ccode_attribute_get_default_param_spec_function (ValaCCodeAttribute* self);
119 static gchar* vala_ccode_attribute_get_default_default_value (ValaCCodeAttribute* self);
120 static gdouble* _double_dup (gdouble* self);
121 static gchar* vala_ccode_attribute_get_default_real_name (ValaCCodeAttribute* self);
122 static gchar* vala_ccode_attribute_get_finish_name_for_basename (ValaCCodeAttribute* self,
123 const gchar* basename);
124 static gboolean vala_ccode_attribute_get_default_delegate_target (ValaCCodeAttribute* self);
125 static gboolean vala_ccode_attribute_get_default_array_length (ValaCCodeAttribute* self);
126 static gboolean vala_ccode_attribute_get_default_array_null_terminated (ValaCCodeAttribute* self);
127 static gchar* vala_ccode_attribute_get_default_array_length_type (ValaCCodeAttribute* self);
128 static void vala_ccode_attribute_set_array_length_name (ValaCCodeAttribute* self,
129 const gchar* value);
130 static void vala_ccode_attribute_set_array_length_expr (ValaCCodeAttribute* self,
131 const gchar* value);
132 G_GNUC_INTERNAL ValaCCodeAttribute* vala_get_ccode_attribute (ValaCodeNode* node);
133 static void vala_ccode_attribute_finalize (ValaAttributeCache * obj);
134 static GType vala_ccode_attribute_get_type_once (void);
135
136 static inline gpointer
vala_ccode_attribute_get_instance_private(ValaCCodeAttribute * self)137 vala_ccode_attribute_get_instance_private (ValaCCodeAttribute* self)
138 {
139 return G_STRUCT_MEMBER_P (self, ValaCCodeAttribute_private_offset);
140 }
141
142 const gchar*
vala_ccode_attribute_get_name(ValaCCodeAttribute * self)143 vala_ccode_attribute_get_name (ValaCCodeAttribute* self)
144 {
145 const gchar* result;
146 const gchar* _tmp0_;
147 const gchar* _tmp6_;
148 g_return_val_if_fail (self != NULL, NULL);
149 _tmp0_ = self->priv->_name;
150 if (_tmp0_ == NULL) {
151 ValaAttribute* _tmp1_;
152 const gchar* _tmp4_;
153 _tmp1_ = self->priv->ccode;
154 if (_tmp1_ != NULL) {
155 ValaAttribute* _tmp2_;
156 gchar* _tmp3_;
157 _tmp2_ = self->priv->ccode;
158 _tmp3_ = vala_attribute_get_string (_tmp2_, "cname", NULL);
159 _g_free0 (self->priv->_name);
160 self->priv->_name = _tmp3_;
161 }
162 _tmp4_ = self->priv->_name;
163 if (_tmp4_ == NULL) {
164 gchar* _tmp5_;
165 _tmp5_ = vala_ccode_attribute_get_default_name (self);
166 _g_free0 (self->priv->_name);
167 self->priv->_name = _tmp5_;
168 }
169 }
170 _tmp6_ = self->priv->_name;
171 result = _tmp6_;
172 return result;
173 }
174
175 const gchar*
vala_ccode_attribute_get_const_name(ValaCCodeAttribute * self)176 vala_ccode_attribute_get_const_name (ValaCCodeAttribute* self)
177 {
178 const gchar* result;
179 const gchar* _tmp0_;
180 const gchar* _tmp6_;
181 g_return_val_if_fail (self != NULL, NULL);
182 _tmp0_ = self->priv->_const_name;
183 if (_tmp0_ == NULL) {
184 ValaAttribute* _tmp1_;
185 const gchar* _tmp4_;
186 _tmp1_ = self->priv->ccode;
187 if (_tmp1_ != NULL) {
188 ValaAttribute* _tmp2_;
189 gchar* _tmp3_;
190 _tmp2_ = self->priv->ccode;
191 _tmp3_ = vala_attribute_get_string (_tmp2_, "const_cname", NULL);
192 _g_free0 (self->priv->_const_name);
193 self->priv->_const_name = _tmp3_;
194 }
195 _tmp4_ = self->priv->_const_name;
196 if (_tmp4_ == NULL) {
197 gchar* _tmp5_;
198 _tmp5_ = vala_ccode_attribute_get_default_const_name (self);
199 _g_free0 (self->priv->_const_name);
200 self->priv->_const_name = _tmp5_;
201 }
202 }
203 _tmp6_ = self->priv->_const_name;
204 result = _tmp6_;
205 return result;
206 }
207
208 const gchar*
vala_ccode_attribute_get_type_name(ValaCCodeAttribute * self)209 vala_ccode_attribute_get_type_name (ValaCCodeAttribute* self)
210 {
211 const gchar* result;
212 const gchar* _tmp0_;
213 const gchar* _tmp19_;
214 g_return_val_if_fail (self != NULL, NULL);
215 _tmp0_ = self->priv->_type_name;
216 if (_tmp0_ == NULL) {
217 ValaAttribute* _tmp1_;
218 const gchar* _tmp4_;
219 _tmp1_ = self->priv->ccode;
220 if (_tmp1_ != NULL) {
221 ValaAttribute* _tmp2_;
222 gchar* _tmp3_;
223 _tmp2_ = self->priv->ccode;
224 _tmp3_ = vala_attribute_get_string (_tmp2_, "type_cname", NULL);
225 _g_free0 (self->priv->_type_name);
226 self->priv->_type_name = _tmp3_;
227 }
228 _tmp4_ = self->priv->_type_name;
229 if (_tmp4_ == NULL) {
230 ValaSymbol* _tmp5_;
231 _tmp5_ = self->priv->sym;
232 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp5_, VALA_TYPE_CLASS)) {
233 ValaSymbol* _tmp6_;
234 gchar* _tmp7_;
235 gchar* _tmp8_;
236 gchar* _tmp9_;
237 _tmp6_ = self->priv->sym;
238 _tmp7_ = vala_get_ccode_name ((ValaCodeNode*) _tmp6_);
239 _tmp8_ = _tmp7_;
240 _tmp9_ = g_strdup_printf ("%sClass", _tmp8_);
241 _g_free0 (self->priv->_type_name);
242 self->priv->_type_name = _tmp9_;
243 _g_free0 (_tmp8_);
244 } else {
245 ValaSymbol* _tmp10_;
246 _tmp10_ = self->priv->sym;
247 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp10_, VALA_TYPE_INTERFACE)) {
248 ValaSymbol* _tmp11_;
249 gchar* _tmp12_;
250 gchar* _tmp13_;
251 gchar* _tmp14_;
252 _tmp11_ = self->priv->sym;
253 _tmp12_ = vala_get_ccode_name ((ValaCodeNode*) _tmp11_);
254 _tmp13_ = _tmp12_;
255 _tmp14_ = g_strdup_printf ("%sIface", _tmp13_);
256 _g_free0 (self->priv->_type_name);
257 self->priv->_type_name = _tmp14_;
258 _g_free0 (_tmp13_);
259 } else {
260 ValaSymbol* _tmp15_;
261 ValaSourceReference* _tmp16_;
262 ValaSourceReference* _tmp17_;
263 gchar* _tmp18_;
264 _tmp15_ = self->priv->sym;
265 _tmp16_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp15_);
266 _tmp17_ = _tmp16_;
267 vala_report_error (_tmp17_, "`CCode.type_cname' not supported");
268 _tmp18_ = g_strdup ("");
269 _g_free0 (self->priv->_type_name);
270 self->priv->_type_name = _tmp18_;
271 }
272 }
273 }
274 }
275 _tmp19_ = self->priv->_type_name;
276 result = _tmp19_;
277 return result;
278 }
279
280 const gchar*
vala_ccode_attribute_get_feature_test_macros(ValaCCodeAttribute * self)281 vala_ccode_attribute_get_feature_test_macros (ValaCCodeAttribute* self)
282 {
283 const gchar* result;
284 const gchar* _tmp0_;
285 const gchar* _tmp6_;
286 g_return_val_if_fail (self != NULL, NULL);
287 _tmp0_ = self->priv->_feature_test_macros;
288 if (_tmp0_ == NULL) {
289 ValaAttribute* _tmp1_;
290 const gchar* _tmp4_;
291 _tmp1_ = self->priv->ccode;
292 if (_tmp1_ != NULL) {
293 ValaAttribute* _tmp2_;
294 gchar* _tmp3_;
295 _tmp2_ = self->priv->ccode;
296 _tmp3_ = vala_attribute_get_string (_tmp2_, "feature_test_macro", NULL);
297 _g_free0 (self->priv->_feature_test_macros);
298 self->priv->_feature_test_macros = _tmp3_;
299 }
300 _tmp4_ = self->priv->_feature_test_macros;
301 if (_tmp4_ == NULL) {
302 gchar* _tmp5_;
303 _tmp5_ = g_strdup ("");
304 _g_free0 (self->priv->_feature_test_macros);
305 self->priv->_feature_test_macros = _tmp5_;
306 }
307 }
308 _tmp6_ = self->priv->_feature_test_macros;
309 result = _tmp6_;
310 return result;
311 }
312
313 const gchar*
vala_ccode_attribute_get_header_filenames(ValaCCodeAttribute * self)314 vala_ccode_attribute_get_header_filenames (ValaCCodeAttribute* self)
315 {
316 const gchar* result;
317 const gchar* _tmp0_;
318 const gchar* _tmp6_;
319 g_return_val_if_fail (self != NULL, NULL);
320 _tmp0_ = self->priv->_header_filenames;
321 if (_tmp0_ == NULL) {
322 ValaAttribute* _tmp1_;
323 const gchar* _tmp4_;
324 _tmp1_ = self->priv->ccode;
325 if (_tmp1_ != NULL) {
326 ValaAttribute* _tmp2_;
327 gchar* _tmp3_;
328 _tmp2_ = self->priv->ccode;
329 _tmp3_ = vala_attribute_get_string (_tmp2_, "cheader_filename", NULL);
330 _g_free0 (self->priv->_header_filenames);
331 self->priv->_header_filenames = _tmp3_;
332 }
333 _tmp4_ = self->priv->_header_filenames;
334 if (_tmp4_ == NULL) {
335 gchar* _tmp5_;
336 _tmp5_ = vala_ccode_attribute_get_default_header_filenames (self);
337 _g_free0 (self->priv->_header_filenames);
338 self->priv->_header_filenames = _tmp5_;
339 }
340 }
341 _tmp6_ = self->priv->_header_filenames;
342 result = _tmp6_;
343 return result;
344 }
345
346 const gchar*
vala_ccode_attribute_get_prefix(ValaCCodeAttribute * self)347 vala_ccode_attribute_get_prefix (ValaCCodeAttribute* self)
348 {
349 const gchar* result;
350 const gchar* _tmp0_;
351 const gchar* _tmp6_;
352 g_return_val_if_fail (self != NULL, NULL);
353 _tmp0_ = self->priv->_prefix;
354 if (_tmp0_ == NULL) {
355 ValaAttribute* _tmp1_;
356 const gchar* _tmp4_;
357 _tmp1_ = self->priv->ccode;
358 if (_tmp1_ != NULL) {
359 ValaAttribute* _tmp2_;
360 gchar* _tmp3_;
361 _tmp2_ = self->priv->ccode;
362 _tmp3_ = vala_attribute_get_string (_tmp2_, "cprefix", NULL);
363 _g_free0 (self->priv->_prefix);
364 self->priv->_prefix = _tmp3_;
365 }
366 _tmp4_ = self->priv->_prefix;
367 if (_tmp4_ == NULL) {
368 gchar* _tmp5_;
369 _tmp5_ = vala_ccode_attribute_get_default_prefix (self);
370 _g_free0 (self->priv->_prefix);
371 self->priv->_prefix = _tmp5_;
372 }
373 }
374 _tmp6_ = self->priv->_prefix;
375 result = _tmp6_;
376 return result;
377 }
378
379 const gchar*
vala_ccode_attribute_get_lower_case_prefix(ValaCCodeAttribute * self)380 vala_ccode_attribute_get_lower_case_prefix (ValaCCodeAttribute* self)
381 {
382 const gchar* result;
383 const gchar* _tmp0_;
384 const gchar* _tmp13_;
385 g_return_val_if_fail (self != NULL, NULL);
386 _tmp0_ = self->priv->_lower_case_prefix;
387 if (_tmp0_ == NULL) {
388 ValaAttribute* _tmp1_;
389 const gchar* _tmp11_;
390 _tmp1_ = self->priv->ccode;
391 if (_tmp1_ != NULL) {
392 ValaAttribute* _tmp2_;
393 gchar* _tmp3_;
394 gboolean _tmp4_ = FALSE;
395 const gchar* _tmp5_;
396 _tmp2_ = self->priv->ccode;
397 _tmp3_ = vala_attribute_get_string (_tmp2_, "lower_case_cprefix", NULL);
398 _g_free0 (self->priv->_lower_case_prefix);
399 self->priv->_lower_case_prefix = _tmp3_;
400 _tmp5_ = self->priv->_lower_case_prefix;
401 if (_tmp5_ == NULL) {
402 gboolean _tmp6_ = FALSE;
403 ValaSymbol* _tmp7_;
404 _tmp7_ = self->priv->sym;
405 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp7_, VALA_TYPE_OBJECT_TYPE_SYMBOL)) {
406 _tmp6_ = TRUE;
407 } else {
408 ValaSymbol* _tmp8_;
409 _tmp8_ = self->priv->sym;
410 _tmp6_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp8_, VALA_TYPE_STRUCT);
411 }
412 _tmp4_ = _tmp6_;
413 } else {
414 _tmp4_ = FALSE;
415 }
416 if (_tmp4_) {
417 ValaAttribute* _tmp9_;
418 gchar* _tmp10_;
419 _tmp9_ = self->priv->ccode;
420 _tmp10_ = vala_attribute_get_string (_tmp9_, "cprefix", NULL);
421 _g_free0 (self->priv->_lower_case_prefix);
422 self->priv->_lower_case_prefix = _tmp10_;
423 }
424 }
425 _tmp11_ = self->priv->_lower_case_prefix;
426 if (_tmp11_ == NULL) {
427 gchar* _tmp12_;
428 _tmp12_ = vala_ccode_attribute_get_default_lower_case_prefix (self);
429 _g_free0 (self->priv->_lower_case_prefix);
430 self->priv->_lower_case_prefix = _tmp12_;
431 }
432 }
433 _tmp13_ = self->priv->_lower_case_prefix;
434 result = _tmp13_;
435 return result;
436 }
437
438 const gchar*
vala_ccode_attribute_get_lower_case_suffix(ValaCCodeAttribute * self)439 vala_ccode_attribute_get_lower_case_suffix (ValaCCodeAttribute* self)
440 {
441 const gchar* result;
442 const gchar* _tmp0_;
443 const gchar* _tmp6_;
444 g_return_val_if_fail (self != NULL, NULL);
445 _tmp0_ = self->priv->_lower_case_suffix;
446 if (_tmp0_ == NULL) {
447 ValaAttribute* _tmp1_;
448 const gchar* _tmp4_;
449 _tmp1_ = self->priv->ccode;
450 if (_tmp1_ != NULL) {
451 ValaAttribute* _tmp2_;
452 gchar* _tmp3_;
453 _tmp2_ = self->priv->ccode;
454 _tmp3_ = vala_attribute_get_string (_tmp2_, "lower_case_csuffix", NULL);
455 _g_free0 (self->priv->_lower_case_suffix);
456 self->priv->_lower_case_suffix = _tmp3_;
457 }
458 _tmp4_ = self->priv->_lower_case_suffix;
459 if (_tmp4_ == NULL) {
460 gchar* _tmp5_;
461 _tmp5_ = vala_ccode_attribute_get_default_lower_case_suffix (self);
462 _g_free0 (self->priv->_lower_case_suffix);
463 self->priv->_lower_case_suffix = _tmp5_;
464 }
465 }
466 _tmp6_ = self->priv->_lower_case_suffix;
467 result = _tmp6_;
468 return result;
469 }
470
471 const gchar*
vala_ccode_attribute_get_ref_function(ValaCCodeAttribute * self)472 vala_ccode_attribute_get_ref_function (ValaCCodeAttribute* self)
473 {
474 const gchar* result;
475 const gchar* _tmp5_;
476 g_return_val_if_fail (self != NULL, NULL);
477 if (!self->priv->ref_function_set) {
478 ValaAttribute* _tmp0_;
479 const gchar* _tmp3_;
480 _tmp0_ = self->priv->ccode;
481 if (_tmp0_ != NULL) {
482 ValaAttribute* _tmp1_;
483 gchar* _tmp2_;
484 _tmp1_ = self->priv->ccode;
485 _tmp2_ = vala_attribute_get_string (_tmp1_, "ref_function", NULL);
486 _g_free0 (self->priv->_ref_function);
487 self->priv->_ref_function = _tmp2_;
488 }
489 _tmp3_ = self->priv->_ref_function;
490 if (_tmp3_ == NULL) {
491 gchar* _tmp4_;
492 _tmp4_ = vala_ccode_attribute_get_default_ref_function (self);
493 _g_free0 (self->priv->_ref_function);
494 self->priv->_ref_function = _tmp4_;
495 }
496 self->priv->ref_function_set = TRUE;
497 }
498 _tmp5_ = self->priv->_ref_function;
499 result = _tmp5_;
500 return result;
501 }
502
503 static gboolean*
_bool_dup(gboolean * self)504 _bool_dup (gboolean* self)
505 {
506 gboolean* dup;
507 dup = g_new0 (gboolean, 1);
508 memcpy (dup, self, sizeof (gboolean));
509 return dup;
510 }
511
512 static gpointer
__bool_dup0(gpointer self)513 __bool_dup0 (gpointer self)
514 {
515 return self ? _bool_dup (self) : NULL;
516 }
517
518 static gpointer
_vala_code_node_ref0(gpointer self)519 _vala_code_node_ref0 (gpointer self)
520 {
521 return self ? vala_code_node_ref (self) : NULL;
522 }
523
524 gboolean
vala_ccode_attribute_get_ref_function_void(ValaCCodeAttribute * self)525 vala_ccode_attribute_get_ref_function_void (ValaCCodeAttribute* self)
526 {
527 gboolean result;
528 gboolean* _tmp0_;
529 gboolean* _tmp19_;
530 g_return_val_if_fail (self != NULL, FALSE);
531 _tmp0_ = self->priv->_ref_function_void;
532 if (_tmp0_ == NULL) {
533 gboolean _tmp1_ = FALSE;
534 ValaAttribute* _tmp2_;
535 _tmp2_ = self->priv->ccode;
536 if (_tmp2_ != NULL) {
537 ValaAttribute* _tmp3_;
538 _tmp3_ = self->priv->ccode;
539 _tmp1_ = vala_attribute_has_argument (_tmp3_, "ref_function_void");
540 } else {
541 _tmp1_ = FALSE;
542 }
543 if (_tmp1_) {
544 ValaAttribute* _tmp4_;
545 gboolean _tmp5_;
546 gboolean* _tmp6_;
547 _tmp4_ = self->priv->ccode;
548 _tmp5_ = vala_attribute_get_bool (_tmp4_, "ref_function_void", FALSE);
549 _tmp6_ = __bool_dup0 (&_tmp5_);
550 _g_free0 (self->priv->_ref_function_void);
551 self->priv->_ref_function_void = _tmp6_;
552 } else {
553 ValaClass* cl = NULL;
554 ValaSymbol* _tmp7_;
555 ValaClass* _tmp8_;
556 ValaClass* _tmp9_;
557 ValaClass* _tmp10_;
558 ValaClass* _tmp11_;
559 _tmp7_ = self->priv->sym;
560 _tmp8_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp7_, VALA_TYPE_CLASS, ValaClass));
561 cl = _tmp8_;
562 _tmp9_ = cl;
563 _tmp10_ = vala_class_get_base_class (_tmp9_);
564 _tmp11_ = _tmp10_;
565 if (_tmp11_ != NULL) {
566 ValaClass* _tmp12_;
567 ValaClass* _tmp13_;
568 ValaClass* _tmp14_;
569 gboolean _tmp15_;
570 gboolean* _tmp16_;
571 _tmp12_ = cl;
572 _tmp13_ = vala_class_get_base_class (_tmp12_);
573 _tmp14_ = _tmp13_;
574 _tmp15_ = vala_get_ccode_ref_function_void (_tmp14_);
575 _tmp16_ = __bool_dup0 (&_tmp15_);
576 _g_free0 (self->priv->_ref_function_void);
577 self->priv->_ref_function_void = _tmp16_;
578 } else {
579 gboolean _tmp17_;
580 gboolean* _tmp18_;
581 _tmp17_ = FALSE;
582 _tmp18_ = __bool_dup0 (&_tmp17_);
583 _g_free0 (self->priv->_ref_function_void);
584 self->priv->_ref_function_void = _tmp18_;
585 }
586 _vala_code_node_unref0 (cl);
587 }
588 }
589 _tmp19_ = self->priv->_ref_function_void;
590 result = *_tmp19_;
591 return result;
592 }
593
594 const gchar*
vala_ccode_attribute_get_unref_function(ValaCCodeAttribute * self)595 vala_ccode_attribute_get_unref_function (ValaCCodeAttribute* self)
596 {
597 const gchar* result;
598 const gchar* _tmp5_;
599 g_return_val_if_fail (self != NULL, NULL);
600 if (!self->priv->unref_function_set) {
601 ValaAttribute* _tmp0_;
602 const gchar* _tmp3_;
603 _tmp0_ = self->priv->ccode;
604 if (_tmp0_ != NULL) {
605 ValaAttribute* _tmp1_;
606 gchar* _tmp2_;
607 _tmp1_ = self->priv->ccode;
608 _tmp2_ = vala_attribute_get_string (_tmp1_, "unref_function", NULL);
609 _g_free0 (self->priv->_unref_function);
610 self->priv->_unref_function = _tmp2_;
611 }
612 _tmp3_ = self->priv->_unref_function;
613 if (_tmp3_ == NULL) {
614 gchar* _tmp4_;
615 _tmp4_ = vala_ccode_attribute_get_default_unref_function (self);
616 _g_free0 (self->priv->_unref_function);
617 self->priv->_unref_function = _tmp4_;
618 }
619 self->priv->unref_function_set = TRUE;
620 }
621 _tmp5_ = self->priv->_unref_function;
622 result = _tmp5_;
623 return result;
624 }
625
626 const gchar*
vala_ccode_attribute_get_ref_sink_function(ValaCCodeAttribute * self)627 vala_ccode_attribute_get_ref_sink_function (ValaCCodeAttribute* self)
628 {
629 const gchar* result;
630 const gchar* _tmp0_;
631 const gchar* _tmp6_;
632 g_return_val_if_fail (self != NULL, NULL);
633 _tmp0_ = self->priv->_ref_sink_function;
634 if (_tmp0_ == NULL) {
635 ValaAttribute* _tmp1_;
636 const gchar* _tmp4_;
637 _tmp1_ = self->priv->ccode;
638 if (_tmp1_ != NULL) {
639 ValaAttribute* _tmp2_;
640 gchar* _tmp3_;
641 _tmp2_ = self->priv->ccode;
642 _tmp3_ = vala_attribute_get_string (_tmp2_, "ref_sink_function", NULL);
643 _g_free0 (self->priv->_ref_sink_function);
644 self->priv->_ref_sink_function = _tmp3_;
645 }
646 _tmp4_ = self->priv->_ref_sink_function;
647 if (_tmp4_ == NULL) {
648 gchar* _tmp5_;
649 _tmp5_ = vala_ccode_attribute_get_default_ref_sink_function (self);
650 _g_free0 (self->priv->_ref_sink_function);
651 self->priv->_ref_sink_function = _tmp5_;
652 }
653 }
654 _tmp6_ = self->priv->_ref_sink_function;
655 result = _tmp6_;
656 return result;
657 }
658
659 const gchar*
vala_ccode_attribute_get_copy_function(ValaCCodeAttribute * self)660 vala_ccode_attribute_get_copy_function (ValaCCodeAttribute* self)
661 {
662 const gchar* result;
663 const gchar* _tmp9_;
664 g_return_val_if_fail (self != NULL, NULL);
665 if (!self->priv->copy_function_set) {
666 ValaAttribute* _tmp0_;
667 gboolean _tmp3_ = FALSE;
668 const gchar* _tmp4_;
669 _tmp0_ = self->priv->ccode;
670 if (_tmp0_ != NULL) {
671 ValaAttribute* _tmp1_;
672 gchar* _tmp2_;
673 _tmp1_ = self->priv->ccode;
674 _tmp2_ = vala_attribute_get_string (_tmp1_, "copy_function", NULL);
675 _g_free0 (self->priv->_copy_function);
676 self->priv->_copy_function = _tmp2_;
677 }
678 _tmp4_ = self->priv->_copy_function;
679 if (_tmp4_ == NULL) {
680 ValaSymbol* _tmp5_;
681 _tmp5_ = self->priv->sym;
682 _tmp3_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp5_, VALA_TYPE_STRUCT);
683 } else {
684 _tmp3_ = FALSE;
685 }
686 if (_tmp3_) {
687 const gchar* _tmp6_;
688 const gchar* _tmp7_;
689 gchar* _tmp8_;
690 _tmp6_ = vala_ccode_attribute_get_lower_case_prefix (self);
691 _tmp7_ = _tmp6_;
692 _tmp8_ = g_strdup_printf ("%scopy", _tmp7_);
693 _g_free0 (self->priv->_copy_function);
694 self->priv->_copy_function = _tmp8_;
695 }
696 self->priv->copy_function_set = TRUE;
697 }
698 _tmp9_ = self->priv->_copy_function;
699 result = _tmp9_;
700 return result;
701 }
702
703 const gchar*
vala_ccode_attribute_get_destroy_function(ValaCCodeAttribute * self)704 vala_ccode_attribute_get_destroy_function (ValaCCodeAttribute* self)
705 {
706 const gchar* result;
707 const gchar* _tmp9_;
708 g_return_val_if_fail (self != NULL, NULL);
709 if (!self->priv->destroy_function_set) {
710 ValaAttribute* _tmp0_;
711 gboolean _tmp3_ = FALSE;
712 const gchar* _tmp4_;
713 _tmp0_ = self->priv->ccode;
714 if (_tmp0_ != NULL) {
715 ValaAttribute* _tmp1_;
716 gchar* _tmp2_;
717 _tmp1_ = self->priv->ccode;
718 _tmp2_ = vala_attribute_get_string (_tmp1_, "destroy_function", NULL);
719 _g_free0 (self->priv->_destroy_function);
720 self->priv->_destroy_function = _tmp2_;
721 }
722 _tmp4_ = self->priv->_destroy_function;
723 if (_tmp4_ == NULL) {
724 ValaSymbol* _tmp5_;
725 _tmp5_ = self->priv->sym;
726 _tmp3_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp5_, VALA_TYPE_STRUCT);
727 } else {
728 _tmp3_ = FALSE;
729 }
730 if (_tmp3_) {
731 const gchar* _tmp6_;
732 const gchar* _tmp7_;
733 gchar* _tmp8_;
734 _tmp6_ = vala_ccode_attribute_get_lower_case_prefix (self);
735 _tmp7_ = _tmp6_;
736 _tmp8_ = g_strdup_printf ("%sdestroy", _tmp7_);
737 _g_free0 (self->priv->_destroy_function);
738 self->priv->_destroy_function = _tmp8_;
739 }
740 self->priv->destroy_function_set = TRUE;
741 }
742 _tmp9_ = self->priv->_destroy_function;
743 result = _tmp9_;
744 return result;
745 }
746
747 const gchar*
vala_ccode_attribute_get_dup_function(ValaCCodeAttribute * self)748 vala_ccode_attribute_get_dup_function (ValaCCodeAttribute* self)
749 {
750 const gchar* result;
751 const gchar* _tmp13_;
752 g_return_val_if_fail (self != NULL, NULL);
753 if (!self->priv->dup_function_set) {
754 ValaAttribute* _tmp0_;
755 gboolean _tmp3_ = FALSE;
756 gboolean _tmp4_ = FALSE;
757 const gchar* _tmp5_;
758 _tmp0_ = self->priv->ccode;
759 if (_tmp0_ != NULL) {
760 ValaAttribute* _tmp1_;
761 gchar* _tmp2_;
762 _tmp1_ = self->priv->ccode;
763 _tmp2_ = vala_attribute_get_string (_tmp1_, "dup_function", NULL);
764 _g_free0 (self->priv->_dup_function);
765 self->priv->_dup_function = _tmp2_;
766 }
767 _tmp5_ = self->priv->_dup_function;
768 if (_tmp5_ == NULL) {
769 ValaSymbol* _tmp6_;
770 gboolean _tmp7_;
771 gboolean _tmp8_;
772 _tmp6_ = self->priv->sym;
773 _tmp7_ = vala_symbol_get_external_package (_tmp6_);
774 _tmp8_ = _tmp7_;
775 _tmp4_ = !_tmp8_;
776 } else {
777 _tmp4_ = FALSE;
778 }
779 if (_tmp4_) {
780 ValaSymbol* _tmp9_;
781 _tmp9_ = self->priv->sym;
782 _tmp3_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp9_, VALA_TYPE_STRUCT);
783 } else {
784 _tmp3_ = FALSE;
785 }
786 if (_tmp3_) {
787 const gchar* _tmp10_;
788 const gchar* _tmp11_;
789 gchar* _tmp12_;
790 _tmp10_ = vala_ccode_attribute_get_lower_case_prefix (self);
791 _tmp11_ = _tmp10_;
792 _tmp12_ = g_strdup_printf ("%sdup", _tmp11_);
793 _g_free0 (self->priv->_dup_function);
794 self->priv->_dup_function = _tmp12_;
795 }
796 self->priv->dup_function_set = TRUE;
797 }
798 _tmp13_ = self->priv->_dup_function;
799 result = _tmp13_;
800 return result;
801 }
802
803 const gchar*
vala_ccode_attribute_get_free_function(ValaCCodeAttribute * self)804 vala_ccode_attribute_get_free_function (ValaCCodeAttribute* self)
805 {
806 const gchar* result;
807 const gchar* _tmp5_;
808 g_return_val_if_fail (self != NULL, NULL);
809 if (!self->priv->free_function_set) {
810 ValaAttribute* _tmp0_;
811 const gchar* _tmp3_;
812 _tmp0_ = self->priv->ccode;
813 if (_tmp0_ != NULL) {
814 ValaAttribute* _tmp1_;
815 gchar* _tmp2_;
816 _tmp1_ = self->priv->ccode;
817 _tmp2_ = vala_attribute_get_string (_tmp1_, "free_function", NULL);
818 _g_free0 (self->priv->_free_function);
819 self->priv->_free_function = _tmp2_;
820 }
821 _tmp3_ = self->priv->_free_function;
822 if (_tmp3_ == NULL) {
823 gchar* _tmp4_;
824 _tmp4_ = vala_ccode_attribute_get_default_free_function (self);
825 _g_free0 (self->priv->_free_function);
826 self->priv->_free_function = _tmp4_;
827 }
828 self->priv->free_function_set = TRUE;
829 }
830 _tmp5_ = self->priv->_free_function;
831 result = _tmp5_;
832 return result;
833 }
834
835 gboolean
vala_ccode_attribute_get_free_function_address_of(ValaCCodeAttribute * self)836 vala_ccode_attribute_get_free_function_address_of (ValaCCodeAttribute* self)
837 {
838 gboolean result;
839 gboolean* _tmp0_;
840 gboolean* _tmp18_;
841 g_return_val_if_fail (self != NULL, FALSE);
842 _tmp0_ = self->priv->_free_function_address_of;
843 if (_tmp0_ == NULL) {
844 gboolean _tmp1_ = FALSE;
845 ValaAttribute* _tmp2_;
846 _tmp2_ = self->priv->ccode;
847 if (_tmp2_ != NULL) {
848 ValaAttribute* _tmp3_;
849 _tmp3_ = self->priv->ccode;
850 _tmp1_ = vala_attribute_has_argument (_tmp3_, "free_function_address_of");
851 } else {
852 _tmp1_ = FALSE;
853 }
854 if (_tmp1_) {
855 ValaAttribute* _tmp4_;
856 gboolean _tmp5_;
857 gboolean* _tmp6_;
858 _tmp4_ = self->priv->ccode;
859 _tmp5_ = vala_attribute_get_bool (_tmp4_, "free_function_address_of", FALSE);
860 _tmp6_ = __bool_dup0 (&_tmp5_);
861 _g_free0 (self->priv->_free_function_address_of);
862 self->priv->_free_function_address_of = _tmp6_;
863 } else {
864 ValaClass* cl = NULL;
865 ValaSymbol* _tmp7_;
866 ValaClass* _tmp8_;
867 ValaClass* _tmp9_;
868 ValaClass* _tmp10_;
869 _tmp7_ = self->priv->sym;
870 cl = G_TYPE_CHECK_INSTANCE_CAST (_tmp7_, VALA_TYPE_CLASS, ValaClass);
871 _tmp8_ = cl;
872 _tmp9_ = vala_class_get_base_class (_tmp8_);
873 _tmp10_ = _tmp9_;
874 if (_tmp10_ != NULL) {
875 ValaClass* _tmp11_;
876 ValaClass* _tmp12_;
877 ValaClass* _tmp13_;
878 gboolean _tmp14_;
879 gboolean* _tmp15_;
880 _tmp11_ = cl;
881 _tmp12_ = vala_class_get_base_class (_tmp11_);
882 _tmp13_ = _tmp12_;
883 _tmp14_ = vala_get_ccode_free_function_address_of (_tmp13_);
884 _tmp15_ = __bool_dup0 (&_tmp14_);
885 _g_free0 (self->priv->_free_function_address_of);
886 self->priv->_free_function_address_of = _tmp15_;
887 } else {
888 gboolean _tmp16_;
889 gboolean* _tmp17_;
890 _tmp16_ = FALSE;
891 _tmp17_ = __bool_dup0 (&_tmp16_);
892 _g_free0 (self->priv->_free_function_address_of);
893 self->priv->_free_function_address_of = _tmp17_;
894 }
895 }
896 }
897 _tmp18_ = self->priv->_free_function_address_of;
898 result = *_tmp18_;
899 return result;
900 }
901
902 const gchar*
vala_ccode_attribute_get_ctype(ValaCCodeAttribute * self)903 vala_ccode_attribute_get_ctype (ValaCCodeAttribute* self)
904 {
905 const gchar* result;
906 const gchar* _tmp10_;
907 g_return_val_if_fail (self != NULL, NULL);
908 if (!self->priv->ctype_set) {
909 ValaAttribute* _tmp0_;
910 _tmp0_ = self->priv->ccode;
911 if (_tmp0_ != NULL) {
912 ValaAttribute* _tmp1_;
913 gchar* _tmp2_;
914 const gchar* _tmp3_;
915 _tmp1_ = self->priv->ccode;
916 _tmp2_ = vala_attribute_get_string (_tmp1_, "type", NULL);
917 _g_free0 (self->priv->_ctype);
918 self->priv->_ctype = _tmp2_;
919 _tmp3_ = self->priv->_ctype;
920 if (_tmp3_ == NULL) {
921 ValaAttribute* _tmp4_;
922 gchar* _tmp5_;
923 const gchar* _tmp6_;
924 _tmp4_ = self->priv->ccode;
925 _tmp5_ = vala_attribute_get_string (_tmp4_, "ctype", NULL);
926 _g_free0 (self->priv->_ctype);
927 self->priv->_ctype = _tmp5_;
928 _tmp6_ = self->priv->_ctype;
929 if (_tmp6_ != NULL) {
930 ValaCodeNode* _tmp7_;
931 ValaSourceReference* _tmp8_;
932 ValaSourceReference* _tmp9_;
933 _tmp7_ = self->priv->node;
934 _tmp8_ = vala_code_node_get_source_reference (_tmp7_);
935 _tmp9_ = _tmp8_;
936 vala_report_deprecated (_tmp9_, "[CCode (ctype = \"...\")] is deprecated, use [CCode (type = \"...\")] " \
937 "instead.");
938 }
939 }
940 }
941 self->priv->ctype_set = TRUE;
942 }
943 _tmp10_ = self->priv->_ctype;
944 result = _tmp10_;
945 return result;
946 }
947
948 const gchar*
vala_ccode_attribute_get_type_id(ValaCCodeAttribute * self)949 vala_ccode_attribute_get_type_id (ValaCCodeAttribute* self)
950 {
951 const gchar* result;
952 const gchar* _tmp0_;
953 const gchar* _tmp6_;
954 g_return_val_if_fail (self != NULL, NULL);
955 _tmp0_ = self->priv->_type_id;
956 if (_tmp0_ == NULL) {
957 ValaAttribute* _tmp1_;
958 const gchar* _tmp4_;
959 _tmp1_ = self->priv->ccode;
960 if (_tmp1_ != NULL) {
961 ValaAttribute* _tmp2_;
962 gchar* _tmp3_;
963 _tmp2_ = self->priv->ccode;
964 _tmp3_ = vala_attribute_get_string (_tmp2_, "type_id", NULL);
965 _g_free0 (self->priv->_type_id);
966 self->priv->_type_id = _tmp3_;
967 }
968 _tmp4_ = self->priv->_type_id;
969 if (_tmp4_ == NULL) {
970 gchar* _tmp5_;
971 _tmp5_ = vala_ccode_attribute_get_default_type_id (self);
972 _g_free0 (self->priv->_type_id);
973 self->priv->_type_id = _tmp5_;
974 }
975 }
976 _tmp6_ = self->priv->_type_id;
977 result = _tmp6_;
978 return result;
979 }
980
981 const gchar*
vala_ccode_attribute_get_marshaller_type_name(ValaCCodeAttribute * self)982 vala_ccode_attribute_get_marshaller_type_name (ValaCCodeAttribute* self)
983 {
984 const gchar* result;
985 const gchar* _tmp0_;
986 const gchar* _tmp6_;
987 g_return_val_if_fail (self != NULL, NULL);
988 _tmp0_ = self->priv->_marshaller_type_name;
989 if (_tmp0_ == NULL) {
990 ValaAttribute* _tmp1_;
991 const gchar* _tmp4_;
992 _tmp1_ = self->priv->ccode;
993 if (_tmp1_ != NULL) {
994 ValaAttribute* _tmp2_;
995 gchar* _tmp3_;
996 _tmp2_ = self->priv->ccode;
997 _tmp3_ = vala_attribute_get_string (_tmp2_, "marshaller_type_name", NULL);
998 _g_free0 (self->priv->_marshaller_type_name);
999 self->priv->_marshaller_type_name = _tmp3_;
1000 }
1001 _tmp4_ = self->priv->_marshaller_type_name;
1002 if (_tmp4_ == NULL) {
1003 gchar* _tmp5_;
1004 _tmp5_ = vala_ccode_attribute_get_default_marshaller_type_name (self);
1005 _g_free0 (self->priv->_marshaller_type_name);
1006 self->priv->_marshaller_type_name = _tmp5_;
1007 }
1008 }
1009 _tmp6_ = self->priv->_marshaller_type_name;
1010 result = _tmp6_;
1011 return result;
1012 }
1013
1014 const gchar*
vala_ccode_attribute_get_get_value_function(ValaCCodeAttribute * self)1015 vala_ccode_attribute_get_get_value_function (ValaCCodeAttribute* self)
1016 {
1017 const gchar* result;
1018 const gchar* _tmp0_;
1019 const gchar* _tmp6_;
1020 g_return_val_if_fail (self != NULL, NULL);
1021 _tmp0_ = self->priv->_get_value_function;
1022 if (_tmp0_ == NULL) {
1023 ValaAttribute* _tmp1_;
1024 const gchar* _tmp4_;
1025 _tmp1_ = self->priv->ccode;
1026 if (_tmp1_ != NULL) {
1027 ValaAttribute* _tmp2_;
1028 gchar* _tmp3_;
1029 _tmp2_ = self->priv->ccode;
1030 _tmp3_ = vala_attribute_get_string (_tmp2_, "get_value_function", NULL);
1031 _g_free0 (self->priv->_get_value_function);
1032 self->priv->_get_value_function = _tmp3_;
1033 }
1034 _tmp4_ = self->priv->_get_value_function;
1035 if (_tmp4_ == NULL) {
1036 gchar* _tmp5_;
1037 _tmp5_ = vala_ccode_attribute_get_default_get_value_function (self);
1038 _g_free0 (self->priv->_get_value_function);
1039 self->priv->_get_value_function = _tmp5_;
1040 }
1041 }
1042 _tmp6_ = self->priv->_get_value_function;
1043 result = _tmp6_;
1044 return result;
1045 }
1046
1047 const gchar*
vala_ccode_attribute_get_set_value_function(ValaCCodeAttribute * self)1048 vala_ccode_attribute_get_set_value_function (ValaCCodeAttribute* self)
1049 {
1050 const gchar* result;
1051 const gchar* _tmp0_;
1052 const gchar* _tmp6_;
1053 g_return_val_if_fail (self != NULL, NULL);
1054 _tmp0_ = self->priv->_set_value_function;
1055 if (_tmp0_ == NULL) {
1056 ValaAttribute* _tmp1_;
1057 const gchar* _tmp4_;
1058 _tmp1_ = self->priv->ccode;
1059 if (_tmp1_ != NULL) {
1060 ValaAttribute* _tmp2_;
1061 gchar* _tmp3_;
1062 _tmp2_ = self->priv->ccode;
1063 _tmp3_ = vala_attribute_get_string (_tmp2_, "set_value_function", NULL);
1064 _g_free0 (self->priv->_set_value_function);
1065 self->priv->_set_value_function = _tmp3_;
1066 }
1067 _tmp4_ = self->priv->_set_value_function;
1068 if (_tmp4_ == NULL) {
1069 gchar* _tmp5_;
1070 _tmp5_ = vala_ccode_attribute_get_default_set_value_function (self);
1071 _g_free0 (self->priv->_set_value_function);
1072 self->priv->_set_value_function = _tmp5_;
1073 }
1074 }
1075 _tmp6_ = self->priv->_set_value_function;
1076 result = _tmp6_;
1077 return result;
1078 }
1079
1080 const gchar*
vala_ccode_attribute_get_take_value_function(ValaCCodeAttribute * self)1081 vala_ccode_attribute_get_take_value_function (ValaCCodeAttribute* self)
1082 {
1083 const gchar* result;
1084 const gchar* _tmp0_;
1085 const gchar* _tmp6_;
1086 g_return_val_if_fail (self != NULL, NULL);
1087 _tmp0_ = self->priv->_take_value_function;
1088 if (_tmp0_ == NULL) {
1089 ValaAttribute* _tmp1_;
1090 const gchar* _tmp4_;
1091 _tmp1_ = self->priv->ccode;
1092 if (_tmp1_ != NULL) {
1093 ValaAttribute* _tmp2_;
1094 gchar* _tmp3_;
1095 _tmp2_ = self->priv->ccode;
1096 _tmp3_ = vala_attribute_get_string (_tmp2_, "take_value_function", NULL);
1097 _g_free0 (self->priv->_take_value_function);
1098 self->priv->_take_value_function = _tmp3_;
1099 }
1100 _tmp4_ = self->priv->_take_value_function;
1101 if (_tmp4_ == NULL) {
1102 gchar* _tmp5_;
1103 _tmp5_ = vala_ccode_attribute_get_default_take_value_function (self);
1104 _g_free0 (self->priv->_take_value_function);
1105 self->priv->_take_value_function = _tmp5_;
1106 }
1107 }
1108 _tmp6_ = self->priv->_take_value_function;
1109 result = _tmp6_;
1110 return result;
1111 }
1112
1113 const gchar*
vala_ccode_attribute_get_param_spec_function(ValaCCodeAttribute * self)1114 vala_ccode_attribute_get_param_spec_function (ValaCCodeAttribute* self)
1115 {
1116 const gchar* result;
1117 const gchar* _tmp0_;
1118 const gchar* _tmp6_;
1119 g_return_val_if_fail (self != NULL, NULL);
1120 _tmp0_ = self->priv->_param_spec_function;
1121 if (_tmp0_ == NULL) {
1122 ValaAttribute* _tmp1_;
1123 const gchar* _tmp4_;
1124 _tmp1_ = self->priv->ccode;
1125 if (_tmp1_ != NULL) {
1126 ValaAttribute* _tmp2_;
1127 gchar* _tmp3_;
1128 _tmp2_ = self->priv->ccode;
1129 _tmp3_ = vala_attribute_get_string (_tmp2_, "param_spec_function", NULL);
1130 _g_free0 (self->priv->_param_spec_function);
1131 self->priv->_param_spec_function = _tmp3_;
1132 }
1133 _tmp4_ = self->priv->_param_spec_function;
1134 if (_tmp4_ == NULL) {
1135 gchar* _tmp5_;
1136 _tmp5_ = vala_ccode_attribute_get_default_param_spec_function (self);
1137 _g_free0 (self->priv->_param_spec_function);
1138 self->priv->_param_spec_function = _tmp5_;
1139 }
1140 }
1141 _tmp6_ = self->priv->_param_spec_function;
1142 result = _tmp6_;
1143 return result;
1144 }
1145
1146 const gchar*
vala_ccode_attribute_get_default_value(ValaCCodeAttribute * self)1147 vala_ccode_attribute_get_default_value (ValaCCodeAttribute* self)
1148 {
1149 const gchar* result;
1150 const gchar* _tmp0_;
1151 const gchar* _tmp6_;
1152 g_return_val_if_fail (self != NULL, NULL);
1153 _tmp0_ = self->priv->_default_value;
1154 if (_tmp0_ == NULL) {
1155 ValaAttribute* _tmp1_;
1156 const gchar* _tmp4_;
1157 _tmp1_ = self->priv->ccode;
1158 if (_tmp1_ != NULL) {
1159 ValaAttribute* _tmp2_;
1160 gchar* _tmp3_;
1161 _tmp2_ = self->priv->ccode;
1162 _tmp3_ = vala_attribute_get_string (_tmp2_, "default_value", NULL);
1163 _g_free0 (self->priv->_default_value);
1164 self->priv->_default_value = _tmp3_;
1165 }
1166 _tmp4_ = self->priv->_default_value;
1167 if (_tmp4_ == NULL) {
1168 gchar* _tmp5_;
1169 _tmp5_ = vala_ccode_attribute_get_default_default_value (self);
1170 _g_free0 (self->priv->_default_value);
1171 self->priv->_default_value = _tmp5_;
1172 }
1173 }
1174 _tmp6_ = self->priv->_default_value;
1175 result = _tmp6_;
1176 return result;
1177 }
1178
1179 const gchar*
vala_ccode_attribute_get_default_value_on_error(ValaCCodeAttribute * self)1180 vala_ccode_attribute_get_default_value_on_error (ValaCCodeAttribute* self)
1181 {
1182 const gchar* result;
1183 const gchar* _tmp0_;
1184 const gchar* _tmp8_;
1185 g_return_val_if_fail (self != NULL, NULL);
1186 _tmp0_ = self->priv->_default_value_on_error;
1187 if (_tmp0_ == NULL) {
1188 ValaAttribute* _tmp1_;
1189 const gchar* _tmp4_;
1190 _tmp1_ = self->priv->ccode;
1191 if (_tmp1_ != NULL) {
1192 ValaAttribute* _tmp2_;
1193 gchar* _tmp3_;
1194 _tmp2_ = self->priv->ccode;
1195 _tmp3_ = vala_attribute_get_string (_tmp2_, "default_value_on_error", NULL);
1196 _g_free0 (self->priv->_default_value_on_error);
1197 self->priv->_default_value_on_error = _tmp3_;
1198 }
1199 _tmp4_ = self->priv->_default_value_on_error;
1200 if (_tmp4_ == NULL) {
1201 const gchar* _tmp5_;
1202 const gchar* _tmp6_;
1203 gchar* _tmp7_;
1204 _tmp5_ = vala_ccode_attribute_get_default_value (self);
1205 _tmp6_ = _tmp5_;
1206 _tmp7_ = g_strdup (_tmp6_);
1207 _g_free0 (self->priv->_default_value_on_error);
1208 self->priv->_default_value_on_error = _tmp7_;
1209 }
1210 }
1211 _tmp8_ = self->priv->_default_value_on_error;
1212 result = _tmp8_;
1213 return result;
1214 }
1215
1216 static gdouble*
_double_dup(gdouble * self)1217 _double_dup (gdouble* self)
1218 {
1219 gdouble* dup;
1220 dup = g_new0 (gdouble, 1);
1221 memcpy (dup, self, sizeof (gdouble));
1222 return dup;
1223 }
1224
1225 static gpointer
__double_dup0(gpointer self)1226 __double_dup0 (gpointer self)
1227 {
1228 return self ? _double_dup (self) : NULL;
1229 }
1230
1231 gdouble
vala_ccode_attribute_get_pos(ValaCCodeAttribute * self)1232 vala_ccode_attribute_get_pos (ValaCCodeAttribute* self)
1233 {
1234 gdouble result;
1235 gdouble* _tmp0_;
1236 gdouble* _tmp49_;
1237 g_return_val_if_fail (self != NULL, 0.0);
1238 _tmp0_ = self->priv->_pos;
1239 if (_tmp0_ == NULL) {
1240 gboolean _tmp1_ = FALSE;
1241 ValaAttribute* _tmp2_;
1242 _tmp2_ = self->priv->ccode;
1243 if (_tmp2_ != NULL) {
1244 ValaAttribute* _tmp3_;
1245 _tmp3_ = self->priv->ccode;
1246 _tmp1_ = vala_attribute_has_argument (_tmp3_, "pos");
1247 } else {
1248 _tmp1_ = FALSE;
1249 }
1250 if (_tmp1_) {
1251 ValaAttribute* _tmp4_;
1252 gdouble _tmp5_;
1253 gdouble* _tmp6_;
1254 _tmp4_ = self->priv->ccode;
1255 _tmp5_ = vala_attribute_get_double (_tmp4_, "pos", (gdouble) 0);
1256 _tmp6_ = __double_dup0 (&_tmp5_);
1257 _g_free0 (self->priv->_pos);
1258 self->priv->_pos = _tmp6_;
1259 } else {
1260 ValaParameter* param = NULL;
1261 ValaCodeNode* _tmp7_;
1262 ValaCallable* callable = NULL;
1263 ValaParameter* _tmp8_;
1264 ValaSymbol* _tmp9_;
1265 ValaSymbol* _tmp10_;
1266 ValaMethod* method = NULL;
1267 ValaParameter* _tmp11_;
1268 ValaSymbol* _tmp12_;
1269 ValaSymbol* _tmp13_;
1270 gboolean _tmp14_ = FALSE;
1271 ValaMethod* _tmp15_;
1272 _tmp7_ = self->priv->node;
1273 param = G_TYPE_CHECK_INSTANCE_CAST (_tmp7_, VALA_TYPE_PARAMETER, ValaParameter);
1274 _tmp8_ = param;
1275 _tmp9_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp8_);
1276 _tmp10_ = _tmp9_;
1277 callable = G_TYPE_CHECK_INSTANCE_TYPE (_tmp10_, VALA_TYPE_CALLABLE) ? ((ValaCallable*) _tmp10_) : NULL;
1278 _tmp11_ = param;
1279 _tmp12_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp11_);
1280 _tmp13_ = _tmp12_;
1281 method = G_TYPE_CHECK_INSTANCE_TYPE (_tmp13_, VALA_TYPE_METHOD) ? ((ValaMethod*) _tmp13_) : NULL;
1282 _tmp15_ = method;
1283 if (_tmp15_ != NULL) {
1284 ValaMethod* _tmp16_;
1285 gboolean _tmp17_;
1286 gboolean _tmp18_;
1287 _tmp16_ = method;
1288 _tmp17_ = vala_method_get_coroutine (_tmp16_);
1289 _tmp18_ = _tmp17_;
1290 _tmp14_ = _tmp18_;
1291 } else {
1292 _tmp14_ = FALSE;
1293 }
1294 if (_tmp14_) {
1295 gint index = 0;
1296 ValaMethod* _tmp19_;
1297 ValaList* _tmp20_;
1298 ValaList* _tmp21_;
1299 ValaParameter* _tmp22_;
1300 gint _tmp23_;
1301 gdouble _tmp39_;
1302 gdouble* _tmp40_;
1303 _tmp19_ = method;
1304 _tmp20_ = vala_method_get_async_begin_parameters (_tmp19_);
1305 _tmp21_ = _tmp20_;
1306 _tmp22_ = param;
1307 _tmp23_ = vala_list_index_of (_tmp21_, _tmp22_);
1308 _vala_iterable_unref0 (_tmp21_);
1309 index = _tmp23_;
1310 if (index < 0) {
1311 ValaMethod* _tmp24_;
1312 ValaList* _tmp25_;
1313 ValaList* _tmp26_;
1314 ValaParameter* _tmp27_;
1315 _tmp24_ = method;
1316 _tmp25_ = vala_method_get_async_end_parameters (_tmp24_);
1317 _tmp26_ = _tmp25_;
1318 _tmp27_ = param;
1319 index = vala_list_index_of (_tmp26_, _tmp27_);
1320 _vala_iterable_unref0 (_tmp26_);
1321 }
1322 if (index < 0) {
1323 ValaParameter* _tmp28_;
1324 ValaSourceReference* _tmp29_;
1325 ValaSourceReference* _tmp30_;
1326 ValaParameter* _tmp31_;
1327 const gchar* _tmp32_;
1328 const gchar* _tmp33_;
1329 ValaMethod* _tmp34_;
1330 gchar* _tmp35_;
1331 gchar* _tmp36_;
1332 gchar* _tmp37_;
1333 gchar* _tmp38_;
1334 _tmp28_ = param;
1335 _tmp29_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp28_);
1336 _tmp30_ = _tmp29_;
1337 _tmp31_ = param;
1338 _tmp32_ = vala_symbol_get_name ((ValaSymbol*) _tmp31_);
1339 _tmp33_ = _tmp32_;
1340 _tmp34_ = method;
1341 _tmp35_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp34_);
1342 _tmp36_ = _tmp35_;
1343 _tmp37_ = g_strdup_printf ("internal: Parameter `%s' not found in `%s'", _tmp33_, _tmp36_);
1344 _tmp38_ = _tmp37_;
1345 vala_report_error (_tmp30_, _tmp38_);
1346 _g_free0 (_tmp38_);
1347 _g_free0 (_tmp36_);
1348 }
1349 _tmp39_ = index + 1.0;
1350 _tmp40_ = __double_dup0 (&_tmp39_);
1351 _g_free0 (self->priv->_pos);
1352 self->priv->_pos = _tmp40_;
1353 } else {
1354 ValaCallable* _tmp41_;
1355 _tmp41_ = callable;
1356 if (_tmp41_ != NULL) {
1357 ValaCallable* _tmp42_;
1358 ValaList* _tmp43_;
1359 ValaParameter* _tmp44_;
1360 gdouble _tmp45_;
1361 gdouble* _tmp46_;
1362 _tmp42_ = callable;
1363 _tmp43_ = vala_callable_get_parameters (_tmp42_);
1364 _tmp44_ = param;
1365 _tmp45_ = vala_list_index_of (_tmp43_, _tmp44_) + 1.0;
1366 _tmp46_ = __double_dup0 (&_tmp45_);
1367 _g_free0 (self->priv->_pos);
1368 self->priv->_pos = _tmp46_;
1369 } else {
1370 gdouble _tmp47_;
1371 gdouble* _tmp48_;
1372 _tmp47_ = 0.0;
1373 _tmp48_ = __double_dup0 (&_tmp47_);
1374 _g_free0 (self->priv->_pos);
1375 self->priv->_pos = _tmp48_;
1376 }
1377 }
1378 }
1379 }
1380 _tmp49_ = self->priv->_pos;
1381 result = *_tmp49_;
1382 return result;
1383 }
1384
1385 const gchar*
vala_ccode_attribute_get_real_name(ValaCCodeAttribute * self)1386 vala_ccode_attribute_get_real_name (ValaCCodeAttribute* self)
1387 {
1388 const gchar* result;
1389 const gchar* _tmp0_;
1390 const gchar* _tmp8_;
1391 g_return_val_if_fail (self != NULL, NULL);
1392 _tmp0_ = self->priv->_real_name;
1393 if (_tmp0_ == NULL) {
1394 gboolean _tmp1_ = FALSE;
1395 ValaAttribute* _tmp2_;
1396 const gchar* _tmp6_;
1397 _tmp2_ = self->priv->ccode;
1398 if (_tmp2_ != NULL) {
1399 ValaSymbol* _tmp3_;
1400 _tmp3_ = self->priv->sym;
1401 _tmp1_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp3_, VALA_TYPE_CREATION_METHOD);
1402 } else {
1403 _tmp1_ = FALSE;
1404 }
1405 if (_tmp1_) {
1406 ValaAttribute* _tmp4_;
1407 gchar* _tmp5_;
1408 _tmp4_ = self->priv->ccode;
1409 _tmp5_ = vala_attribute_get_string (_tmp4_, "construct_function", NULL);
1410 _g_free0 (self->priv->_real_name);
1411 self->priv->_real_name = _tmp5_;
1412 }
1413 _tmp6_ = self->priv->_real_name;
1414 if (_tmp6_ == NULL) {
1415 gchar* _tmp7_;
1416 _tmp7_ = vala_ccode_attribute_get_default_real_name (self);
1417 _g_free0 (self->priv->_real_name);
1418 self->priv->_real_name = _tmp7_;
1419 }
1420 }
1421 _tmp8_ = self->priv->_real_name;
1422 result = _tmp8_;
1423 return result;
1424 }
1425
1426 const gchar*
vala_ccode_attribute_get_vfunc_name(ValaCCodeAttribute * self)1427 vala_ccode_attribute_get_vfunc_name (ValaCCodeAttribute* self)
1428 {
1429 const gchar* result;
1430 const gchar* _tmp0_;
1431 const gchar* _tmp19_;
1432 g_return_val_if_fail (self != NULL, NULL);
1433 _tmp0_ = self->priv->_vfunc_name;
1434 if (_tmp0_ == NULL) {
1435 ValaAttribute* _tmp1_;
1436 const gchar* _tmp4_;
1437 _tmp1_ = self->priv->ccode;
1438 if (_tmp1_ != NULL) {
1439 ValaAttribute* _tmp2_;
1440 gchar* _tmp3_;
1441 _tmp2_ = self->priv->ccode;
1442 _tmp3_ = vala_attribute_get_string (_tmp2_, "vfunc_name", NULL);
1443 _g_free0 (self->priv->_vfunc_name);
1444 self->priv->_vfunc_name = _tmp3_;
1445 }
1446 _tmp4_ = self->priv->_vfunc_name;
1447 if (_tmp4_ == NULL) {
1448 ValaMethod* m = NULL;
1449 ValaCodeNode* _tmp5_;
1450 gboolean _tmp6_ = FALSE;
1451 ValaMethod* _tmp7_;
1452 _tmp5_ = self->priv->node;
1453 m = G_TYPE_CHECK_INSTANCE_TYPE (_tmp5_, VALA_TYPE_METHOD) ? ((ValaMethod*) _tmp5_) : NULL;
1454 _tmp7_ = m;
1455 if (_tmp7_ != NULL) {
1456 ValaMethod* _tmp8_;
1457 ValaSignal* _tmp9_;
1458 ValaSignal* _tmp10_;
1459 _tmp8_ = m;
1460 _tmp9_ = vala_method_get_signal_reference (_tmp8_);
1461 _tmp10_ = _tmp9_;
1462 _tmp6_ = _tmp10_ != NULL;
1463 } else {
1464 _tmp6_ = FALSE;
1465 }
1466 if (_tmp6_) {
1467 ValaMethod* _tmp11_;
1468 ValaSignal* _tmp12_;
1469 ValaSignal* _tmp13_;
1470 gchar* _tmp14_;
1471 _tmp11_ = m;
1472 _tmp12_ = vala_method_get_signal_reference (_tmp11_);
1473 _tmp13_ = _tmp12_;
1474 _tmp14_ = vala_get_ccode_lower_case_name ((ValaCodeNode*) _tmp13_, NULL);
1475 _g_free0 (self->priv->_vfunc_name);
1476 self->priv->_vfunc_name = _tmp14_;
1477 } else {
1478 ValaSymbol* _tmp15_;
1479 const gchar* _tmp16_;
1480 const gchar* _tmp17_;
1481 gchar* _tmp18_;
1482 _tmp15_ = self->priv->sym;
1483 _tmp16_ = vala_symbol_get_name (_tmp15_);
1484 _tmp17_ = _tmp16_;
1485 _tmp18_ = g_strdup (_tmp17_);
1486 _g_free0 (self->priv->_vfunc_name);
1487 self->priv->_vfunc_name = _tmp18_;
1488 }
1489 }
1490 }
1491 _tmp19_ = self->priv->_vfunc_name;
1492 result = _tmp19_;
1493 return result;
1494 }
1495
1496 const gchar*
vala_ccode_attribute_get_finish_name(ValaCCodeAttribute * self)1497 vala_ccode_attribute_get_finish_name (ValaCCodeAttribute* self)
1498 {
1499 const gchar* result;
1500 const gchar* _tmp0_;
1501 const gchar* _tmp15_;
1502 g_return_val_if_fail (self != NULL, NULL);
1503 _tmp0_ = self->priv->_finish_name;
1504 if (_tmp0_ == NULL) {
1505 ValaAttribute* _tmp1_;
1506 const gchar* _tmp11_;
1507 _tmp1_ = self->priv->ccode;
1508 if (_tmp1_ != NULL) {
1509 ValaAttribute* _tmp2_;
1510 gchar* _tmp3_;
1511 const gchar* _tmp4_;
1512 _tmp2_ = self->priv->ccode;
1513 _tmp3_ = vala_attribute_get_string (_tmp2_, "finish_name", NULL);
1514 _g_free0 (self->priv->_finish_name);
1515 self->priv->_finish_name = _tmp3_;
1516 _tmp4_ = self->priv->_finish_name;
1517 if (_tmp4_ == NULL) {
1518 ValaAttribute* _tmp5_;
1519 gchar* _tmp6_;
1520 const gchar* _tmp7_;
1521 _tmp5_ = self->priv->ccode;
1522 _tmp6_ = vala_attribute_get_string (_tmp5_, "finish_function", NULL);
1523 _g_free0 (self->priv->_finish_name);
1524 self->priv->_finish_name = _tmp6_;
1525 _tmp7_ = self->priv->_finish_name;
1526 if (_tmp7_ != NULL) {
1527 ValaCodeNode* _tmp8_;
1528 ValaSourceReference* _tmp9_;
1529 ValaSourceReference* _tmp10_;
1530 _tmp8_ = self->priv->node;
1531 _tmp9_ = vala_code_node_get_source_reference (_tmp8_);
1532 _tmp10_ = _tmp9_;
1533 vala_report_deprecated (_tmp10_, "[CCode (finish_function = \"...\")] is deprecated, use [CCode (finish_" \
1534 "name = \"...\")] instead.");
1535 }
1536 }
1537 }
1538 _tmp11_ = self->priv->_finish_name;
1539 if (_tmp11_ == NULL) {
1540 const gchar* _tmp12_;
1541 const gchar* _tmp13_;
1542 gchar* _tmp14_;
1543 _tmp12_ = vala_ccode_attribute_get_name (self);
1544 _tmp13_ = _tmp12_;
1545 _tmp14_ = vala_ccode_attribute_get_finish_name_for_basename (self, _tmp13_);
1546 _g_free0 (self->priv->_finish_name);
1547 self->priv->_finish_name = _tmp14_;
1548 }
1549 }
1550 _tmp15_ = self->priv->_finish_name;
1551 result = _tmp15_;
1552 return result;
1553 }
1554
1555 const gchar*
vala_ccode_attribute_get_finish_vfunc_name(ValaCCodeAttribute * self)1556 vala_ccode_attribute_get_finish_vfunc_name (ValaCCodeAttribute* self)
1557 {
1558 const gchar* result;
1559 const gchar* _tmp0_;
1560 const gchar* _tmp8_;
1561 g_return_val_if_fail (self != NULL, NULL);
1562 _tmp0_ = self->priv->_finish_vfunc_name;
1563 if (_tmp0_ == NULL) {
1564 ValaAttribute* _tmp1_;
1565 const gchar* _tmp4_;
1566 _tmp1_ = self->priv->ccode;
1567 if (_tmp1_ != NULL) {
1568 ValaAttribute* _tmp2_;
1569 gchar* _tmp3_;
1570 _tmp2_ = self->priv->ccode;
1571 _tmp3_ = vala_attribute_get_string (_tmp2_, "finish_vfunc_name", NULL);
1572 _g_free0 (self->priv->_finish_vfunc_name);
1573 self->priv->_finish_vfunc_name = _tmp3_;
1574 }
1575 _tmp4_ = self->priv->_finish_vfunc_name;
1576 if (_tmp4_ == NULL) {
1577 const gchar* _tmp5_;
1578 const gchar* _tmp6_;
1579 gchar* _tmp7_;
1580 _tmp5_ = vala_ccode_attribute_get_vfunc_name (self);
1581 _tmp6_ = _tmp5_;
1582 _tmp7_ = vala_ccode_attribute_get_finish_name_for_basename (self, _tmp6_);
1583 _g_free0 (self->priv->_finish_vfunc_name);
1584 self->priv->_finish_vfunc_name = _tmp7_;
1585 }
1586 }
1587 _tmp8_ = self->priv->_finish_vfunc_name;
1588 result = _tmp8_;
1589 return result;
1590 }
1591
1592 const gchar*
vala_ccode_attribute_get_finish_real_name(ValaCCodeAttribute * self)1593 vala_ccode_attribute_get_finish_real_name (ValaCCodeAttribute* self)
1594 {
1595 const gchar* result;
1596 const gchar* _tmp0_;
1597 const gchar* _tmp19_;
1598 g_return_val_if_fail (self != NULL, NULL);
1599 _tmp0_ = self->priv->_finish_real_name;
1600 if (_tmp0_ == NULL) {
1601 ValaMethod* m = NULL;
1602 ValaCodeNode* _tmp1_;
1603 gboolean _tmp2_ = FALSE;
1604 gboolean _tmp3_ = FALSE;
1605 ValaMethod* _tmp4_;
1606 _tmp1_ = self->priv->node;
1607 m = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1_, VALA_TYPE_METHOD) ? ((ValaMethod*) _tmp1_) : NULL;
1608 _tmp4_ = m;
1609 if (_tmp4_ != NULL) {
1610 ValaMethod* _tmp5_;
1611 _tmp5_ = m;
1612 _tmp3_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp5_, VALA_TYPE_CREATION_METHOD);
1613 } else {
1614 _tmp3_ = FALSE;
1615 }
1616 if (_tmp3_) {
1617 gboolean _tmp6_ = FALSE;
1618 ValaMethod* _tmp7_;
1619 gboolean _tmp8_;
1620 gboolean _tmp9_;
1621 _tmp7_ = m;
1622 _tmp8_ = vala_method_get_is_abstract (_tmp7_);
1623 _tmp9_ = _tmp8_;
1624 if (_tmp9_) {
1625 _tmp6_ = TRUE;
1626 } else {
1627 ValaMethod* _tmp10_;
1628 gboolean _tmp11_;
1629 gboolean _tmp12_;
1630 _tmp10_ = m;
1631 _tmp11_ = vala_method_get_is_virtual (_tmp10_);
1632 _tmp12_ = _tmp11_;
1633 _tmp6_ = _tmp12_;
1634 }
1635 _tmp2_ = !_tmp6_;
1636 } else {
1637 _tmp2_ = FALSE;
1638 }
1639 if (_tmp2_) {
1640 const gchar* _tmp13_;
1641 const gchar* _tmp14_;
1642 gchar* _tmp15_;
1643 _tmp13_ = vala_ccode_attribute_get_finish_name (self);
1644 _tmp14_ = _tmp13_;
1645 _tmp15_ = g_strdup (_tmp14_);
1646 _g_free0 (self->priv->_finish_real_name);
1647 self->priv->_finish_real_name = _tmp15_;
1648 } else {
1649 const gchar* _tmp16_;
1650 const gchar* _tmp17_;
1651 gchar* _tmp18_;
1652 _tmp16_ = vala_ccode_attribute_get_real_name (self);
1653 _tmp17_ = _tmp16_;
1654 _tmp18_ = vala_ccode_attribute_get_finish_name_for_basename (self, _tmp17_);
1655 _g_free0 (self->priv->_finish_real_name);
1656 self->priv->_finish_real_name = _tmp18_;
1657 }
1658 }
1659 _tmp19_ = self->priv->_finish_real_name;
1660 result = _tmp19_;
1661 return result;
1662 }
1663
1664 gboolean
vala_ccode_attribute_get_finish_instance(ValaCCodeAttribute * self)1665 vala_ccode_attribute_get_finish_instance (ValaCCodeAttribute* self)
1666 {
1667 gboolean result;
1668 gboolean* _tmp0_;
1669 gboolean* _tmp19_;
1670 g_return_val_if_fail (self != NULL, FALSE);
1671 _tmp0_ = self->priv->_finish_instance;
1672 if (_tmp0_ == NULL) {
1673 ValaMethod* m = NULL;
1674 ValaCodeNode* _tmp1_;
1675 gboolean is_creation_method = FALSE;
1676 ValaMethod* _tmp2_;
1677 gboolean _tmp3_ = FALSE;
1678 gboolean _tmp4_ = FALSE;
1679 gboolean _tmp5_ = FALSE;
1680 ValaAttribute* _tmp6_;
1681 _tmp1_ = self->priv->node;
1682 m = G_TYPE_CHECK_INSTANCE_TYPE (_tmp1_, VALA_TYPE_METHOD) ? ((ValaMethod*) _tmp1_) : NULL;
1683 _tmp2_ = m;
1684 is_creation_method = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2_, VALA_TYPE_CREATION_METHOD);
1685 _tmp6_ = self->priv->ccode;
1686 if (_tmp6_ == NULL) {
1687 _tmp5_ = TRUE;
1688 } else {
1689 ValaMethod* _tmp7_;
1690 _tmp7_ = m;
1691 _tmp5_ = _tmp7_ == NULL;
1692 }
1693 if (_tmp5_) {
1694 _tmp4_ = TRUE;
1695 } else {
1696 ValaMethod* _tmp8_;
1697 gboolean _tmp9_;
1698 gboolean _tmp10_;
1699 _tmp8_ = m;
1700 _tmp9_ = vala_method_get_is_abstract (_tmp8_);
1701 _tmp10_ = _tmp9_;
1702 _tmp4_ = _tmp10_;
1703 }
1704 if (_tmp4_) {
1705 _tmp3_ = TRUE;
1706 } else {
1707 ValaMethod* _tmp11_;
1708 gboolean _tmp12_;
1709 gboolean _tmp13_;
1710 _tmp11_ = m;
1711 _tmp12_ = vala_method_get_is_virtual (_tmp11_);
1712 _tmp13_ = _tmp12_;
1713 _tmp3_ = _tmp13_;
1714 }
1715 if (_tmp3_) {
1716 gboolean _tmp14_;
1717 gboolean* _tmp15_;
1718 _tmp14_ = !is_creation_method;
1719 _tmp15_ = __bool_dup0 (&_tmp14_);
1720 _g_free0 (self->priv->_finish_instance);
1721 self->priv->_finish_instance = _tmp15_;
1722 } else {
1723 ValaAttribute* _tmp16_;
1724 gboolean _tmp17_;
1725 gboolean* _tmp18_;
1726 _tmp16_ = self->priv->ccode;
1727 _tmp17_ = vala_attribute_get_bool (_tmp16_, "finish_instance", !is_creation_method);
1728 _tmp18_ = __bool_dup0 (&_tmp17_);
1729 _g_free0 (self->priv->_finish_instance);
1730 self->priv->_finish_instance = _tmp18_;
1731 }
1732 }
1733 _tmp19_ = self->priv->_finish_instance;
1734 result = *_tmp19_;
1735 return result;
1736 }
1737
1738 gboolean
vala_ccode_attribute_get_delegate_target(ValaCCodeAttribute * self)1739 vala_ccode_attribute_get_delegate_target (ValaCCodeAttribute* self)
1740 {
1741 gboolean result;
1742 gboolean* _tmp0_;
1743 gboolean* _tmp7_;
1744 g_return_val_if_fail (self != NULL, FALSE);
1745 _tmp0_ = self->priv->_delegate_target;
1746 if (_tmp0_ == NULL) {
1747 ValaAttribute* _tmp1_;
1748 _tmp1_ = self->priv->ccode;
1749 if (_tmp1_ != NULL) {
1750 ValaAttribute* _tmp2_;
1751 gboolean _tmp3_;
1752 gboolean* _tmp4_;
1753 _tmp2_ = self->priv->ccode;
1754 _tmp3_ = vala_attribute_get_bool (_tmp2_, "delegate_target", vala_ccode_attribute_get_default_delegate_target (self));
1755 _tmp4_ = __bool_dup0 (&_tmp3_);
1756 _g_free0 (self->priv->_delegate_target);
1757 self->priv->_delegate_target = _tmp4_;
1758 } else {
1759 gboolean _tmp5_;
1760 gboolean* _tmp6_;
1761 _tmp5_ = vala_ccode_attribute_get_default_delegate_target (self);
1762 _tmp6_ = __bool_dup0 (&_tmp5_);
1763 _g_free0 (self->priv->_delegate_target);
1764 self->priv->_delegate_target = _tmp6_;
1765 }
1766 }
1767 _tmp7_ = self->priv->_delegate_target;
1768 result = *_tmp7_;
1769 return result;
1770 }
1771
1772 const gchar*
vala_ccode_attribute_get_delegate_target_name(ValaCCodeAttribute * self)1773 vala_ccode_attribute_get_delegate_target_name (ValaCCodeAttribute* self)
1774 {
1775 const gchar* result;
1776 const gchar* _tmp0_;
1777 const gchar* _tmp8_;
1778 g_return_val_if_fail (self != NULL, NULL);
1779 _tmp0_ = self->priv->_delegate_target_name;
1780 if (_tmp0_ == NULL) {
1781 ValaAttribute* _tmp1_;
1782 const gchar* _tmp4_;
1783 _tmp1_ = self->priv->ccode;
1784 if (_tmp1_ != NULL) {
1785 ValaAttribute* _tmp2_;
1786 gchar* _tmp3_;
1787 _tmp2_ = self->priv->ccode;
1788 _tmp3_ = vala_attribute_get_string (_tmp2_, "delegate_target_cname", NULL);
1789 _g_free0 (self->priv->_delegate_target_name);
1790 self->priv->_delegate_target_name = _tmp3_;
1791 }
1792 _tmp4_ = self->priv->_delegate_target_name;
1793 if (_tmp4_ == NULL) {
1794 const gchar* _tmp5_;
1795 const gchar* _tmp6_;
1796 gchar* _tmp7_;
1797 _tmp5_ = vala_ccode_attribute_get_name (self);
1798 _tmp6_ = _tmp5_;
1799 _tmp7_ = g_strdup_printf ("%s_target", _tmp6_);
1800 _g_free0 (self->priv->_delegate_target_name);
1801 self->priv->_delegate_target_name = _tmp7_;
1802 }
1803 }
1804 _tmp8_ = self->priv->_delegate_target_name;
1805 result = _tmp8_;
1806 return result;
1807 }
1808
1809 const gchar*
vala_ccode_attribute_get_delegate_target_destroy_notify_name(ValaCCodeAttribute * self)1810 vala_ccode_attribute_get_delegate_target_destroy_notify_name (ValaCCodeAttribute* self)
1811 {
1812 const gchar* result;
1813 const gchar* _tmp0_;
1814 const gchar* _tmp8_;
1815 g_return_val_if_fail (self != NULL, NULL);
1816 _tmp0_ = self->priv->_delegate_target_destroy_notify_name;
1817 if (_tmp0_ == NULL) {
1818 ValaAttribute* _tmp1_;
1819 const gchar* _tmp4_;
1820 _tmp1_ = self->priv->ccode;
1821 if (_tmp1_ != NULL) {
1822 ValaAttribute* _tmp2_;
1823 gchar* _tmp3_;
1824 _tmp2_ = self->priv->ccode;
1825 _tmp3_ = vala_attribute_get_string (_tmp2_, "destroy_notify_cname", NULL);
1826 _g_free0 (self->priv->_delegate_target_destroy_notify_name);
1827 self->priv->_delegate_target_destroy_notify_name = _tmp3_;
1828 }
1829 _tmp4_ = self->priv->_delegate_target_destroy_notify_name;
1830 if (_tmp4_ == NULL) {
1831 const gchar* _tmp5_;
1832 const gchar* _tmp6_;
1833 gchar* _tmp7_;
1834 _tmp5_ = vala_ccode_attribute_get_delegate_target_name (self);
1835 _tmp6_ = _tmp5_;
1836 _tmp7_ = g_strdup_printf ("%s_destroy_notify", _tmp6_);
1837 _g_free0 (self->priv->_delegate_target_destroy_notify_name);
1838 self->priv->_delegate_target_destroy_notify_name = _tmp7_;
1839 }
1840 }
1841 _tmp8_ = self->priv->_delegate_target_destroy_notify_name;
1842 result = _tmp8_;
1843 return result;
1844 }
1845
1846 gboolean
vala_ccode_attribute_get_array_length(ValaCCodeAttribute * self)1847 vala_ccode_attribute_get_array_length (ValaCCodeAttribute* self)
1848 {
1849 gboolean result;
1850 gboolean* _tmp0_;
1851 gboolean* _tmp16_;
1852 g_return_val_if_fail (self != NULL, FALSE);
1853 _tmp0_ = self->priv->_array_length;
1854 if (_tmp0_ == NULL) {
1855 ValaCodeNode* _tmp1_;
1856 ValaAttribute* _tmp2_;
1857 _tmp1_ = self->priv->node;
1858 _tmp2_ = vala_code_node_get_attribute (_tmp1_, "NoArrayLength");
1859 if (_tmp2_ != NULL) {
1860 ValaCodeNode* _tmp3_;
1861 ValaSourceReference* _tmp4_;
1862 ValaSourceReference* _tmp5_;
1863 gboolean _tmp6_;
1864 gboolean* _tmp7_;
1865 _tmp3_ = self->priv->node;
1866 _tmp4_ = vala_code_node_get_source_reference (_tmp3_);
1867 _tmp5_ = _tmp4_;
1868 vala_report_deprecated (_tmp5_, "[NoArrayLength] is deprecated, use [CCode (array_length = false)] inst" \
1869 "ead.");
1870 _tmp6_ = FALSE;
1871 _tmp7_ = __bool_dup0 (&_tmp6_);
1872 _g_free0 (self->priv->_array_length);
1873 self->priv->_array_length = _tmp7_;
1874 } else {
1875 gboolean _tmp8_ = FALSE;
1876 ValaAttribute* _tmp9_;
1877 _tmp9_ = self->priv->ccode;
1878 if (_tmp9_ != NULL) {
1879 ValaAttribute* _tmp10_;
1880 _tmp10_ = self->priv->ccode;
1881 _tmp8_ = vala_attribute_has_argument (_tmp10_, "array_length");
1882 } else {
1883 _tmp8_ = FALSE;
1884 }
1885 if (_tmp8_) {
1886 ValaAttribute* _tmp11_;
1887 gboolean _tmp12_;
1888 gboolean* _tmp13_;
1889 _tmp11_ = self->priv->ccode;
1890 _tmp12_ = vala_attribute_get_bool (_tmp11_, "array_length", FALSE);
1891 _tmp13_ = __bool_dup0 (&_tmp12_);
1892 _g_free0 (self->priv->_array_length);
1893 self->priv->_array_length = _tmp13_;
1894 } else {
1895 gboolean _tmp14_;
1896 gboolean* _tmp15_;
1897 _tmp14_ = vala_ccode_attribute_get_default_array_length (self);
1898 _tmp15_ = __bool_dup0 (&_tmp14_);
1899 _g_free0 (self->priv->_array_length);
1900 self->priv->_array_length = _tmp15_;
1901 }
1902 }
1903 }
1904 _tmp16_ = self->priv->_array_length;
1905 result = *_tmp16_;
1906 return result;
1907 }
1908
1909 gboolean
vala_ccode_attribute_get_array_null_terminated(ValaCCodeAttribute * self)1910 vala_ccode_attribute_get_array_null_terminated (ValaCCodeAttribute* self)
1911 {
1912 gboolean result;
1913 gboolean* _tmp0_;
1914 gboolean* _tmp16_;
1915 g_return_val_if_fail (self != NULL, FALSE);
1916 _tmp0_ = self->priv->_array_null_terminated;
1917 if (_tmp0_ == NULL) {
1918 gboolean _tmp1_ = FALSE;
1919 gboolean _tmp2_ = FALSE;
1920 ValaAttribute* _tmp3_;
1921 _tmp3_ = self->priv->ccode;
1922 if (_tmp3_ != NULL) {
1923 ValaAttribute* _tmp4_;
1924 _tmp4_ = self->priv->ccode;
1925 _tmp2_ = vala_attribute_has_argument (_tmp4_, "array_length");
1926 } else {
1927 _tmp2_ = FALSE;
1928 }
1929 if (_tmp2_) {
1930 ValaAttribute* _tmp5_;
1931 _tmp5_ = self->priv->ccode;
1932 _tmp1_ = vala_attribute_get_bool (_tmp5_, "array_length", FALSE);
1933 } else {
1934 _tmp1_ = FALSE;
1935 }
1936 if (_tmp1_) {
1937 gboolean _tmp6_;
1938 gboolean* _tmp7_;
1939 _tmp6_ = FALSE;
1940 _tmp7_ = __bool_dup0 (&_tmp6_);
1941 _g_free0 (self->priv->_array_null_terminated);
1942 self->priv->_array_null_terminated = _tmp7_;
1943 } else {
1944 gboolean _tmp8_ = FALSE;
1945 ValaAttribute* _tmp9_;
1946 _tmp9_ = self->priv->ccode;
1947 if (_tmp9_ != NULL) {
1948 ValaAttribute* _tmp10_;
1949 _tmp10_ = self->priv->ccode;
1950 _tmp8_ = vala_attribute_has_argument (_tmp10_, "array_null_terminated");
1951 } else {
1952 _tmp8_ = FALSE;
1953 }
1954 if (_tmp8_) {
1955 ValaAttribute* _tmp11_;
1956 gboolean _tmp12_;
1957 gboolean* _tmp13_;
1958 _tmp11_ = self->priv->ccode;
1959 _tmp12_ = vala_attribute_get_bool (_tmp11_, "array_null_terminated", FALSE);
1960 _tmp13_ = __bool_dup0 (&_tmp12_);
1961 _g_free0 (self->priv->_array_null_terminated);
1962 self->priv->_array_null_terminated = _tmp13_;
1963 } else {
1964 gboolean _tmp14_;
1965 gboolean* _tmp15_;
1966 _tmp14_ = vala_ccode_attribute_get_default_array_null_terminated (self);
1967 _tmp15_ = __bool_dup0 (&_tmp14_);
1968 _g_free0 (self->priv->_array_null_terminated);
1969 self->priv->_array_null_terminated = _tmp15_;
1970 }
1971 }
1972 }
1973 _tmp16_ = self->priv->_array_null_terminated;
1974 result = *_tmp16_;
1975 return result;
1976 }
1977
1978 const gchar*
vala_ccode_attribute_get_array_length_type(ValaCCodeAttribute * self)1979 vala_ccode_attribute_get_array_length_type (ValaCCodeAttribute* self)
1980 {
1981 const gchar* result;
1982 const gchar* _tmp0_;
1983 const gchar* _tmp7_;
1984 g_return_val_if_fail (self != NULL, NULL);
1985 _tmp0_ = self->priv->_array_length_type;
1986 if (_tmp0_ == NULL) {
1987 gboolean _tmp1_ = FALSE;
1988 ValaAttribute* _tmp2_;
1989 _tmp2_ = self->priv->ccode;
1990 if (_tmp2_ != NULL) {
1991 ValaAttribute* _tmp3_;
1992 _tmp3_ = self->priv->ccode;
1993 _tmp1_ = vala_attribute_has_argument (_tmp3_, "array_length_type");
1994 } else {
1995 _tmp1_ = FALSE;
1996 }
1997 if (_tmp1_) {
1998 ValaAttribute* _tmp4_;
1999 gchar* _tmp5_;
2000 _tmp4_ = self->priv->ccode;
2001 _tmp5_ = vala_attribute_get_string (_tmp4_, "array_length_type", NULL);
2002 _g_free0 (self->priv->_array_length_type);
2003 self->priv->_array_length_type = _tmp5_;
2004 } else {
2005 gchar* _tmp6_;
2006 _tmp6_ = vala_ccode_attribute_get_default_array_length_type (self);
2007 _g_free0 (self->priv->_array_length_type);
2008 self->priv->_array_length_type = _tmp6_;
2009 }
2010 }
2011 _tmp7_ = self->priv->_array_length_type;
2012 result = _tmp7_;
2013 return result;
2014 }
2015
2016 const gchar*
vala_ccode_attribute_get_sentinel(ValaCCodeAttribute * self)2017 vala_ccode_attribute_get_sentinel (ValaCCodeAttribute* self)
2018 {
2019 const gchar* result;
2020 const gchar* _tmp0_;
2021 const gchar* _tmp5_;
2022 g_return_val_if_fail (self != NULL, NULL);
2023 _tmp0_ = self->priv->_sentinel;
2024 if (_tmp0_ == NULL) {
2025 ValaAttribute* _tmp1_;
2026 _tmp1_ = self->priv->ccode;
2027 if (_tmp1_ != NULL) {
2028 ValaAttribute* _tmp2_;
2029 gchar* _tmp3_;
2030 _tmp2_ = self->priv->ccode;
2031 _tmp3_ = vala_attribute_get_string (_tmp2_, "sentinel", "NULL");
2032 _g_free0 (self->priv->_sentinel);
2033 self->priv->_sentinel = _tmp3_;
2034 } else {
2035 gchar* _tmp4_;
2036 _tmp4_ = g_strdup ("NULL");
2037 _g_free0 (self->priv->_sentinel);
2038 self->priv->_sentinel = _tmp4_;
2039 }
2040 }
2041 _tmp5_ = self->priv->_sentinel;
2042 result = _tmp5_;
2043 return result;
2044 }
2045
2046 const gchar*
vala_ccode_attribute_get_array_length_name(ValaCCodeAttribute * self)2047 vala_ccode_attribute_get_array_length_name (ValaCCodeAttribute* self)
2048 {
2049 const gchar* result;
2050 const gchar* _tmp0_;
2051 g_return_val_if_fail (self != NULL, NULL);
2052 _tmp0_ = self->priv->_array_length_name;
2053 result = _tmp0_;
2054 return result;
2055 }
2056
2057 static void
vala_ccode_attribute_set_array_length_name(ValaCCodeAttribute * self,const gchar * value)2058 vala_ccode_attribute_set_array_length_name (ValaCCodeAttribute* self,
2059 const gchar* value)
2060 {
2061 gchar* _tmp0_;
2062 g_return_if_fail (self != NULL);
2063 _tmp0_ = g_strdup (value);
2064 _g_free0 (self->priv->_array_length_name);
2065 self->priv->_array_length_name = _tmp0_;
2066 }
2067
2068 const gchar*
vala_ccode_attribute_get_array_length_expr(ValaCCodeAttribute * self)2069 vala_ccode_attribute_get_array_length_expr (ValaCCodeAttribute* self)
2070 {
2071 const gchar* result;
2072 const gchar* _tmp0_;
2073 g_return_val_if_fail (self != NULL, NULL);
2074 _tmp0_ = self->priv->_array_length_expr;
2075 result = _tmp0_;
2076 return result;
2077 }
2078
2079 static void
vala_ccode_attribute_set_array_length_expr(ValaCCodeAttribute * self,const gchar * value)2080 vala_ccode_attribute_set_array_length_expr (ValaCCodeAttribute* self,
2081 const gchar* value)
2082 {
2083 gchar* _tmp0_;
2084 g_return_if_fail (self != NULL);
2085 _tmp0_ = g_strdup (value);
2086 _g_free0 (self->priv->_array_length_expr);
2087 self->priv->_array_length_expr = _tmp0_;
2088 }
2089
2090 ValaCCodeAttribute*
vala_ccode_attribute_construct(GType object_type,ValaCodeNode * node)2091 vala_ccode_attribute_construct (GType object_type,
2092 ValaCodeNode* node)
2093 {
2094 ValaCCodeAttribute* self = NULL;
2095 ValaAttribute* _tmp0_;
2096 ValaAttribute* _tmp1_;
2097 ValaAttribute* _tmp2_;
2098 g_return_val_if_fail (node != NULL, NULL);
2099 self = (ValaCCodeAttribute*) vala_attribute_cache_construct (object_type);
2100 self->priv->node = node;
2101 self->priv->sym = G_TYPE_CHECK_INSTANCE_TYPE (node, VALA_TYPE_SYMBOL) ? ((ValaSymbol*) node) : NULL;
2102 _tmp0_ = vala_code_node_get_attribute (node, "CCode");
2103 _tmp1_ = _vala_code_node_ref0 (_tmp0_);
2104 _vala_code_node_unref0 (self->priv->ccode);
2105 self->priv->ccode = _tmp1_;
2106 _tmp2_ = self->priv->ccode;
2107 if (_tmp2_ != NULL) {
2108 ValaAttribute* _tmp3_;
2109 gchar* _tmp4_;
2110 gchar* _tmp5_;
2111 ValaAttribute* _tmp6_;
2112 gchar* _tmp7_;
2113 gchar* _tmp8_;
2114 _tmp3_ = self->priv->ccode;
2115 _tmp4_ = vala_attribute_get_string (_tmp3_, "array_length_cname", NULL);
2116 _tmp5_ = _tmp4_;
2117 vala_ccode_attribute_set_array_length_name (self, _tmp5_);
2118 _g_free0 (_tmp5_);
2119 _tmp6_ = self->priv->ccode;
2120 _tmp7_ = vala_attribute_get_string (_tmp6_, "array_length_cexpr", NULL);
2121 _tmp8_ = _tmp7_;
2122 vala_ccode_attribute_set_array_length_expr (self, _tmp8_);
2123 _g_free0 (_tmp8_);
2124 }
2125 return self;
2126 }
2127
2128 ValaCCodeAttribute*
vala_ccode_attribute_new(ValaCodeNode * node)2129 vala_ccode_attribute_new (ValaCodeNode* node)
2130 {
2131 return vala_ccode_attribute_construct (VALA_TYPE_CCODE_ATTRIBUTE, node);
2132 }
2133
2134 static gchar
string_get(const gchar * self,glong index)2135 string_get (const gchar* self,
2136 glong index)
2137 {
2138 gchar _tmp0_;
2139 gchar result = '\0';
2140 g_return_val_if_fail (self != NULL, '\0');
2141 _tmp0_ = ((gchar*) self)[index];
2142 result = _tmp0_;
2143 return result;
2144 }
2145
2146 static glong
string_strnlen(gchar * str,glong maxlen)2147 string_strnlen (gchar* str,
2148 glong maxlen)
2149 {
2150 gchar* end = NULL;
2151 gchar* _tmp0_;
2152 gchar* _tmp1_;
2153 glong result = 0L;
2154 _tmp0_ = memchr (str, 0, (gsize) maxlen);
2155 end = _tmp0_;
2156 _tmp1_ = end;
2157 if (_tmp1_ == NULL) {
2158 result = maxlen;
2159 return result;
2160 } else {
2161 gchar* _tmp2_;
2162 _tmp2_ = end;
2163 result = (glong) (_tmp2_ - str);
2164 return result;
2165 }
2166 }
2167
2168 static gchar*
string_substring(const gchar * self,glong offset,glong len)2169 string_substring (const gchar* self,
2170 glong offset,
2171 glong len)
2172 {
2173 glong string_length = 0L;
2174 gboolean _tmp0_ = FALSE;
2175 gchar* _tmp3_;
2176 gchar* result = NULL;
2177 g_return_val_if_fail (self != NULL, NULL);
2178 if (offset >= ((glong) 0)) {
2179 _tmp0_ = len >= ((glong) 0);
2180 } else {
2181 _tmp0_ = FALSE;
2182 }
2183 if (_tmp0_) {
2184 string_length = string_strnlen ((gchar*) self, offset + len);
2185 } else {
2186 gint _tmp1_;
2187 gint _tmp2_;
2188 _tmp1_ = strlen (self);
2189 _tmp2_ = _tmp1_;
2190 string_length = (glong) _tmp2_;
2191 }
2192 if (offset < ((glong) 0)) {
2193 offset = string_length + offset;
2194 g_return_val_if_fail (offset >= ((glong) 0), NULL);
2195 } else {
2196 g_return_val_if_fail (offset <= string_length, NULL);
2197 }
2198 if (len < ((glong) 0)) {
2199 len = string_length - offset;
2200 }
2201 g_return_val_if_fail ((offset + len) <= string_length, NULL);
2202 _tmp3_ = g_strndup (((gchar*) self) + offset, (gsize) len);
2203 result = _tmp3_;
2204 return result;
2205 }
2206
2207 static gchar*
string_replace(const gchar * self,const gchar * old,const gchar * replacement)2208 string_replace (const gchar* self,
2209 const gchar* old,
2210 const gchar* replacement)
2211 {
2212 gboolean _tmp0_ = FALSE;
2213 gboolean _tmp1_ = FALSE;
2214 GError* _inner_error0_ = NULL;
2215 gchar* result = NULL;
2216 g_return_val_if_fail (self != NULL, NULL);
2217 g_return_val_if_fail (old != NULL, NULL);
2218 g_return_val_if_fail (replacement != NULL, NULL);
2219 if ((*((gchar*) self)) == '\0') {
2220 _tmp1_ = TRUE;
2221 } else {
2222 _tmp1_ = (*((gchar*) old)) == '\0';
2223 }
2224 if (_tmp1_) {
2225 _tmp0_ = TRUE;
2226 } else {
2227 _tmp0_ = g_strcmp0 (old, replacement) == 0;
2228 }
2229 if (_tmp0_) {
2230 gchar* _tmp2_;
2231 _tmp2_ = g_strdup (self);
2232 result = _tmp2_;
2233 return result;
2234 }
2235 {
2236 GRegex* regex = NULL;
2237 gchar* _tmp3_;
2238 gchar* _tmp4_;
2239 GRegex* _tmp5_;
2240 GRegex* _tmp6_;
2241 gchar* _tmp7_ = NULL;
2242 GRegex* _tmp8_;
2243 gchar* _tmp9_;
2244 gchar* _tmp10_;
2245 _tmp3_ = g_regex_escape_string (old, -1);
2246 _tmp4_ = _tmp3_;
2247 _tmp5_ = g_regex_new (_tmp4_, 0, 0, &_inner_error0_);
2248 _tmp6_ = _tmp5_;
2249 _g_free0 (_tmp4_);
2250 regex = _tmp6_;
2251 if (G_UNLIKELY (_inner_error0_ != NULL)) {
2252 _g_free0 (_tmp7_);
2253 _g_regex_unref0 (regex);
2254 if (_inner_error0_->domain == G_REGEX_ERROR) {
2255 goto __catch0_g_regex_error;
2256 }
2257 g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
2258 g_clear_error (&_inner_error0_);
2259 return NULL;
2260 }
2261 _tmp8_ = regex;
2262 _tmp9_ = g_regex_replace_literal (_tmp8_, self, (gssize) -1, 0, replacement, 0, &_inner_error0_);
2263 _tmp7_ = _tmp9_;
2264 if (G_UNLIKELY (_inner_error0_ != NULL)) {
2265 _g_free0 (_tmp7_);
2266 _g_regex_unref0 (regex);
2267 if (_inner_error0_->domain == G_REGEX_ERROR) {
2268 goto __catch0_g_regex_error;
2269 }
2270 g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
2271 g_clear_error (&_inner_error0_);
2272 return NULL;
2273 }
2274 _tmp10_ = _tmp7_;
2275 _tmp7_ = NULL;
2276 result = _tmp10_;
2277 _g_free0 (_tmp7_);
2278 _g_regex_unref0 (regex);
2279 return result;
2280 }
2281 goto __finally0;
2282 __catch0_g_regex_error:
2283 {
2284 g_clear_error (&_inner_error0_);
2285 g_assert_not_reached ();
2286 }
2287 __finally0:
2288 g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
2289 g_clear_error (&_inner_error0_);
2290 return NULL;
2291 }
2292
2293 static gchar*
vala_ccode_attribute_get_default_name(ValaCCodeAttribute * self)2294 vala_ccode_attribute_get_default_name (ValaCCodeAttribute* self)
2295 {
2296 ValaSymbol* _tmp0_;
2297 gchar* result = NULL;
2298 g_return_val_if_fail (self != NULL, NULL);
2299 _tmp0_ = self->priv->sym;
2300 if (_tmp0_ != NULL) {
2301 gboolean _tmp1_ = FALSE;
2302 ValaSymbol* _tmp2_;
2303 _tmp2_ = self->priv->sym;
2304 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2_, VALA_TYPE_CONSTANT)) {
2305 ValaSymbol* _tmp3_;
2306 _tmp3_ = self->priv->sym;
2307 _tmp1_ = !G_TYPE_CHECK_INSTANCE_TYPE (_tmp3_, VALA_TYPE_ENUM_VALUE);
2308 } else {
2309 _tmp1_ = FALSE;
2310 }
2311 if (_tmp1_) {
2312 ValaSymbol* _tmp4_;
2313 ValaSymbol* _tmp5_;
2314 ValaSymbol* _tmp6_;
2315 ValaSymbol* _tmp11_;
2316 ValaSymbol* _tmp12_;
2317 ValaSymbol* _tmp13_;
2318 gchar* _tmp14_;
2319 gchar* _tmp15_;
2320 gchar* _tmp16_;
2321 gchar* _tmp17_;
2322 ValaSymbol* _tmp18_;
2323 const gchar* _tmp19_;
2324 const gchar* _tmp20_;
2325 gchar* _tmp21_;
2326 gchar* _tmp22_;
2327 _tmp4_ = self->priv->sym;
2328 _tmp5_ = vala_symbol_get_parent_symbol (_tmp4_);
2329 _tmp6_ = _tmp5_;
2330 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp6_, VALA_TYPE_BLOCK)) {
2331 ValaSymbol* _tmp7_;
2332 const gchar* _tmp8_;
2333 const gchar* _tmp9_;
2334 gchar* _tmp10_;
2335 _tmp7_ = self->priv->sym;
2336 _tmp8_ = vala_symbol_get_name (_tmp7_);
2337 _tmp9_ = _tmp8_;
2338 _tmp10_ = g_strdup (_tmp9_);
2339 result = _tmp10_;
2340 return result;
2341 }
2342 _tmp11_ = self->priv->sym;
2343 _tmp12_ = vala_symbol_get_parent_symbol (_tmp11_);
2344 _tmp13_ = _tmp12_;
2345 _tmp14_ = vala_get_ccode_lower_case_prefix (_tmp13_);
2346 _tmp15_ = _tmp14_;
2347 _tmp16_ = g_ascii_strup (_tmp15_, (gssize) -1);
2348 _tmp17_ = _tmp16_;
2349 _tmp18_ = self->priv->sym;
2350 _tmp19_ = vala_symbol_get_name (_tmp18_);
2351 _tmp20_ = _tmp19_;
2352 _tmp21_ = g_strdup_printf ("%s%s", _tmp17_, _tmp20_);
2353 _tmp22_ = _tmp21_;
2354 _g_free0 (_tmp17_);
2355 _g_free0 (_tmp15_);
2356 result = _tmp22_;
2357 return result;
2358 } else {
2359 ValaSymbol* _tmp23_;
2360 _tmp23_ = self->priv->sym;
2361 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp23_, VALA_TYPE_FIELD)) {
2362 gchar* cname = NULL;
2363 ValaSymbol* _tmp24_;
2364 const gchar* _tmp25_;
2365 const gchar* _tmp26_;
2366 gchar* _tmp27_;
2367 ValaSymbol* _tmp28_;
2368 ValaMemberBinding _tmp29_;
2369 ValaMemberBinding _tmp30_;
2370 const gchar* _tmp40_;
2371 _tmp24_ = self->priv->sym;
2372 _tmp25_ = vala_symbol_get_name (_tmp24_);
2373 _tmp26_ = _tmp25_;
2374 _tmp27_ = g_strdup (_tmp26_);
2375 cname = _tmp27_;
2376 _tmp28_ = self->priv->sym;
2377 _tmp29_ = vala_field_get_binding (G_TYPE_CHECK_INSTANCE_CAST (_tmp28_, VALA_TYPE_FIELD, ValaField));
2378 _tmp30_ = _tmp29_;
2379 if (_tmp30_ == VALA_MEMBER_BINDING_STATIC) {
2380 ValaSymbol* _tmp31_;
2381 ValaSymbol* _tmp32_;
2382 ValaSymbol* _tmp33_;
2383 gchar* _tmp34_;
2384 gchar* _tmp35_;
2385 ValaSymbol* _tmp36_;
2386 const gchar* _tmp37_;
2387 const gchar* _tmp38_;
2388 gchar* _tmp39_;
2389 _tmp31_ = self->priv->sym;
2390 _tmp32_ = vala_symbol_get_parent_symbol (_tmp31_);
2391 _tmp33_ = _tmp32_;
2392 _tmp34_ = vala_get_ccode_lower_case_prefix (_tmp33_);
2393 _tmp35_ = _tmp34_;
2394 _tmp36_ = self->priv->sym;
2395 _tmp37_ = vala_symbol_get_name (_tmp36_);
2396 _tmp38_ = _tmp37_;
2397 _tmp39_ = g_strdup_printf ("%s%s", _tmp35_, _tmp38_);
2398 _g_free0 (cname);
2399 cname = _tmp39_;
2400 _g_free0 (_tmp35_);
2401 }
2402 _tmp40_ = cname;
2403 if (g_ascii_isdigit (string_get (_tmp40_, (glong) 0))) {
2404 ValaCodeNode* _tmp41_;
2405 ValaSourceReference* _tmp42_;
2406 ValaSourceReference* _tmp43_;
2407 gchar* _tmp44_;
2408 _tmp41_ = self->priv->node;
2409 _tmp42_ = vala_code_node_get_source_reference (_tmp41_);
2410 _tmp43_ = _tmp42_;
2411 vala_report_error (_tmp43_, "Field name starts with a digit. Use the `cname' attribute to provide a" \
2412 " valid C name if intended");
2413 _tmp44_ = g_strdup ("");
2414 result = _tmp44_;
2415 _g_free0 (cname);
2416 return result;
2417 }
2418 result = cname;
2419 return result;
2420 } else {
2421 ValaSymbol* _tmp45_;
2422 _tmp45_ = self->priv->sym;
2423 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp45_, VALA_TYPE_CREATION_METHOD)) {
2424 ValaCreationMethod* m = NULL;
2425 ValaSymbol* _tmp46_;
2426 gchar* infix = NULL;
2427 ValaCreationMethod* _tmp47_;
2428 ValaSymbol* _tmp48_;
2429 ValaSymbol* _tmp49_;
2430 ValaCreationMethod* _tmp52_;
2431 const gchar* _tmp53_;
2432 const gchar* _tmp54_;
2433 _tmp46_ = self->priv->sym;
2434 m = G_TYPE_CHECK_INSTANCE_CAST (_tmp46_, VALA_TYPE_CREATION_METHOD, ValaCreationMethod);
2435 _tmp47_ = m;
2436 _tmp48_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp47_);
2437 _tmp49_ = _tmp48_;
2438 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp49_, VALA_TYPE_STRUCT)) {
2439 gchar* _tmp50_;
2440 _tmp50_ = g_strdup ("init");
2441 _g_free0 (infix);
2442 infix = _tmp50_;
2443 } else {
2444 gchar* _tmp51_;
2445 _tmp51_ = g_strdup ("new");
2446 _g_free0 (infix);
2447 infix = _tmp51_;
2448 }
2449 _tmp52_ = m;
2450 _tmp53_ = vala_symbol_get_name ((ValaSymbol*) _tmp52_);
2451 _tmp54_ = _tmp53_;
2452 if (g_strcmp0 (_tmp54_, ".new") == 0) {
2453 ValaCreationMethod* _tmp55_;
2454 ValaSymbol* _tmp56_;
2455 ValaSymbol* _tmp57_;
2456 gchar* _tmp58_;
2457 gchar* _tmp59_;
2458 const gchar* _tmp60_;
2459 gchar* _tmp61_;
2460 gchar* _tmp62_;
2461 _tmp55_ = m;
2462 _tmp56_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp55_);
2463 _tmp57_ = _tmp56_;
2464 _tmp58_ = vala_get_ccode_lower_case_prefix (_tmp57_);
2465 _tmp59_ = _tmp58_;
2466 _tmp60_ = infix;
2467 _tmp61_ = g_strdup_printf ("%s%s", _tmp59_, _tmp60_);
2468 _tmp62_ = _tmp61_;
2469 _g_free0 (_tmp59_);
2470 result = _tmp62_;
2471 _g_free0 (infix);
2472 return result;
2473 } else {
2474 ValaCreationMethod* _tmp63_;
2475 ValaSymbol* _tmp64_;
2476 ValaSymbol* _tmp65_;
2477 gchar* _tmp66_;
2478 gchar* _tmp67_;
2479 const gchar* _tmp68_;
2480 ValaCreationMethod* _tmp69_;
2481 const gchar* _tmp70_;
2482 const gchar* _tmp71_;
2483 gchar* _tmp72_;
2484 gchar* _tmp73_;
2485 _tmp63_ = m;
2486 _tmp64_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp63_);
2487 _tmp65_ = _tmp64_;
2488 _tmp66_ = vala_get_ccode_lower_case_prefix (_tmp65_);
2489 _tmp67_ = _tmp66_;
2490 _tmp68_ = infix;
2491 _tmp69_ = m;
2492 _tmp70_ = vala_symbol_get_name ((ValaSymbol*) _tmp69_);
2493 _tmp71_ = _tmp70_;
2494 _tmp72_ = g_strdup_printf ("%s%s_%s", _tmp67_, _tmp68_, _tmp71_);
2495 _tmp73_ = _tmp72_;
2496 _g_free0 (_tmp67_);
2497 result = _tmp73_;
2498 _g_free0 (infix);
2499 return result;
2500 }
2501 _g_free0 (infix);
2502 } else {
2503 ValaSymbol* _tmp74_;
2504 _tmp74_ = self->priv->sym;
2505 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp74_, VALA_TYPE_DYNAMIC_METHOD)) {
2506 ValaSymbol* _tmp75_;
2507 const gchar* _tmp76_;
2508 const gchar* _tmp77_;
2509 gint _tmp78_;
2510 gchar* _tmp79_;
2511 _tmp75_ = self->priv->sym;
2512 _tmp76_ = vala_symbol_get_name (_tmp75_);
2513 _tmp77_ = _tmp76_;
2514 _tmp78_ = vala_ccode_attribute_dynamic_method_id;
2515 vala_ccode_attribute_dynamic_method_id = _tmp78_ + 1;
2516 _tmp79_ = g_strdup_printf ("_dynamic_%s%d", _tmp77_, _tmp78_);
2517 result = _tmp79_;
2518 return result;
2519 } else {
2520 ValaSymbol* _tmp80_;
2521 _tmp80_ = self->priv->sym;
2522 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp80_, VALA_TYPE_METHOD)) {
2523 ValaMethod* m = NULL;
2524 ValaSymbol* _tmp81_;
2525 ValaMethod* _tmp82_;
2526 gboolean _tmp83_;
2527 gboolean _tmp84_;
2528 ValaMethod* _tmp92_;
2529 ValaSignal* _tmp93_;
2530 ValaSignal* _tmp94_;
2531 gboolean _tmp107_ = FALSE;
2532 ValaSymbol* _tmp108_;
2533 const gchar* _tmp109_;
2534 const gchar* _tmp110_;
2535 _tmp81_ = self->priv->sym;
2536 m = G_TYPE_CHECK_INSTANCE_CAST (_tmp81_, VALA_TYPE_METHOD, ValaMethod);
2537 _tmp82_ = m;
2538 _tmp83_ = vala_method_get_is_async_callback (_tmp82_);
2539 _tmp84_ = _tmp83_;
2540 if (_tmp84_) {
2541 ValaMethod* _tmp85_;
2542 ValaSymbol* _tmp86_;
2543 ValaSymbol* _tmp87_;
2544 gchar* _tmp88_;
2545 gchar* _tmp89_;
2546 gchar* _tmp90_;
2547 gchar* _tmp91_;
2548 _tmp85_ = m;
2549 _tmp86_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp85_);
2550 _tmp87_ = _tmp86_;
2551 _tmp88_ = vala_get_ccode_real_name ((ValaSymbol*) G_TYPE_CHECK_INSTANCE_CAST (_tmp87_, VALA_TYPE_METHOD, ValaMethod));
2552 _tmp89_ = _tmp88_;
2553 _tmp90_ = g_strdup_printf ("%s_co", _tmp89_);
2554 _tmp91_ = _tmp90_;
2555 _g_free0 (_tmp89_);
2556 result = _tmp91_;
2557 return result;
2558 }
2559 _tmp92_ = m;
2560 _tmp93_ = vala_method_get_signal_reference (_tmp92_);
2561 _tmp94_ = _tmp93_;
2562 if (_tmp94_ != NULL) {
2563 ValaMethod* _tmp95_;
2564 ValaSymbol* _tmp96_;
2565 ValaSymbol* _tmp97_;
2566 gchar* _tmp98_;
2567 gchar* _tmp99_;
2568 ValaMethod* _tmp100_;
2569 ValaSignal* _tmp101_;
2570 ValaSignal* _tmp102_;
2571 gchar* _tmp103_;
2572 gchar* _tmp104_;
2573 gchar* _tmp105_;
2574 gchar* _tmp106_;
2575 _tmp95_ = m;
2576 _tmp96_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp95_);
2577 _tmp97_ = _tmp96_;
2578 _tmp98_ = vala_get_ccode_lower_case_prefix (_tmp97_);
2579 _tmp99_ = _tmp98_;
2580 _tmp100_ = m;
2581 _tmp101_ = vala_method_get_signal_reference (_tmp100_);
2582 _tmp102_ = _tmp101_;
2583 _tmp103_ = vala_get_ccode_lower_case_name ((ValaCodeNode*) _tmp102_, NULL);
2584 _tmp104_ = _tmp103_;
2585 _tmp105_ = g_strdup_printf ("%s%s", _tmp99_, _tmp104_);
2586 _tmp106_ = _tmp105_;
2587 _g_free0 (_tmp104_);
2588 _g_free0 (_tmp99_);
2589 result = _tmp106_;
2590 return result;
2591 }
2592 _tmp108_ = self->priv->sym;
2593 _tmp109_ = vala_symbol_get_name (_tmp108_);
2594 _tmp110_ = _tmp109_;
2595 if (g_strcmp0 (_tmp110_, "main") == 0) {
2596 ValaSymbol* _tmp111_;
2597 ValaSymbol* _tmp112_;
2598 ValaSymbol* _tmp113_;
2599 const gchar* _tmp114_;
2600 const gchar* _tmp115_;
2601 _tmp111_ = self->priv->sym;
2602 _tmp112_ = vala_symbol_get_parent_symbol (_tmp111_);
2603 _tmp113_ = _tmp112_;
2604 _tmp114_ = vala_symbol_get_name (_tmp113_);
2605 _tmp115_ = _tmp114_;
2606 _tmp107_ = _tmp115_ == NULL;
2607 } else {
2608 _tmp107_ = FALSE;
2609 }
2610 if (_tmp107_) {
2611 gchar* _tmp116_;
2612 _tmp116_ = g_strdup ("_vala_main");
2613 result = _tmp116_;
2614 return result;
2615 } else {
2616 ValaSymbol* _tmp117_;
2617 const gchar* _tmp118_;
2618 const gchar* _tmp119_;
2619 _tmp117_ = self->priv->sym;
2620 _tmp118_ = vala_symbol_get_name (_tmp117_);
2621 _tmp119_ = _tmp118_;
2622 if (g_str_has_prefix (_tmp119_, "_")) {
2623 ValaSymbol* _tmp120_;
2624 ValaSymbol* _tmp121_;
2625 ValaSymbol* _tmp122_;
2626 gchar* _tmp123_;
2627 gchar* _tmp124_;
2628 ValaSymbol* _tmp125_;
2629 const gchar* _tmp126_;
2630 const gchar* _tmp127_;
2631 gchar* _tmp128_;
2632 gchar* _tmp129_;
2633 gchar* _tmp130_;
2634 gchar* _tmp131_;
2635 _tmp120_ = self->priv->sym;
2636 _tmp121_ = vala_symbol_get_parent_symbol (_tmp120_);
2637 _tmp122_ = _tmp121_;
2638 _tmp123_ = vala_get_ccode_lower_case_prefix (_tmp122_);
2639 _tmp124_ = _tmp123_;
2640 _tmp125_ = self->priv->sym;
2641 _tmp126_ = vala_symbol_get_name (_tmp125_);
2642 _tmp127_ = _tmp126_;
2643 _tmp128_ = string_substring (_tmp127_, (glong) 1, (glong) -1);
2644 _tmp129_ = _tmp128_;
2645 _tmp130_ = g_strdup_printf ("_%s%s", _tmp124_, _tmp129_);
2646 _tmp131_ = _tmp130_;
2647 _g_free0 (_tmp129_);
2648 _g_free0 (_tmp124_);
2649 result = _tmp131_;
2650 return result;
2651 } else {
2652 ValaSymbol* _tmp132_;
2653 ValaSymbol* _tmp133_;
2654 ValaSymbol* _tmp134_;
2655 gchar* _tmp135_;
2656 gchar* _tmp136_;
2657 ValaSymbol* _tmp137_;
2658 const gchar* _tmp138_;
2659 const gchar* _tmp139_;
2660 gchar* _tmp140_;
2661 gchar* _tmp141_;
2662 _tmp132_ = self->priv->sym;
2663 _tmp133_ = vala_symbol_get_parent_symbol (_tmp132_);
2664 _tmp134_ = _tmp133_;
2665 _tmp135_ = vala_get_ccode_lower_case_prefix (_tmp134_);
2666 _tmp136_ = _tmp135_;
2667 _tmp137_ = self->priv->sym;
2668 _tmp138_ = vala_symbol_get_name (_tmp137_);
2669 _tmp139_ = _tmp138_;
2670 _tmp140_ = g_strdup_printf ("%s%s", _tmp136_, _tmp139_);
2671 _tmp141_ = _tmp140_;
2672 _g_free0 (_tmp136_);
2673 result = _tmp141_;
2674 return result;
2675 }
2676 }
2677 } else {
2678 ValaSymbol* _tmp142_;
2679 _tmp142_ = self->priv->sym;
2680 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp142_, VALA_TYPE_PROPERTY)) {
2681 ValaSymbol* _tmp143_;
2682 const gchar* _tmp144_;
2683 const gchar* _tmp145_;
2684 gchar* _tmp146_;
2685 _tmp143_ = self->priv->sym;
2686 _tmp144_ = vala_symbol_get_name (_tmp143_);
2687 _tmp145_ = _tmp144_;
2688 _tmp146_ = string_replace (_tmp145_, "_", "-");
2689 result = _tmp146_;
2690 return result;
2691 } else {
2692 ValaSymbol* _tmp147_;
2693 _tmp147_ = self->priv->sym;
2694 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp147_, VALA_TYPE_PROPERTY_ACCESSOR)) {
2695 ValaPropertyAccessor* acc = NULL;
2696 ValaSymbol* _tmp148_;
2697 ValaTypeSymbol* t = NULL;
2698 ValaPropertyAccessor* _tmp149_;
2699 ValaProperty* _tmp150_;
2700 ValaProperty* _tmp151_;
2701 ValaSymbol* _tmp152_;
2702 ValaSymbol* _tmp153_;
2703 ValaTypeSymbol* _tmp154_;
2704 ValaPropertyAccessor* _tmp155_;
2705 gboolean _tmp156_;
2706 gboolean _tmp157_;
2707 _tmp148_ = self->priv->sym;
2708 acc = G_TYPE_CHECK_INSTANCE_CAST (_tmp148_, VALA_TYPE_PROPERTY_ACCESSOR, ValaPropertyAccessor);
2709 _tmp149_ = acc;
2710 _tmp150_ = vala_property_accessor_get_prop (_tmp149_);
2711 _tmp151_ = _tmp150_;
2712 _tmp152_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp151_);
2713 _tmp153_ = _tmp152_;
2714 _tmp154_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp153_, VALA_TYPE_TYPESYMBOL, ValaTypeSymbol));
2715 t = _tmp154_;
2716 _tmp155_ = acc;
2717 _tmp156_ = vala_property_accessor_get_readable (_tmp155_);
2718 _tmp157_ = _tmp156_;
2719 if (_tmp157_) {
2720 ValaTypeSymbol* _tmp158_;
2721 gchar* _tmp159_;
2722 gchar* _tmp160_;
2723 ValaPropertyAccessor* _tmp161_;
2724 ValaProperty* _tmp162_;
2725 ValaProperty* _tmp163_;
2726 const gchar* _tmp164_;
2727 const gchar* _tmp165_;
2728 gchar* _tmp166_;
2729 gchar* _tmp167_;
2730 _tmp158_ = t;
2731 _tmp159_ = vala_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp158_);
2732 _tmp160_ = _tmp159_;
2733 _tmp161_ = acc;
2734 _tmp162_ = vala_property_accessor_get_prop (_tmp161_);
2735 _tmp163_ = _tmp162_;
2736 _tmp164_ = vala_symbol_get_name ((ValaSymbol*) _tmp163_);
2737 _tmp165_ = _tmp164_;
2738 _tmp166_ = g_strdup_printf ("%sget_%s", _tmp160_, _tmp165_);
2739 _tmp167_ = _tmp166_;
2740 _g_free0 (_tmp160_);
2741 result = _tmp167_;
2742 _vala_code_node_unref0 (t);
2743 return result;
2744 } else {
2745 ValaTypeSymbol* _tmp168_;
2746 gchar* _tmp169_;
2747 gchar* _tmp170_;
2748 ValaPropertyAccessor* _tmp171_;
2749 ValaProperty* _tmp172_;
2750 ValaProperty* _tmp173_;
2751 const gchar* _tmp174_;
2752 const gchar* _tmp175_;
2753 gchar* _tmp176_;
2754 gchar* _tmp177_;
2755 _tmp168_ = t;
2756 _tmp169_ = vala_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp168_);
2757 _tmp170_ = _tmp169_;
2758 _tmp171_ = acc;
2759 _tmp172_ = vala_property_accessor_get_prop (_tmp171_);
2760 _tmp173_ = _tmp172_;
2761 _tmp174_ = vala_symbol_get_name ((ValaSymbol*) _tmp173_);
2762 _tmp175_ = _tmp174_;
2763 _tmp176_ = g_strdup_printf ("%sset_%s", _tmp170_, _tmp175_);
2764 _tmp177_ = _tmp176_;
2765 _g_free0 (_tmp170_);
2766 result = _tmp177_;
2767 _vala_code_node_unref0 (t);
2768 return result;
2769 }
2770 _vala_code_node_unref0 (t);
2771 } else {
2772 ValaSymbol* _tmp178_;
2773 _tmp178_ = self->priv->sym;
2774 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp178_, VALA_TYPE_SIGNAL)) {
2775 ValaSymbol* _tmp179_;
2776 const gchar* _tmp180_;
2777 const gchar* _tmp181_;
2778 gchar* _tmp182_;
2779 gchar* _tmp183_;
2780 gchar* _tmp184_;
2781 gchar* _tmp185_;
2782 _tmp179_ = self->priv->sym;
2783 _tmp180_ = vala_symbol_get_name (_tmp179_);
2784 _tmp181_ = _tmp180_;
2785 _tmp182_ = vala_symbol_camel_case_to_lower_case (_tmp181_);
2786 _tmp183_ = _tmp182_;
2787 _tmp184_ = string_replace (_tmp183_, "_", "-");
2788 _tmp185_ = _tmp184_;
2789 _g_free0 (_tmp183_);
2790 result = _tmp185_;
2791 return result;
2792 } else {
2793 ValaSymbol* _tmp186_;
2794 _tmp186_ = self->priv->sym;
2795 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp186_, VALA_TYPE_LOCAL_VARIABLE)) {
2796 const gchar* name = NULL;
2797 ValaSymbol* _tmp187_;
2798 const gchar* _tmp188_;
2799 const gchar* _tmp189_;
2800 ValaSet* _tmp190_;
2801 const gchar* _tmp191_;
2802 _tmp187_ = self->priv->sym;
2803 _tmp188_ = vala_symbol_get_name (_tmp187_);
2804 _tmp189_ = _tmp188_;
2805 name = _tmp189_;
2806 _tmp190_ = vala_ccode_base_module_reserved_identifiers;
2807 _tmp191_ = name;
2808 if (vala_collection_contains ((ValaCollection*) _tmp190_, _tmp191_)) {
2809 const gchar* _tmp192_;
2810 gchar* _tmp193_;
2811 _tmp192_ = name;
2812 _tmp193_ = g_strdup_printf ("_%s_", _tmp192_);
2813 result = _tmp193_;
2814 return result;
2815 } else {
2816 const gchar* _tmp194_;
2817 gchar* _tmp195_;
2818 _tmp194_ = name;
2819 _tmp195_ = g_strdup (_tmp194_);
2820 result = _tmp195_;
2821 return result;
2822 }
2823 } else {
2824 ValaSymbol* _tmp196_;
2825 _tmp196_ = self->priv->sym;
2826 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp196_, VALA_TYPE_PARAMETER)) {
2827 ValaParameter* param = NULL;
2828 ValaSymbol* _tmp197_;
2829 ValaParameter* _tmp198_;
2830 gboolean _tmp199_;
2831 gboolean _tmp200_;
2832 const gchar* name = NULL;
2833 ValaSymbol* _tmp202_;
2834 const gchar* _tmp203_;
2835 const gchar* _tmp204_;
2836 ValaSet* _tmp205_;
2837 const gchar* _tmp206_;
2838 _tmp197_ = self->priv->sym;
2839 param = G_TYPE_CHECK_INSTANCE_CAST (_tmp197_, VALA_TYPE_PARAMETER, ValaParameter);
2840 _tmp198_ = param;
2841 _tmp199_ = vala_parameter_get_ellipsis (_tmp198_);
2842 _tmp200_ = _tmp199_;
2843 if (_tmp200_) {
2844 gchar* _tmp201_;
2845 _tmp201_ = g_strdup ("...");
2846 result = _tmp201_;
2847 return result;
2848 }
2849 _tmp202_ = self->priv->sym;
2850 _tmp203_ = vala_symbol_get_name (_tmp202_);
2851 _tmp204_ = _tmp203_;
2852 name = _tmp204_;
2853 _tmp205_ = vala_ccode_base_module_reserved_identifiers;
2854 _tmp206_ = name;
2855 if (vala_collection_contains ((ValaCollection*) _tmp205_, _tmp206_)) {
2856 const gchar* _tmp207_;
2857 gchar* _tmp208_;
2858 _tmp207_ = name;
2859 _tmp208_ = g_strdup_printf ("_%s_", _tmp207_);
2860 result = _tmp208_;
2861 return result;
2862 } else {
2863 const gchar* _tmp209_;
2864 gchar* _tmp210_;
2865 _tmp209_ = name;
2866 _tmp210_ = g_strdup (_tmp209_);
2867 result = _tmp210_;
2868 return result;
2869 }
2870 } else {
2871 ValaSymbol* _tmp211_;
2872 ValaSymbol* _tmp212_;
2873 ValaSymbol* _tmp213_;
2874 gchar* _tmp214_;
2875 gchar* _tmp215_;
2876 ValaSymbol* _tmp216_;
2877 const gchar* _tmp217_;
2878 const gchar* _tmp218_;
2879 gchar* _tmp219_;
2880 gchar* _tmp220_;
2881 _tmp211_ = self->priv->sym;
2882 _tmp212_ = vala_symbol_get_parent_symbol (_tmp211_);
2883 _tmp213_ = _tmp212_;
2884 _tmp214_ = vala_get_ccode_prefix (_tmp213_);
2885 _tmp215_ = _tmp214_;
2886 _tmp216_ = self->priv->sym;
2887 _tmp217_ = vala_symbol_get_name (_tmp216_);
2888 _tmp218_ = _tmp217_;
2889 _tmp219_ = g_strdup_printf ("%s%s", _tmp215_, _tmp218_);
2890 _tmp220_ = _tmp219_;
2891 _g_free0 (_tmp215_);
2892 result = _tmp220_;
2893 return result;
2894 }
2895 }
2896 }
2897 }
2898 }
2899 }
2900 }
2901 }
2902 }
2903 }
2904 } else {
2905 ValaCodeNode* _tmp221_;
2906 _tmp221_ = self->priv->node;
2907 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp221_, VALA_TYPE_OBJECT_TYPE)) {
2908 ValaObjectType* type = NULL;
2909 ValaCodeNode* _tmp222_;
2910 ValaObjectType* _tmp223_;
2911 gchar* cname = NULL;
2912 ValaObjectType* _tmp224_;
2913 gboolean _tmp225_;
2914 gboolean _tmp226_;
2915 const gchar* _tmp235_;
2916 gchar* _tmp236_;
2917 _tmp222_ = self->priv->node;
2918 _tmp223_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp222_, VALA_TYPE_OBJECT_TYPE, ValaObjectType));
2919 type = _tmp223_;
2920 _tmp224_ = type;
2921 _tmp225_ = vala_data_type_get_value_owned ((ValaDataType*) _tmp224_);
2922 _tmp226_ = _tmp225_;
2923 if (!_tmp226_) {
2924 ValaObjectType* _tmp227_;
2925 ValaTypeSymbol* _tmp228_;
2926 ValaTypeSymbol* _tmp229_;
2927 gchar* _tmp230_;
2928 _tmp227_ = type;
2929 _tmp228_ = vala_data_type_get_type_symbol ((ValaDataType*) _tmp227_);
2930 _tmp229_ = _tmp228_;
2931 _tmp230_ = vala_get_ccode_const_name ((ValaCodeNode*) _tmp229_);
2932 _g_free0 (cname);
2933 cname = _tmp230_;
2934 } else {
2935 ValaObjectType* _tmp231_;
2936 ValaTypeSymbol* _tmp232_;
2937 ValaTypeSymbol* _tmp233_;
2938 gchar* _tmp234_;
2939 _tmp231_ = type;
2940 _tmp232_ = vala_data_type_get_type_symbol ((ValaDataType*) _tmp231_);
2941 _tmp233_ = _tmp232_;
2942 _tmp234_ = vala_get_ccode_name ((ValaCodeNode*) _tmp233_);
2943 _g_free0 (cname);
2944 cname = _tmp234_;
2945 }
2946 _tmp235_ = cname;
2947 _tmp236_ = g_strdup_printf ("%s*", _tmp235_);
2948 result = _tmp236_;
2949 _g_free0 (cname);
2950 _vala_code_node_unref0 (type);
2951 return result;
2952 } else {
2953 ValaCodeNode* _tmp237_;
2954 _tmp237_ = self->priv->node;
2955 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp237_, VALA_TYPE_ARRAY_TYPE)) {
2956 ValaArrayType* type = NULL;
2957 ValaCodeNode* _tmp238_;
2958 ValaArrayType* _tmp239_;
2959 gchar* cname = NULL;
2960 ValaArrayType* _tmp240_;
2961 ValaDataType* _tmp241_;
2962 ValaDataType* _tmp242_;
2963 gchar* _tmp243_;
2964 ValaArrayType* _tmp244_;
2965 gboolean _tmp245_;
2966 gboolean _tmp246_;
2967 _tmp238_ = self->priv->node;
2968 _tmp239_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp238_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
2969 type = _tmp239_;
2970 _tmp240_ = type;
2971 _tmp241_ = vala_array_type_get_element_type (_tmp240_);
2972 _tmp242_ = _tmp241_;
2973 _tmp243_ = vala_get_ccode_name ((ValaCodeNode*) _tmp242_);
2974 cname = _tmp243_;
2975 _tmp244_ = type;
2976 _tmp245_ = vala_array_type_get_inline_allocated (_tmp244_);
2977 _tmp246_ = _tmp245_;
2978 if (_tmp246_) {
2979 result = cname;
2980 _vala_code_node_unref0 (type);
2981 return result;
2982 } else {
2983 const gchar* _tmp247_;
2984 gchar* _tmp248_;
2985 _tmp247_ = cname;
2986 _tmp248_ = g_strdup_printf ("%s*", _tmp247_);
2987 result = _tmp248_;
2988 _g_free0 (cname);
2989 _vala_code_node_unref0 (type);
2990 return result;
2991 }
2992 _g_free0 (cname);
2993 _vala_code_node_unref0 (type);
2994 } else {
2995 ValaCodeNode* _tmp249_;
2996 _tmp249_ = self->priv->node;
2997 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp249_, VALA_TYPE_DELEGATE_TYPE)) {
2998 ValaDelegateType* type = NULL;
2999 ValaCodeNode* _tmp250_;
3000 ValaDelegateType* _tmp251_;
3001 ValaDelegateType* _tmp252_;
3002 ValaDelegate* _tmp253_;
3003 ValaDelegate* _tmp254_;
3004 gchar* _tmp255_;
3005 _tmp250_ = self->priv->node;
3006 _tmp251_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp250_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType));
3007 type = _tmp251_;
3008 _tmp252_ = type;
3009 _tmp253_ = vala_delegate_type_get_delegate_symbol (_tmp252_);
3010 _tmp254_ = _tmp253_;
3011 _tmp255_ = vala_get_ccode_name ((ValaCodeNode*) _tmp254_);
3012 result = _tmp255_;
3013 _vala_code_node_unref0 (type);
3014 return result;
3015 } else {
3016 ValaCodeNode* _tmp256_;
3017 _tmp256_ = self->priv->node;
3018 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp256_, VALA_TYPE_ERROR_TYPE)) {
3019 gchar* _tmp257_;
3020 _tmp257_ = g_strdup ("GError*");
3021 result = _tmp257_;
3022 return result;
3023 } else {
3024 ValaCodeNode* _tmp258_;
3025 _tmp258_ = self->priv->node;
3026 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp258_, VALA_TYPE_GENERIC_TYPE)) {
3027 ValaGenericType* type = NULL;
3028 ValaCodeNode* _tmp259_;
3029 ValaGenericType* _tmp260_;
3030 ValaGenericType* _tmp261_;
3031 gboolean _tmp262_;
3032 gboolean _tmp263_;
3033 _tmp259_ = self->priv->node;
3034 _tmp260_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp259_, VALA_TYPE_GENERIC_TYPE, ValaGenericType));
3035 type = _tmp260_;
3036 _tmp261_ = type;
3037 _tmp262_ = vala_data_type_get_value_owned ((ValaDataType*) _tmp261_);
3038 _tmp263_ = _tmp262_;
3039 if (_tmp263_) {
3040 ValaCodeContext* _tmp264_;
3041 ValaCodeContext* _tmp265_;
3042 ValaProfile _tmp266_;
3043 ValaProfile _tmp267_;
3044 gboolean _tmp268_;
3045 _tmp264_ = vala_code_context_get ();
3046 _tmp265_ = _tmp264_;
3047 _tmp266_ = vala_code_context_get_profile (_tmp265_);
3048 _tmp267_ = _tmp266_;
3049 _tmp268_ = _tmp267_ == VALA_PROFILE_GOBJECT;
3050 _vala_code_context_unref0 (_tmp265_);
3051 if (_tmp268_) {
3052 gchar* _tmp269_;
3053 _tmp269_ = g_strdup ("gpointer");
3054 result = _tmp269_;
3055 _vala_code_node_unref0 (type);
3056 return result;
3057 } else {
3058 gchar* _tmp270_;
3059 _tmp270_ = g_strdup ("void *");
3060 result = _tmp270_;
3061 _vala_code_node_unref0 (type);
3062 return result;
3063 }
3064 } else {
3065 ValaCodeContext* _tmp271_;
3066 ValaCodeContext* _tmp272_;
3067 ValaProfile _tmp273_;
3068 ValaProfile _tmp274_;
3069 gboolean _tmp275_;
3070 _tmp271_ = vala_code_context_get ();
3071 _tmp272_ = _tmp271_;
3072 _tmp273_ = vala_code_context_get_profile (_tmp272_);
3073 _tmp274_ = _tmp273_;
3074 _tmp275_ = _tmp274_ == VALA_PROFILE_GOBJECT;
3075 _vala_code_context_unref0 (_tmp272_);
3076 if (_tmp275_) {
3077 gchar* _tmp276_;
3078 _tmp276_ = g_strdup ("gconstpointer");
3079 result = _tmp276_;
3080 _vala_code_node_unref0 (type);
3081 return result;
3082 } else {
3083 gchar* _tmp277_;
3084 _tmp277_ = g_strdup ("const void *");
3085 result = _tmp277_;
3086 _vala_code_node_unref0 (type);
3087 return result;
3088 }
3089 }
3090 _vala_code_node_unref0 (type);
3091 } else {
3092 ValaCodeNode* _tmp278_;
3093 _tmp278_ = self->priv->node;
3094 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp278_, VALA_TYPE_METHOD_TYPE)) {
3095 ValaCodeContext* _tmp279_;
3096 ValaCodeContext* _tmp280_;
3097 ValaProfile _tmp281_;
3098 ValaProfile _tmp282_;
3099 gboolean _tmp283_;
3100 _tmp279_ = vala_code_context_get ();
3101 _tmp280_ = _tmp279_;
3102 _tmp281_ = vala_code_context_get_profile (_tmp280_);
3103 _tmp282_ = _tmp281_;
3104 _tmp283_ = _tmp282_ == VALA_PROFILE_GOBJECT;
3105 _vala_code_context_unref0 (_tmp280_);
3106 if (_tmp283_) {
3107 gchar* _tmp284_;
3108 _tmp284_ = g_strdup ("gpointer");
3109 result = _tmp284_;
3110 return result;
3111 } else {
3112 gchar* _tmp285_;
3113 _tmp285_ = g_strdup ("void *");
3114 result = _tmp285_;
3115 return result;
3116 }
3117 } else {
3118 ValaCodeNode* _tmp286_;
3119 _tmp286_ = self->priv->node;
3120 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp286_, VALA_TYPE_NULL_TYPE)) {
3121 ValaCodeContext* _tmp287_;
3122 ValaCodeContext* _tmp288_;
3123 ValaProfile _tmp289_;
3124 ValaProfile _tmp290_;
3125 gboolean _tmp291_;
3126 _tmp287_ = vala_code_context_get ();
3127 _tmp288_ = _tmp287_;
3128 _tmp289_ = vala_code_context_get_profile (_tmp288_);
3129 _tmp290_ = _tmp289_;
3130 _tmp291_ = _tmp290_ == VALA_PROFILE_GOBJECT;
3131 _vala_code_context_unref0 (_tmp288_);
3132 if (_tmp291_) {
3133 gchar* _tmp292_;
3134 _tmp292_ = g_strdup ("gpointer");
3135 result = _tmp292_;
3136 return result;
3137 } else {
3138 gchar* _tmp293_;
3139 _tmp293_ = g_strdup ("void *");
3140 result = _tmp293_;
3141 return result;
3142 }
3143 } else {
3144 ValaCodeNode* _tmp294_;
3145 _tmp294_ = self->priv->node;
3146 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp294_, VALA_TYPE_POINTER_TYPE)) {
3147 ValaPointerType* type = NULL;
3148 ValaCodeNode* _tmp295_;
3149 ValaPointerType* _tmp296_;
3150 gboolean _tmp297_ = FALSE;
3151 ValaPointerType* _tmp298_;
3152 ValaDataType* _tmp299_;
3153 ValaDataType* _tmp300_;
3154 ValaTypeSymbol* _tmp301_;
3155 ValaTypeSymbol* _tmp302_;
3156 _tmp295_ = self->priv->node;
3157 _tmp296_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp295_, VALA_TYPE_POINTER_TYPE, ValaPointerType));
3158 type = _tmp296_;
3159 _tmp298_ = type;
3160 _tmp299_ = vala_pointer_type_get_base_type (_tmp298_);
3161 _tmp300_ = _tmp299_;
3162 _tmp301_ = vala_data_type_get_type_symbol (_tmp300_);
3163 _tmp302_ = _tmp301_;
3164 if (_tmp302_ != NULL) {
3165 ValaPointerType* _tmp303_;
3166 ValaDataType* _tmp304_;
3167 ValaDataType* _tmp305_;
3168 ValaTypeSymbol* _tmp306_;
3169 ValaTypeSymbol* _tmp307_;
3170 _tmp303_ = type;
3171 _tmp304_ = vala_pointer_type_get_base_type (_tmp303_);
3172 _tmp305_ = _tmp304_;
3173 _tmp306_ = vala_data_type_get_type_symbol (_tmp305_);
3174 _tmp307_ = _tmp306_;
3175 _tmp297_ = vala_typesymbol_is_reference_type (_tmp307_);
3176 } else {
3177 _tmp297_ = FALSE;
3178 }
3179 if (_tmp297_) {
3180 ValaPointerType* _tmp308_;
3181 ValaDataType* _tmp309_;
3182 ValaDataType* _tmp310_;
3183 gchar* _tmp311_;
3184 _tmp308_ = type;
3185 _tmp309_ = vala_pointer_type_get_base_type (_tmp308_);
3186 _tmp310_ = _tmp309_;
3187 _tmp311_ = vala_get_ccode_name ((ValaCodeNode*) _tmp310_);
3188 result = _tmp311_;
3189 _vala_code_node_unref0 (type);
3190 return result;
3191 } else {
3192 ValaPointerType* _tmp312_;
3193 ValaDataType* _tmp313_;
3194 ValaDataType* _tmp314_;
3195 gchar* _tmp315_;
3196 gchar* _tmp316_;
3197 gchar* _tmp317_;
3198 gchar* _tmp318_;
3199 _tmp312_ = type;
3200 _tmp313_ = vala_pointer_type_get_base_type (_tmp312_);
3201 _tmp314_ = _tmp313_;
3202 _tmp315_ = vala_get_ccode_name ((ValaCodeNode*) _tmp314_);
3203 _tmp316_ = _tmp315_;
3204 _tmp317_ = g_strdup_printf ("%s*", _tmp316_);
3205 _tmp318_ = _tmp317_;
3206 _g_free0 (_tmp316_);
3207 result = _tmp318_;
3208 _vala_code_node_unref0 (type);
3209 return result;
3210 }
3211 _vala_code_node_unref0 (type);
3212 } else {
3213 ValaCodeNode* _tmp319_;
3214 _tmp319_ = self->priv->node;
3215 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp319_, VALA_TYPE_VOID_TYPE)) {
3216 gchar* _tmp320_;
3217 _tmp320_ = g_strdup ("void");
3218 result = _tmp320_;
3219 return result;
3220 } else {
3221 ValaCodeNode* _tmp321_;
3222 _tmp321_ = self->priv->node;
3223 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp321_, VALA_TYPE_CLASS_TYPE)) {
3224 ValaClassType* type = NULL;
3225 ValaCodeNode* _tmp322_;
3226 ValaClassType* _tmp323_;
3227 ValaClassType* _tmp324_;
3228 ValaClass* _tmp325_;
3229 ValaClass* _tmp326_;
3230 gchar* _tmp327_;
3231 gchar* _tmp328_;
3232 gchar* _tmp329_;
3233 gchar* _tmp330_;
3234 _tmp322_ = self->priv->node;
3235 _tmp323_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp322_, VALA_TYPE_CLASS_TYPE, ValaClassType));
3236 type = _tmp323_;
3237 _tmp324_ = type;
3238 _tmp325_ = vala_class_type_get_class_symbol (_tmp324_);
3239 _tmp326_ = _tmp325_;
3240 _tmp327_ = vala_get_ccode_type_name ((ValaObjectTypeSymbol*) _tmp326_);
3241 _tmp328_ = _tmp327_;
3242 _tmp329_ = g_strdup_printf ("%s*", _tmp328_);
3243 _tmp330_ = _tmp329_;
3244 _g_free0 (_tmp328_);
3245 result = _tmp330_;
3246 _vala_code_node_unref0 (type);
3247 return result;
3248 } else {
3249 ValaCodeNode* _tmp331_;
3250 _tmp331_ = self->priv->node;
3251 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp331_, VALA_TYPE_INTERFACE_TYPE)) {
3252 ValaInterfaceType* type = NULL;
3253 ValaCodeNode* _tmp332_;
3254 ValaInterfaceType* _tmp333_;
3255 ValaInterfaceType* _tmp334_;
3256 ValaInterface* _tmp335_;
3257 ValaInterface* _tmp336_;
3258 gchar* _tmp337_;
3259 gchar* _tmp338_;
3260 gchar* _tmp339_;
3261 gchar* _tmp340_;
3262 _tmp332_ = self->priv->node;
3263 _tmp333_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp332_, VALA_TYPE_INTERFACE_TYPE, ValaInterfaceType));
3264 type = _tmp333_;
3265 _tmp334_ = type;
3266 _tmp335_ = vala_interface_type_get_interface_symbol (_tmp334_);
3267 _tmp336_ = _tmp335_;
3268 _tmp337_ = vala_get_ccode_type_name ((ValaObjectTypeSymbol*) _tmp336_);
3269 _tmp338_ = _tmp337_;
3270 _tmp339_ = g_strdup_printf ("%s*", _tmp338_);
3271 _tmp340_ = _tmp339_;
3272 _g_free0 (_tmp338_);
3273 result = _tmp340_;
3274 _vala_code_node_unref0 (type);
3275 return result;
3276 } else {
3277 ValaCodeNode* _tmp341_;
3278 _tmp341_ = self->priv->node;
3279 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp341_, VALA_TYPE_VALUE_TYPE)) {
3280 ValaValueType* type = NULL;
3281 ValaCodeNode* _tmp342_;
3282 ValaValueType* _tmp343_;
3283 gchar* cname = NULL;
3284 ValaValueType* _tmp344_;
3285 ValaTypeSymbol* _tmp345_;
3286 ValaTypeSymbol* _tmp346_;
3287 gchar* _tmp347_;
3288 ValaValueType* _tmp348_;
3289 gboolean _tmp349_;
3290 gboolean _tmp350_;
3291 _tmp342_ = self->priv->node;
3292 _tmp343_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp342_, VALA_TYPE_VALUE_TYPE, ValaValueType));
3293 type = _tmp343_;
3294 _tmp344_ = type;
3295 _tmp345_ = vala_data_type_get_type_symbol ((ValaDataType*) _tmp344_);
3296 _tmp346_ = _tmp345_;
3297 _tmp347_ = vala_get_ccode_name ((ValaCodeNode*) _tmp346_);
3298 cname = _tmp347_;
3299 _tmp348_ = type;
3300 _tmp349_ = vala_data_type_get_nullable ((ValaDataType*) _tmp348_);
3301 _tmp350_ = _tmp349_;
3302 if (_tmp350_) {
3303 const gchar* _tmp351_;
3304 gchar* _tmp352_;
3305 _tmp351_ = cname;
3306 _tmp352_ = g_strdup_printf ("%s*", _tmp351_);
3307 result = _tmp352_;
3308 _g_free0 (cname);
3309 _vala_code_node_unref0 (type);
3310 return result;
3311 } else {
3312 result = cname;
3313 _vala_code_node_unref0 (type);
3314 return result;
3315 }
3316 _g_free0 (cname);
3317 _vala_code_node_unref0 (type);
3318 } else {
3319 ValaCodeNode* _tmp353_;
3320 _tmp353_ = self->priv->node;
3321 if (VALA_IS_CTYPE (_tmp353_)) {
3322 ValaCodeNode* _tmp354_;
3323 const gchar* _tmp355_;
3324 const gchar* _tmp356_;
3325 gchar* _tmp357_;
3326 _tmp354_ = self->priv->node;
3327 _tmp355_ = vala_ctype_get_ctype_name (G_TYPE_CHECK_INSTANCE_CAST (_tmp354_, VALA_TYPE_CTYPE, ValaCType));
3328 _tmp356_ = _tmp355_;
3329 _tmp357_ = g_strdup (_tmp356_);
3330 result = _tmp357_;
3331 return result;
3332 } else {
3333 ValaCodeNode* _tmp358_;
3334 ValaSourceReference* _tmp359_;
3335 ValaSourceReference* _tmp360_;
3336 gchar* _tmp361_;
3337 _tmp358_ = self->priv->node;
3338 _tmp359_ = vala_code_node_get_source_reference (_tmp358_);
3339 _tmp360_ = _tmp359_;
3340 vala_report_error (_tmp360_, "Unresolved type reference");
3341 _tmp361_ = g_strdup ("");
3342 result = _tmp361_;
3343 return result;
3344 }
3345 }
3346 }
3347 }
3348 }
3349 }
3350 }
3351 }
3352 }
3353 }
3354 }
3355 }
3356 }
3357 }
3358 }
3359
3360 static gchar*
vala_ccode_attribute_get_default_header_filenames(ValaCCodeAttribute * self)3361 vala_ccode_attribute_get_default_header_filenames (ValaCCodeAttribute* self)
3362 {
3363 gboolean _tmp0_ = FALSE;
3364 ValaSymbol* _tmp1_;
3365 gboolean _tmp4_ = FALSE;
3366 ValaSymbol* _tmp5_;
3367 ValaSymbol* _tmp6_;
3368 ValaSymbol* _tmp7_;
3369 gboolean _tmp18_ = FALSE;
3370 gboolean _tmp19_ = FALSE;
3371 ValaSymbol* _tmp20_;
3372 ValaSourceReference* _tmp21_;
3373 ValaSourceReference* _tmp22_;
3374 gchar* _tmp35_;
3375 gchar* result = NULL;
3376 g_return_val_if_fail (self != NULL, NULL);
3377 _tmp1_ = self->priv->sym;
3378 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1_, VALA_TYPE_DYNAMIC_PROPERTY)) {
3379 _tmp0_ = TRUE;
3380 } else {
3381 ValaSymbol* _tmp2_;
3382 _tmp2_ = self->priv->sym;
3383 _tmp0_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2_, VALA_TYPE_DYNAMIC_METHOD);
3384 }
3385 if (_tmp0_) {
3386 gchar* _tmp3_;
3387 _tmp3_ = g_strdup ("");
3388 result = _tmp3_;
3389 return result;
3390 }
3391 _tmp5_ = self->priv->sym;
3392 _tmp6_ = vala_symbol_get_parent_symbol (_tmp5_);
3393 _tmp7_ = _tmp6_;
3394 if (_tmp7_ != NULL) {
3395 ValaSymbol* _tmp8_;
3396 gboolean _tmp9_;
3397 gboolean _tmp10_;
3398 _tmp8_ = self->priv->sym;
3399 _tmp9_ = vala_symbol_get_is_extern (_tmp8_);
3400 _tmp10_ = _tmp9_;
3401 _tmp4_ = !_tmp10_;
3402 } else {
3403 _tmp4_ = FALSE;
3404 }
3405 if (_tmp4_) {
3406 gchar* parent_headers = NULL;
3407 ValaSymbol* _tmp11_;
3408 ValaSymbol* _tmp12_;
3409 ValaSymbol* _tmp13_;
3410 gchar* _tmp14_;
3411 const gchar* _tmp15_;
3412 gint _tmp16_;
3413 gint _tmp17_;
3414 _tmp11_ = self->priv->sym;
3415 _tmp12_ = vala_symbol_get_parent_symbol (_tmp11_);
3416 _tmp13_ = _tmp12_;
3417 _tmp14_ = vala_get_ccode_header_filenames (_tmp13_);
3418 parent_headers = _tmp14_;
3419 _tmp15_ = parent_headers;
3420 _tmp16_ = strlen (_tmp15_);
3421 _tmp17_ = _tmp16_;
3422 if (_tmp17_ > 0) {
3423 result = parent_headers;
3424 return result;
3425 }
3426 _g_free0 (parent_headers);
3427 }
3428 _tmp20_ = self->priv->sym;
3429 _tmp21_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp20_);
3430 _tmp22_ = _tmp21_;
3431 if (_tmp22_ != NULL) {
3432 ValaSymbol* _tmp23_;
3433 gboolean _tmp24_;
3434 gboolean _tmp25_;
3435 _tmp23_ = self->priv->sym;
3436 _tmp24_ = vala_symbol_get_external_package (_tmp23_);
3437 _tmp25_ = _tmp24_;
3438 _tmp19_ = !_tmp25_;
3439 } else {
3440 _tmp19_ = FALSE;
3441 }
3442 if (_tmp19_) {
3443 ValaSymbol* _tmp26_;
3444 gboolean _tmp27_;
3445 gboolean _tmp28_;
3446 _tmp26_ = self->priv->sym;
3447 _tmp27_ = vala_symbol_get_is_extern (_tmp26_);
3448 _tmp28_ = _tmp27_;
3449 _tmp18_ = !_tmp28_;
3450 } else {
3451 _tmp18_ = FALSE;
3452 }
3453 if (_tmp18_) {
3454 ValaSymbol* _tmp29_;
3455 ValaSourceReference* _tmp30_;
3456 ValaSourceReference* _tmp31_;
3457 ValaSourceFile* _tmp32_;
3458 ValaSourceFile* _tmp33_;
3459 gchar* _tmp34_;
3460 _tmp29_ = self->priv->sym;
3461 _tmp30_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp29_);
3462 _tmp31_ = _tmp30_;
3463 _tmp32_ = vala_source_reference_get_file (_tmp31_);
3464 _tmp33_ = _tmp32_;
3465 _tmp34_ = vala_source_file_get_cinclude_filename (_tmp33_);
3466 result = _tmp34_;
3467 return result;
3468 }
3469 _tmp35_ = g_strdup ("");
3470 result = _tmp35_;
3471 return result;
3472 }
3473
3474 static gchar*
vala_ccode_attribute_get_default_prefix(ValaCCodeAttribute * self)3475 vala_ccode_attribute_get_default_prefix (ValaCCodeAttribute* self)
3476 {
3477 ValaSymbol* _tmp0_;
3478 gchar* _tmp37_;
3479 gchar* result = NULL;
3480 g_return_val_if_fail (self != NULL, NULL);
3481 _tmp0_ = self->priv->sym;
3482 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_OBJECT_TYPE_SYMBOL)) {
3483 const gchar* _tmp1_;
3484 const gchar* _tmp2_;
3485 gchar* _tmp3_;
3486 _tmp1_ = vala_ccode_attribute_get_name (self);
3487 _tmp2_ = _tmp1_;
3488 _tmp3_ = g_strdup (_tmp2_);
3489 result = _tmp3_;
3490 return result;
3491 } else {
3492 gboolean _tmp4_ = FALSE;
3493 ValaSymbol* _tmp5_;
3494 _tmp5_ = self->priv->sym;
3495 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp5_, VALA_TYPE_ENUM)) {
3496 _tmp4_ = TRUE;
3497 } else {
3498 ValaSymbol* _tmp6_;
3499 _tmp6_ = self->priv->sym;
3500 _tmp4_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp6_, VALA_TYPE_ERROR_DOMAIN);
3501 }
3502 if (_tmp4_) {
3503 ValaSymbol* _tmp7_;
3504 gchar* _tmp8_;
3505 gchar* _tmp9_;
3506 gchar* _tmp10_;
3507 gchar* _tmp11_;
3508 _tmp7_ = self->priv->sym;
3509 _tmp8_ = vala_get_ccode_upper_case_name (_tmp7_, NULL);
3510 _tmp9_ = _tmp8_;
3511 _tmp10_ = g_strdup_printf ("%s_", _tmp9_);
3512 _tmp11_ = _tmp10_;
3513 _g_free0 (_tmp9_);
3514 result = _tmp11_;
3515 return result;
3516 } else {
3517 ValaSymbol* _tmp12_;
3518 _tmp12_ = self->priv->sym;
3519 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp12_, VALA_TYPE_NAMESPACE)) {
3520 ValaSymbol* _tmp13_;
3521 const gchar* _tmp14_;
3522 const gchar* _tmp15_;
3523 _tmp13_ = self->priv->sym;
3524 _tmp14_ = vala_symbol_get_name (_tmp13_);
3525 _tmp15_ = _tmp14_;
3526 if (_tmp15_ != NULL) {
3527 gchar* parent_prefix = NULL;
3528 gchar* _tmp16_;
3529 ValaSymbol* _tmp17_;
3530 ValaSymbol* _tmp18_;
3531 ValaSymbol* _tmp19_;
3532 const gchar* _tmp24_;
3533 ValaSymbol* _tmp25_;
3534 const gchar* _tmp26_;
3535 const gchar* _tmp27_;
3536 gchar* _tmp28_;
3537 _tmp16_ = g_strdup ("");
3538 parent_prefix = _tmp16_;
3539 _tmp17_ = self->priv->sym;
3540 _tmp18_ = vala_symbol_get_parent_symbol (_tmp17_);
3541 _tmp19_ = _tmp18_;
3542 if (_tmp19_ != NULL) {
3543 ValaSymbol* _tmp20_;
3544 ValaSymbol* _tmp21_;
3545 ValaSymbol* _tmp22_;
3546 gchar* _tmp23_;
3547 _tmp20_ = self->priv->sym;
3548 _tmp21_ = vala_symbol_get_parent_symbol (_tmp20_);
3549 _tmp22_ = _tmp21_;
3550 _tmp23_ = vala_get_ccode_prefix (_tmp22_);
3551 _g_free0 (parent_prefix);
3552 parent_prefix = _tmp23_;
3553 }
3554 _tmp24_ = parent_prefix;
3555 _tmp25_ = self->priv->sym;
3556 _tmp26_ = vala_symbol_get_name (_tmp25_);
3557 _tmp27_ = _tmp26_;
3558 _tmp28_ = g_strdup_printf ("%s%s", _tmp24_, _tmp27_);
3559 result = _tmp28_;
3560 _g_free0 (parent_prefix);
3561 return result;
3562 } else {
3563 gchar* _tmp29_;
3564 _tmp29_ = g_strdup ("");
3565 result = _tmp29_;
3566 return result;
3567 }
3568 } else {
3569 ValaSymbol* _tmp30_;
3570 const gchar* _tmp31_;
3571 const gchar* _tmp32_;
3572 _tmp30_ = self->priv->sym;
3573 _tmp31_ = vala_symbol_get_name (_tmp30_);
3574 _tmp32_ = _tmp31_;
3575 if (_tmp32_ != NULL) {
3576 ValaSymbol* _tmp33_;
3577 const gchar* _tmp34_;
3578 const gchar* _tmp35_;
3579 gchar* _tmp36_;
3580 _tmp33_ = self->priv->sym;
3581 _tmp34_ = vala_symbol_get_name (_tmp33_);
3582 _tmp35_ = _tmp34_;
3583 _tmp36_ = g_strdup (_tmp35_);
3584 result = _tmp36_;
3585 return result;
3586 }
3587 }
3588 }
3589 }
3590 _tmp37_ = g_strdup ("");
3591 result = _tmp37_;
3592 return result;
3593 }
3594
3595 static gchar*
vala_ccode_attribute_get_default_lower_case_prefix(ValaCCodeAttribute * self)3596 vala_ccode_attribute_get_default_lower_case_prefix (ValaCCodeAttribute* self)
3597 {
3598 ValaSymbol* _tmp0_;
3599 gchar* result = NULL;
3600 g_return_val_if_fail (self != NULL, NULL);
3601 _tmp0_ = self->priv->sym;
3602 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_NAMESPACE)) {
3603 ValaSymbol* _tmp1_;
3604 const gchar* _tmp2_;
3605 const gchar* _tmp3_;
3606 _tmp1_ = self->priv->sym;
3607 _tmp2_ = vala_symbol_get_name (_tmp1_);
3608 _tmp3_ = _tmp2_;
3609 if (_tmp3_ == NULL) {
3610 gchar* _tmp4_;
3611 _tmp4_ = g_strdup ("");
3612 result = _tmp4_;
3613 return result;
3614 } else {
3615 ValaSymbol* _tmp5_;
3616 ValaSymbol* _tmp6_;
3617 ValaSymbol* _tmp7_;
3618 gchar* _tmp8_;
3619 gchar* _tmp9_;
3620 ValaSymbol* _tmp10_;
3621 const gchar* _tmp11_;
3622 const gchar* _tmp12_;
3623 gchar* _tmp13_;
3624 gchar* _tmp14_;
3625 gchar* _tmp15_;
3626 gchar* _tmp16_;
3627 _tmp5_ = self->priv->sym;
3628 _tmp6_ = vala_symbol_get_parent_symbol (_tmp5_);
3629 _tmp7_ = _tmp6_;
3630 _tmp8_ = vala_get_ccode_lower_case_prefix (_tmp7_);
3631 _tmp9_ = _tmp8_;
3632 _tmp10_ = self->priv->sym;
3633 _tmp11_ = vala_symbol_get_name (_tmp10_);
3634 _tmp12_ = _tmp11_;
3635 _tmp13_ = vala_symbol_camel_case_to_lower_case (_tmp12_);
3636 _tmp14_ = _tmp13_;
3637 _tmp15_ = g_strdup_printf ("%s%s_", _tmp9_, _tmp14_);
3638 _tmp16_ = _tmp15_;
3639 _g_free0 (_tmp14_);
3640 _g_free0 (_tmp9_);
3641 result = _tmp16_;
3642 return result;
3643 }
3644 } else {
3645 ValaSymbol* _tmp17_;
3646 _tmp17_ = self->priv->sym;
3647 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp17_, VALA_TYPE_METHOD)) {
3648 gchar* _tmp18_;
3649 _tmp18_ = g_strdup ("");
3650 result = _tmp18_;
3651 return result;
3652 } else {
3653 ValaSymbol* _tmp19_;
3654 gchar* _tmp20_;
3655 gchar* _tmp21_;
3656 gchar* _tmp22_;
3657 gchar* _tmp23_;
3658 _tmp19_ = self->priv->sym;
3659 _tmp20_ = vala_get_ccode_lower_case_name ((ValaCodeNode*) _tmp19_, NULL);
3660 _tmp21_ = _tmp20_;
3661 _tmp22_ = g_strdup_printf ("%s_", _tmp21_);
3662 _tmp23_ = _tmp22_;
3663 _g_free0 (_tmp21_);
3664 result = _tmp23_;
3665 return result;
3666 }
3667 }
3668 }
3669
3670 static gchar*
vala_ccode_attribute_get_default_lower_case_suffix(ValaCCodeAttribute * self)3671 vala_ccode_attribute_get_default_lower_case_suffix (ValaCCodeAttribute* self)
3672 {
3673 ValaSymbol* _tmp0_;
3674 gchar* _tmp42_;
3675 gchar* result = NULL;
3676 g_return_val_if_fail (self != NULL, NULL);
3677 _tmp0_ = self->priv->sym;
3678 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_OBJECT_TYPE_SYMBOL)) {
3679 gchar* csuffix = NULL;
3680 ValaSymbol* _tmp1_;
3681 const gchar* _tmp2_;
3682 const gchar* _tmp3_;
3683 gchar* _tmp4_;
3684 const gchar* _tmp5_;
3685 const gchar* _tmp19_;
3686 _tmp1_ = self->priv->sym;
3687 _tmp2_ = vala_symbol_get_name (_tmp1_);
3688 _tmp3_ = _tmp2_;
3689 _tmp4_ = vala_symbol_camel_case_to_lower_case (_tmp3_);
3690 csuffix = _tmp4_;
3691 _tmp5_ = csuffix;
3692 if (g_str_has_prefix (_tmp5_, "type_")) {
3693 const gchar* _tmp6_;
3694 gint _tmp7_;
3695 gint _tmp8_;
3696 gchar* _tmp9_;
3697 gchar* _tmp10_;
3698 gchar* _tmp11_;
3699 _tmp6_ = csuffix;
3700 _tmp7_ = strlen ("type_");
3701 _tmp8_ = _tmp7_;
3702 _tmp9_ = string_substring (_tmp6_, (glong) _tmp8_, (glong) -1);
3703 _tmp10_ = _tmp9_;
3704 _tmp11_ = g_strconcat ("type", _tmp10_, NULL);
3705 _g_free0 (csuffix);
3706 csuffix = _tmp11_;
3707 _g_free0 (_tmp10_);
3708 } else {
3709 const gchar* _tmp12_;
3710 _tmp12_ = csuffix;
3711 if (g_str_has_prefix (_tmp12_, "is_")) {
3712 const gchar* _tmp13_;
3713 gint _tmp14_;
3714 gint _tmp15_;
3715 gchar* _tmp16_;
3716 gchar* _tmp17_;
3717 gchar* _tmp18_;
3718 _tmp13_ = csuffix;
3719 _tmp14_ = strlen ("is_");
3720 _tmp15_ = _tmp14_;
3721 _tmp16_ = string_substring (_tmp13_, (glong) _tmp15_, (glong) -1);
3722 _tmp17_ = _tmp16_;
3723 _tmp18_ = g_strconcat ("is", _tmp17_, NULL);
3724 _g_free0 (csuffix);
3725 csuffix = _tmp18_;
3726 _g_free0 (_tmp17_);
3727 }
3728 }
3729 _tmp19_ = csuffix;
3730 if (g_str_has_suffix (_tmp19_, "_class")) {
3731 const gchar* _tmp20_;
3732 const gchar* _tmp21_;
3733 gint _tmp22_;
3734 gint _tmp23_;
3735 gint _tmp24_;
3736 gint _tmp25_;
3737 gchar* _tmp26_;
3738 gchar* _tmp27_;
3739 gchar* _tmp28_;
3740 _tmp20_ = csuffix;
3741 _tmp21_ = csuffix;
3742 _tmp22_ = strlen (_tmp21_);
3743 _tmp23_ = _tmp22_;
3744 _tmp24_ = strlen ("_class");
3745 _tmp25_ = _tmp24_;
3746 _tmp26_ = string_substring (_tmp20_, (glong) 0, (glong) (_tmp23_ - _tmp25_));
3747 _tmp27_ = _tmp26_;
3748 _tmp28_ = g_strconcat (_tmp27_, "class", NULL);
3749 _g_free0 (csuffix);
3750 csuffix = _tmp28_;
3751 _g_free0 (_tmp27_);
3752 }
3753 result = csuffix;
3754 return result;
3755 } else {
3756 ValaSymbol* _tmp29_;
3757 _tmp29_ = self->priv->sym;
3758 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp29_, VALA_TYPE_SIGNAL)) {
3759 ValaSymbol* _tmp30_;
3760 ValaCCodeAttribute* _tmp31_;
3761 const gchar* _tmp32_;
3762 const gchar* _tmp33_;
3763 gchar* _tmp34_;
3764 _tmp30_ = self->priv->sym;
3765 _tmp31_ = vala_get_ccode_attribute ((ValaCodeNode*) _tmp30_);
3766 _tmp32_ = vala_ccode_attribute_get_name (_tmp31_);
3767 _tmp33_ = _tmp32_;
3768 _tmp34_ = string_replace (_tmp33_, "-", "_");
3769 result = _tmp34_;
3770 return result;
3771 } else {
3772 ValaSymbol* _tmp35_;
3773 const gchar* _tmp36_;
3774 const gchar* _tmp37_;
3775 _tmp35_ = self->priv->sym;
3776 _tmp36_ = vala_symbol_get_name (_tmp35_);
3777 _tmp37_ = _tmp36_;
3778 if (_tmp37_ != NULL) {
3779 ValaSymbol* _tmp38_;
3780 const gchar* _tmp39_;
3781 const gchar* _tmp40_;
3782 gchar* _tmp41_;
3783 _tmp38_ = self->priv->sym;
3784 _tmp39_ = vala_symbol_get_name (_tmp38_);
3785 _tmp40_ = _tmp39_;
3786 _tmp41_ = vala_symbol_camel_case_to_lower_case (_tmp40_);
3787 result = _tmp41_;
3788 return result;
3789 }
3790 }
3791 }
3792 _tmp42_ = g_strdup ("");
3793 result = _tmp42_;
3794 return result;
3795 }
3796
3797 static gpointer
_vala_iterable_ref0(gpointer self)3798 _vala_iterable_ref0 (gpointer self)
3799 {
3800 return self ? vala_iterable_ref (self) : NULL;
3801 }
3802
3803 static gchar*
vala_ccode_attribute_get_default_ref_function(ValaCCodeAttribute * self)3804 vala_ccode_attribute_get_default_ref_function (ValaCCodeAttribute* self)
3805 {
3806 ValaSymbol* _tmp0_;
3807 gchar* result = NULL;
3808 g_return_val_if_fail (self != NULL, NULL);
3809 _tmp0_ = self->priv->sym;
3810 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_CLASS)) {
3811 ValaClass* cl = NULL;
3812 ValaSymbol* _tmp1_;
3813 ValaClass* _tmp2_;
3814 _tmp1_ = self->priv->sym;
3815 cl = G_TYPE_CHECK_INSTANCE_CAST (_tmp1_, VALA_TYPE_CLASS, ValaClass);
3816 _tmp2_ = cl;
3817 if (vala_class_is_fundamental (_tmp2_)) {
3818 const gchar* _tmp3_;
3819 const gchar* _tmp4_;
3820 gchar* _tmp5_;
3821 _tmp3_ = vala_ccode_attribute_get_lower_case_prefix (self);
3822 _tmp4_ = _tmp3_;
3823 _tmp5_ = g_strdup_printf ("%sref", _tmp4_);
3824 result = _tmp5_;
3825 return result;
3826 } else {
3827 ValaClass* _tmp6_;
3828 ValaClass* _tmp7_;
3829 ValaClass* _tmp8_;
3830 _tmp6_ = cl;
3831 _tmp7_ = vala_class_get_base_class (_tmp6_);
3832 _tmp8_ = _tmp7_;
3833 if (_tmp8_ != NULL) {
3834 ValaClass* _tmp9_;
3835 ValaClass* _tmp10_;
3836 ValaClass* _tmp11_;
3837 gchar* _tmp12_;
3838 _tmp9_ = cl;
3839 _tmp10_ = vala_class_get_base_class (_tmp9_);
3840 _tmp11_ = _tmp10_;
3841 _tmp12_ = vala_get_ccode_ref_function ((ValaTypeSymbol*) _tmp11_);
3842 result = _tmp12_;
3843 return result;
3844 }
3845 }
3846 } else {
3847 ValaSymbol* _tmp13_;
3848 _tmp13_ = self->priv->sym;
3849 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp13_, VALA_TYPE_INTERFACE)) {
3850 {
3851 ValaList* _prereq_list = NULL;
3852 ValaSymbol* _tmp14_;
3853 ValaList* _tmp15_;
3854 ValaList* _tmp16_;
3855 gint _prereq_size = 0;
3856 ValaList* _tmp17_;
3857 gint _tmp18_;
3858 gint _tmp19_;
3859 gint _prereq_index = 0;
3860 _tmp14_ = self->priv->sym;
3861 _tmp15_ = vala_interface_get_prerequisites (G_TYPE_CHECK_INSTANCE_CAST (_tmp14_, VALA_TYPE_INTERFACE, ValaInterface));
3862 _tmp16_ = _vala_iterable_ref0 (_tmp15_);
3863 _prereq_list = _tmp16_;
3864 _tmp17_ = _prereq_list;
3865 _tmp18_ = vala_collection_get_size ((ValaCollection*) _tmp17_);
3866 _tmp19_ = _tmp18_;
3867 _prereq_size = _tmp19_;
3868 _prereq_index = -1;
3869 while (TRUE) {
3870 gint _tmp20_;
3871 gint _tmp21_;
3872 ValaDataType* prereq = NULL;
3873 ValaList* _tmp22_;
3874 gpointer _tmp23_;
3875 gchar* ref_func = NULL;
3876 ValaDataType* _tmp24_;
3877 ValaTypeSymbol* _tmp25_;
3878 ValaTypeSymbol* _tmp26_;
3879 gchar* _tmp27_;
3880 const gchar* _tmp28_;
3881 _prereq_index = _prereq_index + 1;
3882 _tmp20_ = _prereq_index;
3883 _tmp21_ = _prereq_size;
3884 if (!(_tmp20_ < _tmp21_)) {
3885 break;
3886 }
3887 _tmp22_ = _prereq_list;
3888 _tmp23_ = vala_list_get (_tmp22_, _prereq_index);
3889 prereq = (ValaDataType*) _tmp23_;
3890 _tmp24_ = prereq;
3891 _tmp25_ = vala_data_type_get_type_symbol (_tmp24_);
3892 _tmp26_ = _tmp25_;
3893 _tmp27_ = vala_get_ccode_ref_function ((ValaTypeSymbol*) G_TYPE_CHECK_INSTANCE_CAST (_tmp26_, VALA_TYPE_OBJECT_TYPE_SYMBOL, ValaObjectTypeSymbol));
3894 ref_func = _tmp27_;
3895 _tmp28_ = ref_func;
3896 if (_tmp28_ != NULL) {
3897 result = ref_func;
3898 _vala_code_node_unref0 (prereq);
3899 _vala_iterable_unref0 (_prereq_list);
3900 return result;
3901 }
3902 _g_free0 (ref_func);
3903 _vala_code_node_unref0 (prereq);
3904 }
3905 _vala_iterable_unref0 (_prereq_list);
3906 }
3907 }
3908 }
3909 result = NULL;
3910 return result;
3911 }
3912
3913 static gchar*
vala_ccode_attribute_get_default_unref_function(ValaCCodeAttribute * self)3914 vala_ccode_attribute_get_default_unref_function (ValaCCodeAttribute* self)
3915 {
3916 ValaSymbol* _tmp0_;
3917 gchar* result = NULL;
3918 g_return_val_if_fail (self != NULL, NULL);
3919 _tmp0_ = self->priv->sym;
3920 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_CLASS)) {
3921 ValaClass* cl = NULL;
3922 ValaSymbol* _tmp1_;
3923 ValaClass* _tmp2_;
3924 _tmp1_ = self->priv->sym;
3925 cl = G_TYPE_CHECK_INSTANCE_CAST (_tmp1_, VALA_TYPE_CLASS, ValaClass);
3926 _tmp2_ = cl;
3927 if (vala_class_is_fundamental (_tmp2_)) {
3928 const gchar* _tmp3_;
3929 const gchar* _tmp4_;
3930 gchar* _tmp5_;
3931 _tmp3_ = vala_ccode_attribute_get_lower_case_prefix (self);
3932 _tmp4_ = _tmp3_;
3933 _tmp5_ = g_strdup_printf ("%sunref", _tmp4_);
3934 result = _tmp5_;
3935 return result;
3936 } else {
3937 ValaClass* _tmp6_;
3938 ValaClass* _tmp7_;
3939 ValaClass* _tmp8_;
3940 _tmp6_ = cl;
3941 _tmp7_ = vala_class_get_base_class (_tmp6_);
3942 _tmp8_ = _tmp7_;
3943 if (_tmp8_ != NULL) {
3944 ValaClass* _tmp9_;
3945 ValaClass* _tmp10_;
3946 ValaClass* _tmp11_;
3947 gchar* _tmp12_;
3948 _tmp9_ = cl;
3949 _tmp10_ = vala_class_get_base_class (_tmp9_);
3950 _tmp11_ = _tmp10_;
3951 _tmp12_ = vala_get_ccode_unref_function ((ValaObjectTypeSymbol*) _tmp11_);
3952 result = _tmp12_;
3953 return result;
3954 }
3955 }
3956 } else {
3957 ValaSymbol* _tmp13_;
3958 _tmp13_ = self->priv->sym;
3959 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp13_, VALA_TYPE_INTERFACE)) {
3960 {
3961 ValaList* _prereq_list = NULL;
3962 ValaSymbol* _tmp14_;
3963 ValaList* _tmp15_;
3964 ValaList* _tmp16_;
3965 gint _prereq_size = 0;
3966 ValaList* _tmp17_;
3967 gint _tmp18_;
3968 gint _tmp19_;
3969 gint _prereq_index = 0;
3970 _tmp14_ = self->priv->sym;
3971 _tmp15_ = vala_interface_get_prerequisites (G_TYPE_CHECK_INSTANCE_CAST (_tmp14_, VALA_TYPE_INTERFACE, ValaInterface));
3972 _tmp16_ = _vala_iterable_ref0 (_tmp15_);
3973 _prereq_list = _tmp16_;
3974 _tmp17_ = _prereq_list;
3975 _tmp18_ = vala_collection_get_size ((ValaCollection*) _tmp17_);
3976 _tmp19_ = _tmp18_;
3977 _prereq_size = _tmp19_;
3978 _prereq_index = -1;
3979 while (TRUE) {
3980 gint _tmp20_;
3981 gint _tmp21_;
3982 ValaDataType* prereq = NULL;
3983 ValaList* _tmp22_;
3984 gpointer _tmp23_;
3985 gchar* unref_func = NULL;
3986 ValaDataType* _tmp24_;
3987 ValaTypeSymbol* _tmp25_;
3988 ValaTypeSymbol* _tmp26_;
3989 gchar* _tmp27_;
3990 const gchar* _tmp28_;
3991 _prereq_index = _prereq_index + 1;
3992 _tmp20_ = _prereq_index;
3993 _tmp21_ = _prereq_size;
3994 if (!(_tmp20_ < _tmp21_)) {
3995 break;
3996 }
3997 _tmp22_ = _prereq_list;
3998 _tmp23_ = vala_list_get (_tmp22_, _prereq_index);
3999 prereq = (ValaDataType*) _tmp23_;
4000 _tmp24_ = prereq;
4001 _tmp25_ = vala_data_type_get_type_symbol (_tmp24_);
4002 _tmp26_ = _tmp25_;
4003 _tmp27_ = vala_get_ccode_unref_function (G_TYPE_CHECK_INSTANCE_CAST (_tmp26_, VALA_TYPE_OBJECT_TYPE_SYMBOL, ValaObjectTypeSymbol));
4004 unref_func = _tmp27_;
4005 _tmp28_ = unref_func;
4006 if (_tmp28_ != NULL) {
4007 result = unref_func;
4008 _vala_code_node_unref0 (prereq);
4009 _vala_iterable_unref0 (_prereq_list);
4010 return result;
4011 }
4012 _g_free0 (unref_func);
4013 _vala_code_node_unref0 (prereq);
4014 }
4015 _vala_iterable_unref0 (_prereq_list);
4016 }
4017 }
4018 }
4019 result = NULL;
4020 return result;
4021 }
4022
4023 static gchar*
vala_ccode_attribute_get_default_ref_sink_function(ValaCCodeAttribute * self)4024 vala_ccode_attribute_get_default_ref_sink_function (ValaCCodeAttribute* self)
4025 {
4026 ValaSymbol* _tmp0_;
4027 gchar* _tmp23_;
4028 gchar* result = NULL;
4029 g_return_val_if_fail (self != NULL, NULL);
4030 _tmp0_ = self->priv->sym;
4031 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_CLASS)) {
4032 ValaClass* base_class = NULL;
4033 ValaSymbol* _tmp1_;
4034 ValaClass* _tmp2_;
4035 ValaClass* _tmp3_;
4036 ValaClass* _tmp4_;
4037 _tmp1_ = self->priv->sym;
4038 _tmp2_ = vala_class_get_base_class (G_TYPE_CHECK_INSTANCE_CAST (_tmp1_, VALA_TYPE_CLASS, ValaClass));
4039 _tmp3_ = _tmp2_;
4040 base_class = _tmp3_;
4041 _tmp4_ = base_class;
4042 if (_tmp4_ != NULL) {
4043 ValaClass* _tmp5_;
4044 gchar* _tmp6_;
4045 _tmp5_ = base_class;
4046 _tmp6_ = vala_get_ccode_ref_sink_function ((ValaObjectTypeSymbol*) _tmp5_);
4047 result = _tmp6_;
4048 return result;
4049 }
4050 } else {
4051 ValaSymbol* _tmp7_;
4052 _tmp7_ = self->priv->sym;
4053 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp7_, VALA_TYPE_INTERFACE)) {
4054 {
4055 ValaList* _prereq_list = NULL;
4056 ValaSymbol* _tmp8_;
4057 ValaList* _tmp9_;
4058 ValaList* _tmp10_;
4059 gint _prereq_size = 0;
4060 ValaList* _tmp11_;
4061 gint _tmp12_;
4062 gint _tmp13_;
4063 gint _prereq_index = 0;
4064 _tmp8_ = self->priv->sym;
4065 _tmp9_ = vala_interface_get_prerequisites (G_TYPE_CHECK_INSTANCE_CAST (_tmp8_, VALA_TYPE_INTERFACE, ValaInterface));
4066 _tmp10_ = _vala_iterable_ref0 (_tmp9_);
4067 _prereq_list = _tmp10_;
4068 _tmp11_ = _prereq_list;
4069 _tmp12_ = vala_collection_get_size ((ValaCollection*) _tmp11_);
4070 _tmp13_ = _tmp12_;
4071 _prereq_size = _tmp13_;
4072 _prereq_index = -1;
4073 while (TRUE) {
4074 gint _tmp14_;
4075 gint _tmp15_;
4076 ValaDataType* prereq = NULL;
4077 ValaList* _tmp16_;
4078 gpointer _tmp17_;
4079 gchar* ref_sink_func = NULL;
4080 ValaDataType* _tmp18_;
4081 ValaTypeSymbol* _tmp19_;
4082 ValaTypeSymbol* _tmp20_;
4083 gchar* _tmp21_;
4084 const gchar* _tmp22_;
4085 _prereq_index = _prereq_index + 1;
4086 _tmp14_ = _prereq_index;
4087 _tmp15_ = _prereq_size;
4088 if (!(_tmp14_ < _tmp15_)) {
4089 break;
4090 }
4091 _tmp16_ = _prereq_list;
4092 _tmp17_ = vala_list_get (_tmp16_, _prereq_index);
4093 prereq = (ValaDataType*) _tmp17_;
4094 _tmp18_ = prereq;
4095 _tmp19_ = vala_data_type_get_type_symbol (_tmp18_);
4096 _tmp20_ = _tmp19_;
4097 _tmp21_ = vala_get_ccode_ref_sink_function (G_TYPE_CHECK_INSTANCE_CAST (_tmp20_, VALA_TYPE_OBJECT_TYPE_SYMBOL, ValaObjectTypeSymbol));
4098 ref_sink_func = _tmp21_;
4099 _tmp22_ = ref_sink_func;
4100 if (g_strcmp0 (_tmp22_, "") != 0) {
4101 result = ref_sink_func;
4102 _vala_code_node_unref0 (prereq);
4103 _vala_iterable_unref0 (_prereq_list);
4104 return result;
4105 }
4106 _g_free0 (ref_sink_func);
4107 _vala_code_node_unref0 (prereq);
4108 }
4109 _vala_iterable_unref0 (_prereq_list);
4110 }
4111 }
4112 }
4113 _tmp23_ = g_strdup ("");
4114 result = _tmp23_;
4115 return result;
4116 }
4117
4118 static gchar*
vala_ccode_attribute_get_default_free_function(ValaCCodeAttribute * self)4119 vala_ccode_attribute_get_default_free_function (ValaCCodeAttribute* self)
4120 {
4121 ValaSymbol* _tmp0_;
4122 gchar* result = NULL;
4123 g_return_val_if_fail (self != NULL, NULL);
4124 _tmp0_ = self->priv->sym;
4125 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_CLASS)) {
4126 ValaClass* cl = NULL;
4127 ValaSymbol* _tmp1_;
4128 ValaClass* _tmp2_;
4129 ValaClass* _tmp3_;
4130 ValaClass* _tmp4_;
4131 const gchar* _tmp9_;
4132 const gchar* _tmp10_;
4133 gchar* _tmp11_;
4134 _tmp1_ = self->priv->sym;
4135 cl = G_TYPE_CHECK_INSTANCE_CAST (_tmp1_, VALA_TYPE_CLASS, ValaClass);
4136 _tmp2_ = cl;
4137 _tmp3_ = vala_class_get_base_class (_tmp2_);
4138 _tmp4_ = _tmp3_;
4139 if (_tmp4_ != NULL) {
4140 ValaClass* _tmp5_;
4141 ValaClass* _tmp6_;
4142 ValaClass* _tmp7_;
4143 gchar* _tmp8_;
4144 _tmp5_ = cl;
4145 _tmp6_ = vala_class_get_base_class (_tmp5_);
4146 _tmp7_ = _tmp6_;
4147 _tmp8_ = vala_get_ccode_free_function ((ValaTypeSymbol*) _tmp7_);
4148 result = _tmp8_;
4149 return result;
4150 }
4151 _tmp9_ = vala_ccode_attribute_get_lower_case_prefix (self);
4152 _tmp10_ = _tmp9_;
4153 _tmp11_ = g_strdup_printf ("%sfree", _tmp10_);
4154 result = _tmp11_;
4155 return result;
4156 } else {
4157 ValaSymbol* _tmp12_;
4158 _tmp12_ = self->priv->sym;
4159 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp12_, VALA_TYPE_STRUCT)) {
4160 ValaSymbol* _tmp13_;
4161 gboolean _tmp14_;
4162 gboolean _tmp15_;
4163 _tmp13_ = self->priv->sym;
4164 _tmp14_ = vala_symbol_get_external_package (_tmp13_);
4165 _tmp15_ = _tmp14_;
4166 if (!_tmp15_) {
4167 const gchar* _tmp16_;
4168 const gchar* _tmp17_;
4169 gchar* _tmp18_;
4170 _tmp16_ = vala_ccode_attribute_get_lower_case_prefix (self);
4171 _tmp17_ = _tmp16_;
4172 _tmp18_ = g_strdup_printf ("%sfree", _tmp17_);
4173 result = _tmp18_;
4174 return result;
4175 }
4176 }
4177 }
4178 result = NULL;
4179 return result;
4180 }
4181
4182 static gchar*
vala_ccode_attribute_get_default_type_id(ValaCCodeAttribute * self)4183 vala_ccode_attribute_get_default_type_id (ValaCCodeAttribute* self)
4184 {
4185 ValaSymbol* _tmp0_;
4186 gchar* _tmp65_;
4187 gchar* result = NULL;
4188 g_return_val_if_fail (self != NULL, NULL);
4189 _tmp0_ = self->priv->sym;
4190 if (_tmp0_ != NULL) {
4191 gboolean _tmp1_ = FALSE;
4192 gboolean _tmp2_ = FALSE;
4193 ValaSymbol* _tmp3_;
4194 _tmp3_ = self->priv->sym;
4195 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp3_, VALA_TYPE_CLASS)) {
4196 ValaSymbol* _tmp4_;
4197 gboolean _tmp5_;
4198 gboolean _tmp6_;
4199 _tmp4_ = self->priv->sym;
4200 _tmp5_ = vala_class_get_is_compact (G_TYPE_CHECK_INSTANCE_CAST (_tmp4_, VALA_TYPE_CLASS, ValaClass));
4201 _tmp6_ = _tmp5_;
4202 _tmp2_ = !_tmp6_;
4203 } else {
4204 _tmp2_ = FALSE;
4205 }
4206 if (_tmp2_) {
4207 _tmp1_ = TRUE;
4208 } else {
4209 ValaSymbol* _tmp7_;
4210 _tmp7_ = self->priv->sym;
4211 _tmp1_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp7_, VALA_TYPE_INTERFACE);
4212 }
4213 if (_tmp1_) {
4214 ValaSymbol* _tmp8_;
4215 gchar* _tmp9_;
4216 _tmp8_ = self->priv->sym;
4217 _tmp9_ = vala_get_ccode_upper_case_name (_tmp8_, "TYPE_");
4218 result = _tmp9_;
4219 return result;
4220 } else {
4221 ValaSymbol* _tmp10_;
4222 _tmp10_ = self->priv->sym;
4223 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp10_, VALA_TYPE_STRUCT)) {
4224 ValaStruct* st = NULL;
4225 ValaSymbol* _tmp11_;
4226 ValaStruct* base_struct = NULL;
4227 ValaStruct* _tmp12_;
4228 ValaStruct* _tmp13_;
4229 ValaStruct* _tmp14_;
4230 gboolean _tmp15_ = FALSE;
4231 ValaStruct* _tmp16_;
4232 _tmp11_ = self->priv->sym;
4233 st = G_TYPE_CHECK_INSTANCE_CAST (_tmp11_, VALA_TYPE_STRUCT, ValaStruct);
4234 _tmp12_ = st;
4235 _tmp13_ = vala_struct_get_base_struct (_tmp12_);
4236 _tmp14_ = _tmp13_;
4237 base_struct = _tmp14_;
4238 _tmp16_ = st;
4239 if (!vala_get_ccode_has_type_id ((ValaTypeSymbol*) _tmp16_)) {
4240 _tmp15_ = TRUE;
4241 } else {
4242 gboolean _tmp17_ = FALSE;
4243 ValaStruct* _tmp18_;
4244 _tmp18_ = base_struct;
4245 if (_tmp18_ != NULL) {
4246 ValaStruct* _tmp19_;
4247 _tmp19_ = base_struct;
4248 _tmp17_ = vala_struct_is_simple_type (_tmp19_);
4249 } else {
4250 _tmp17_ = FALSE;
4251 }
4252 _tmp15_ = _tmp17_;
4253 }
4254 if (_tmp15_) {
4255 ValaStruct* _tmp20_;
4256 ValaStruct* _tmp23_;
4257 _tmp20_ = base_struct;
4258 if (_tmp20_ != NULL) {
4259 ValaStruct* _tmp21_;
4260 gchar* _tmp22_;
4261 _tmp21_ = base_struct;
4262 _tmp22_ = vala_get_ccode_type_id ((ValaCodeNode*) _tmp21_);
4263 result = _tmp22_;
4264 return result;
4265 }
4266 _tmp23_ = st;
4267 if (!vala_struct_is_simple_type (_tmp23_)) {
4268 gchar* _tmp24_;
4269 _tmp24_ = g_strdup ("G_TYPE_POINTER");
4270 result = _tmp24_;
4271 return result;
4272 }
4273 } else {
4274 ValaStruct* _tmp25_;
4275 gchar* _tmp26_;
4276 _tmp25_ = st;
4277 _tmp26_ = vala_get_ccode_upper_case_name ((ValaSymbol*) _tmp25_, "TYPE_");
4278 result = _tmp26_;
4279 return result;
4280 }
4281 } else {
4282 ValaSymbol* _tmp27_;
4283 _tmp27_ = self->priv->sym;
4284 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp27_, VALA_TYPE_ENUM)) {
4285 ValaEnum* en = NULL;
4286 ValaSymbol* _tmp28_;
4287 ValaEnum* _tmp29_;
4288 _tmp28_ = self->priv->sym;
4289 en = G_TYPE_CHECK_INSTANCE_CAST (_tmp28_, VALA_TYPE_ENUM, ValaEnum);
4290 _tmp29_ = en;
4291 if (vala_get_ccode_has_type_id ((ValaTypeSymbol*) _tmp29_)) {
4292 ValaEnum* _tmp30_;
4293 gchar* _tmp31_;
4294 _tmp30_ = en;
4295 _tmp31_ = vala_get_ccode_upper_case_name ((ValaSymbol*) _tmp30_, "TYPE_");
4296 result = _tmp31_;
4297 return result;
4298 } else {
4299 const gchar* _tmp32_ = NULL;
4300 ValaEnum* _tmp33_;
4301 gboolean _tmp34_;
4302 gboolean _tmp35_;
4303 gchar* _tmp36_;
4304 _tmp33_ = en;
4305 _tmp34_ = vala_enum_get_is_flags (_tmp33_);
4306 _tmp35_ = _tmp34_;
4307 if (_tmp35_) {
4308 _tmp32_ = "G_TYPE_UINT";
4309 } else {
4310 _tmp32_ = "G_TYPE_INT";
4311 }
4312 _tmp36_ = g_strdup (_tmp32_);
4313 result = _tmp36_;
4314 return result;
4315 }
4316 } else {
4317 gchar* _tmp37_;
4318 _tmp37_ = g_strdup ("G_TYPE_POINTER");
4319 result = _tmp37_;
4320 return result;
4321 }
4322 }
4323 }
4324 } else {
4325 gboolean _tmp38_ = FALSE;
4326 ValaCodeNode* _tmp39_;
4327 _tmp39_ = self->priv->node;
4328 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp39_, VALA_TYPE_ARRAY_TYPE)) {
4329 ValaCodeNode* _tmp40_;
4330 ValaDataType* _tmp41_;
4331 ValaDataType* _tmp42_;
4332 ValaTypeSymbol* _tmp43_;
4333 ValaTypeSymbol* _tmp44_;
4334 gchar* _tmp45_;
4335 gchar* _tmp46_;
4336 _tmp40_ = self->priv->node;
4337 _tmp41_ = vala_array_type_get_element_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp40_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
4338 _tmp42_ = _tmp41_;
4339 _tmp43_ = vala_data_type_get_type_symbol (_tmp42_);
4340 _tmp44_ = _tmp43_;
4341 _tmp45_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp44_);
4342 _tmp46_ = _tmp45_;
4343 _tmp38_ = g_strcmp0 (_tmp46_, "string") == 0;
4344 _g_free0 (_tmp46_);
4345 } else {
4346 _tmp38_ = FALSE;
4347 }
4348 if (_tmp38_) {
4349 gchar* _tmp47_;
4350 _tmp47_ = g_strdup ("G_TYPE_STRV");
4351 result = _tmp47_;
4352 return result;
4353 } else {
4354 gboolean _tmp48_ = FALSE;
4355 ValaCodeNode* _tmp49_;
4356 _tmp49_ = self->priv->node;
4357 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp49_, VALA_TYPE_POINTER_TYPE)) {
4358 _tmp48_ = TRUE;
4359 } else {
4360 ValaCodeNode* _tmp50_;
4361 _tmp50_ = self->priv->node;
4362 _tmp48_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp50_, VALA_TYPE_DELEGATE_TYPE);
4363 }
4364 if (_tmp48_) {
4365 gchar* _tmp51_;
4366 _tmp51_ = g_strdup ("G_TYPE_POINTER");
4367 result = _tmp51_;
4368 return result;
4369 } else {
4370 ValaCodeNode* _tmp52_;
4371 _tmp52_ = self->priv->node;
4372 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp52_, VALA_TYPE_ERROR_TYPE)) {
4373 gchar* _tmp53_;
4374 _tmp53_ = g_strdup ("G_TYPE_ERROR");
4375 result = _tmp53_;
4376 return result;
4377 } else {
4378 ValaCodeNode* _tmp54_;
4379 _tmp54_ = self->priv->node;
4380 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp54_, VALA_TYPE_VOID_TYPE)) {
4381 gchar* _tmp55_;
4382 _tmp55_ = g_strdup ("G_TYPE_NONE");
4383 result = _tmp55_;
4384 return result;
4385 } else {
4386 ValaDataType* type = NULL;
4387 ValaCodeNode* _tmp56_;
4388 ValaDataType* _tmp57_;
4389 ValaDataType* _tmp58_;
4390 ValaTypeSymbol* _tmp59_;
4391 ValaTypeSymbol* _tmp60_;
4392 _tmp56_ = self->priv->node;
4393 _tmp57_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp56_, VALA_TYPE_DATA_TYPE, ValaDataType));
4394 type = _tmp57_;
4395 _tmp58_ = type;
4396 _tmp59_ = vala_data_type_get_type_symbol (_tmp58_);
4397 _tmp60_ = _tmp59_;
4398 if (_tmp60_ != NULL) {
4399 ValaDataType* _tmp61_;
4400 ValaTypeSymbol* _tmp62_;
4401 ValaTypeSymbol* _tmp63_;
4402 gchar* _tmp64_;
4403 _tmp61_ = type;
4404 _tmp62_ = vala_data_type_get_type_symbol (_tmp61_);
4405 _tmp63_ = _tmp62_;
4406 _tmp64_ = vala_get_ccode_type_id ((ValaCodeNode*) _tmp63_);
4407 result = _tmp64_;
4408 _vala_code_node_unref0 (type);
4409 return result;
4410 }
4411 _vala_code_node_unref0 (type);
4412 }
4413 }
4414 }
4415 }
4416 }
4417 _tmp65_ = g_strdup ("");
4418 result = _tmp65_;
4419 return result;
4420 }
4421
4422 static gchar*
vala_ccode_attribute_get_default_marshaller_type_name(ValaCCodeAttribute * self)4423 vala_ccode_attribute_get_default_marshaller_type_name (ValaCCodeAttribute* self)
4424 {
4425 ValaSymbol* _tmp0_;
4426 gchar* _tmp149_;
4427 gchar* result = NULL;
4428 g_return_val_if_fail (self != NULL, NULL);
4429 _tmp0_ = self->priv->sym;
4430 if (_tmp0_ != NULL) {
4431 ValaSymbol* _tmp1_;
4432 _tmp1_ = self->priv->sym;
4433 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1_, VALA_TYPE_CLASS)) {
4434 ValaClass* cl = NULL;
4435 ValaSymbol* _tmp2_;
4436 ValaClass* _tmp3_;
4437 ValaClass* _tmp4_;
4438 ValaClass* _tmp5_;
4439 _tmp2_ = self->priv->sym;
4440 cl = G_TYPE_CHECK_INSTANCE_CAST (_tmp2_, VALA_TYPE_CLASS, ValaClass);
4441 _tmp3_ = cl;
4442 _tmp4_ = vala_class_get_base_class (_tmp3_);
4443 _tmp5_ = _tmp4_;
4444 if (_tmp5_ != NULL) {
4445 ValaClass* _tmp6_;
4446 ValaClass* _tmp7_;
4447 ValaClass* _tmp8_;
4448 gchar* _tmp9_;
4449 _tmp6_ = cl;
4450 _tmp7_ = vala_class_get_base_class (_tmp6_);
4451 _tmp8_ = _tmp7_;
4452 _tmp9_ = vala_get_ccode_marshaller_type_name ((ValaCodeNode*) _tmp8_);
4453 result = _tmp9_;
4454 return result;
4455 } else {
4456 ValaClass* _tmp10_;
4457 gboolean _tmp11_;
4458 gboolean _tmp12_;
4459 _tmp10_ = cl;
4460 _tmp11_ = vala_class_get_is_compact (_tmp10_);
4461 _tmp12_ = _tmp11_;
4462 if (!_tmp12_) {
4463 ValaClass* _tmp13_;
4464 gchar* _tmp14_;
4465 _tmp13_ = cl;
4466 _tmp14_ = vala_get_ccode_upper_case_name ((ValaSymbol*) _tmp13_, NULL);
4467 result = _tmp14_;
4468 return result;
4469 } else {
4470 const gchar* _tmp15_;
4471 const gchar* _tmp16_;
4472 _tmp15_ = vala_ccode_attribute_get_type_id (self);
4473 _tmp16_ = _tmp15_;
4474 if (g_strcmp0 (_tmp16_, "G_TYPE_POINTER") == 0) {
4475 gchar* _tmp17_;
4476 _tmp17_ = g_strdup ("POINTER");
4477 result = _tmp17_;
4478 return result;
4479 } else {
4480 gchar* _tmp18_;
4481 _tmp18_ = g_strdup ("BOXED");
4482 result = _tmp18_;
4483 return result;
4484 }
4485 }
4486 }
4487 } else {
4488 ValaSymbol* _tmp19_;
4489 _tmp19_ = self->priv->sym;
4490 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp19_, VALA_TYPE_ENUM)) {
4491 ValaEnum* en = NULL;
4492 ValaSymbol* _tmp20_;
4493 ValaEnum* _tmp21_;
4494 _tmp20_ = self->priv->sym;
4495 en = G_TYPE_CHECK_INSTANCE_CAST (_tmp20_, VALA_TYPE_ENUM, ValaEnum);
4496 _tmp21_ = en;
4497 if (vala_get_ccode_has_type_id ((ValaTypeSymbol*) _tmp21_)) {
4498 ValaEnum* _tmp22_;
4499 gboolean _tmp23_;
4500 gboolean _tmp24_;
4501 _tmp22_ = en;
4502 _tmp23_ = vala_enum_get_is_flags (_tmp22_);
4503 _tmp24_ = _tmp23_;
4504 if (_tmp24_) {
4505 gchar* _tmp25_;
4506 _tmp25_ = g_strdup ("FLAGS");
4507 result = _tmp25_;
4508 return result;
4509 } else {
4510 gchar* _tmp26_;
4511 _tmp26_ = g_strdup ("ENUM");
4512 result = _tmp26_;
4513 return result;
4514 }
4515 } else {
4516 ValaEnum* _tmp27_;
4517 gboolean _tmp28_;
4518 gboolean _tmp29_;
4519 _tmp27_ = en;
4520 _tmp28_ = vala_enum_get_is_flags (_tmp27_);
4521 _tmp29_ = _tmp28_;
4522 if (_tmp29_) {
4523 gchar* _tmp30_;
4524 _tmp30_ = g_strdup ("UINT");
4525 result = _tmp30_;
4526 return result;
4527 } else {
4528 gchar* _tmp31_;
4529 _tmp31_ = g_strdup ("INT");
4530 result = _tmp31_;
4531 return result;
4532 }
4533 }
4534 } else {
4535 ValaSymbol* _tmp32_;
4536 _tmp32_ = self->priv->sym;
4537 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp32_, VALA_TYPE_INTERFACE)) {
4538 gchar* _tmp48_;
4539 {
4540 ValaList* _prereq_list = NULL;
4541 ValaSymbol* _tmp33_;
4542 ValaList* _tmp34_;
4543 ValaList* _tmp35_;
4544 gint _prereq_size = 0;
4545 ValaList* _tmp36_;
4546 gint _tmp37_;
4547 gint _tmp38_;
4548 gint _prereq_index = 0;
4549 _tmp33_ = self->priv->sym;
4550 _tmp34_ = vala_interface_get_prerequisites (G_TYPE_CHECK_INSTANCE_CAST (_tmp33_, VALA_TYPE_INTERFACE, ValaInterface));
4551 _tmp35_ = _vala_iterable_ref0 (_tmp34_);
4552 _prereq_list = _tmp35_;
4553 _tmp36_ = _prereq_list;
4554 _tmp37_ = vala_collection_get_size ((ValaCollection*) _tmp36_);
4555 _tmp38_ = _tmp37_;
4556 _prereq_size = _tmp38_;
4557 _prereq_index = -1;
4558 while (TRUE) {
4559 gint _tmp39_;
4560 gint _tmp40_;
4561 ValaDataType* prereq = NULL;
4562 ValaList* _tmp41_;
4563 gpointer _tmp42_;
4564 gchar* type_name = NULL;
4565 ValaDataType* _tmp43_;
4566 ValaTypeSymbol* _tmp44_;
4567 ValaTypeSymbol* _tmp45_;
4568 gchar* _tmp46_;
4569 const gchar* _tmp47_;
4570 _prereq_index = _prereq_index + 1;
4571 _tmp39_ = _prereq_index;
4572 _tmp40_ = _prereq_size;
4573 if (!(_tmp39_ < _tmp40_)) {
4574 break;
4575 }
4576 _tmp41_ = _prereq_list;
4577 _tmp42_ = vala_list_get (_tmp41_, _prereq_index);
4578 prereq = (ValaDataType*) _tmp42_;
4579 _tmp43_ = prereq;
4580 _tmp44_ = vala_data_type_get_type_symbol (_tmp43_);
4581 _tmp45_ = _tmp44_;
4582 _tmp46_ = vala_get_ccode_marshaller_type_name ((ValaCodeNode*) _tmp45_);
4583 type_name = _tmp46_;
4584 _tmp47_ = type_name;
4585 if (g_strcmp0 (_tmp47_, "") != 0) {
4586 result = type_name;
4587 _vala_code_node_unref0 (prereq);
4588 _vala_iterable_unref0 (_prereq_list);
4589 return result;
4590 }
4591 _g_free0 (type_name);
4592 _vala_code_node_unref0 (prereq);
4593 }
4594 _vala_iterable_unref0 (_prereq_list);
4595 }
4596 _tmp48_ = g_strdup ("POINTER");
4597 result = _tmp48_;
4598 return result;
4599 } else {
4600 ValaSymbol* _tmp49_;
4601 _tmp49_ = self->priv->sym;
4602 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp49_, VALA_TYPE_STRUCT)) {
4603 ValaStruct* st = NULL;
4604 ValaSymbol* _tmp50_;
4605 ValaStruct* base_st = NULL;
4606 ValaStruct* _tmp51_;
4607 ValaStruct* _tmp52_;
4608 ValaStruct* _tmp53_;
4609 ValaStruct* _tmp61_;
4610 _tmp50_ = self->priv->sym;
4611 st = G_TYPE_CHECK_INSTANCE_CAST (_tmp50_, VALA_TYPE_STRUCT, ValaStruct);
4612 _tmp51_ = st;
4613 _tmp52_ = vala_struct_get_base_struct (_tmp51_);
4614 _tmp53_ = _tmp52_;
4615 base_st = _tmp53_;
4616 while (TRUE) {
4617 ValaStruct* _tmp54_;
4618 ValaStruct* _tmp55_;
4619 _tmp54_ = base_st;
4620 if (!(_tmp54_ != NULL)) {
4621 break;
4622 }
4623 _tmp55_ = base_st;
4624 if (vala_get_ccode_has_type_id ((ValaTypeSymbol*) _tmp55_)) {
4625 ValaStruct* _tmp56_;
4626 gchar* _tmp57_;
4627 _tmp56_ = base_st;
4628 _tmp57_ = vala_get_ccode_marshaller_type_name ((ValaCodeNode*) _tmp56_);
4629 result = _tmp57_;
4630 return result;
4631 } else {
4632 ValaStruct* _tmp58_;
4633 ValaStruct* _tmp59_;
4634 ValaStruct* _tmp60_;
4635 _tmp58_ = base_st;
4636 _tmp59_ = vala_struct_get_base_struct (_tmp58_);
4637 _tmp60_ = _tmp59_;
4638 base_st = _tmp60_;
4639 }
4640 }
4641 _tmp61_ = st;
4642 if (vala_struct_is_simple_type (_tmp61_)) {
4643 ValaStruct* _tmp62_;
4644 ValaSourceReference* _tmp63_;
4645 ValaSourceReference* _tmp64_;
4646 ValaStruct* _tmp65_;
4647 gchar* _tmp66_;
4648 gchar* _tmp67_;
4649 gchar* _tmp68_;
4650 gchar* _tmp69_;
4651 _tmp62_ = st;
4652 _tmp63_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp62_);
4653 _tmp64_ = _tmp63_;
4654 _tmp65_ = st;
4655 _tmp66_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp65_);
4656 _tmp67_ = _tmp66_;
4657 _tmp68_ = g_strdup_printf ("The type `%s' doesn't declare a marshaller type name", _tmp67_);
4658 _tmp69_ = _tmp68_;
4659 vala_report_error (_tmp64_, _tmp69_);
4660 _g_free0 (_tmp69_);
4661 _g_free0 (_tmp67_);
4662 } else {
4663 ValaStruct* _tmp70_;
4664 _tmp70_ = st;
4665 if (vala_get_ccode_has_type_id ((ValaTypeSymbol*) _tmp70_)) {
4666 gchar* _tmp71_;
4667 _tmp71_ = g_strdup ("BOXED");
4668 result = _tmp71_;
4669 return result;
4670 } else {
4671 gchar* _tmp72_;
4672 _tmp72_ = g_strdup ("POINTER");
4673 result = _tmp72_;
4674 return result;
4675 }
4676 }
4677 } else {
4678 ValaSymbol* _tmp73_;
4679 _tmp73_ = self->priv->sym;
4680 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp73_, VALA_TYPE_PARAMETER)) {
4681 ValaParameter* param = NULL;
4682 ValaSymbol* _tmp74_;
4683 ValaParameter* _tmp75_;
4684 ValaParameterDirection _tmp76_;
4685 ValaParameterDirection _tmp77_;
4686 _tmp74_ = self->priv->sym;
4687 param = G_TYPE_CHECK_INSTANCE_CAST (_tmp74_, VALA_TYPE_PARAMETER, ValaParameter);
4688 _tmp75_ = param;
4689 _tmp76_ = vala_parameter_get_direction (_tmp75_);
4690 _tmp77_ = _tmp76_;
4691 if (_tmp77_ != VALA_PARAMETER_DIRECTION_IN) {
4692 gchar* _tmp78_;
4693 _tmp78_ = g_strdup ("POINTER");
4694 result = _tmp78_;
4695 return result;
4696 } else {
4697 ValaParameter* _tmp79_;
4698 ValaDataType* _tmp80_;
4699 ValaDataType* _tmp81_;
4700 gchar* _tmp82_;
4701 _tmp79_ = param;
4702 _tmp80_ = vala_variable_get_variable_type ((ValaVariable*) _tmp79_);
4703 _tmp81_ = _tmp80_;
4704 _tmp82_ = vala_get_ccode_marshaller_type_name ((ValaCodeNode*) _tmp81_);
4705 result = _tmp82_;
4706 return result;
4707 }
4708 } else {
4709 gchar* _tmp83_;
4710 _tmp83_ = g_strdup ("POINTER");
4711 result = _tmp83_;
4712 return result;
4713 }
4714 }
4715 }
4716 }
4717 }
4718 } else {
4719 gboolean _tmp84_ = FALSE;
4720 ValaCodeNode* _tmp85_;
4721 _tmp85_ = self->priv->node;
4722 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp85_, VALA_TYPE_VALUE_TYPE)) {
4723 ValaCodeNode* _tmp86_;
4724 gboolean _tmp87_;
4725 gboolean _tmp88_;
4726 _tmp86_ = self->priv->node;
4727 _tmp87_ = vala_data_type_get_nullable ((ValaDataType*) G_TYPE_CHECK_INSTANCE_CAST (_tmp86_, VALA_TYPE_VALUE_TYPE, ValaValueType));
4728 _tmp88_ = _tmp87_;
4729 _tmp84_ = _tmp88_;
4730 } else {
4731 _tmp84_ = FALSE;
4732 }
4733 if (_tmp84_) {
4734 gchar* _tmp89_;
4735 _tmp89_ = g_strdup ("POINTER");
4736 result = _tmp89_;
4737 return result;
4738 } else {
4739 gboolean _tmp90_ = FALSE;
4740 ValaCodeNode* _tmp91_;
4741 _tmp91_ = self->priv->node;
4742 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp91_, VALA_TYPE_POINTER_TYPE)) {
4743 _tmp90_ = TRUE;
4744 } else {
4745 ValaCodeNode* _tmp92_;
4746 _tmp92_ = self->priv->node;
4747 _tmp90_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp92_, VALA_TYPE_GENERIC_TYPE);
4748 }
4749 if (_tmp90_) {
4750 gchar* _tmp93_;
4751 _tmp93_ = g_strdup ("POINTER");
4752 result = _tmp93_;
4753 return result;
4754 } else {
4755 ValaCodeNode* _tmp94_;
4756 _tmp94_ = self->priv->node;
4757 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp94_, VALA_TYPE_ERROR_TYPE)) {
4758 gchar* _tmp95_;
4759 _tmp95_ = g_strdup ("POINTER");
4760 result = _tmp95_;
4761 return result;
4762 } else {
4763 ValaCodeNode* _tmp96_;
4764 _tmp96_ = self->priv->node;
4765 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp96_, VALA_TYPE_ARRAY_TYPE)) {
4766 ValaArrayType* array_type = NULL;
4767 ValaCodeNode* _tmp97_;
4768 ValaArrayType* _tmp98_;
4769 ValaDataType* _tmp99_;
4770 ValaDataType* _tmp100_;
4771 ValaTypeSymbol* _tmp101_;
4772 ValaTypeSymbol* _tmp102_;
4773 gchar* _tmp103_;
4774 gchar* _tmp104_;
4775 gboolean _tmp105_;
4776 _tmp97_ = self->priv->node;
4777 array_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp97_, VALA_TYPE_ARRAY_TYPE, ValaArrayType);
4778 _tmp98_ = array_type;
4779 _tmp99_ = vala_array_type_get_element_type (_tmp98_);
4780 _tmp100_ = _tmp99_;
4781 _tmp101_ = vala_data_type_get_type_symbol (_tmp100_);
4782 _tmp102_ = _tmp101_;
4783 _tmp103_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp102_);
4784 _tmp104_ = _tmp103_;
4785 _tmp105_ = g_strcmp0 (_tmp104_, "string") == 0;
4786 _g_free0 (_tmp104_);
4787 if (_tmp105_) {
4788 ValaArrayType* _tmp106_;
4789 ValaDataType* _tmp107_;
4790 ValaDataType* _tmp108_;
4791 ValaTypeSymbol* _tmp109_;
4792 ValaTypeSymbol* _tmp110_;
4793 gchar* _tmp111_;
4794 gchar* _tmp112_;
4795 gchar* _tmp113_;
4796 gchar* _tmp114_;
4797 _tmp106_ = array_type;
4798 _tmp107_ = vala_array_type_get_length_type (_tmp106_);
4799 _tmp108_ = _tmp107_;
4800 _tmp109_ = vala_data_type_get_type_symbol (_tmp108_);
4801 _tmp110_ = _tmp109_;
4802 _tmp111_ = vala_get_ccode_marshaller_type_name ((ValaCodeNode*) _tmp110_);
4803 _tmp112_ = _tmp111_;
4804 _tmp113_ = g_strdup_printf ("BOXED,%s", _tmp112_);
4805 _tmp114_ = _tmp113_;
4806 _g_free0 (_tmp112_);
4807 result = _tmp114_;
4808 return result;
4809 } else {
4810 gchar* ret = NULL;
4811 gchar* _tmp115_;
4812 gchar* length_marshaller_type_name = NULL;
4813 ValaArrayType* _tmp116_;
4814 ValaDataType* _tmp117_;
4815 ValaDataType* _tmp118_;
4816 ValaTypeSymbol* _tmp119_;
4817 ValaTypeSymbol* _tmp120_;
4818 gchar* _tmp121_;
4819 _tmp115_ = g_strdup ("POINTER");
4820 ret = _tmp115_;
4821 _tmp116_ = array_type;
4822 _tmp117_ = vala_array_type_get_length_type (_tmp116_);
4823 _tmp118_ = _tmp117_;
4824 _tmp119_ = vala_data_type_get_type_symbol (_tmp118_);
4825 _tmp120_ = _tmp119_;
4826 _tmp121_ = vala_get_ccode_marshaller_type_name ((ValaCodeNode*) _tmp120_);
4827 length_marshaller_type_name = _tmp121_;
4828 {
4829 gint i = 0;
4830 i = 0;
4831 {
4832 gboolean _tmp122_ = FALSE;
4833 _tmp122_ = TRUE;
4834 while (TRUE) {
4835 ValaArrayType* _tmp124_;
4836 gint _tmp125_;
4837 gint _tmp126_;
4838 const gchar* _tmp127_;
4839 const gchar* _tmp128_;
4840 gchar* _tmp129_;
4841 if (!_tmp122_) {
4842 gint _tmp123_;
4843 _tmp123_ = i;
4844 i = _tmp123_ + 1;
4845 }
4846 _tmp122_ = FALSE;
4847 _tmp124_ = array_type;
4848 _tmp125_ = vala_array_type_get_rank (_tmp124_);
4849 _tmp126_ = _tmp125_;
4850 if (!(i < _tmp126_)) {
4851 break;
4852 }
4853 _tmp127_ = ret;
4854 _tmp128_ = length_marshaller_type_name;
4855 _tmp129_ = g_strdup_printf ("%s,%s", _tmp127_, _tmp128_);
4856 _g_free0 (ret);
4857 ret = _tmp129_;
4858 }
4859 }
4860 }
4861 result = ret;
4862 _g_free0 (length_marshaller_type_name);
4863 return result;
4864 }
4865 } else {
4866 ValaCodeNode* _tmp130_;
4867 _tmp130_ = self->priv->node;
4868 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp130_, VALA_TYPE_DELEGATE_TYPE)) {
4869 ValaDelegateType* delegate_type = NULL;
4870 ValaCodeNode* _tmp131_;
4871 gchar* ret = NULL;
4872 gchar* _tmp132_;
4873 ValaDelegateType* _tmp133_;
4874 ValaDelegate* _tmp134_;
4875 ValaDelegate* _tmp135_;
4876 gboolean _tmp136_;
4877 gboolean _tmp137_;
4878 _tmp131_ = self->priv->node;
4879 delegate_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp131_, VALA_TYPE_DELEGATE_TYPE, ValaDelegateType);
4880 _tmp132_ = g_strdup ("POINTER");
4881 ret = _tmp132_;
4882 _tmp133_ = delegate_type;
4883 _tmp134_ = vala_delegate_type_get_delegate_symbol (_tmp133_);
4884 _tmp135_ = _tmp134_;
4885 _tmp136_ = vala_delegate_get_has_target (_tmp135_);
4886 _tmp137_ = _tmp136_;
4887 if (_tmp137_) {
4888 const gchar* _tmp138_;
4889 gchar* _tmp139_;
4890 ValaDelegateType* _tmp140_;
4891 _tmp138_ = ret;
4892 _tmp139_ = g_strdup_printf ("%s,POINTER", _tmp138_);
4893 _g_free0 (ret);
4894 ret = _tmp139_;
4895 _tmp140_ = delegate_type;
4896 if (vala_data_type_is_disposable ((ValaDataType*) _tmp140_)) {
4897 const gchar* _tmp141_;
4898 gchar* _tmp142_;
4899 _tmp141_ = ret;
4900 _tmp142_ = g_strdup_printf ("%s,POINTER", _tmp141_);
4901 _g_free0 (ret);
4902 ret = _tmp142_;
4903 }
4904 }
4905 result = ret;
4906 return result;
4907 } else {
4908 ValaCodeNode* _tmp143_;
4909 _tmp143_ = self->priv->node;
4910 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp143_, VALA_TYPE_VOID_TYPE)) {
4911 gchar* _tmp144_;
4912 _tmp144_ = g_strdup ("VOID");
4913 result = _tmp144_;
4914 return result;
4915 } else {
4916 ValaCodeNode* _tmp145_;
4917 ValaTypeSymbol* _tmp146_;
4918 ValaTypeSymbol* _tmp147_;
4919 gchar* _tmp148_;
4920 _tmp145_ = self->priv->node;
4921 _tmp146_ = vala_data_type_get_type_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp145_, VALA_TYPE_DATA_TYPE, ValaDataType));
4922 _tmp147_ = _tmp146_;
4923 _tmp148_ = vala_get_ccode_marshaller_type_name ((ValaCodeNode*) _tmp147_);
4924 result = _tmp148_;
4925 return result;
4926 }
4927 }
4928 }
4929 }
4930 }
4931 }
4932 }
4933 _tmp149_ = g_strdup ("");
4934 result = _tmp149_;
4935 return result;
4936 }
4937
4938 static gchar*
vala_ccode_attribute_get_default_get_value_function(ValaCCodeAttribute * self)4939 vala_ccode_attribute_get_default_get_value_function (ValaCCodeAttribute* self)
4940 {
4941 ValaSymbol* _tmp0_;
4942 gchar* _tmp71_;
4943 gchar* result = NULL;
4944 g_return_val_if_fail (self != NULL, NULL);
4945 _tmp0_ = self->priv->sym;
4946 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_CLASS)) {
4947 ValaClass* cl = NULL;
4948 ValaSymbol* _tmp1_;
4949 ValaClass* _tmp2_;
4950 _tmp1_ = self->priv->sym;
4951 cl = G_TYPE_CHECK_INSTANCE_CAST (_tmp1_, VALA_TYPE_CLASS, ValaClass);
4952 _tmp2_ = cl;
4953 if (vala_class_is_fundamental (_tmp2_)) {
4954 ValaClass* _tmp3_;
4955 gchar* _tmp4_;
4956 _tmp3_ = cl;
4957 _tmp4_ = vala_get_ccode_lower_case_name ((ValaCodeNode*) _tmp3_, "value_get_");
4958 result = _tmp4_;
4959 return result;
4960 } else {
4961 ValaClass* _tmp5_;
4962 ValaClass* _tmp6_;
4963 ValaClass* _tmp7_;
4964 _tmp5_ = cl;
4965 _tmp6_ = vala_class_get_base_class (_tmp5_);
4966 _tmp7_ = _tmp6_;
4967 if (_tmp7_ != NULL) {
4968 ValaClass* _tmp8_;
4969 ValaClass* _tmp9_;
4970 ValaClass* _tmp10_;
4971 gchar* _tmp11_;
4972 _tmp8_ = cl;
4973 _tmp9_ = vala_class_get_base_class (_tmp8_);
4974 _tmp10_ = _tmp9_;
4975 _tmp11_ = vala_get_ccode_get_value_function ((ValaCodeNode*) _tmp10_);
4976 result = _tmp11_;
4977 return result;
4978 } else {
4979 const gchar* _tmp12_;
4980 const gchar* _tmp13_;
4981 _tmp12_ = vala_ccode_attribute_get_type_id (self);
4982 _tmp13_ = _tmp12_;
4983 if (g_strcmp0 (_tmp13_, "G_TYPE_POINTER") == 0) {
4984 gchar* _tmp14_;
4985 _tmp14_ = g_strdup ("g_value_get_pointer");
4986 result = _tmp14_;
4987 return result;
4988 } else {
4989 gchar* _tmp15_;
4990 _tmp15_ = g_strdup ("g_value_get_boxed");
4991 result = _tmp15_;
4992 return result;
4993 }
4994 }
4995 }
4996 } else {
4997 ValaSymbol* _tmp16_;
4998 _tmp16_ = self->priv->sym;
4999 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp16_, VALA_TYPE_ENUM)) {
5000 ValaEnum* en = NULL;
5001 ValaSymbol* _tmp17_;
5002 ValaEnum* _tmp18_;
5003 _tmp17_ = self->priv->sym;
5004 en = G_TYPE_CHECK_INSTANCE_CAST (_tmp17_, VALA_TYPE_ENUM, ValaEnum);
5005 _tmp18_ = en;
5006 if (vala_get_ccode_has_type_id ((ValaTypeSymbol*) _tmp18_)) {
5007 ValaEnum* _tmp19_;
5008 gboolean _tmp20_;
5009 gboolean _tmp21_;
5010 _tmp19_ = en;
5011 _tmp20_ = vala_enum_get_is_flags (_tmp19_);
5012 _tmp21_ = _tmp20_;
5013 if (_tmp21_) {
5014 gchar* _tmp22_;
5015 _tmp22_ = g_strdup ("g_value_get_flags");
5016 result = _tmp22_;
5017 return result;
5018 } else {
5019 gchar* _tmp23_;
5020 _tmp23_ = g_strdup ("g_value_get_enum");
5021 result = _tmp23_;
5022 return result;
5023 }
5024 } else {
5025 ValaEnum* _tmp24_;
5026 gboolean _tmp25_;
5027 gboolean _tmp26_;
5028 _tmp24_ = en;
5029 _tmp25_ = vala_enum_get_is_flags (_tmp24_);
5030 _tmp26_ = _tmp25_;
5031 if (_tmp26_) {
5032 gchar* _tmp27_;
5033 _tmp27_ = g_strdup ("g_value_get_uint");
5034 result = _tmp27_;
5035 return result;
5036 } else {
5037 gchar* _tmp28_;
5038 _tmp28_ = g_strdup ("g_value_get_int");
5039 result = _tmp28_;
5040 return result;
5041 }
5042 }
5043 } else {
5044 ValaSymbol* _tmp29_;
5045 _tmp29_ = self->priv->sym;
5046 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp29_, VALA_TYPE_INTERFACE)) {
5047 gchar* _tmp45_;
5048 {
5049 ValaList* _prereq_list = NULL;
5050 ValaSymbol* _tmp30_;
5051 ValaList* _tmp31_;
5052 ValaList* _tmp32_;
5053 gint _prereq_size = 0;
5054 ValaList* _tmp33_;
5055 gint _tmp34_;
5056 gint _tmp35_;
5057 gint _prereq_index = 0;
5058 _tmp30_ = self->priv->sym;
5059 _tmp31_ = vala_interface_get_prerequisites (G_TYPE_CHECK_INSTANCE_CAST (_tmp30_, VALA_TYPE_INTERFACE, ValaInterface));
5060 _tmp32_ = _vala_iterable_ref0 (_tmp31_);
5061 _prereq_list = _tmp32_;
5062 _tmp33_ = _prereq_list;
5063 _tmp34_ = vala_collection_get_size ((ValaCollection*) _tmp33_);
5064 _tmp35_ = _tmp34_;
5065 _prereq_size = _tmp35_;
5066 _prereq_index = -1;
5067 while (TRUE) {
5068 gint _tmp36_;
5069 gint _tmp37_;
5070 ValaDataType* prereq = NULL;
5071 ValaList* _tmp38_;
5072 gpointer _tmp39_;
5073 gchar* type_name = NULL;
5074 ValaDataType* _tmp40_;
5075 ValaTypeSymbol* _tmp41_;
5076 ValaTypeSymbol* _tmp42_;
5077 gchar* _tmp43_;
5078 const gchar* _tmp44_;
5079 _prereq_index = _prereq_index + 1;
5080 _tmp36_ = _prereq_index;
5081 _tmp37_ = _prereq_size;
5082 if (!(_tmp36_ < _tmp37_)) {
5083 break;
5084 }
5085 _tmp38_ = _prereq_list;
5086 _tmp39_ = vala_list_get (_tmp38_, _prereq_index);
5087 prereq = (ValaDataType*) _tmp39_;
5088 _tmp40_ = prereq;
5089 _tmp41_ = vala_data_type_get_type_symbol (_tmp40_);
5090 _tmp42_ = _tmp41_;
5091 _tmp43_ = vala_get_ccode_get_value_function ((ValaCodeNode*) _tmp42_);
5092 type_name = _tmp43_;
5093 _tmp44_ = type_name;
5094 if (g_strcmp0 (_tmp44_, "") != 0) {
5095 result = type_name;
5096 _vala_code_node_unref0 (prereq);
5097 _vala_iterable_unref0 (_prereq_list);
5098 return result;
5099 }
5100 _g_free0 (type_name);
5101 _vala_code_node_unref0 (prereq);
5102 }
5103 _vala_iterable_unref0 (_prereq_list);
5104 }
5105 _tmp45_ = g_strdup ("g_value_get_pointer");
5106 result = _tmp45_;
5107 return result;
5108 } else {
5109 ValaSymbol* _tmp46_;
5110 _tmp46_ = self->priv->sym;
5111 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp46_, VALA_TYPE_STRUCT)) {
5112 ValaStruct* st = NULL;
5113 ValaSymbol* _tmp47_;
5114 ValaStruct* base_st = NULL;
5115 ValaStruct* _tmp48_;
5116 ValaStruct* _tmp49_;
5117 ValaStruct* _tmp50_;
5118 ValaStruct* _tmp58_;
5119 _tmp47_ = self->priv->sym;
5120 st = G_TYPE_CHECK_INSTANCE_CAST (_tmp47_, VALA_TYPE_STRUCT, ValaStruct);
5121 _tmp48_ = st;
5122 _tmp49_ = vala_struct_get_base_struct (_tmp48_);
5123 _tmp50_ = _tmp49_;
5124 base_st = _tmp50_;
5125 while (TRUE) {
5126 ValaStruct* _tmp51_;
5127 ValaStruct* _tmp52_;
5128 _tmp51_ = base_st;
5129 if (!(_tmp51_ != NULL)) {
5130 break;
5131 }
5132 _tmp52_ = base_st;
5133 if (vala_get_ccode_has_type_id ((ValaTypeSymbol*) _tmp52_)) {
5134 ValaStruct* _tmp53_;
5135 gchar* _tmp54_;
5136 _tmp53_ = base_st;
5137 _tmp54_ = vala_get_ccode_get_value_function ((ValaCodeNode*) _tmp53_);
5138 result = _tmp54_;
5139 return result;
5140 } else {
5141 ValaStruct* _tmp55_;
5142 ValaStruct* _tmp56_;
5143 ValaStruct* _tmp57_;
5144 _tmp55_ = base_st;
5145 _tmp56_ = vala_struct_get_base_struct (_tmp55_);
5146 _tmp57_ = _tmp56_;
5147 base_st = _tmp57_;
5148 }
5149 }
5150 _tmp58_ = st;
5151 if (vala_struct_is_simple_type (_tmp58_)) {
5152 ValaStruct* _tmp59_;
5153 ValaSourceReference* _tmp60_;
5154 ValaSourceReference* _tmp61_;
5155 ValaStruct* _tmp62_;
5156 gchar* _tmp63_;
5157 gchar* _tmp64_;
5158 gchar* _tmp65_;
5159 gchar* _tmp66_;
5160 _tmp59_ = st;
5161 _tmp60_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp59_);
5162 _tmp61_ = _tmp60_;
5163 _tmp62_ = st;
5164 _tmp63_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp62_);
5165 _tmp64_ = _tmp63_;
5166 _tmp65_ = g_strdup_printf ("The type `%s' doesn't declare a GValue get function", _tmp64_);
5167 _tmp66_ = _tmp65_;
5168 vala_report_error (_tmp61_, _tmp66_);
5169 _g_free0 (_tmp66_);
5170 _g_free0 (_tmp64_);
5171 } else {
5172 ValaStruct* _tmp67_;
5173 _tmp67_ = st;
5174 if (vala_get_ccode_has_type_id ((ValaTypeSymbol*) _tmp67_)) {
5175 gchar* _tmp68_;
5176 _tmp68_ = g_strdup ("g_value_get_boxed");
5177 result = _tmp68_;
5178 return result;
5179 } else {
5180 gchar* _tmp69_;
5181 _tmp69_ = g_strdup ("g_value_get_pointer");
5182 result = _tmp69_;
5183 return result;
5184 }
5185 }
5186 } else {
5187 gchar* _tmp70_;
5188 _tmp70_ = g_strdup ("g_value_get_pointer");
5189 result = _tmp70_;
5190 return result;
5191 }
5192 }
5193 }
5194 }
5195 _tmp71_ = g_strdup ("");
5196 result = _tmp71_;
5197 return result;
5198 }
5199
5200 static gchar*
vala_ccode_attribute_get_default_set_value_function(ValaCCodeAttribute * self)5201 vala_ccode_attribute_get_default_set_value_function (ValaCCodeAttribute* self)
5202 {
5203 ValaSymbol* _tmp0_;
5204 gchar* _tmp71_;
5205 gchar* result = NULL;
5206 g_return_val_if_fail (self != NULL, NULL);
5207 _tmp0_ = self->priv->sym;
5208 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_CLASS)) {
5209 ValaClass* cl = NULL;
5210 ValaSymbol* _tmp1_;
5211 ValaClass* _tmp2_;
5212 _tmp1_ = self->priv->sym;
5213 cl = G_TYPE_CHECK_INSTANCE_CAST (_tmp1_, VALA_TYPE_CLASS, ValaClass);
5214 _tmp2_ = cl;
5215 if (vala_class_is_fundamental (_tmp2_)) {
5216 ValaClass* _tmp3_;
5217 gchar* _tmp4_;
5218 _tmp3_ = cl;
5219 _tmp4_ = vala_get_ccode_lower_case_name ((ValaCodeNode*) _tmp3_, "value_set_");
5220 result = _tmp4_;
5221 return result;
5222 } else {
5223 ValaClass* _tmp5_;
5224 ValaClass* _tmp6_;
5225 ValaClass* _tmp7_;
5226 _tmp5_ = cl;
5227 _tmp6_ = vala_class_get_base_class (_tmp5_);
5228 _tmp7_ = _tmp6_;
5229 if (_tmp7_ != NULL) {
5230 ValaClass* _tmp8_;
5231 ValaClass* _tmp9_;
5232 ValaClass* _tmp10_;
5233 gchar* _tmp11_;
5234 _tmp8_ = cl;
5235 _tmp9_ = vala_class_get_base_class (_tmp8_);
5236 _tmp10_ = _tmp9_;
5237 _tmp11_ = vala_get_ccode_set_value_function ((ValaCodeNode*) _tmp10_);
5238 result = _tmp11_;
5239 return result;
5240 } else {
5241 const gchar* _tmp12_;
5242 const gchar* _tmp13_;
5243 _tmp12_ = vala_ccode_attribute_get_type_id (self);
5244 _tmp13_ = _tmp12_;
5245 if (g_strcmp0 (_tmp13_, "G_TYPE_POINTER") == 0) {
5246 gchar* _tmp14_;
5247 _tmp14_ = g_strdup ("g_value_set_pointer");
5248 result = _tmp14_;
5249 return result;
5250 } else {
5251 gchar* _tmp15_;
5252 _tmp15_ = g_strdup ("g_value_set_boxed");
5253 result = _tmp15_;
5254 return result;
5255 }
5256 }
5257 }
5258 } else {
5259 ValaSymbol* _tmp16_;
5260 _tmp16_ = self->priv->sym;
5261 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp16_, VALA_TYPE_ENUM)) {
5262 ValaEnum* en = NULL;
5263 ValaSymbol* _tmp17_;
5264 ValaEnum* _tmp18_;
5265 _tmp17_ = self->priv->sym;
5266 en = G_TYPE_CHECK_INSTANCE_CAST (_tmp17_, VALA_TYPE_ENUM, ValaEnum);
5267 _tmp18_ = en;
5268 if (vala_get_ccode_has_type_id ((ValaTypeSymbol*) _tmp18_)) {
5269 ValaEnum* _tmp19_;
5270 gboolean _tmp20_;
5271 gboolean _tmp21_;
5272 _tmp19_ = en;
5273 _tmp20_ = vala_enum_get_is_flags (_tmp19_);
5274 _tmp21_ = _tmp20_;
5275 if (_tmp21_) {
5276 gchar* _tmp22_;
5277 _tmp22_ = g_strdup ("g_value_set_flags");
5278 result = _tmp22_;
5279 return result;
5280 } else {
5281 gchar* _tmp23_;
5282 _tmp23_ = g_strdup ("g_value_set_enum");
5283 result = _tmp23_;
5284 return result;
5285 }
5286 } else {
5287 ValaEnum* _tmp24_;
5288 gboolean _tmp25_;
5289 gboolean _tmp26_;
5290 _tmp24_ = en;
5291 _tmp25_ = vala_enum_get_is_flags (_tmp24_);
5292 _tmp26_ = _tmp25_;
5293 if (_tmp26_) {
5294 gchar* _tmp27_;
5295 _tmp27_ = g_strdup ("g_value_set_uint");
5296 result = _tmp27_;
5297 return result;
5298 } else {
5299 gchar* _tmp28_;
5300 _tmp28_ = g_strdup ("g_value_set_int");
5301 result = _tmp28_;
5302 return result;
5303 }
5304 }
5305 } else {
5306 ValaSymbol* _tmp29_;
5307 _tmp29_ = self->priv->sym;
5308 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp29_, VALA_TYPE_INTERFACE)) {
5309 gchar* _tmp45_;
5310 {
5311 ValaList* _prereq_list = NULL;
5312 ValaSymbol* _tmp30_;
5313 ValaList* _tmp31_;
5314 ValaList* _tmp32_;
5315 gint _prereq_size = 0;
5316 ValaList* _tmp33_;
5317 gint _tmp34_;
5318 gint _tmp35_;
5319 gint _prereq_index = 0;
5320 _tmp30_ = self->priv->sym;
5321 _tmp31_ = vala_interface_get_prerequisites (G_TYPE_CHECK_INSTANCE_CAST (_tmp30_, VALA_TYPE_INTERFACE, ValaInterface));
5322 _tmp32_ = _vala_iterable_ref0 (_tmp31_);
5323 _prereq_list = _tmp32_;
5324 _tmp33_ = _prereq_list;
5325 _tmp34_ = vala_collection_get_size ((ValaCollection*) _tmp33_);
5326 _tmp35_ = _tmp34_;
5327 _prereq_size = _tmp35_;
5328 _prereq_index = -1;
5329 while (TRUE) {
5330 gint _tmp36_;
5331 gint _tmp37_;
5332 ValaDataType* prereq = NULL;
5333 ValaList* _tmp38_;
5334 gpointer _tmp39_;
5335 gchar* type_name = NULL;
5336 ValaDataType* _tmp40_;
5337 ValaTypeSymbol* _tmp41_;
5338 ValaTypeSymbol* _tmp42_;
5339 gchar* _tmp43_;
5340 const gchar* _tmp44_;
5341 _prereq_index = _prereq_index + 1;
5342 _tmp36_ = _prereq_index;
5343 _tmp37_ = _prereq_size;
5344 if (!(_tmp36_ < _tmp37_)) {
5345 break;
5346 }
5347 _tmp38_ = _prereq_list;
5348 _tmp39_ = vala_list_get (_tmp38_, _prereq_index);
5349 prereq = (ValaDataType*) _tmp39_;
5350 _tmp40_ = prereq;
5351 _tmp41_ = vala_data_type_get_type_symbol (_tmp40_);
5352 _tmp42_ = _tmp41_;
5353 _tmp43_ = vala_get_ccode_set_value_function ((ValaCodeNode*) _tmp42_);
5354 type_name = _tmp43_;
5355 _tmp44_ = type_name;
5356 if (g_strcmp0 (_tmp44_, "") != 0) {
5357 result = type_name;
5358 _vala_code_node_unref0 (prereq);
5359 _vala_iterable_unref0 (_prereq_list);
5360 return result;
5361 }
5362 _g_free0 (type_name);
5363 _vala_code_node_unref0 (prereq);
5364 }
5365 _vala_iterable_unref0 (_prereq_list);
5366 }
5367 _tmp45_ = g_strdup ("g_value_set_pointer");
5368 result = _tmp45_;
5369 return result;
5370 } else {
5371 ValaSymbol* _tmp46_;
5372 _tmp46_ = self->priv->sym;
5373 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp46_, VALA_TYPE_STRUCT)) {
5374 ValaStruct* st = NULL;
5375 ValaSymbol* _tmp47_;
5376 ValaStruct* base_st = NULL;
5377 ValaStruct* _tmp48_;
5378 ValaStruct* _tmp49_;
5379 ValaStruct* _tmp50_;
5380 ValaStruct* _tmp58_;
5381 _tmp47_ = self->priv->sym;
5382 st = G_TYPE_CHECK_INSTANCE_CAST (_tmp47_, VALA_TYPE_STRUCT, ValaStruct);
5383 _tmp48_ = st;
5384 _tmp49_ = vala_struct_get_base_struct (_tmp48_);
5385 _tmp50_ = _tmp49_;
5386 base_st = _tmp50_;
5387 while (TRUE) {
5388 ValaStruct* _tmp51_;
5389 ValaStruct* _tmp52_;
5390 _tmp51_ = base_st;
5391 if (!(_tmp51_ != NULL)) {
5392 break;
5393 }
5394 _tmp52_ = base_st;
5395 if (vala_get_ccode_has_type_id ((ValaTypeSymbol*) _tmp52_)) {
5396 ValaStruct* _tmp53_;
5397 gchar* _tmp54_;
5398 _tmp53_ = base_st;
5399 _tmp54_ = vala_get_ccode_set_value_function ((ValaCodeNode*) _tmp53_);
5400 result = _tmp54_;
5401 return result;
5402 } else {
5403 ValaStruct* _tmp55_;
5404 ValaStruct* _tmp56_;
5405 ValaStruct* _tmp57_;
5406 _tmp55_ = base_st;
5407 _tmp56_ = vala_struct_get_base_struct (_tmp55_);
5408 _tmp57_ = _tmp56_;
5409 base_st = _tmp57_;
5410 }
5411 }
5412 _tmp58_ = st;
5413 if (vala_struct_is_simple_type (_tmp58_)) {
5414 ValaStruct* _tmp59_;
5415 ValaSourceReference* _tmp60_;
5416 ValaSourceReference* _tmp61_;
5417 ValaStruct* _tmp62_;
5418 gchar* _tmp63_;
5419 gchar* _tmp64_;
5420 gchar* _tmp65_;
5421 gchar* _tmp66_;
5422 _tmp59_ = st;
5423 _tmp60_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp59_);
5424 _tmp61_ = _tmp60_;
5425 _tmp62_ = st;
5426 _tmp63_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp62_);
5427 _tmp64_ = _tmp63_;
5428 _tmp65_ = g_strdup_printf ("The type `%s' doesn't declare a GValue set function", _tmp64_);
5429 _tmp66_ = _tmp65_;
5430 vala_report_error (_tmp61_, _tmp66_);
5431 _g_free0 (_tmp66_);
5432 _g_free0 (_tmp64_);
5433 } else {
5434 ValaStruct* _tmp67_;
5435 _tmp67_ = st;
5436 if (vala_get_ccode_has_type_id ((ValaTypeSymbol*) _tmp67_)) {
5437 gchar* _tmp68_;
5438 _tmp68_ = g_strdup ("g_value_set_boxed");
5439 result = _tmp68_;
5440 return result;
5441 } else {
5442 gchar* _tmp69_;
5443 _tmp69_ = g_strdup ("g_value_set_pointer");
5444 result = _tmp69_;
5445 return result;
5446 }
5447 }
5448 } else {
5449 gchar* _tmp70_;
5450 _tmp70_ = g_strdup ("g_value_set_pointer");
5451 result = _tmp70_;
5452 return result;
5453 }
5454 }
5455 }
5456 }
5457 _tmp71_ = g_strdup ("");
5458 result = _tmp71_;
5459 return result;
5460 }
5461
5462 static gchar*
vala_ccode_attribute_get_default_take_value_function(ValaCCodeAttribute * self)5463 vala_ccode_attribute_get_default_take_value_function (ValaCCodeAttribute* self)
5464 {
5465 ValaSymbol* _tmp0_;
5466 gchar* _tmp71_;
5467 gchar* result = NULL;
5468 g_return_val_if_fail (self != NULL, NULL);
5469 _tmp0_ = self->priv->sym;
5470 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_CLASS)) {
5471 ValaClass* cl = NULL;
5472 ValaSymbol* _tmp1_;
5473 ValaClass* _tmp2_;
5474 _tmp1_ = self->priv->sym;
5475 cl = G_TYPE_CHECK_INSTANCE_CAST (_tmp1_, VALA_TYPE_CLASS, ValaClass);
5476 _tmp2_ = cl;
5477 if (vala_class_is_fundamental (_tmp2_)) {
5478 ValaClass* _tmp3_;
5479 gchar* _tmp4_;
5480 _tmp3_ = cl;
5481 _tmp4_ = vala_get_ccode_lower_case_name ((ValaCodeNode*) _tmp3_, "value_take_");
5482 result = _tmp4_;
5483 return result;
5484 } else {
5485 ValaClass* _tmp5_;
5486 ValaClass* _tmp6_;
5487 ValaClass* _tmp7_;
5488 _tmp5_ = cl;
5489 _tmp6_ = vala_class_get_base_class (_tmp5_);
5490 _tmp7_ = _tmp6_;
5491 if (_tmp7_ != NULL) {
5492 ValaClass* _tmp8_;
5493 ValaClass* _tmp9_;
5494 ValaClass* _tmp10_;
5495 gchar* _tmp11_;
5496 _tmp8_ = cl;
5497 _tmp9_ = vala_class_get_base_class (_tmp8_);
5498 _tmp10_ = _tmp9_;
5499 _tmp11_ = vala_get_ccode_take_value_function ((ValaCodeNode*) _tmp10_);
5500 result = _tmp11_;
5501 return result;
5502 } else {
5503 const gchar* _tmp12_;
5504 const gchar* _tmp13_;
5505 _tmp12_ = vala_ccode_attribute_get_type_id (self);
5506 _tmp13_ = _tmp12_;
5507 if (g_strcmp0 (_tmp13_, "G_TYPE_POINTER") == 0) {
5508 gchar* _tmp14_;
5509 _tmp14_ = g_strdup ("g_value_set_pointer");
5510 result = _tmp14_;
5511 return result;
5512 } else {
5513 gchar* _tmp15_;
5514 _tmp15_ = g_strdup ("g_value_take_boxed");
5515 result = _tmp15_;
5516 return result;
5517 }
5518 }
5519 }
5520 } else {
5521 ValaSymbol* _tmp16_;
5522 _tmp16_ = self->priv->sym;
5523 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp16_, VALA_TYPE_ENUM)) {
5524 ValaEnum* en = NULL;
5525 ValaSymbol* _tmp17_;
5526 ValaEnum* _tmp18_;
5527 _tmp17_ = self->priv->sym;
5528 en = G_TYPE_CHECK_INSTANCE_CAST (_tmp17_, VALA_TYPE_ENUM, ValaEnum);
5529 _tmp18_ = en;
5530 if (vala_get_ccode_has_type_id ((ValaTypeSymbol*) _tmp18_)) {
5531 ValaEnum* _tmp19_;
5532 gboolean _tmp20_;
5533 gboolean _tmp21_;
5534 _tmp19_ = en;
5535 _tmp20_ = vala_enum_get_is_flags (_tmp19_);
5536 _tmp21_ = _tmp20_;
5537 if (_tmp21_) {
5538 gchar* _tmp22_;
5539 _tmp22_ = g_strdup ("g_value_take_flags");
5540 result = _tmp22_;
5541 return result;
5542 } else {
5543 gchar* _tmp23_;
5544 _tmp23_ = g_strdup ("g_value_take_enum");
5545 result = _tmp23_;
5546 return result;
5547 }
5548 } else {
5549 ValaEnum* _tmp24_;
5550 gboolean _tmp25_;
5551 gboolean _tmp26_;
5552 _tmp24_ = en;
5553 _tmp25_ = vala_enum_get_is_flags (_tmp24_);
5554 _tmp26_ = _tmp25_;
5555 if (_tmp26_) {
5556 gchar* _tmp27_;
5557 _tmp27_ = g_strdup ("g_value_take_uint");
5558 result = _tmp27_;
5559 return result;
5560 } else {
5561 gchar* _tmp28_;
5562 _tmp28_ = g_strdup ("g_value_take_int");
5563 result = _tmp28_;
5564 return result;
5565 }
5566 }
5567 } else {
5568 ValaSymbol* _tmp29_;
5569 _tmp29_ = self->priv->sym;
5570 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp29_, VALA_TYPE_INTERFACE)) {
5571 gchar* _tmp45_;
5572 {
5573 ValaList* _prereq_list = NULL;
5574 ValaSymbol* _tmp30_;
5575 ValaList* _tmp31_;
5576 ValaList* _tmp32_;
5577 gint _prereq_size = 0;
5578 ValaList* _tmp33_;
5579 gint _tmp34_;
5580 gint _tmp35_;
5581 gint _prereq_index = 0;
5582 _tmp30_ = self->priv->sym;
5583 _tmp31_ = vala_interface_get_prerequisites (G_TYPE_CHECK_INSTANCE_CAST (_tmp30_, VALA_TYPE_INTERFACE, ValaInterface));
5584 _tmp32_ = _vala_iterable_ref0 (_tmp31_);
5585 _prereq_list = _tmp32_;
5586 _tmp33_ = _prereq_list;
5587 _tmp34_ = vala_collection_get_size ((ValaCollection*) _tmp33_);
5588 _tmp35_ = _tmp34_;
5589 _prereq_size = _tmp35_;
5590 _prereq_index = -1;
5591 while (TRUE) {
5592 gint _tmp36_;
5593 gint _tmp37_;
5594 ValaDataType* prereq = NULL;
5595 ValaList* _tmp38_;
5596 gpointer _tmp39_;
5597 gchar* func = NULL;
5598 ValaDataType* _tmp40_;
5599 ValaTypeSymbol* _tmp41_;
5600 ValaTypeSymbol* _tmp42_;
5601 gchar* _tmp43_;
5602 const gchar* _tmp44_;
5603 _prereq_index = _prereq_index + 1;
5604 _tmp36_ = _prereq_index;
5605 _tmp37_ = _prereq_size;
5606 if (!(_tmp36_ < _tmp37_)) {
5607 break;
5608 }
5609 _tmp38_ = _prereq_list;
5610 _tmp39_ = vala_list_get (_tmp38_, _prereq_index);
5611 prereq = (ValaDataType*) _tmp39_;
5612 _tmp40_ = prereq;
5613 _tmp41_ = vala_data_type_get_type_symbol (_tmp40_);
5614 _tmp42_ = _tmp41_;
5615 _tmp43_ = vala_get_ccode_take_value_function ((ValaCodeNode*) _tmp42_);
5616 func = _tmp43_;
5617 _tmp44_ = func;
5618 if (g_strcmp0 (_tmp44_, "") != 0) {
5619 result = func;
5620 _vala_code_node_unref0 (prereq);
5621 _vala_iterable_unref0 (_prereq_list);
5622 return result;
5623 }
5624 _g_free0 (func);
5625 _vala_code_node_unref0 (prereq);
5626 }
5627 _vala_iterable_unref0 (_prereq_list);
5628 }
5629 _tmp45_ = g_strdup ("g_value_set_pointer");
5630 result = _tmp45_;
5631 return result;
5632 } else {
5633 ValaSymbol* _tmp46_;
5634 _tmp46_ = self->priv->sym;
5635 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp46_, VALA_TYPE_STRUCT)) {
5636 ValaStruct* st = NULL;
5637 ValaSymbol* _tmp47_;
5638 ValaStruct* base_st = NULL;
5639 ValaStruct* _tmp48_;
5640 ValaStruct* _tmp49_;
5641 ValaStruct* _tmp50_;
5642 ValaStruct* _tmp58_;
5643 _tmp47_ = self->priv->sym;
5644 st = G_TYPE_CHECK_INSTANCE_CAST (_tmp47_, VALA_TYPE_STRUCT, ValaStruct);
5645 _tmp48_ = st;
5646 _tmp49_ = vala_struct_get_base_struct (_tmp48_);
5647 _tmp50_ = _tmp49_;
5648 base_st = _tmp50_;
5649 while (TRUE) {
5650 ValaStruct* _tmp51_;
5651 ValaStruct* _tmp52_;
5652 _tmp51_ = base_st;
5653 if (!(_tmp51_ != NULL)) {
5654 break;
5655 }
5656 _tmp52_ = base_st;
5657 if (vala_get_ccode_has_type_id ((ValaTypeSymbol*) _tmp52_)) {
5658 ValaStruct* _tmp53_;
5659 gchar* _tmp54_;
5660 _tmp53_ = base_st;
5661 _tmp54_ = vala_get_ccode_take_value_function ((ValaCodeNode*) _tmp53_);
5662 result = _tmp54_;
5663 return result;
5664 } else {
5665 ValaStruct* _tmp55_;
5666 ValaStruct* _tmp56_;
5667 ValaStruct* _tmp57_;
5668 _tmp55_ = base_st;
5669 _tmp56_ = vala_struct_get_base_struct (_tmp55_);
5670 _tmp57_ = _tmp56_;
5671 base_st = _tmp57_;
5672 }
5673 }
5674 _tmp58_ = st;
5675 if (vala_struct_is_simple_type (_tmp58_)) {
5676 ValaStruct* _tmp59_;
5677 ValaSourceReference* _tmp60_;
5678 ValaSourceReference* _tmp61_;
5679 ValaStruct* _tmp62_;
5680 gchar* _tmp63_;
5681 gchar* _tmp64_;
5682 gchar* _tmp65_;
5683 gchar* _tmp66_;
5684 _tmp59_ = st;
5685 _tmp60_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp59_);
5686 _tmp61_ = _tmp60_;
5687 _tmp62_ = st;
5688 _tmp63_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp62_);
5689 _tmp64_ = _tmp63_;
5690 _tmp65_ = g_strdup_printf ("The type `%s' doesn't declare a GValue take function", _tmp64_);
5691 _tmp66_ = _tmp65_;
5692 vala_report_error (_tmp61_, _tmp66_);
5693 _g_free0 (_tmp66_);
5694 _g_free0 (_tmp64_);
5695 } else {
5696 ValaStruct* _tmp67_;
5697 _tmp67_ = st;
5698 if (vala_get_ccode_has_type_id ((ValaTypeSymbol*) _tmp67_)) {
5699 gchar* _tmp68_;
5700 _tmp68_ = g_strdup ("g_value_take_boxed");
5701 result = _tmp68_;
5702 return result;
5703 } else {
5704 gchar* _tmp69_;
5705 _tmp69_ = g_strdup ("g_value_set_pointer");
5706 result = _tmp69_;
5707 return result;
5708 }
5709 }
5710 } else {
5711 gchar* _tmp70_;
5712 _tmp70_ = g_strdup ("g_value_set_pointer");
5713 result = _tmp70_;
5714 return result;
5715 }
5716 }
5717 }
5718 }
5719 _tmp71_ = g_strdup ("");
5720 result = _tmp71_;
5721 return result;
5722 }
5723
5724 static gchar*
vala_ccode_attribute_get_default_param_spec_function(ValaCCodeAttribute * self)5725 vala_ccode_attribute_get_default_param_spec_function (ValaCCodeAttribute* self)
5726 {
5727 ValaCodeNode* _tmp0_;
5728 gchar* _tmp99_;
5729 gchar* result = NULL;
5730 g_return_val_if_fail (self != NULL, NULL);
5731 _tmp0_ = self->priv->node;
5732 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_SYMBOL)) {
5733 ValaSymbol* _tmp1_;
5734 _tmp1_ = self->priv->sym;
5735 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1_, VALA_TYPE_CLASS)) {
5736 ValaClass* cl = NULL;
5737 ValaSymbol* _tmp2_;
5738 ValaClass* _tmp3_;
5739 _tmp2_ = self->priv->sym;
5740 cl = G_TYPE_CHECK_INSTANCE_CAST (_tmp2_, VALA_TYPE_CLASS, ValaClass);
5741 _tmp3_ = cl;
5742 if (vala_class_is_fundamental (_tmp3_)) {
5743 ValaClass* _tmp4_;
5744 gchar* _tmp5_;
5745 _tmp4_ = cl;
5746 _tmp5_ = vala_get_ccode_lower_case_name ((ValaCodeNode*) _tmp4_, "param_spec_");
5747 result = _tmp5_;
5748 return result;
5749 } else {
5750 ValaClass* _tmp6_;
5751 ValaClass* _tmp7_;
5752 ValaClass* _tmp8_;
5753 _tmp6_ = cl;
5754 _tmp7_ = vala_class_get_base_class (_tmp6_);
5755 _tmp8_ = _tmp7_;
5756 if (_tmp8_ != NULL) {
5757 ValaClass* _tmp9_;
5758 ValaClass* _tmp10_;
5759 ValaClass* _tmp11_;
5760 gchar* _tmp12_;
5761 _tmp9_ = cl;
5762 _tmp10_ = vala_class_get_base_class (_tmp9_);
5763 _tmp11_ = _tmp10_;
5764 _tmp12_ = vala_get_ccode_param_spec_function ((ValaCodeNode*) _tmp11_);
5765 result = _tmp12_;
5766 return result;
5767 } else {
5768 const gchar* _tmp13_;
5769 const gchar* _tmp14_;
5770 _tmp13_ = vala_ccode_attribute_get_type_id (self);
5771 _tmp14_ = _tmp13_;
5772 if (g_strcmp0 (_tmp14_, "G_TYPE_POINTER") == 0) {
5773 gchar* _tmp15_;
5774 _tmp15_ = g_strdup ("g_param_spec_pointer");
5775 result = _tmp15_;
5776 return result;
5777 } else {
5778 gchar* _tmp16_;
5779 _tmp16_ = g_strdup ("g_param_spec_boxed");
5780 result = _tmp16_;
5781 return result;
5782 }
5783 }
5784 }
5785 } else {
5786 ValaSymbol* _tmp17_;
5787 _tmp17_ = self->priv->sym;
5788 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp17_, VALA_TYPE_INTERFACE)) {
5789 gchar* _tmp33_;
5790 {
5791 ValaList* _prereq_list = NULL;
5792 ValaSymbol* _tmp18_;
5793 ValaList* _tmp19_;
5794 ValaList* _tmp20_;
5795 gint _prereq_size = 0;
5796 ValaList* _tmp21_;
5797 gint _tmp22_;
5798 gint _tmp23_;
5799 gint _prereq_index = 0;
5800 _tmp18_ = self->priv->sym;
5801 _tmp19_ = vala_interface_get_prerequisites (G_TYPE_CHECK_INSTANCE_CAST (_tmp18_, VALA_TYPE_INTERFACE, ValaInterface));
5802 _tmp20_ = _vala_iterable_ref0 (_tmp19_);
5803 _prereq_list = _tmp20_;
5804 _tmp21_ = _prereq_list;
5805 _tmp22_ = vala_collection_get_size ((ValaCollection*) _tmp21_);
5806 _tmp23_ = _tmp22_;
5807 _prereq_size = _tmp23_;
5808 _prereq_index = -1;
5809 while (TRUE) {
5810 gint _tmp24_;
5811 gint _tmp25_;
5812 ValaDataType* prereq = NULL;
5813 ValaList* _tmp26_;
5814 gpointer _tmp27_;
5815 gchar* func = NULL;
5816 ValaDataType* _tmp28_;
5817 ValaTypeSymbol* _tmp29_;
5818 ValaTypeSymbol* _tmp30_;
5819 gchar* _tmp31_;
5820 const gchar* _tmp32_;
5821 _prereq_index = _prereq_index + 1;
5822 _tmp24_ = _prereq_index;
5823 _tmp25_ = _prereq_size;
5824 if (!(_tmp24_ < _tmp25_)) {
5825 break;
5826 }
5827 _tmp26_ = _prereq_list;
5828 _tmp27_ = vala_list_get (_tmp26_, _prereq_index);
5829 prereq = (ValaDataType*) _tmp27_;
5830 _tmp28_ = prereq;
5831 _tmp29_ = vala_data_type_get_type_symbol (_tmp28_);
5832 _tmp30_ = _tmp29_;
5833 _tmp31_ = vala_get_ccode_param_spec_function ((ValaCodeNode*) _tmp30_);
5834 func = _tmp31_;
5835 _tmp32_ = func;
5836 if (g_strcmp0 (_tmp32_, "") != 0) {
5837 result = func;
5838 _vala_code_node_unref0 (prereq);
5839 _vala_iterable_unref0 (_prereq_list);
5840 return result;
5841 }
5842 _g_free0 (func);
5843 _vala_code_node_unref0 (prereq);
5844 }
5845 _vala_iterable_unref0 (_prereq_list);
5846 }
5847 _tmp33_ = g_strdup ("g_param_spec_pointer");
5848 result = _tmp33_;
5849 return result;
5850 } else {
5851 ValaSymbol* _tmp34_;
5852 _tmp34_ = self->priv->sym;
5853 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp34_, VALA_TYPE_ENUM)) {
5854 ValaEnum* e = NULL;
5855 ValaSymbol* _tmp35_;
5856 ValaEnum* _tmp36_;
5857 _tmp35_ = self->priv->sym;
5858 e = G_TYPE_CHECK_INSTANCE_CAST (_tmp35_, VALA_TYPE_ENUM, ValaEnum);
5859 _tmp36_ = e;
5860 if (vala_get_ccode_has_type_id ((ValaTypeSymbol*) _tmp36_)) {
5861 ValaEnum* _tmp37_;
5862 gboolean _tmp38_;
5863 gboolean _tmp39_;
5864 _tmp37_ = e;
5865 _tmp38_ = vala_enum_get_is_flags (_tmp37_);
5866 _tmp39_ = _tmp38_;
5867 if (_tmp39_) {
5868 gchar* _tmp40_;
5869 _tmp40_ = g_strdup ("g_param_spec_flags");
5870 result = _tmp40_;
5871 return result;
5872 } else {
5873 gchar* _tmp41_;
5874 _tmp41_ = g_strdup ("g_param_spec_enum");
5875 result = _tmp41_;
5876 return result;
5877 }
5878 } else {
5879 ValaEnum* _tmp42_;
5880 gboolean _tmp43_;
5881 gboolean _tmp44_;
5882 _tmp42_ = e;
5883 _tmp43_ = vala_enum_get_is_flags (_tmp42_);
5884 _tmp44_ = _tmp43_;
5885 if (_tmp44_) {
5886 gchar* _tmp45_;
5887 _tmp45_ = g_strdup ("g_param_spec_uint");
5888 result = _tmp45_;
5889 return result;
5890 } else {
5891 gchar* _tmp46_;
5892 _tmp46_ = g_strdup ("g_param_spec_int");
5893 result = _tmp46_;
5894 return result;
5895 }
5896 }
5897 } else {
5898 ValaSymbol* _tmp47_;
5899 _tmp47_ = self->priv->sym;
5900 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp47_, VALA_TYPE_STRUCT)) {
5901 gchar* type_id = NULL;
5902 ValaSymbol* _tmp48_;
5903 gchar* _tmp49_;
5904 const gchar* _tmp50_;
5905 _tmp48_ = self->priv->sym;
5906 _tmp49_ = vala_get_ccode_type_id ((ValaCodeNode*) _tmp48_);
5907 type_id = _tmp49_;
5908 _tmp50_ = type_id;
5909 if (g_strcmp0 (_tmp50_, "G_TYPE_INT") == 0) {
5910 gchar* _tmp51_;
5911 _tmp51_ = g_strdup ("g_param_spec_int");
5912 result = _tmp51_;
5913 _g_free0 (type_id);
5914 return result;
5915 } else {
5916 const gchar* _tmp52_;
5917 _tmp52_ = type_id;
5918 if (g_strcmp0 (_tmp52_, "G_TYPE_UINT") == 0) {
5919 gchar* _tmp53_;
5920 _tmp53_ = g_strdup ("g_param_spec_uint");
5921 result = _tmp53_;
5922 _g_free0 (type_id);
5923 return result;
5924 } else {
5925 const gchar* _tmp54_;
5926 _tmp54_ = type_id;
5927 if (g_strcmp0 (_tmp54_, "G_TYPE_INT64") == 0) {
5928 gchar* _tmp55_;
5929 _tmp55_ = g_strdup ("g_param_spec_int64");
5930 result = _tmp55_;
5931 _g_free0 (type_id);
5932 return result;
5933 } else {
5934 const gchar* _tmp56_;
5935 _tmp56_ = type_id;
5936 if (g_strcmp0 (_tmp56_, "G_TYPE_UINT64") == 0) {
5937 gchar* _tmp57_;
5938 _tmp57_ = g_strdup ("g_param_spec_uint64");
5939 result = _tmp57_;
5940 _g_free0 (type_id);
5941 return result;
5942 } else {
5943 const gchar* _tmp58_;
5944 _tmp58_ = type_id;
5945 if (g_strcmp0 (_tmp58_, "G_TYPE_LONG") == 0) {
5946 gchar* _tmp59_;
5947 _tmp59_ = g_strdup ("g_param_spec_long");
5948 result = _tmp59_;
5949 _g_free0 (type_id);
5950 return result;
5951 } else {
5952 const gchar* _tmp60_;
5953 _tmp60_ = type_id;
5954 if (g_strcmp0 (_tmp60_, "G_TYPE_ULONG") == 0) {
5955 gchar* _tmp61_;
5956 _tmp61_ = g_strdup ("g_param_spec_ulong");
5957 result = _tmp61_;
5958 _g_free0 (type_id);
5959 return result;
5960 } else {
5961 const gchar* _tmp62_;
5962 _tmp62_ = type_id;
5963 if (g_strcmp0 (_tmp62_, "G_TYPE_BOOLEAN") == 0) {
5964 gchar* _tmp63_;
5965 _tmp63_ = g_strdup ("g_param_spec_boolean");
5966 result = _tmp63_;
5967 _g_free0 (type_id);
5968 return result;
5969 } else {
5970 const gchar* _tmp64_;
5971 _tmp64_ = type_id;
5972 if (g_strcmp0 (_tmp64_, "G_TYPE_CHAR") == 0) {
5973 gchar* _tmp65_;
5974 _tmp65_ = g_strdup ("g_param_spec_char");
5975 result = _tmp65_;
5976 _g_free0 (type_id);
5977 return result;
5978 } else {
5979 const gchar* _tmp66_;
5980 _tmp66_ = type_id;
5981 if (g_strcmp0 (_tmp66_, "G_TYPE_UCHAR") == 0) {
5982 gchar* _tmp67_;
5983 _tmp67_ = g_strdup ("g_param_spec_uchar");
5984 result = _tmp67_;
5985 _g_free0 (type_id);
5986 return result;
5987 } else {
5988 const gchar* _tmp68_;
5989 _tmp68_ = type_id;
5990 if (g_strcmp0 (_tmp68_, "G_TYPE_FLOAT") == 0) {
5991 gchar* _tmp69_;
5992 _tmp69_ = g_strdup ("g_param_spec_float");
5993 result = _tmp69_;
5994 _g_free0 (type_id);
5995 return result;
5996 } else {
5997 const gchar* _tmp70_;
5998 _tmp70_ = type_id;
5999 if (g_strcmp0 (_tmp70_, "G_TYPE_DOUBLE") == 0) {
6000 gchar* _tmp71_;
6001 _tmp71_ = g_strdup ("g_param_spec_double");
6002 result = _tmp71_;
6003 _g_free0 (type_id);
6004 return result;
6005 } else {
6006 const gchar* _tmp72_;
6007 _tmp72_ = type_id;
6008 if (g_strcmp0 (_tmp72_, "G_TYPE_GTYPE") == 0) {
6009 gchar* _tmp73_;
6010 _tmp73_ = g_strdup ("g_param_spec_gtype");
6011 result = _tmp73_;
6012 _g_free0 (type_id);
6013 return result;
6014 } else {
6015 gchar* _tmp74_;
6016 _tmp74_ = g_strdup ("g_param_spec_boxed");
6017 result = _tmp74_;
6018 _g_free0 (type_id);
6019 return result;
6020 }
6021 }
6022 }
6023 }
6024 }
6025 }
6026 }
6027 }
6028 }
6029 }
6030 }
6031 }
6032 _g_free0 (type_id);
6033 }
6034 }
6035 }
6036 }
6037 } else {
6038 gboolean _tmp75_ = FALSE;
6039 ValaCodeNode* _tmp76_;
6040 _tmp76_ = self->priv->node;
6041 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp76_, VALA_TYPE_ARRAY_TYPE)) {
6042 ValaCodeNode* _tmp77_;
6043 ValaDataType* _tmp78_;
6044 ValaDataType* _tmp79_;
6045 ValaTypeSymbol* _tmp80_;
6046 ValaTypeSymbol* _tmp81_;
6047 ValaCodeContext* _tmp82_;
6048 ValaCodeContext* _tmp83_;
6049 ValaSemanticAnalyzer* _tmp84_;
6050 ValaSemanticAnalyzer* _tmp85_;
6051 ValaDataType* _tmp86_;
6052 ValaTypeSymbol* _tmp87_;
6053 ValaTypeSymbol* _tmp88_;
6054 _tmp77_ = self->priv->node;
6055 _tmp78_ = vala_array_type_get_element_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp77_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
6056 _tmp79_ = _tmp78_;
6057 _tmp80_ = vala_data_type_get_type_symbol (_tmp79_);
6058 _tmp81_ = _tmp80_;
6059 _tmp82_ = vala_code_context_get ();
6060 _tmp83_ = _tmp82_;
6061 _tmp84_ = vala_code_context_get_analyzer (_tmp83_);
6062 _tmp85_ = _tmp84_;
6063 _tmp86_ = _tmp85_->string_type;
6064 _tmp87_ = vala_data_type_get_type_symbol (_tmp86_);
6065 _tmp88_ = _tmp87_;
6066 _tmp75_ = _tmp81_ == _tmp88_;
6067 _vala_code_context_unref0 (_tmp83_);
6068 } else {
6069 _tmp75_ = FALSE;
6070 }
6071 if (_tmp75_) {
6072 gchar* _tmp89_;
6073 _tmp89_ = g_strdup ("g_param_spec_boxed");
6074 result = _tmp89_;
6075 return result;
6076 } else {
6077 gboolean _tmp90_ = FALSE;
6078 ValaCodeNode* _tmp91_;
6079 _tmp91_ = self->priv->node;
6080 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp91_, VALA_TYPE_DATA_TYPE)) {
6081 ValaCodeNode* _tmp92_;
6082 ValaTypeSymbol* _tmp93_;
6083 ValaTypeSymbol* _tmp94_;
6084 _tmp92_ = self->priv->node;
6085 _tmp93_ = vala_data_type_get_type_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp92_, VALA_TYPE_DATA_TYPE, ValaDataType));
6086 _tmp94_ = _tmp93_;
6087 _tmp90_ = _tmp94_ != NULL;
6088 } else {
6089 _tmp90_ = FALSE;
6090 }
6091 if (_tmp90_) {
6092 ValaCodeNode* _tmp95_;
6093 ValaTypeSymbol* _tmp96_;
6094 ValaTypeSymbol* _tmp97_;
6095 gchar* _tmp98_;
6096 _tmp95_ = self->priv->node;
6097 _tmp96_ = vala_data_type_get_type_symbol (G_TYPE_CHECK_INSTANCE_CAST (_tmp95_, VALA_TYPE_DATA_TYPE, ValaDataType));
6098 _tmp97_ = _tmp96_;
6099 _tmp98_ = vala_get_ccode_param_spec_function ((ValaCodeNode*) _tmp97_);
6100 result = _tmp98_;
6101 return result;
6102 }
6103 }
6104 }
6105 _tmp99_ = g_strdup ("g_param_spec_pointer");
6106 result = _tmp99_;
6107 return result;
6108 }
6109
6110 static gchar*
vala_ccode_attribute_get_default_default_value(ValaCCodeAttribute * self)6111 vala_ccode_attribute_get_default_default_value (ValaCCodeAttribute* self)
6112 {
6113 ValaSymbol* _tmp0_;
6114 gchar* _tmp15_;
6115 gchar* result = NULL;
6116 g_return_val_if_fail (self != NULL, NULL);
6117 _tmp0_ = self->priv->sym;
6118 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_ENUM)) {
6119 ValaEnum* en = NULL;
6120 ValaSymbol* _tmp1_;
6121 ValaEnum* _tmp2_;
6122 gboolean _tmp3_;
6123 gboolean _tmp4_;
6124 _tmp1_ = self->priv->sym;
6125 en = G_TYPE_CHECK_INSTANCE_CAST (_tmp1_, VALA_TYPE_ENUM, ValaEnum);
6126 _tmp2_ = en;
6127 _tmp3_ = vala_enum_get_is_flags (_tmp2_);
6128 _tmp4_ = _tmp3_;
6129 if (_tmp4_) {
6130 gchar* _tmp5_;
6131 _tmp5_ = g_strdup ("0U");
6132 result = _tmp5_;
6133 return result;
6134 } else {
6135 gchar* _tmp6_;
6136 _tmp6_ = g_strdup ("0");
6137 result = _tmp6_;
6138 return result;
6139 }
6140 } else {
6141 ValaSymbol* _tmp7_;
6142 _tmp7_ = self->priv->sym;
6143 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp7_, VALA_TYPE_STRUCT)) {
6144 ValaStruct* st = NULL;
6145 ValaSymbol* _tmp8_;
6146 ValaStruct* base_st = NULL;
6147 ValaStruct* _tmp9_;
6148 ValaStruct* _tmp10_;
6149 ValaStruct* _tmp11_;
6150 ValaStruct* _tmp12_;
6151 _tmp8_ = self->priv->sym;
6152 st = G_TYPE_CHECK_INSTANCE_CAST (_tmp8_, VALA_TYPE_STRUCT, ValaStruct);
6153 _tmp9_ = st;
6154 _tmp10_ = vala_struct_get_base_struct (_tmp9_);
6155 _tmp11_ = _tmp10_;
6156 base_st = _tmp11_;
6157 _tmp12_ = base_st;
6158 if (_tmp12_ != NULL) {
6159 ValaStruct* _tmp13_;
6160 gchar* _tmp14_;
6161 _tmp13_ = base_st;
6162 _tmp14_ = vala_get_ccode_default_value ((ValaTypeSymbol*) _tmp13_);
6163 result = _tmp14_;
6164 return result;
6165 }
6166 }
6167 }
6168 _tmp15_ = g_strdup ("");
6169 result = _tmp15_;
6170 return result;
6171 }
6172
6173 static gchar*
vala_ccode_attribute_get_finish_name_for_basename(ValaCCodeAttribute * self,const gchar * basename)6174 vala_ccode_attribute_get_finish_name_for_basename (ValaCCodeAttribute* self,
6175 const gchar* basename)
6176 {
6177 gchar* _result_ = NULL;
6178 gchar* _tmp0_;
6179 const gchar* _tmp1_;
6180 const gchar* _tmp9_;
6181 gchar* _tmp10_;
6182 gchar* result = NULL;
6183 g_return_val_if_fail (self != NULL, NULL);
6184 g_return_val_if_fail (basename != NULL, NULL);
6185 _tmp0_ = g_strdup (basename);
6186 _result_ = _tmp0_;
6187 _tmp1_ = _result_;
6188 if (g_str_has_suffix (_tmp1_, "_async")) {
6189 const gchar* _tmp2_;
6190 const gchar* _tmp3_;
6191 gint _tmp4_;
6192 gint _tmp5_;
6193 gint _tmp6_;
6194 gint _tmp7_;
6195 gchar* _tmp8_;
6196 _tmp2_ = _result_;
6197 _tmp3_ = _result_;
6198 _tmp4_ = strlen (_tmp3_);
6199 _tmp5_ = _tmp4_;
6200 _tmp6_ = strlen ("_async");
6201 _tmp7_ = _tmp6_;
6202 _tmp8_ = string_substring (_tmp2_, (glong) 0, (glong) (_tmp5_ - _tmp7_));
6203 _g_free0 (_result_);
6204 _result_ = _tmp8_;
6205 }
6206 _tmp9_ = _result_;
6207 _tmp10_ = g_strdup_printf ("%s_finish", _tmp9_);
6208 result = _tmp10_;
6209 _g_free0 (_result_);
6210 return result;
6211 }
6212
6213 static gchar*
vala_ccode_attribute_get_default_real_name(ValaCCodeAttribute * self)6214 vala_ccode_attribute_get_default_real_name (ValaCCodeAttribute* self)
6215 {
6216 ValaSymbol* _tmp0_;
6217 gchar* result = NULL;
6218 g_return_val_if_fail (self != NULL, NULL);
6219 _tmp0_ = self->priv->sym;
6220 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_CREATION_METHOD)) {
6221 ValaCreationMethod* m = NULL;
6222 ValaSymbol* _tmp1_;
6223 ValaClass* parent = NULL;
6224 ValaCreationMethod* _tmp2_;
6225 ValaSymbol* _tmp3_;
6226 ValaSymbol* _tmp4_;
6227 gboolean _tmp5_ = FALSE;
6228 ValaClass* _tmp6_;
6229 gchar* infix = NULL;
6230 gchar* _tmp13_;
6231 ValaCreationMethod* _tmp14_;
6232 const gchar* _tmp15_;
6233 const gchar* _tmp16_;
6234 _tmp1_ = self->priv->sym;
6235 m = G_TYPE_CHECK_INSTANCE_CAST (_tmp1_, VALA_TYPE_CREATION_METHOD, ValaCreationMethod);
6236 _tmp2_ = m;
6237 _tmp3_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp2_);
6238 _tmp4_ = _tmp3_;
6239 parent = G_TYPE_CHECK_INSTANCE_TYPE (_tmp4_, VALA_TYPE_CLASS) ? ((ValaClass*) _tmp4_) : NULL;
6240 _tmp6_ = parent;
6241 if (_tmp6_ == NULL) {
6242 _tmp5_ = TRUE;
6243 } else {
6244 ValaClass* _tmp7_;
6245 gboolean _tmp8_;
6246 gboolean _tmp9_;
6247 _tmp7_ = parent;
6248 _tmp8_ = vala_class_get_is_compact (_tmp7_);
6249 _tmp9_ = _tmp8_;
6250 _tmp5_ = _tmp9_;
6251 }
6252 if (_tmp5_) {
6253 const gchar* _tmp10_;
6254 const gchar* _tmp11_;
6255 gchar* _tmp12_;
6256 _tmp10_ = vala_ccode_attribute_get_name (self);
6257 _tmp11_ = _tmp10_;
6258 _tmp12_ = g_strdup (_tmp11_);
6259 result = _tmp12_;
6260 return result;
6261 }
6262 _tmp13_ = g_strdup ("construct");
6263 infix = _tmp13_;
6264 _tmp14_ = m;
6265 _tmp15_ = vala_symbol_get_name ((ValaSymbol*) _tmp14_);
6266 _tmp16_ = _tmp15_;
6267 if (g_strcmp0 (_tmp16_, ".new") == 0) {
6268 ValaClass* _tmp17_;
6269 gchar* _tmp18_;
6270 gchar* _tmp19_;
6271 const gchar* _tmp20_;
6272 gchar* _tmp21_;
6273 gchar* _tmp22_;
6274 _tmp17_ = parent;
6275 _tmp18_ = vala_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp17_);
6276 _tmp19_ = _tmp18_;
6277 _tmp20_ = infix;
6278 _tmp21_ = g_strdup_printf ("%s%s", _tmp19_, _tmp20_);
6279 _tmp22_ = _tmp21_;
6280 _g_free0 (_tmp19_);
6281 result = _tmp22_;
6282 _g_free0 (infix);
6283 return result;
6284 } else {
6285 ValaClass* _tmp23_;
6286 gchar* _tmp24_;
6287 gchar* _tmp25_;
6288 const gchar* _tmp26_;
6289 ValaCreationMethod* _tmp27_;
6290 const gchar* _tmp28_;
6291 const gchar* _tmp29_;
6292 gchar* _tmp30_;
6293 gchar* _tmp31_;
6294 _tmp23_ = parent;
6295 _tmp24_ = vala_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp23_);
6296 _tmp25_ = _tmp24_;
6297 _tmp26_ = infix;
6298 _tmp27_ = m;
6299 _tmp28_ = vala_symbol_get_name ((ValaSymbol*) _tmp27_);
6300 _tmp29_ = _tmp28_;
6301 _tmp30_ = g_strdup_printf ("%s%s_%s", _tmp25_, _tmp26_, _tmp29_);
6302 _tmp31_ = _tmp30_;
6303 _g_free0 (_tmp25_);
6304 result = _tmp31_;
6305 _g_free0 (infix);
6306 return result;
6307 }
6308 _g_free0 (infix);
6309 } else {
6310 ValaSymbol* _tmp32_;
6311 _tmp32_ = self->priv->sym;
6312 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp32_, VALA_TYPE_METHOD)) {
6313 ValaMethod* m = NULL;
6314 ValaSymbol* _tmp33_;
6315 gboolean _tmp34_ = FALSE;
6316 ValaMethod* _tmp35_;
6317 ValaMethod* _tmp36_;
6318 ValaMethod* _tmp37_;
6319 _tmp33_ = self->priv->sym;
6320 m = G_TYPE_CHECK_INSTANCE_CAST (_tmp33_, VALA_TYPE_METHOD, ValaMethod);
6321 _tmp35_ = m;
6322 _tmp36_ = vala_method_get_base_method (_tmp35_);
6323 _tmp37_ = _tmp36_;
6324 if (_tmp37_ != NULL) {
6325 _tmp34_ = TRUE;
6326 } else {
6327 ValaMethod* _tmp38_;
6328 ValaMethod* _tmp39_;
6329 ValaMethod* _tmp40_;
6330 _tmp38_ = m;
6331 _tmp39_ = vala_method_get_base_interface_method (_tmp38_);
6332 _tmp40_ = _tmp39_;
6333 _tmp34_ = _tmp40_ != NULL;
6334 }
6335 if (_tmp34_) {
6336 gchar* m_name = NULL;
6337 ValaMethod* _tmp41_;
6338 ValaSignal* _tmp42_;
6339 ValaSignal* _tmp43_;
6340 ValaMethod* _tmp52_;
6341 ValaDataType* _tmp53_;
6342 ValaDataType* _tmp54_;
6343 _tmp41_ = m;
6344 _tmp42_ = vala_method_get_signal_reference (_tmp41_);
6345 _tmp43_ = _tmp42_;
6346 if (_tmp43_ != NULL) {
6347 ValaMethod* _tmp44_;
6348 ValaSignal* _tmp45_;
6349 ValaSignal* _tmp46_;
6350 gchar* _tmp47_;
6351 _tmp44_ = m;
6352 _tmp45_ = vala_method_get_signal_reference (_tmp44_);
6353 _tmp46_ = _tmp45_;
6354 _tmp47_ = vala_get_ccode_lower_case_name ((ValaCodeNode*) _tmp46_, NULL);
6355 _g_free0 (m_name);
6356 m_name = _tmp47_;
6357 } else {
6358 ValaMethod* _tmp48_;
6359 const gchar* _tmp49_;
6360 const gchar* _tmp50_;
6361 gchar* _tmp51_;
6362 _tmp48_ = m;
6363 _tmp49_ = vala_symbol_get_name ((ValaSymbol*) _tmp48_);
6364 _tmp50_ = _tmp49_;
6365 _tmp51_ = g_strdup (_tmp50_);
6366 _g_free0 (m_name);
6367 m_name = _tmp51_;
6368 }
6369 _tmp52_ = m;
6370 _tmp53_ = vala_method_get_base_interface_type (_tmp52_);
6371 _tmp54_ = _tmp53_;
6372 if (_tmp54_ != NULL) {
6373 ValaMethod* _tmp55_;
6374 ValaSymbol* _tmp56_;
6375 ValaSymbol* _tmp57_;
6376 gchar* _tmp58_;
6377 gchar* _tmp59_;
6378 ValaMethod* _tmp60_;
6379 ValaDataType* _tmp61_;
6380 ValaDataType* _tmp62_;
6381 ValaTypeSymbol* _tmp63_;
6382 ValaTypeSymbol* _tmp64_;
6383 gchar* _tmp65_;
6384 gchar* _tmp66_;
6385 const gchar* _tmp67_;
6386 gchar* _tmp68_;
6387 gchar* _tmp69_;
6388 _tmp55_ = m;
6389 _tmp56_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp55_);
6390 _tmp57_ = _tmp56_;
6391 _tmp58_ = vala_get_ccode_lower_case_prefix (_tmp57_);
6392 _tmp59_ = _tmp58_;
6393 _tmp60_ = m;
6394 _tmp61_ = vala_method_get_base_interface_type (_tmp60_);
6395 _tmp62_ = _tmp61_;
6396 _tmp63_ = vala_data_type_get_type_symbol (_tmp62_);
6397 _tmp64_ = _tmp63_;
6398 _tmp65_ = vala_get_ccode_lower_case_prefix ((ValaSymbol*) _tmp64_);
6399 _tmp66_ = _tmp65_;
6400 _tmp67_ = m_name;
6401 _tmp68_ = g_strdup_printf ("%sreal_%s%s", _tmp59_, _tmp66_, _tmp67_);
6402 _tmp69_ = _tmp68_;
6403 _g_free0 (_tmp66_);
6404 _g_free0 (_tmp59_);
6405 result = _tmp69_;
6406 _g_free0 (m_name);
6407 return result;
6408 } else {
6409 ValaMethod* _tmp70_;
6410 ValaSymbol* _tmp71_;
6411 ValaSymbol* _tmp72_;
6412 gchar* _tmp73_;
6413 gchar* _tmp74_;
6414 const gchar* _tmp75_;
6415 gchar* _tmp76_;
6416 gchar* _tmp77_;
6417 _tmp70_ = m;
6418 _tmp71_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp70_);
6419 _tmp72_ = _tmp71_;
6420 _tmp73_ = vala_get_ccode_lower_case_prefix (_tmp72_);
6421 _tmp74_ = _tmp73_;
6422 _tmp75_ = m_name;
6423 _tmp76_ = g_strdup_printf ("%sreal_%s", _tmp74_, _tmp75_);
6424 _tmp77_ = _tmp76_;
6425 _g_free0 (_tmp74_);
6426 result = _tmp77_;
6427 _g_free0 (m_name);
6428 return result;
6429 }
6430 _g_free0 (m_name);
6431 } else {
6432 const gchar* _tmp78_;
6433 const gchar* _tmp79_;
6434 gchar* _tmp80_;
6435 _tmp78_ = vala_ccode_attribute_get_name (self);
6436 _tmp79_ = _tmp78_;
6437 _tmp80_ = g_strdup (_tmp79_);
6438 result = _tmp80_;
6439 return result;
6440 }
6441 } else {
6442 ValaSymbol* _tmp81_;
6443 _tmp81_ = self->priv->sym;
6444 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp81_, VALA_TYPE_PROPERTY_ACCESSOR)) {
6445 ValaPropertyAccessor* acc = NULL;
6446 ValaSymbol* _tmp82_;
6447 ValaProperty* prop = NULL;
6448 ValaPropertyAccessor* _tmp83_;
6449 ValaProperty* _tmp84_;
6450 ValaProperty* _tmp85_;
6451 gboolean _tmp86_ = FALSE;
6452 ValaProperty* _tmp87_;
6453 ValaProperty* _tmp88_;
6454 ValaProperty* _tmp89_;
6455 _tmp82_ = self->priv->sym;
6456 acc = G_TYPE_CHECK_INSTANCE_CAST (_tmp82_, VALA_TYPE_PROPERTY_ACCESSOR, ValaPropertyAccessor);
6457 _tmp83_ = acc;
6458 _tmp84_ = vala_property_accessor_get_prop (_tmp83_);
6459 _tmp85_ = _tmp84_;
6460 prop = G_TYPE_CHECK_INSTANCE_CAST (_tmp85_, VALA_TYPE_PROPERTY, ValaProperty);
6461 _tmp87_ = prop;
6462 _tmp88_ = vala_property_get_base_property (_tmp87_);
6463 _tmp89_ = _tmp88_;
6464 if (_tmp89_ != NULL) {
6465 _tmp86_ = TRUE;
6466 } else {
6467 ValaProperty* _tmp90_;
6468 ValaProperty* _tmp91_;
6469 ValaProperty* _tmp92_;
6470 _tmp90_ = prop;
6471 _tmp91_ = vala_property_get_base_interface_property (_tmp90_);
6472 _tmp92_ = _tmp91_;
6473 _tmp86_ = _tmp92_ != NULL;
6474 }
6475 if (_tmp86_) {
6476 ValaPropertyAccessor* _tmp93_;
6477 gboolean _tmp94_;
6478 gboolean _tmp95_;
6479 _tmp93_ = acc;
6480 _tmp94_ = vala_property_accessor_get_readable (_tmp93_);
6481 _tmp95_ = _tmp94_;
6482 if (_tmp95_) {
6483 ValaProperty* _tmp96_;
6484 ValaSymbol* _tmp97_;
6485 ValaSymbol* _tmp98_;
6486 gchar* _tmp99_;
6487 gchar* _tmp100_;
6488 ValaProperty* _tmp101_;
6489 const gchar* _tmp102_;
6490 const gchar* _tmp103_;
6491 gchar* _tmp104_;
6492 gchar* _tmp105_;
6493 _tmp96_ = prop;
6494 _tmp97_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp96_);
6495 _tmp98_ = _tmp97_;
6496 _tmp99_ = vala_get_ccode_lower_case_prefix (_tmp98_);
6497 _tmp100_ = _tmp99_;
6498 _tmp101_ = prop;
6499 _tmp102_ = vala_symbol_get_name ((ValaSymbol*) _tmp101_);
6500 _tmp103_ = _tmp102_;
6501 _tmp104_ = g_strdup_printf ("%sreal_get_%s", _tmp100_, _tmp103_);
6502 _tmp105_ = _tmp104_;
6503 _g_free0 (_tmp100_);
6504 result = _tmp105_;
6505 return result;
6506 } else {
6507 ValaProperty* _tmp106_;
6508 ValaSymbol* _tmp107_;
6509 ValaSymbol* _tmp108_;
6510 gchar* _tmp109_;
6511 gchar* _tmp110_;
6512 ValaProperty* _tmp111_;
6513 const gchar* _tmp112_;
6514 const gchar* _tmp113_;
6515 gchar* _tmp114_;
6516 gchar* _tmp115_;
6517 _tmp106_ = prop;
6518 _tmp107_ = vala_symbol_get_parent_symbol ((ValaSymbol*) _tmp106_);
6519 _tmp108_ = _tmp107_;
6520 _tmp109_ = vala_get_ccode_lower_case_prefix (_tmp108_);
6521 _tmp110_ = _tmp109_;
6522 _tmp111_ = prop;
6523 _tmp112_ = vala_symbol_get_name ((ValaSymbol*) _tmp111_);
6524 _tmp113_ = _tmp112_;
6525 _tmp114_ = g_strdup_printf ("%sreal_set_%s", _tmp110_, _tmp113_);
6526 _tmp115_ = _tmp114_;
6527 _g_free0 (_tmp110_);
6528 result = _tmp115_;
6529 return result;
6530 }
6531 } else {
6532 const gchar* _tmp116_;
6533 const gchar* _tmp117_;
6534 gchar* _tmp118_;
6535 _tmp116_ = vala_ccode_attribute_get_name (self);
6536 _tmp117_ = _tmp116_;
6537 _tmp118_ = g_strdup (_tmp117_);
6538 result = _tmp118_;
6539 return result;
6540 }
6541 }
6542 }
6543 }
6544 g_assert_not_reached ();
6545 }
6546
6547 static gchar*
vala_ccode_attribute_get_default_const_name(ValaCCodeAttribute * self)6548 vala_ccode_attribute_get_default_const_name (ValaCCodeAttribute* self)
6549 {
6550 ValaCodeNode* _tmp0_;
6551 gchar* result = NULL;
6552 g_return_val_if_fail (self != NULL, NULL);
6553 _tmp0_ = self->priv->node;
6554 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_DATA_TYPE)) {
6555 ValaDataType* type = NULL;
6556 ValaCodeNode* _tmp1_;
6557 gchar* ptr = NULL;
6558 ValaTypeSymbol* t = NULL;
6559 ValaDataType* _tmp2_;
6560 ValaTypeSymbol* _tmp13_;
6561 ValaTypeSymbol* _tmp16_;
6562 gchar* _tmp17_;
6563 gchar* _tmp18_;
6564 const gchar* _tmp19_;
6565 gchar* _tmp20_;
6566 gchar* _tmp21_;
6567 _tmp1_ = self->priv->node;
6568 type = G_TYPE_CHECK_INSTANCE_CAST (_tmp1_, VALA_TYPE_DATA_TYPE, ValaDataType);
6569 _tmp2_ = type;
6570 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2_, VALA_TYPE_ARRAY_TYPE)) {
6571 ValaDataType* _tmp3_;
6572 ValaDataType* _tmp4_;
6573 ValaDataType* _tmp5_;
6574 ValaTypeSymbol* _tmp6_;
6575 ValaTypeSymbol* _tmp7_;
6576 ValaTypeSymbol* _tmp8_;
6577 _tmp3_ = type;
6578 _tmp4_ = vala_array_type_get_element_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp3_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
6579 _tmp5_ = _tmp4_;
6580 _tmp6_ = vala_data_type_get_type_symbol (_tmp5_);
6581 _tmp7_ = _tmp6_;
6582 _tmp8_ = _vala_code_node_ref0 (_tmp7_);
6583 _vala_code_node_unref0 (t);
6584 t = _tmp8_;
6585 } else {
6586 ValaDataType* _tmp9_;
6587 ValaTypeSymbol* _tmp10_;
6588 ValaTypeSymbol* _tmp11_;
6589 ValaTypeSymbol* _tmp12_;
6590 _tmp9_ = type;
6591 _tmp10_ = vala_data_type_get_type_symbol (_tmp9_);
6592 _tmp11_ = _tmp10_;
6593 _tmp12_ = _vala_code_node_ref0 (_tmp11_);
6594 _vala_code_node_unref0 (t);
6595 t = _tmp12_;
6596 }
6597 _tmp13_ = t;
6598 if (!vala_typesymbol_is_reference_type (_tmp13_)) {
6599 gchar* _tmp14_;
6600 _tmp14_ = g_strdup ("");
6601 _g_free0 (ptr);
6602 ptr = _tmp14_;
6603 } else {
6604 gchar* _tmp15_;
6605 _tmp15_ = g_strdup ("*");
6606 _g_free0 (ptr);
6607 ptr = _tmp15_;
6608 }
6609 _tmp16_ = t;
6610 _tmp17_ = vala_get_ccode_name ((ValaCodeNode*) _tmp16_);
6611 _tmp18_ = _tmp17_;
6612 _tmp19_ = ptr;
6613 _tmp20_ = g_strdup_printf ("const %s%s", _tmp18_, _tmp19_);
6614 _tmp21_ = _tmp20_;
6615 _g_free0 (_tmp18_);
6616 result = _tmp21_;
6617 _vala_code_node_unref0 (t);
6618 _g_free0 (ptr);
6619 return result;
6620 } else {
6621 gboolean _tmp22_ = FALSE;
6622 ValaCodeNode* _tmp23_;
6623 _tmp23_ = self->priv->node;
6624 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp23_, VALA_TYPE_CLASS)) {
6625 ValaCodeNode* _tmp24_;
6626 gboolean _tmp25_;
6627 gboolean _tmp26_;
6628 _tmp24_ = self->priv->node;
6629 _tmp25_ = vala_class_get_is_immutable (G_TYPE_CHECK_INSTANCE_CAST (_tmp24_, VALA_TYPE_CLASS, ValaClass));
6630 _tmp26_ = _tmp25_;
6631 _tmp22_ = _tmp26_;
6632 } else {
6633 _tmp22_ = FALSE;
6634 }
6635 if (_tmp22_) {
6636 const gchar* _tmp27_;
6637 const gchar* _tmp28_;
6638 gchar* _tmp29_;
6639 _tmp27_ = vala_ccode_attribute_get_name (self);
6640 _tmp28_ = _tmp27_;
6641 _tmp29_ = g_strdup_printf ("const %s", _tmp28_);
6642 result = _tmp29_;
6643 return result;
6644 } else {
6645 const gchar* _tmp30_;
6646 const gchar* _tmp31_;
6647 gchar* _tmp32_;
6648 _tmp30_ = vala_ccode_attribute_get_name (self);
6649 _tmp31_ = _tmp30_;
6650 _tmp32_ = g_strdup (_tmp31_);
6651 result = _tmp32_;
6652 return result;
6653 }
6654 }
6655 }
6656
6657 static gboolean
vala_ccode_attribute_get_default_delegate_target(ValaCCodeAttribute * self)6658 vala_ccode_attribute_get_default_delegate_target (ValaCCodeAttribute* self)
6659 {
6660 gboolean _tmp0_ = FALSE;
6661 gboolean _tmp1_ = FALSE;
6662 ValaCodeNode* _tmp2_;
6663 gboolean result = FALSE;
6664 g_return_val_if_fail (self != NULL, FALSE);
6665 _tmp2_ = self->priv->node;
6666 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp2_, VALA_TYPE_FIELD)) {
6667 _tmp1_ = TRUE;
6668 } else {
6669 ValaCodeNode* _tmp3_;
6670 _tmp3_ = self->priv->node;
6671 _tmp1_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp3_, VALA_TYPE_PARAMETER);
6672 }
6673 if (_tmp1_) {
6674 _tmp0_ = TRUE;
6675 } else {
6676 ValaCodeNode* _tmp4_;
6677 _tmp4_ = self->priv->node;
6678 _tmp0_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp4_, VALA_TYPE_LOCAL_VARIABLE);
6679 }
6680 if (_tmp0_) {
6681 ValaCodeNode* _tmp5_;
6682 ValaDelegateType* delegate_type = NULL;
6683 ValaCodeNode* _tmp13_;
6684 ValaDataType* _tmp14_;
6685 ValaDataType* _tmp15_;
6686 gboolean _tmp16_ = FALSE;
6687 ValaDelegateType* _tmp17_;
6688 _tmp5_ = self->priv->node;
6689 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp5_, VALA_TYPE_PARAMETER)) {
6690 ValaParameter* param = NULL;
6691 ValaCodeNode* _tmp6_;
6692 ValaParameter* _tmp7_;
6693 ValaParameter* _tmp8_;
6694 ValaParameter* _tmp9_;
6695 _tmp6_ = self->priv->node;
6696 param = G_TYPE_CHECK_INSTANCE_CAST (_tmp6_, VALA_TYPE_PARAMETER, ValaParameter);
6697 _tmp7_ = param;
6698 _tmp8_ = vala_parameter_get_base_parameter (_tmp7_);
6699 _tmp9_ = _tmp8_;
6700 if (_tmp9_ != NULL) {
6701 ValaParameter* _tmp10_;
6702 ValaParameter* _tmp11_;
6703 ValaParameter* _tmp12_;
6704 _tmp10_ = param;
6705 _tmp11_ = vala_parameter_get_base_parameter (_tmp10_);
6706 _tmp12_ = _tmp11_;
6707 result = vala_get_ccode_delegate_target ((ValaCodeNode*) _tmp12_);
6708 return result;
6709 }
6710 }
6711 _tmp13_ = self->priv->node;
6712 _tmp14_ = vala_variable_get_variable_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp13_, VALA_TYPE_VARIABLE, ValaVariable));
6713 _tmp15_ = _tmp14_;
6714 delegate_type = G_TYPE_CHECK_INSTANCE_TYPE (_tmp15_, VALA_TYPE_DELEGATE_TYPE) ? ((ValaDelegateType*) _tmp15_) : NULL;
6715 _tmp17_ = delegate_type;
6716 if (_tmp17_ != NULL) {
6717 ValaDelegateType* _tmp18_;
6718 ValaDelegate* _tmp19_;
6719 ValaDelegate* _tmp20_;
6720 gboolean _tmp21_;
6721 gboolean _tmp22_;
6722 _tmp18_ = delegate_type;
6723 _tmp19_ = vala_delegate_type_get_delegate_symbol (_tmp18_);
6724 _tmp20_ = _tmp19_;
6725 _tmp21_ = vala_delegate_get_has_target (_tmp20_);
6726 _tmp22_ = _tmp21_;
6727 _tmp16_ = _tmp22_;
6728 } else {
6729 _tmp16_ = FALSE;
6730 }
6731 result = _tmp16_;
6732 return result;
6733 } else {
6734 ValaCodeNode* _tmp23_;
6735 _tmp23_ = self->priv->node;
6736 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp23_, VALA_TYPE_CALLABLE)) {
6737 ValaCodeNode* _tmp24_;
6738 ValaDelegateType* delegate_type = NULL;
6739 ValaCodeNode* _tmp48_;
6740 ValaDataType* _tmp49_;
6741 ValaDataType* _tmp50_;
6742 gboolean _tmp51_ = FALSE;
6743 ValaDelegateType* _tmp52_;
6744 _tmp24_ = self->priv->node;
6745 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp24_, VALA_TYPE_METHOD)) {
6746 ValaMethod* method = NULL;
6747 ValaCodeNode* _tmp25_;
6748 gboolean _tmp26_ = FALSE;
6749 ValaMethod* _tmp27_;
6750 ValaMethod* _tmp28_;
6751 ValaMethod* _tmp29_;
6752 _tmp25_ = self->priv->node;
6753 method = G_TYPE_CHECK_INSTANCE_CAST (_tmp25_, VALA_TYPE_METHOD, ValaMethod);
6754 _tmp27_ = method;
6755 _tmp28_ = vala_method_get_base_method (_tmp27_);
6756 _tmp29_ = _tmp28_;
6757 if (_tmp29_ != NULL) {
6758 ValaMethod* _tmp30_;
6759 ValaMethod* _tmp31_;
6760 ValaMethod* _tmp32_;
6761 ValaMethod* _tmp33_;
6762 _tmp30_ = method;
6763 _tmp31_ = vala_method_get_base_method (_tmp30_);
6764 _tmp32_ = _tmp31_;
6765 _tmp33_ = method;
6766 _tmp26_ = _tmp32_ != _tmp33_;
6767 } else {
6768 _tmp26_ = FALSE;
6769 }
6770 if (_tmp26_) {
6771 ValaMethod* _tmp34_;
6772 ValaMethod* _tmp35_;
6773 ValaMethod* _tmp36_;
6774 _tmp34_ = method;
6775 _tmp35_ = vala_method_get_base_method (_tmp34_);
6776 _tmp36_ = _tmp35_;
6777 result = vala_get_ccode_delegate_target ((ValaCodeNode*) _tmp36_);
6778 return result;
6779 } else {
6780 gboolean _tmp37_ = FALSE;
6781 ValaMethod* _tmp38_;
6782 ValaMethod* _tmp39_;
6783 ValaMethod* _tmp40_;
6784 _tmp38_ = method;
6785 _tmp39_ = vala_method_get_base_interface_method (_tmp38_);
6786 _tmp40_ = _tmp39_;
6787 if (_tmp40_ != NULL) {
6788 ValaMethod* _tmp41_;
6789 ValaMethod* _tmp42_;
6790 ValaMethod* _tmp43_;
6791 ValaMethod* _tmp44_;
6792 _tmp41_ = method;
6793 _tmp42_ = vala_method_get_base_interface_method (_tmp41_);
6794 _tmp43_ = _tmp42_;
6795 _tmp44_ = method;
6796 _tmp37_ = _tmp43_ != _tmp44_;
6797 } else {
6798 _tmp37_ = FALSE;
6799 }
6800 if (_tmp37_) {
6801 ValaMethod* _tmp45_;
6802 ValaMethod* _tmp46_;
6803 ValaMethod* _tmp47_;
6804 _tmp45_ = method;
6805 _tmp46_ = vala_method_get_base_interface_method (_tmp45_);
6806 _tmp47_ = _tmp46_;
6807 result = vala_get_ccode_delegate_target ((ValaCodeNode*) _tmp47_);
6808 return result;
6809 }
6810 }
6811 }
6812 _tmp48_ = self->priv->node;
6813 _tmp49_ = vala_callable_get_return_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp48_, VALA_TYPE_CALLABLE, ValaCallable));
6814 _tmp50_ = _tmp49_;
6815 delegate_type = G_TYPE_CHECK_INSTANCE_TYPE (_tmp50_, VALA_TYPE_DELEGATE_TYPE) ? ((ValaDelegateType*) _tmp50_) : NULL;
6816 _tmp52_ = delegate_type;
6817 if (_tmp52_ != NULL) {
6818 ValaDelegateType* _tmp53_;
6819 ValaDelegate* _tmp54_;
6820 ValaDelegate* _tmp55_;
6821 gboolean _tmp56_;
6822 gboolean _tmp57_;
6823 _tmp53_ = delegate_type;
6824 _tmp54_ = vala_delegate_type_get_delegate_symbol (_tmp53_);
6825 _tmp55_ = _tmp54_;
6826 _tmp56_ = vala_delegate_get_has_target (_tmp55_);
6827 _tmp57_ = _tmp56_;
6828 _tmp51_ = _tmp57_;
6829 } else {
6830 _tmp51_ = FALSE;
6831 }
6832 result = _tmp51_;
6833 return result;
6834 } else {
6835 ValaCodeNode* _tmp58_;
6836 _tmp58_ = self->priv->node;
6837 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp58_, VALA_TYPE_PROPERTY)) {
6838 ValaProperty* prop = NULL;
6839 ValaCodeNode* _tmp59_;
6840 gboolean _tmp60_ = FALSE;
6841 ValaProperty* _tmp61_;
6842 ValaProperty* _tmp62_;
6843 ValaProperty* _tmp63_;
6844 ValaDelegateType* delegate_type = NULL;
6845 ValaProperty* _tmp82_;
6846 ValaDataType* _tmp83_;
6847 ValaDataType* _tmp84_;
6848 gboolean _tmp85_ = FALSE;
6849 ValaDelegateType* _tmp86_;
6850 _tmp59_ = self->priv->node;
6851 prop = G_TYPE_CHECK_INSTANCE_CAST (_tmp59_, VALA_TYPE_PROPERTY, ValaProperty);
6852 _tmp61_ = prop;
6853 _tmp62_ = vala_property_get_base_property (_tmp61_);
6854 _tmp63_ = _tmp62_;
6855 if (_tmp63_ != NULL) {
6856 ValaProperty* _tmp64_;
6857 ValaProperty* _tmp65_;
6858 ValaProperty* _tmp66_;
6859 ValaProperty* _tmp67_;
6860 _tmp64_ = prop;
6861 _tmp65_ = vala_property_get_base_property (_tmp64_);
6862 _tmp66_ = _tmp65_;
6863 _tmp67_ = prop;
6864 _tmp60_ = _tmp66_ != _tmp67_;
6865 } else {
6866 _tmp60_ = FALSE;
6867 }
6868 if (_tmp60_) {
6869 ValaProperty* _tmp68_;
6870 ValaProperty* _tmp69_;
6871 ValaProperty* _tmp70_;
6872 _tmp68_ = prop;
6873 _tmp69_ = vala_property_get_base_property (_tmp68_);
6874 _tmp70_ = _tmp69_;
6875 result = vala_get_ccode_delegate_target ((ValaCodeNode*) _tmp70_);
6876 return result;
6877 } else {
6878 gboolean _tmp71_ = FALSE;
6879 ValaProperty* _tmp72_;
6880 ValaProperty* _tmp73_;
6881 ValaProperty* _tmp74_;
6882 _tmp72_ = prop;
6883 _tmp73_ = vala_property_get_base_interface_property (_tmp72_);
6884 _tmp74_ = _tmp73_;
6885 if (_tmp74_ != NULL) {
6886 ValaProperty* _tmp75_;
6887 ValaProperty* _tmp76_;
6888 ValaProperty* _tmp77_;
6889 ValaProperty* _tmp78_;
6890 _tmp75_ = prop;
6891 _tmp76_ = vala_property_get_base_interface_property (_tmp75_);
6892 _tmp77_ = _tmp76_;
6893 _tmp78_ = prop;
6894 _tmp71_ = _tmp77_ != _tmp78_;
6895 } else {
6896 _tmp71_ = FALSE;
6897 }
6898 if (_tmp71_) {
6899 ValaProperty* _tmp79_;
6900 ValaProperty* _tmp80_;
6901 ValaProperty* _tmp81_;
6902 _tmp79_ = prop;
6903 _tmp80_ = vala_property_get_base_interface_property (_tmp79_);
6904 _tmp81_ = _tmp80_;
6905 result = vala_get_ccode_delegate_target ((ValaCodeNode*) _tmp81_);
6906 return result;
6907 }
6908 }
6909 _tmp82_ = prop;
6910 _tmp83_ = vala_property_get_property_type (_tmp82_);
6911 _tmp84_ = _tmp83_;
6912 delegate_type = G_TYPE_CHECK_INSTANCE_TYPE (_tmp84_, VALA_TYPE_DELEGATE_TYPE) ? ((ValaDelegateType*) _tmp84_) : NULL;
6913 _tmp86_ = delegate_type;
6914 if (_tmp86_ != NULL) {
6915 ValaDelegateType* _tmp87_;
6916 ValaDelegate* _tmp88_;
6917 ValaDelegate* _tmp89_;
6918 gboolean _tmp90_;
6919 gboolean _tmp91_;
6920 _tmp87_ = delegate_type;
6921 _tmp88_ = vala_delegate_type_get_delegate_symbol (_tmp87_);
6922 _tmp89_ = _tmp88_;
6923 _tmp90_ = vala_delegate_get_has_target (_tmp89_);
6924 _tmp91_ = _tmp90_;
6925 _tmp85_ = _tmp91_;
6926 } else {
6927 _tmp85_ = FALSE;
6928 }
6929 result = _tmp85_;
6930 return result;
6931 } else {
6932 ValaCodeNode* _tmp92_;
6933 _tmp92_ = self->priv->node;
6934 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp92_, VALA_TYPE_PROPERTY_ACCESSOR)) {
6935 ValaCodeNode* _tmp93_;
6936 ValaProperty* _tmp94_;
6937 ValaProperty* _tmp95_;
6938 _tmp93_ = self->priv->node;
6939 _tmp94_ = vala_property_accessor_get_prop (G_TYPE_CHECK_INSTANCE_CAST (_tmp93_, VALA_TYPE_PROPERTY_ACCESSOR, ValaPropertyAccessor));
6940 _tmp95_ = _tmp94_;
6941 result = vala_get_ccode_delegate_target ((ValaCodeNode*) _tmp95_);
6942 return result;
6943 } else {
6944 ValaCodeNode* _tmp96_;
6945 _tmp96_ = self->priv->node;
6946 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp96_, VALA_TYPE_EXPRESSION)) {
6947 ValaSymbol* symbol = NULL;
6948 ValaCodeNode* _tmp97_;
6949 ValaSymbol* _tmp98_;
6950 ValaSymbol* _tmp99_;
6951 ValaSymbol* _tmp100_;
6952 _tmp97_ = self->priv->node;
6953 _tmp98_ = vala_expression_get_symbol_reference (G_TYPE_CHECK_INSTANCE_CAST (_tmp97_, VALA_TYPE_EXPRESSION, ValaExpression));
6954 _tmp99_ = _tmp98_;
6955 symbol = _tmp99_;
6956 _tmp100_ = symbol;
6957 if (_tmp100_ != NULL) {
6958 ValaSymbol* _tmp101_;
6959 _tmp101_ = symbol;
6960 result = vala_get_ccode_delegate_target ((ValaCodeNode*) _tmp101_);
6961 return result;
6962 }
6963 }
6964 }
6965 }
6966 }
6967 }
6968 result = FALSE;
6969 return result;
6970 }
6971
6972 static gboolean
vala_ccode_attribute_get_default_array_length(ValaCCodeAttribute * self)6973 vala_ccode_attribute_get_default_array_length (ValaCCodeAttribute* self)
6974 {
6975 ValaCodeNode* _tmp0_;
6976 gboolean result = FALSE;
6977 g_return_val_if_fail (self != NULL, FALSE);
6978 _tmp0_ = self->priv->node;
6979 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_PARAMETER)) {
6980 ValaParameter* param = NULL;
6981 ValaCodeNode* _tmp1_;
6982 ValaParameter* _tmp2_;
6983 ValaParameter* _tmp3_;
6984 ValaParameter* _tmp4_;
6985 _tmp1_ = self->priv->node;
6986 param = G_TYPE_CHECK_INSTANCE_CAST (_tmp1_, VALA_TYPE_PARAMETER, ValaParameter);
6987 _tmp2_ = param;
6988 _tmp3_ = vala_parameter_get_base_parameter (_tmp2_);
6989 _tmp4_ = _tmp3_;
6990 if (_tmp4_ != NULL) {
6991 ValaParameter* _tmp5_;
6992 ValaParameter* _tmp6_;
6993 ValaParameter* _tmp7_;
6994 _tmp5_ = param;
6995 _tmp6_ = vala_parameter_get_base_parameter (_tmp5_);
6996 _tmp7_ = _tmp6_;
6997 result = vala_get_ccode_array_length ((ValaCodeNode*) _tmp7_);
6998 return result;
6999 }
7000 } else {
7001 ValaCodeNode* _tmp8_;
7002 _tmp8_ = self->priv->node;
7003 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp8_, VALA_TYPE_METHOD)) {
7004 ValaMethod* method = NULL;
7005 ValaCodeNode* _tmp9_;
7006 gboolean _tmp10_ = FALSE;
7007 ValaMethod* _tmp11_;
7008 ValaMethod* _tmp12_;
7009 ValaMethod* _tmp13_;
7010 _tmp9_ = self->priv->node;
7011 method = G_TYPE_CHECK_INSTANCE_CAST (_tmp9_, VALA_TYPE_METHOD, ValaMethod);
7012 _tmp11_ = method;
7013 _tmp12_ = vala_method_get_base_method (_tmp11_);
7014 _tmp13_ = _tmp12_;
7015 if (_tmp13_ != NULL) {
7016 ValaMethod* _tmp14_;
7017 ValaMethod* _tmp15_;
7018 ValaMethod* _tmp16_;
7019 ValaMethod* _tmp17_;
7020 _tmp14_ = method;
7021 _tmp15_ = vala_method_get_base_method (_tmp14_);
7022 _tmp16_ = _tmp15_;
7023 _tmp17_ = method;
7024 _tmp10_ = _tmp16_ != _tmp17_;
7025 } else {
7026 _tmp10_ = FALSE;
7027 }
7028 if (_tmp10_) {
7029 ValaMethod* _tmp18_;
7030 ValaMethod* _tmp19_;
7031 ValaMethod* _tmp20_;
7032 _tmp18_ = method;
7033 _tmp19_ = vala_method_get_base_method (_tmp18_);
7034 _tmp20_ = _tmp19_;
7035 result = vala_get_ccode_array_length ((ValaCodeNode*) _tmp20_);
7036 return result;
7037 } else {
7038 gboolean _tmp21_ = FALSE;
7039 ValaMethod* _tmp22_;
7040 ValaMethod* _tmp23_;
7041 ValaMethod* _tmp24_;
7042 _tmp22_ = method;
7043 _tmp23_ = vala_method_get_base_interface_method (_tmp22_);
7044 _tmp24_ = _tmp23_;
7045 if (_tmp24_ != NULL) {
7046 ValaMethod* _tmp25_;
7047 ValaMethod* _tmp26_;
7048 ValaMethod* _tmp27_;
7049 ValaMethod* _tmp28_;
7050 _tmp25_ = method;
7051 _tmp26_ = vala_method_get_base_interface_method (_tmp25_);
7052 _tmp27_ = _tmp26_;
7053 _tmp28_ = method;
7054 _tmp21_ = _tmp27_ != _tmp28_;
7055 } else {
7056 _tmp21_ = FALSE;
7057 }
7058 if (_tmp21_) {
7059 ValaMethod* _tmp29_;
7060 ValaMethod* _tmp30_;
7061 ValaMethod* _tmp31_;
7062 _tmp29_ = method;
7063 _tmp30_ = vala_method_get_base_interface_method (_tmp29_);
7064 _tmp31_ = _tmp30_;
7065 result = vala_get_ccode_array_length ((ValaCodeNode*) _tmp31_);
7066 return result;
7067 }
7068 }
7069 } else {
7070 ValaCodeNode* _tmp32_;
7071 _tmp32_ = self->priv->node;
7072 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp32_, VALA_TYPE_PROPERTY)) {
7073 ValaProperty* prop = NULL;
7074 ValaCodeNode* _tmp33_;
7075 gboolean _tmp34_ = FALSE;
7076 ValaProperty* _tmp35_;
7077 ValaProperty* _tmp36_;
7078 ValaProperty* _tmp37_;
7079 _tmp33_ = self->priv->node;
7080 prop = G_TYPE_CHECK_INSTANCE_CAST (_tmp33_, VALA_TYPE_PROPERTY, ValaProperty);
7081 _tmp35_ = prop;
7082 _tmp36_ = vala_property_get_base_property (_tmp35_);
7083 _tmp37_ = _tmp36_;
7084 if (_tmp37_ != NULL) {
7085 ValaProperty* _tmp38_;
7086 ValaProperty* _tmp39_;
7087 ValaProperty* _tmp40_;
7088 ValaProperty* _tmp41_;
7089 _tmp38_ = prop;
7090 _tmp39_ = vala_property_get_base_property (_tmp38_);
7091 _tmp40_ = _tmp39_;
7092 _tmp41_ = prop;
7093 _tmp34_ = _tmp40_ != _tmp41_;
7094 } else {
7095 _tmp34_ = FALSE;
7096 }
7097 if (_tmp34_) {
7098 ValaProperty* _tmp42_;
7099 ValaProperty* _tmp43_;
7100 ValaProperty* _tmp44_;
7101 _tmp42_ = prop;
7102 _tmp43_ = vala_property_get_base_property (_tmp42_);
7103 _tmp44_ = _tmp43_;
7104 result = vala_get_ccode_array_length ((ValaCodeNode*) _tmp44_);
7105 return result;
7106 } else {
7107 gboolean _tmp45_ = FALSE;
7108 ValaProperty* _tmp46_;
7109 ValaProperty* _tmp47_;
7110 ValaProperty* _tmp48_;
7111 _tmp46_ = prop;
7112 _tmp47_ = vala_property_get_base_interface_property (_tmp46_);
7113 _tmp48_ = _tmp47_;
7114 if (_tmp48_ != NULL) {
7115 ValaProperty* _tmp49_;
7116 ValaProperty* _tmp50_;
7117 ValaProperty* _tmp51_;
7118 ValaProperty* _tmp52_;
7119 _tmp49_ = prop;
7120 _tmp50_ = vala_property_get_base_interface_property (_tmp49_);
7121 _tmp51_ = _tmp50_;
7122 _tmp52_ = prop;
7123 _tmp45_ = _tmp51_ != _tmp52_;
7124 } else {
7125 _tmp45_ = FALSE;
7126 }
7127 if (_tmp45_) {
7128 ValaProperty* _tmp53_;
7129 ValaProperty* _tmp54_;
7130 ValaProperty* _tmp55_;
7131 _tmp53_ = prop;
7132 _tmp54_ = vala_property_get_base_interface_property (_tmp53_);
7133 _tmp55_ = _tmp54_;
7134 result = vala_get_ccode_array_length ((ValaCodeNode*) _tmp55_);
7135 return result;
7136 }
7137 }
7138 } else {
7139 ValaCodeNode* _tmp56_;
7140 _tmp56_ = self->priv->node;
7141 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp56_, VALA_TYPE_PROPERTY_ACCESSOR)) {
7142 ValaCodeNode* _tmp57_;
7143 ValaProperty* _tmp58_;
7144 ValaProperty* _tmp59_;
7145 _tmp57_ = self->priv->node;
7146 _tmp58_ = vala_property_accessor_get_prop (G_TYPE_CHECK_INSTANCE_CAST (_tmp57_, VALA_TYPE_PROPERTY_ACCESSOR, ValaPropertyAccessor));
7147 _tmp59_ = _tmp58_;
7148 result = vala_get_ccode_array_length ((ValaCodeNode*) _tmp59_);
7149 return result;
7150 }
7151 }
7152 }
7153 }
7154 result = TRUE;
7155 return result;
7156 }
7157
7158 static gboolean
vala_ccode_attribute_get_default_array_null_terminated(ValaCCodeAttribute * self)7159 vala_ccode_attribute_get_default_array_null_terminated (ValaCCodeAttribute* self)
7160 {
7161 ValaCodeNode* _tmp0_;
7162 gboolean result = FALSE;
7163 g_return_val_if_fail (self != NULL, FALSE);
7164 _tmp0_ = self->priv->node;
7165 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp0_, VALA_TYPE_PARAMETER)) {
7166 ValaParameter* param = NULL;
7167 ValaCodeNode* _tmp1_;
7168 ValaParameter* _tmp2_;
7169 ValaParameter* _tmp3_;
7170 ValaParameter* _tmp4_;
7171 _tmp1_ = self->priv->node;
7172 param = G_TYPE_CHECK_INSTANCE_CAST (_tmp1_, VALA_TYPE_PARAMETER, ValaParameter);
7173 _tmp2_ = param;
7174 _tmp3_ = vala_parameter_get_base_parameter (_tmp2_);
7175 _tmp4_ = _tmp3_;
7176 if (_tmp4_ != NULL) {
7177 ValaParameter* _tmp5_;
7178 ValaParameter* _tmp6_;
7179 ValaParameter* _tmp7_;
7180 _tmp5_ = param;
7181 _tmp6_ = vala_parameter_get_base_parameter (_tmp5_);
7182 _tmp7_ = _tmp6_;
7183 result = vala_get_ccode_array_null_terminated ((ValaCodeNode*) _tmp7_);
7184 return result;
7185 }
7186 } else {
7187 ValaCodeNode* _tmp8_;
7188 _tmp8_ = self->priv->node;
7189 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp8_, VALA_TYPE_METHOD)) {
7190 ValaMethod* method = NULL;
7191 ValaCodeNode* _tmp9_;
7192 gboolean _tmp10_ = FALSE;
7193 ValaMethod* _tmp11_;
7194 ValaMethod* _tmp12_;
7195 ValaMethod* _tmp13_;
7196 _tmp9_ = self->priv->node;
7197 method = G_TYPE_CHECK_INSTANCE_CAST (_tmp9_, VALA_TYPE_METHOD, ValaMethod);
7198 _tmp11_ = method;
7199 _tmp12_ = vala_method_get_base_method (_tmp11_);
7200 _tmp13_ = _tmp12_;
7201 if (_tmp13_ != NULL) {
7202 ValaMethod* _tmp14_;
7203 ValaMethod* _tmp15_;
7204 ValaMethod* _tmp16_;
7205 ValaMethod* _tmp17_;
7206 _tmp14_ = method;
7207 _tmp15_ = vala_method_get_base_method (_tmp14_);
7208 _tmp16_ = _tmp15_;
7209 _tmp17_ = method;
7210 _tmp10_ = _tmp16_ != _tmp17_;
7211 } else {
7212 _tmp10_ = FALSE;
7213 }
7214 if (_tmp10_) {
7215 ValaMethod* _tmp18_;
7216 ValaMethod* _tmp19_;
7217 ValaMethod* _tmp20_;
7218 _tmp18_ = method;
7219 _tmp19_ = vala_method_get_base_method (_tmp18_);
7220 _tmp20_ = _tmp19_;
7221 result = vala_get_ccode_array_null_terminated ((ValaCodeNode*) _tmp20_);
7222 return result;
7223 } else {
7224 gboolean _tmp21_ = FALSE;
7225 ValaMethod* _tmp22_;
7226 ValaMethod* _tmp23_;
7227 ValaMethod* _tmp24_;
7228 _tmp22_ = method;
7229 _tmp23_ = vala_method_get_base_interface_method (_tmp22_);
7230 _tmp24_ = _tmp23_;
7231 if (_tmp24_ != NULL) {
7232 ValaMethod* _tmp25_;
7233 ValaMethod* _tmp26_;
7234 ValaMethod* _tmp27_;
7235 ValaMethod* _tmp28_;
7236 _tmp25_ = method;
7237 _tmp26_ = vala_method_get_base_interface_method (_tmp25_);
7238 _tmp27_ = _tmp26_;
7239 _tmp28_ = method;
7240 _tmp21_ = _tmp27_ != _tmp28_;
7241 } else {
7242 _tmp21_ = FALSE;
7243 }
7244 if (_tmp21_) {
7245 ValaMethod* _tmp29_;
7246 ValaMethod* _tmp30_;
7247 ValaMethod* _tmp31_;
7248 _tmp29_ = method;
7249 _tmp30_ = vala_method_get_base_interface_method (_tmp29_);
7250 _tmp31_ = _tmp30_;
7251 result = vala_get_ccode_array_null_terminated ((ValaCodeNode*) _tmp31_);
7252 return result;
7253 }
7254 }
7255 } else {
7256 ValaCodeNode* _tmp32_;
7257 _tmp32_ = self->priv->node;
7258 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp32_, VALA_TYPE_PROPERTY)) {
7259 ValaProperty* prop = NULL;
7260 ValaCodeNode* _tmp33_;
7261 gboolean _tmp34_ = FALSE;
7262 ValaProperty* _tmp35_;
7263 ValaProperty* _tmp36_;
7264 ValaProperty* _tmp37_;
7265 _tmp33_ = self->priv->node;
7266 prop = G_TYPE_CHECK_INSTANCE_CAST (_tmp33_, VALA_TYPE_PROPERTY, ValaProperty);
7267 _tmp35_ = prop;
7268 _tmp36_ = vala_property_get_base_property (_tmp35_);
7269 _tmp37_ = _tmp36_;
7270 if (_tmp37_ != NULL) {
7271 ValaProperty* _tmp38_;
7272 ValaProperty* _tmp39_;
7273 ValaProperty* _tmp40_;
7274 ValaProperty* _tmp41_;
7275 _tmp38_ = prop;
7276 _tmp39_ = vala_property_get_base_property (_tmp38_);
7277 _tmp40_ = _tmp39_;
7278 _tmp41_ = prop;
7279 _tmp34_ = _tmp40_ != _tmp41_;
7280 } else {
7281 _tmp34_ = FALSE;
7282 }
7283 if (_tmp34_) {
7284 ValaProperty* _tmp42_;
7285 ValaProperty* _tmp43_;
7286 ValaProperty* _tmp44_;
7287 _tmp42_ = prop;
7288 _tmp43_ = vala_property_get_base_property (_tmp42_);
7289 _tmp44_ = _tmp43_;
7290 result = vala_get_ccode_array_null_terminated ((ValaCodeNode*) _tmp44_);
7291 return result;
7292 } else {
7293 gboolean _tmp45_ = FALSE;
7294 ValaProperty* _tmp46_;
7295 ValaProperty* _tmp47_;
7296 ValaProperty* _tmp48_;
7297 _tmp46_ = prop;
7298 _tmp47_ = vala_property_get_base_interface_property (_tmp46_);
7299 _tmp48_ = _tmp47_;
7300 if (_tmp48_ != NULL) {
7301 ValaProperty* _tmp49_;
7302 ValaProperty* _tmp50_;
7303 ValaProperty* _tmp51_;
7304 ValaProperty* _tmp52_;
7305 _tmp49_ = prop;
7306 _tmp50_ = vala_property_get_base_interface_property (_tmp49_);
7307 _tmp51_ = _tmp50_;
7308 _tmp52_ = prop;
7309 _tmp45_ = _tmp51_ != _tmp52_;
7310 } else {
7311 _tmp45_ = FALSE;
7312 }
7313 if (_tmp45_) {
7314 ValaProperty* _tmp53_;
7315 ValaProperty* _tmp54_;
7316 ValaProperty* _tmp55_;
7317 _tmp53_ = prop;
7318 _tmp54_ = vala_property_get_base_interface_property (_tmp53_);
7319 _tmp55_ = _tmp54_;
7320 result = vala_get_ccode_array_null_terminated ((ValaCodeNode*) _tmp55_);
7321 return result;
7322 }
7323 }
7324 } else {
7325 ValaCodeNode* _tmp56_;
7326 _tmp56_ = self->priv->node;
7327 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp56_, VALA_TYPE_PROPERTY_ACCESSOR)) {
7328 ValaCodeNode* _tmp57_;
7329 ValaProperty* _tmp58_;
7330 ValaProperty* _tmp59_;
7331 _tmp57_ = self->priv->node;
7332 _tmp58_ = vala_property_accessor_get_prop (G_TYPE_CHECK_INSTANCE_CAST (_tmp57_, VALA_TYPE_PROPERTY_ACCESSOR, ValaPropertyAccessor));
7333 _tmp59_ = _tmp58_;
7334 result = vala_get_ccode_array_null_terminated ((ValaCodeNode*) _tmp59_);
7335 return result;
7336 }
7337 }
7338 }
7339 }
7340 result = FALSE;
7341 return result;
7342 }
7343
7344 static gchar*
vala_ccode_attribute_get_default_array_length_type(ValaCCodeAttribute * self)7345 vala_ccode_attribute_get_default_array_length_type (ValaCCodeAttribute* self)
7346 {
7347 gboolean _tmp0_ = FALSE;
7348 ValaCodeNode* _tmp1_;
7349 gchar* result = NULL;
7350 g_return_val_if_fail (self != NULL, NULL);
7351 _tmp1_ = self->priv->node;
7352 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1_, VALA_TYPE_FIELD)) {
7353 _tmp0_ = TRUE;
7354 } else {
7355 ValaCodeNode* _tmp2_;
7356 _tmp2_ = self->priv->node;
7357 _tmp0_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp2_, VALA_TYPE_PARAMETER);
7358 }
7359 if (_tmp0_) {
7360 ValaCodeNode* _tmp3_;
7361 ValaCodeNode* _tmp12_;
7362 ValaDataType* _tmp13_;
7363 ValaDataType* _tmp14_;
7364 gchar* _tmp15_;
7365 _tmp3_ = self->priv->node;
7366 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp3_, VALA_TYPE_PARAMETER)) {
7367 ValaParameter* param = NULL;
7368 ValaCodeNode* _tmp4_;
7369 ValaParameter* _tmp5_;
7370 ValaParameter* _tmp6_;
7371 ValaParameter* _tmp7_;
7372 _tmp4_ = self->priv->node;
7373 param = G_TYPE_CHECK_INSTANCE_CAST (_tmp4_, VALA_TYPE_PARAMETER, ValaParameter);
7374 _tmp5_ = param;
7375 _tmp6_ = vala_parameter_get_base_parameter (_tmp5_);
7376 _tmp7_ = _tmp6_;
7377 if (_tmp7_ != NULL) {
7378 ValaParameter* _tmp8_;
7379 ValaParameter* _tmp9_;
7380 ValaParameter* _tmp10_;
7381 gchar* _tmp11_;
7382 _tmp8_ = param;
7383 _tmp9_ = vala_parameter_get_base_parameter (_tmp8_);
7384 _tmp10_ = _tmp9_;
7385 _tmp11_ = vala_get_ccode_array_length_type ((ValaCodeNode*) _tmp10_);
7386 result = _tmp11_;
7387 return result;
7388 }
7389 }
7390 _tmp12_ = self->priv->node;
7391 _tmp13_ = vala_variable_get_variable_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp12_, VALA_TYPE_VARIABLE, ValaVariable));
7392 _tmp14_ = _tmp13_;
7393 _tmp15_ = vala_get_ccode_array_length_type ((ValaCodeNode*) _tmp14_);
7394 result = _tmp15_;
7395 return result;
7396 } else {
7397 gboolean _tmp16_ = FALSE;
7398 ValaCodeNode* _tmp17_;
7399 _tmp17_ = self->priv->node;
7400 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp17_, VALA_TYPE_METHOD)) {
7401 _tmp16_ = TRUE;
7402 } else {
7403 ValaCodeNode* _tmp18_;
7404 _tmp18_ = self->priv->node;
7405 _tmp16_ = G_TYPE_CHECK_INSTANCE_TYPE (_tmp18_, VALA_TYPE_DELEGATE);
7406 }
7407 if (_tmp16_) {
7408 ValaCodeNode* _tmp19_;
7409 ValaCodeNode* _tmp45_;
7410 ValaDataType* _tmp46_;
7411 ValaDataType* _tmp47_;
7412 gchar* _tmp48_;
7413 _tmp19_ = self->priv->node;
7414 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp19_, VALA_TYPE_METHOD)) {
7415 ValaMethod* method = NULL;
7416 ValaCodeNode* _tmp20_;
7417 gboolean _tmp21_ = FALSE;
7418 ValaMethod* _tmp22_;
7419 ValaMethod* _tmp23_;
7420 ValaMethod* _tmp24_;
7421 _tmp20_ = self->priv->node;
7422 method = G_TYPE_CHECK_INSTANCE_CAST (_tmp20_, VALA_TYPE_METHOD, ValaMethod);
7423 _tmp22_ = method;
7424 _tmp23_ = vala_method_get_base_method (_tmp22_);
7425 _tmp24_ = _tmp23_;
7426 if (_tmp24_ != NULL) {
7427 ValaMethod* _tmp25_;
7428 ValaMethod* _tmp26_;
7429 ValaMethod* _tmp27_;
7430 ValaMethod* _tmp28_;
7431 _tmp25_ = method;
7432 _tmp26_ = vala_method_get_base_method (_tmp25_);
7433 _tmp27_ = _tmp26_;
7434 _tmp28_ = method;
7435 _tmp21_ = _tmp27_ != _tmp28_;
7436 } else {
7437 _tmp21_ = FALSE;
7438 }
7439 if (_tmp21_) {
7440 ValaMethod* _tmp29_;
7441 ValaMethod* _tmp30_;
7442 ValaMethod* _tmp31_;
7443 gchar* _tmp32_;
7444 _tmp29_ = method;
7445 _tmp30_ = vala_method_get_base_method (_tmp29_);
7446 _tmp31_ = _tmp30_;
7447 _tmp32_ = vala_get_ccode_array_length_type ((ValaCodeNode*) _tmp31_);
7448 result = _tmp32_;
7449 return result;
7450 } else {
7451 gboolean _tmp33_ = FALSE;
7452 ValaMethod* _tmp34_;
7453 ValaMethod* _tmp35_;
7454 ValaMethod* _tmp36_;
7455 _tmp34_ = method;
7456 _tmp35_ = vala_method_get_base_interface_method (_tmp34_);
7457 _tmp36_ = _tmp35_;
7458 if (_tmp36_ != NULL) {
7459 ValaMethod* _tmp37_;
7460 ValaMethod* _tmp38_;
7461 ValaMethod* _tmp39_;
7462 ValaMethod* _tmp40_;
7463 _tmp37_ = method;
7464 _tmp38_ = vala_method_get_base_interface_method (_tmp37_);
7465 _tmp39_ = _tmp38_;
7466 _tmp40_ = method;
7467 _tmp33_ = _tmp39_ != _tmp40_;
7468 } else {
7469 _tmp33_ = FALSE;
7470 }
7471 if (_tmp33_) {
7472 ValaMethod* _tmp41_;
7473 ValaMethod* _tmp42_;
7474 ValaMethod* _tmp43_;
7475 gchar* _tmp44_;
7476 _tmp41_ = method;
7477 _tmp42_ = vala_method_get_base_interface_method (_tmp41_);
7478 _tmp43_ = _tmp42_;
7479 _tmp44_ = vala_get_ccode_array_length_type ((ValaCodeNode*) _tmp43_);
7480 result = _tmp44_;
7481 return result;
7482 }
7483 }
7484 }
7485 _tmp45_ = self->priv->node;
7486 _tmp46_ = vala_callable_get_return_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp45_, VALA_TYPE_CALLABLE, ValaCallable));
7487 _tmp47_ = _tmp46_;
7488 _tmp48_ = vala_get_ccode_array_length_type ((ValaCodeNode*) _tmp47_);
7489 result = _tmp48_;
7490 return result;
7491 } else {
7492 ValaCodeNode* _tmp49_;
7493 _tmp49_ = self->priv->node;
7494 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp49_, VALA_TYPE_PROPERTY)) {
7495 ValaProperty* prop = NULL;
7496 ValaCodeNode* _tmp50_;
7497 gboolean _tmp51_ = FALSE;
7498 ValaProperty* _tmp52_;
7499 ValaProperty* _tmp53_;
7500 ValaProperty* _tmp54_;
7501 _tmp50_ = self->priv->node;
7502 prop = G_TYPE_CHECK_INSTANCE_CAST (_tmp50_, VALA_TYPE_PROPERTY, ValaProperty);
7503 _tmp52_ = prop;
7504 _tmp53_ = vala_property_get_base_property (_tmp52_);
7505 _tmp54_ = _tmp53_;
7506 if (_tmp54_ != NULL) {
7507 ValaProperty* _tmp55_;
7508 ValaProperty* _tmp56_;
7509 ValaProperty* _tmp57_;
7510 ValaProperty* _tmp58_;
7511 _tmp55_ = prop;
7512 _tmp56_ = vala_property_get_base_property (_tmp55_);
7513 _tmp57_ = _tmp56_;
7514 _tmp58_ = prop;
7515 _tmp51_ = _tmp57_ != _tmp58_;
7516 } else {
7517 _tmp51_ = FALSE;
7518 }
7519 if (_tmp51_) {
7520 ValaProperty* _tmp59_;
7521 ValaProperty* _tmp60_;
7522 ValaProperty* _tmp61_;
7523 gchar* _tmp62_;
7524 _tmp59_ = prop;
7525 _tmp60_ = vala_property_get_base_property (_tmp59_);
7526 _tmp61_ = _tmp60_;
7527 _tmp62_ = vala_get_ccode_array_length_type ((ValaCodeNode*) _tmp61_);
7528 result = _tmp62_;
7529 return result;
7530 } else {
7531 gboolean _tmp63_ = FALSE;
7532 ValaProperty* _tmp64_;
7533 ValaProperty* _tmp65_;
7534 ValaProperty* _tmp66_;
7535 _tmp64_ = prop;
7536 _tmp65_ = vala_property_get_base_interface_property (_tmp64_);
7537 _tmp66_ = _tmp65_;
7538 if (_tmp66_ != NULL) {
7539 ValaProperty* _tmp67_;
7540 ValaProperty* _tmp68_;
7541 ValaProperty* _tmp69_;
7542 ValaProperty* _tmp70_;
7543 _tmp67_ = prop;
7544 _tmp68_ = vala_property_get_base_interface_property (_tmp67_);
7545 _tmp69_ = _tmp68_;
7546 _tmp70_ = prop;
7547 _tmp63_ = _tmp69_ != _tmp70_;
7548 } else {
7549 _tmp63_ = FALSE;
7550 }
7551 if (_tmp63_) {
7552 ValaProperty* _tmp71_;
7553 ValaProperty* _tmp72_;
7554 ValaProperty* _tmp73_;
7555 gchar* _tmp74_;
7556 _tmp71_ = prop;
7557 _tmp72_ = vala_property_get_base_interface_property (_tmp71_);
7558 _tmp73_ = _tmp72_;
7559 _tmp74_ = vala_get_ccode_array_length_type ((ValaCodeNode*) _tmp73_);
7560 result = _tmp74_;
7561 return result;
7562 } else {
7563 ValaProperty* _tmp75_;
7564 ValaDataType* _tmp76_;
7565 ValaDataType* _tmp77_;
7566 gchar* _tmp78_;
7567 _tmp75_ = prop;
7568 _tmp76_ = vala_property_get_property_type (_tmp75_);
7569 _tmp77_ = _tmp76_;
7570 _tmp78_ = vala_get_ccode_array_length_type ((ValaCodeNode*) _tmp77_);
7571 result = _tmp78_;
7572 return result;
7573 }
7574 }
7575 } else {
7576 ValaCodeNode* _tmp79_;
7577 _tmp79_ = self->priv->node;
7578 if (G_TYPE_CHECK_INSTANCE_TYPE (_tmp79_, VALA_TYPE_PROPERTY_ACCESSOR)) {
7579 ValaCodeNode* _tmp80_;
7580 ValaProperty* _tmp81_;
7581 ValaProperty* _tmp82_;
7582 gchar* _tmp83_;
7583 _tmp80_ = self->priv->node;
7584 _tmp81_ = vala_property_accessor_get_prop (G_TYPE_CHECK_INSTANCE_CAST (_tmp80_, VALA_TYPE_PROPERTY_ACCESSOR, ValaPropertyAccessor));
7585 _tmp82_ = _tmp81_;
7586 _tmp83_ = vala_get_ccode_array_length_type ((ValaCodeNode*) _tmp82_);
7587 result = _tmp83_;
7588 return result;
7589 } else {
7590 ValaCodeNode* _tmp84_;
7591 ValaSourceReference* _tmp85_;
7592 ValaSourceReference* _tmp86_;
7593 gchar* _tmp87_;
7594 _tmp84_ = self->priv->node;
7595 _tmp85_ = vala_code_node_get_source_reference (_tmp84_);
7596 _tmp86_ = _tmp85_;
7597 vala_report_error (_tmp86_, "`CCode.array_length_type' not supported");
7598 _tmp87_ = g_strdup ("");
7599 result = _tmp87_;
7600 return result;
7601 }
7602 }
7603 }
7604 }
7605 }
7606
7607 static void
vala_ccode_attribute_class_init(ValaCCodeAttributeClass * klass,gpointer klass_data)7608 vala_ccode_attribute_class_init (ValaCCodeAttributeClass * klass,
7609 gpointer klass_data)
7610 {
7611 vala_ccode_attribute_parent_class = g_type_class_peek_parent (klass);
7612 ((ValaAttributeCacheClass *) klass)->finalize = vala_ccode_attribute_finalize;
7613 g_type_class_adjust_private_offset (klass, &ValaCCodeAttribute_private_offset);
7614 }
7615
7616 static void
vala_ccode_attribute_instance_init(ValaCCodeAttribute * self,gpointer klass)7617 vala_ccode_attribute_instance_init (ValaCCodeAttribute * self,
7618 gpointer klass)
7619 {
7620 self->priv = vala_ccode_attribute_get_instance_private (self);
7621 self->priv->ctype_set = FALSE;
7622 }
7623
7624 static void
vala_ccode_attribute_finalize(ValaAttributeCache * obj)7625 vala_ccode_attribute_finalize (ValaAttributeCache * obj)
7626 {
7627 ValaCCodeAttribute * self;
7628 self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALA_TYPE_CCODE_ATTRIBUTE, ValaCCodeAttribute);
7629 _vala_code_node_unref0 (self->priv->ccode);
7630 _g_free0 (self->priv->_array_length_name);
7631 _g_free0 (self->priv->_array_length_expr);
7632 _g_free0 (self->priv->_name);
7633 _g_free0 (self->priv->_const_name);
7634 _g_free0 (self->priv->_type_name);
7635 _g_free0 (self->priv->_feature_test_macros);
7636 _g_free0 (self->priv->_header_filenames);
7637 _g_free0 (self->priv->_prefix);
7638 _g_free0 (self->priv->_lower_case_prefix);
7639 _g_free0 (self->priv->_lower_case_suffix);
7640 _g_free0 (self->priv->_ref_function);
7641 _g_free0 (self->priv->_ref_function_void);
7642 _g_free0 (self->priv->_unref_function);
7643 _g_free0 (self->priv->_ref_sink_function);
7644 _g_free0 (self->priv->_copy_function);
7645 _g_free0 (self->priv->_destroy_function);
7646 _g_free0 (self->priv->_dup_function);
7647 _g_free0 (self->priv->_free_function);
7648 _g_free0 (self->priv->_free_function_address_of);
7649 _g_free0 (self->priv->_type_id);
7650 _g_free0 (self->priv->_marshaller_type_name);
7651 _g_free0 (self->priv->_get_value_function);
7652 _g_free0 (self->priv->_set_value_function);
7653 _g_free0 (self->priv->_take_value_function);
7654 _g_free0 (self->priv->_param_spec_function);
7655 _g_free0 (self->priv->_default_value);
7656 _g_free0 (self->priv->_default_value_on_error);
7657 _g_free0 (self->priv->_pos);
7658 _g_free0 (self->priv->_vfunc_name);
7659 _g_free0 (self->priv->_finish_name);
7660 _g_free0 (self->priv->_finish_vfunc_name);
7661 _g_free0 (self->priv->_finish_real_name);
7662 _g_free0 (self->priv->_finish_instance);
7663 _g_free0 (self->priv->_real_name);
7664 _g_free0 (self->priv->_delegate_target);
7665 _g_free0 (self->priv->_delegate_target_name);
7666 _g_free0 (self->priv->_delegate_target_destroy_notify_name);
7667 _g_free0 (self->priv->_ctype);
7668 _g_free0 (self->priv->_array_length);
7669 _g_free0 (self->priv->_array_length_type);
7670 _g_free0 (self->priv->_array_null_terminated);
7671 _g_free0 (self->priv->_sentinel);
7672 VALA_ATTRIBUTE_CACHE_CLASS (vala_ccode_attribute_parent_class)->finalize (obj);
7673 }
7674
7675 /**
7676 * Cache for the CCode attribute
7677 */
7678 static GType
vala_ccode_attribute_get_type_once(void)7679 vala_ccode_attribute_get_type_once (void)
7680 {
7681 static const GTypeInfo g_define_type_info = { sizeof (ValaCCodeAttributeClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_ccode_attribute_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaCCodeAttribute), 0, (GInstanceInitFunc) vala_ccode_attribute_instance_init, NULL };
7682 GType vala_ccode_attribute_type_id;
7683 vala_ccode_attribute_type_id = g_type_register_static (VALA_TYPE_ATTRIBUTE_CACHE, "ValaCCodeAttribute", &g_define_type_info, 0);
7684 ValaCCodeAttribute_private_offset = g_type_add_instance_private (vala_ccode_attribute_type_id, sizeof (ValaCCodeAttributePrivate));
7685 return vala_ccode_attribute_type_id;
7686 }
7687
7688 GType
vala_ccode_attribute_get_type(void)7689 vala_ccode_attribute_get_type (void)
7690 {
7691 static volatile gsize vala_ccode_attribute_type_id__volatile = 0;
7692 if (g_once_init_enter (&vala_ccode_attribute_type_id__volatile)) {
7693 GType vala_ccode_attribute_type_id;
7694 vala_ccode_attribute_type_id = vala_ccode_attribute_get_type_once ();
7695 g_once_init_leave (&vala_ccode_attribute_type_id__volatile, vala_ccode_attribute_type_id);
7696 }
7697 return vala_ccode_attribute_type_id__volatile;
7698 }
7699
7700