1 /* valaversionattribute.c generated by valac, the Vala compiler
2 * generated from valaversionattribute.vala, do not modify */
3
4 /* valaversionattribute.vala
5 *
6 * Copyright (C) 2013 Florian Brosch
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 * Florian Brosch <flo.brosch@gmail.com>
24 */
25
26 #include "vala.h"
27 #include <glib.h>
28 #include <string.h>
29 #include <stdlib.h>
30 #include <gobject/gvaluecollector.h>
31
32 #define _g_free0(var) ((var == NULL) ? NULL : (var = (g_free (var), NULL)))
33 #define _vala_code_context_unref0(var) ((var == NULL) ? NULL : (var = (vala_code_context_unref (var), NULL)))
34 typedef struct _ValaParamSpecVersionAttribute ValaParamSpecVersionAttribute;
35
36 struct _ValaVersionAttributePrivate {
37 ValaSymbol* symbol;
38 gboolean* _deprecated;
39 gboolean* _experimental;
40 };
41
42 struct _ValaParamSpecVersionAttribute {
43 GParamSpec parent_instance;
44 };
45
46 static gint ValaVersionAttribute_private_offset;
47 static gpointer vala_version_attribute_parent_class = NULL;
48
49 static gboolean* _bool_dup (gboolean* self);
50 static void vala_version_attribute_finalize (ValaVersionAttribute * obj);
51 static GType vala_version_attribute_get_type_once (void);
52 static void _vala_array_destroy (gpointer array,
53 gint array_length,
54 GDestroyNotify destroy_func);
55 static void _vala_array_free (gpointer array,
56 gint array_length,
57 GDestroyNotify destroy_func);
58 static gint _vala_array_length (gpointer array);
59
60 static inline gpointer
vala_version_attribute_get_instance_private(ValaVersionAttribute * self)61 vala_version_attribute_get_instance_private (ValaVersionAttribute* self)
62 {
63 return G_STRUCT_MEMBER_P (self, ValaVersionAttribute_private_offset);
64 }
65
66 /**
67 * Constructs a new VersionAttribute.
68 *
69 * @param symbol the owner
70 * @return a new VersionAttribute
71 * @see Vala.Symbol
72 */
73 ValaVersionAttribute*
vala_version_attribute_construct(GType object_type,ValaSymbol * symbol)74 vala_version_attribute_construct (GType object_type,
75 ValaSymbol* symbol)
76 {
77 ValaVersionAttribute* self = NULL;
78 g_return_val_if_fail (symbol != NULL, NULL);
79 self = (ValaVersionAttribute*) g_type_create_instance (object_type);
80 self->priv->symbol = symbol;
81 return self;
82 }
83
84 ValaVersionAttribute*
vala_version_attribute_new(ValaSymbol * symbol)85 vala_version_attribute_new (ValaSymbol* symbol)
86 {
87 return vala_version_attribute_construct (VALA_TYPE_VERSION_ATTRIBUTE, symbol);
88 }
89
90 static gboolean*
_bool_dup(gboolean * self)91 _bool_dup (gboolean* self)
92 {
93 gboolean* dup;
94 dup = g_new0 (gboolean, 1);
95 memcpy (dup, self, sizeof (gboolean));
96 return dup;
97 }
98
99 static gpointer
__bool_dup0(gpointer self)100 __bool_dup0 (gpointer self)
101 {
102 return self ? _bool_dup (self) : NULL;
103 }
104
105 gboolean
vala_version_attribute_get_deprecated(ValaVersionAttribute * self)106 vala_version_attribute_get_deprecated (ValaVersionAttribute* self)
107 {
108 gboolean result;
109 gboolean* _tmp0_;
110 gboolean* _tmp14_;
111 g_return_val_if_fail (self != NULL, FALSE);
112 _tmp0_ = self->priv->_deprecated;
113 if (_tmp0_ == NULL) {
114 gboolean _tmp1_ = FALSE;
115 gboolean _tmp2_ = FALSE;
116 gboolean _tmp3_ = FALSE;
117 ValaSymbol* _tmp4_;
118 gboolean* _tmp13_;
119 _tmp4_ = self->priv->symbol;
120 if (vala_code_node_get_attribute_bool ((ValaCodeNode*) _tmp4_, "Version", "deprecated", FALSE)) {
121 _tmp3_ = TRUE;
122 } else {
123 ValaSymbol* _tmp5_;
124 gchar* _tmp6_;
125 gchar* _tmp7_;
126 _tmp5_ = self->priv->symbol;
127 _tmp6_ = vala_code_node_get_attribute_string ((ValaCodeNode*) _tmp5_, "Version", "deprecated_since", NULL);
128 _tmp7_ = _tmp6_;
129 _tmp3_ = _tmp7_ != NULL;
130 _g_free0 (_tmp7_);
131 }
132 if (_tmp3_) {
133 _tmp2_ = TRUE;
134 } else {
135 ValaSymbol* _tmp8_;
136 gchar* _tmp9_;
137 gchar* _tmp10_;
138 _tmp8_ = self->priv->symbol;
139 _tmp9_ = vala_code_node_get_attribute_string ((ValaCodeNode*) _tmp8_, "Version", "replacement", NULL);
140 _tmp10_ = _tmp9_;
141 _tmp2_ = _tmp10_ != NULL;
142 _g_free0 (_tmp10_);
143 }
144 if (_tmp2_) {
145 _tmp1_ = TRUE;
146 } else {
147 ValaSymbol* _tmp11_;
148 ValaAttribute* _tmp12_;
149 _tmp11_ = self->priv->symbol;
150 _tmp12_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp11_, "Deprecated");
151 _tmp1_ = _tmp12_ != NULL;
152 }
153 _tmp13_ = __bool_dup0 (&_tmp1_);
154 _g_free0 (self->priv->_deprecated);
155 self->priv->_deprecated = _tmp13_;
156 }
157 _tmp14_ = self->priv->_deprecated;
158 result = *_tmp14_;
159 return result;
160 }
161
162 void
vala_version_attribute_set_deprecated(ValaVersionAttribute * self,gboolean value)163 vala_version_attribute_set_deprecated (ValaVersionAttribute* self,
164 gboolean value)
165 {
166 gboolean* _tmp0_;
167 ValaSymbol* _tmp1_;
168 gboolean* _tmp2_;
169 g_return_if_fail (self != NULL);
170 _tmp0_ = __bool_dup0 (&value);
171 _g_free0 (self->priv->_deprecated);
172 self->priv->_deprecated = _tmp0_;
173 _tmp1_ = self->priv->symbol;
174 _tmp2_ = self->priv->_deprecated;
175 vala_code_node_set_attribute_bool ((ValaCodeNode*) _tmp1_, "Version", "deprecated", *_tmp2_, NULL);
176 }
177
178 gchar*
vala_version_attribute_get_deprecated_since(ValaVersionAttribute * self)179 vala_version_attribute_get_deprecated_since (ValaVersionAttribute* self)
180 {
181 gchar* result;
182 gchar* _tmp0_ = NULL;
183 ValaSymbol* _tmp1_;
184 gchar* _tmp2_;
185 gchar* _tmp5_;
186 g_return_val_if_fail (self != NULL, NULL);
187 _tmp1_ = self->priv->symbol;
188 _tmp2_ = vala_code_node_get_attribute_string ((ValaCodeNode*) _tmp1_, "Version", "deprecated_since", NULL);
189 _tmp0_ = _tmp2_;
190 if (_tmp0_ == NULL) {
191 ValaSymbol* _tmp3_;
192 gchar* _tmp4_;
193 _tmp3_ = self->priv->symbol;
194 _tmp4_ = vala_code_node_get_attribute_string ((ValaCodeNode*) _tmp3_, "Deprecated", "since", NULL);
195 _g_free0 (_tmp0_);
196 _tmp0_ = _tmp4_;
197 }
198 _tmp5_ = _tmp0_;
199 _tmp0_ = NULL;
200 result = _tmp5_;
201 _g_free0 (_tmp0_);
202 return result;
203 }
204
205 void
vala_version_attribute_set_deprecated_since(ValaVersionAttribute * self,const gchar * value)206 vala_version_attribute_set_deprecated_since (ValaVersionAttribute* self,
207 const gchar* value)
208 {
209 ValaSymbol* _tmp0_;
210 g_return_if_fail (self != NULL);
211 _tmp0_ = self->priv->symbol;
212 vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp0_, "Version", "deprecated_since", value, NULL);
213 }
214
215 gchar*
vala_version_attribute_get_replacement(ValaVersionAttribute * self)216 vala_version_attribute_get_replacement (ValaVersionAttribute* self)
217 {
218 gchar* result;
219 gchar* _tmp0_ = NULL;
220 ValaSymbol* _tmp1_;
221 gchar* _tmp2_;
222 gchar* _tmp5_;
223 g_return_val_if_fail (self != NULL, NULL);
224 _tmp1_ = self->priv->symbol;
225 _tmp2_ = vala_code_node_get_attribute_string ((ValaCodeNode*) _tmp1_, "Version", "replacement", NULL);
226 _tmp0_ = _tmp2_;
227 if (_tmp0_ == NULL) {
228 ValaSymbol* _tmp3_;
229 gchar* _tmp4_;
230 _tmp3_ = self->priv->symbol;
231 _tmp4_ = vala_code_node_get_attribute_string ((ValaCodeNode*) _tmp3_, "Deprecated", "replacement", NULL);
232 _g_free0 (_tmp0_);
233 _tmp0_ = _tmp4_;
234 }
235 _tmp5_ = _tmp0_;
236 _tmp0_ = NULL;
237 result = _tmp5_;
238 _g_free0 (_tmp0_);
239 return result;
240 }
241
242 void
vala_version_attribute_set_replacement(ValaVersionAttribute * self,const gchar * value)243 vala_version_attribute_set_replacement (ValaVersionAttribute* self,
244 const gchar* value)
245 {
246 ValaSymbol* _tmp0_;
247 g_return_if_fail (self != NULL);
248 _tmp0_ = self->priv->symbol;
249 vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp0_, "Version", "replacement", value, NULL);
250 }
251
252 gboolean
vala_version_attribute_get_experimental(ValaVersionAttribute * self)253 vala_version_attribute_get_experimental (ValaVersionAttribute* self)
254 {
255 gboolean result;
256 gboolean* _tmp0_;
257 gboolean* _tmp10_;
258 g_return_val_if_fail (self != NULL, FALSE);
259 _tmp0_ = self->priv->_experimental;
260 if (_tmp0_ == NULL) {
261 gboolean _tmp1_ = FALSE;
262 gboolean _tmp2_ = FALSE;
263 ValaSymbol* _tmp3_;
264 gboolean* _tmp9_;
265 _tmp3_ = self->priv->symbol;
266 if (vala_code_node_get_attribute_bool ((ValaCodeNode*) _tmp3_, "Version", "experimental", FALSE)) {
267 _tmp2_ = TRUE;
268 } else {
269 ValaSymbol* _tmp4_;
270 gchar* _tmp5_;
271 gchar* _tmp6_;
272 _tmp4_ = self->priv->symbol;
273 _tmp5_ = vala_code_node_get_attribute_string ((ValaCodeNode*) _tmp4_, "Version", "experimental_until", NULL);
274 _tmp6_ = _tmp5_;
275 _tmp2_ = _tmp6_ != NULL;
276 _g_free0 (_tmp6_);
277 }
278 if (_tmp2_) {
279 _tmp1_ = TRUE;
280 } else {
281 ValaSymbol* _tmp7_;
282 ValaAttribute* _tmp8_;
283 _tmp7_ = self->priv->symbol;
284 _tmp8_ = vala_code_node_get_attribute ((ValaCodeNode*) _tmp7_, "Experimental");
285 _tmp1_ = _tmp8_ != NULL;
286 }
287 _tmp9_ = __bool_dup0 (&_tmp1_);
288 _g_free0 (self->priv->_experimental);
289 self->priv->_experimental = _tmp9_;
290 }
291 _tmp10_ = self->priv->_experimental;
292 result = *_tmp10_;
293 return result;
294 }
295
296 void
vala_version_attribute_set_experimental(ValaVersionAttribute * self,gboolean value)297 vala_version_attribute_set_experimental (ValaVersionAttribute* self,
298 gboolean value)
299 {
300 gboolean* _tmp0_;
301 ValaSymbol* _tmp1_;
302 g_return_if_fail (self != NULL);
303 _tmp0_ = __bool_dup0 (&value);
304 _g_free0 (self->priv->_experimental);
305 self->priv->_experimental = _tmp0_;
306 _tmp1_ = self->priv->symbol;
307 vala_code_node_set_attribute_bool ((ValaCodeNode*) _tmp1_, "Version", "experimental", value, NULL);
308 }
309
310 gchar*
vala_version_attribute_get_experimental_until(ValaVersionAttribute * self)311 vala_version_attribute_get_experimental_until (ValaVersionAttribute* self)
312 {
313 gchar* result;
314 ValaSymbol* _tmp0_;
315 gchar* _tmp1_;
316 g_return_val_if_fail (self != NULL, NULL);
317 _tmp0_ = self->priv->symbol;
318 _tmp1_ = vala_code_node_get_attribute_string ((ValaCodeNode*) _tmp0_, "Version", "experimental_until", NULL);
319 result = _tmp1_;
320 return result;
321 }
322
323 void
vala_version_attribute_set_experimental_until(ValaVersionAttribute * self,const gchar * value)324 vala_version_attribute_set_experimental_until (ValaVersionAttribute* self,
325 const gchar* value)
326 {
327 ValaSymbol* _tmp0_;
328 g_return_if_fail (self != NULL);
329 _tmp0_ = self->priv->symbol;
330 vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp0_, "Version", "experimental_until", value, NULL);
331 }
332
333 gchar*
vala_version_attribute_get_since(ValaVersionAttribute * self)334 vala_version_attribute_get_since (ValaVersionAttribute* self)
335 {
336 gchar* result;
337 ValaSymbol* _tmp0_;
338 gchar* _tmp1_;
339 g_return_val_if_fail (self != NULL, NULL);
340 _tmp0_ = self->priv->symbol;
341 _tmp1_ = vala_code_node_get_attribute_string ((ValaCodeNode*) _tmp0_, "Version", "since", NULL);
342 result = _tmp1_;
343 return result;
344 }
345
346 void
vala_version_attribute_set_since(ValaVersionAttribute * self,const gchar * value)347 vala_version_attribute_set_since (ValaVersionAttribute* self,
348 const gchar* value)
349 {
350 ValaSymbol* _tmp0_;
351 g_return_if_fail (self != NULL);
352 _tmp0_ = self->priv->symbol;
353 vala_code_node_set_attribute_string ((ValaCodeNode*) _tmp0_, "Version", "since", value, NULL);
354 }
355
356 /**
357 * Check to see if the symbol is experimental, deprecated or not available
358 * and emit a warning if it is.
359 */
360 static gchar*
string_slice(const gchar * self,glong start,glong end)361 string_slice (const gchar* self,
362 glong start,
363 glong end)
364 {
365 glong string_length = 0L;
366 gint _tmp0_;
367 gint _tmp1_;
368 gboolean _tmp2_ = FALSE;
369 gboolean _tmp3_ = FALSE;
370 gchar* _tmp4_;
371 gchar* result = NULL;
372 g_return_val_if_fail (self != NULL, NULL);
373 _tmp0_ = strlen (self);
374 _tmp1_ = _tmp0_;
375 string_length = (glong) _tmp1_;
376 if (start < ((glong) 0)) {
377 start = string_length + start;
378 }
379 if (end < ((glong) 0)) {
380 end = string_length + end;
381 }
382 if (start >= ((glong) 0)) {
383 _tmp2_ = start <= string_length;
384 } else {
385 _tmp2_ = FALSE;
386 }
387 g_return_val_if_fail (_tmp2_, NULL);
388 if (end >= ((glong) 0)) {
389 _tmp3_ = end <= string_length;
390 } else {
391 _tmp3_ = FALSE;
392 }
393 g_return_val_if_fail (_tmp3_, NULL);
394 g_return_val_if_fail (start <= end, NULL);
395 _tmp4_ = g_strndup (((gchar*) self) + start, (gsize) (end - start));
396 result = _tmp4_;
397 return result;
398 }
399
400 static gint
string_last_index_of_char(const gchar * self,gunichar c,gint start_index)401 string_last_index_of_char (const gchar* self,
402 gunichar c,
403 gint start_index)
404 {
405 gchar* _result_ = NULL;
406 gchar* _tmp0_;
407 gchar* _tmp1_;
408 gint result = 0;
409 g_return_val_if_fail (self != NULL, 0);
410 _tmp0_ = g_utf8_strrchr (((gchar*) self) + start_index, (gssize) -1, c);
411 _result_ = _tmp0_;
412 _tmp1_ = _result_;
413 if (_tmp1_ != NULL) {
414 gchar* _tmp2_;
415 _tmp2_ = _result_;
416 result = (gint) (_tmp2_ - ((gchar*) self));
417 return result;
418 } else {
419 result = -1;
420 return result;
421 }
422 }
423
424 gboolean
vala_version_attribute_check(ValaVersionAttribute * self,ValaSourceReference * source_ref)425 vala_version_attribute_check (ValaVersionAttribute* self,
426 ValaSourceReference* source_ref)
427 {
428 gboolean _result_ = FALSE;
429 gboolean _tmp0_ = FALSE;
430 ValaSymbol* _tmp1_;
431 gboolean _tmp2_;
432 gboolean _tmp3_;
433 gboolean _tmp55_ = FALSE;
434 ValaSymbol* _tmp56_;
435 gboolean _tmp57_;
436 gboolean _tmp58_;
437 gboolean _tmp106_ = FALSE;
438 ValaSymbol* _tmp107_;
439 gboolean _tmp108_;
440 gboolean _tmp109_;
441 gboolean result = FALSE;
442 g_return_val_if_fail (self != NULL, FALSE);
443 _result_ = FALSE;
444 _tmp1_ = self->priv->symbol;
445 _tmp2_ = vala_symbol_get_external_package (_tmp1_);
446 _tmp3_ = _tmp2_;
447 if (_tmp3_) {
448 gboolean _tmp4_;
449 gboolean _tmp5_;
450 _tmp4_ = vala_version_attribute_get_deprecated (self);
451 _tmp5_ = _tmp4_;
452 _tmp0_ = _tmp5_;
453 } else {
454 _tmp0_ = FALSE;
455 }
456 if (_tmp0_) {
457 gchar* package_version = NULL;
458 ValaSymbol* _tmp6_;
459 ValaSourceReference* _tmp7_;
460 ValaSourceReference* _tmp8_;
461 ValaSourceFile* _tmp9_;
462 ValaSourceFile* _tmp10_;
463 const gchar* _tmp11_;
464 const gchar* _tmp12_;
465 gchar* _tmp13_;
466 gboolean _tmp14_ = FALSE;
467 ValaCodeContext* _tmp15_;
468 ValaCodeContext* _tmp16_;
469 gboolean _tmp17_;
470 gboolean _tmp18_;
471 gboolean _tmp19_;
472 _tmp6_ = self->priv->symbol;
473 _tmp7_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp6_);
474 _tmp8_ = _tmp7_;
475 _tmp9_ = vala_source_reference_get_file (_tmp8_);
476 _tmp10_ = _tmp9_;
477 _tmp11_ = vala_source_file_get_installed_version (_tmp10_);
478 _tmp12_ = _tmp11_;
479 _tmp13_ = g_strdup (_tmp12_);
480 package_version = _tmp13_;
481 _tmp15_ = vala_code_context_get ();
482 _tmp16_ = _tmp15_;
483 _tmp17_ = vala_code_context_get_deprecated (_tmp16_);
484 _tmp18_ = _tmp17_;
485 _tmp19_ = !_tmp18_;
486 _vala_code_context_unref0 (_tmp16_);
487 if (_tmp19_) {
488 gboolean _tmp20_ = FALSE;
489 gboolean _tmp21_ = FALSE;
490 const gchar* _tmp22_;
491 _tmp22_ = package_version;
492 if (_tmp22_ == NULL) {
493 _tmp21_ = TRUE;
494 } else {
495 gchar* _tmp23_;
496 gchar* _tmp24_;
497 gchar* _tmp25_;
498 _tmp23_ = vala_version_attribute_get_deprecated_since (self);
499 _tmp24_ = _tmp23_;
500 _tmp25_ = _tmp24_;
501 _tmp21_ = _tmp25_ == NULL;
502 _g_free0 (_tmp25_);
503 }
504 if (_tmp21_) {
505 _tmp20_ = TRUE;
506 } else {
507 const gchar* _tmp26_;
508 gchar* _tmp27_;
509 gchar* _tmp28_;
510 gchar* _tmp29_;
511 _tmp26_ = package_version;
512 _tmp27_ = vala_version_attribute_get_deprecated_since (self);
513 _tmp28_ = _tmp27_;
514 _tmp29_ = _tmp28_;
515 _tmp20_ = vala_version_attribute_cmp_versions (_tmp26_, _tmp29_) >= 0;
516 _g_free0 (_tmp29_);
517 }
518 _tmp14_ = _tmp20_;
519 } else {
520 _tmp14_ = FALSE;
521 }
522 if (_tmp14_) {
523 gchar* _tmp30_ = NULL;
524 gchar* _tmp31_;
525 gchar* _tmp32_;
526 gchar* _tmp33_;
527 gboolean _tmp34_;
528 gchar* _tmp40_ = NULL;
529 gchar* _tmp41_;
530 gchar* _tmp42_;
531 gchar* _tmp43_;
532 gboolean _tmp44_;
533 ValaSymbol* _tmp50_;
534 gchar* _tmp51_;
535 gchar* _tmp52_;
536 gchar* _tmp53_;
537 gchar* _tmp54_;
538 _tmp31_ = vala_version_attribute_get_deprecated_since (self);
539 _tmp32_ = _tmp31_;
540 _tmp33_ = _tmp32_;
541 _tmp34_ = _tmp33_ == NULL;
542 _g_free0 (_tmp33_);
543 if (_tmp34_) {
544 gchar* _tmp35_;
545 _tmp35_ = g_strdup ("is deprecated");
546 _g_free0 (_tmp30_);
547 _tmp30_ = _tmp35_;
548 } else {
549 gchar* _tmp36_;
550 gchar* _tmp37_;
551 gchar* _tmp38_;
552 gchar* _tmp39_;
553 _tmp36_ = vala_version_attribute_get_deprecated_since (self);
554 _tmp37_ = _tmp36_;
555 _tmp38_ = _tmp37_;
556 _tmp39_ = g_strdup_printf ("has been deprecated since %s", _tmp38_);
557 _g_free0 (_tmp30_);
558 _tmp30_ = _tmp39_;
559 _g_free0 (_tmp38_);
560 }
561 _tmp41_ = vala_version_attribute_get_replacement (self);
562 _tmp42_ = _tmp41_;
563 _tmp43_ = _tmp42_;
564 _tmp44_ = _tmp43_ == NULL;
565 _g_free0 (_tmp43_);
566 if (_tmp44_) {
567 gchar* _tmp45_;
568 _tmp45_ = g_strdup ("");
569 _g_free0 (_tmp40_);
570 _tmp40_ = _tmp45_;
571 } else {
572 gchar* _tmp46_;
573 gchar* _tmp47_;
574 gchar* _tmp48_;
575 gchar* _tmp49_;
576 _tmp46_ = vala_version_attribute_get_replacement (self);
577 _tmp47_ = _tmp46_;
578 _tmp48_ = _tmp47_;
579 _tmp49_ = g_strdup_printf (". Use %s", _tmp48_);
580 _g_free0 (_tmp40_);
581 _tmp40_ = _tmp49_;
582 _g_free0 (_tmp48_);
583 }
584 _tmp50_ = self->priv->symbol;
585 _tmp51_ = vala_symbol_get_full_name (_tmp50_);
586 _tmp52_ = _tmp51_;
587 _tmp53_ = g_strdup_printf ("`%s' %s%s", _tmp52_, _tmp30_, _tmp40_);
588 _tmp54_ = _tmp53_;
589 vala_report_deprecated (source_ref, _tmp54_);
590 _g_free0 (_tmp54_);
591 _g_free0 (_tmp52_);
592 _g_free0 (_tmp40_);
593 _g_free0 (_tmp30_);
594 }
595 _result_ = TRUE;
596 _g_free0 (package_version);
597 }
598 _tmp56_ = self->priv->symbol;
599 _tmp57_ = vala_symbol_get_external_package (_tmp56_);
600 _tmp58_ = _tmp57_;
601 if (_tmp58_) {
602 gchar* _tmp59_;
603 gchar* _tmp60_;
604 gchar* _tmp61_;
605 _tmp59_ = vala_version_attribute_get_since (self);
606 _tmp60_ = _tmp59_;
607 _tmp61_ = _tmp60_;
608 _tmp55_ = _tmp61_ != NULL;
609 _g_free0 (_tmp61_);
610 } else {
611 _tmp55_ = FALSE;
612 }
613 if (_tmp55_) {
614 gchar* package_version = NULL;
615 ValaSymbol* _tmp62_;
616 ValaSourceReference* _tmp63_;
617 ValaSourceReference* _tmp64_;
618 ValaSourceFile* _tmp65_;
619 ValaSourceFile* _tmp66_;
620 const gchar* _tmp67_;
621 const gchar* _tmp68_;
622 gchar* _tmp69_;
623 gboolean _tmp70_ = FALSE;
624 gboolean _tmp71_ = FALSE;
625 ValaCodeContext* _tmp72_;
626 ValaCodeContext* _tmp73_;
627 gboolean _tmp74_;
628 gboolean _tmp75_;
629 gboolean _tmp76_;
630 _tmp62_ = self->priv->symbol;
631 _tmp63_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp62_);
632 _tmp64_ = _tmp63_;
633 _tmp65_ = vala_source_reference_get_file (_tmp64_);
634 _tmp66_ = _tmp65_;
635 _tmp67_ = vala_source_file_get_installed_version (_tmp66_);
636 _tmp68_ = _tmp67_;
637 _tmp69_ = g_strdup (_tmp68_);
638 package_version = _tmp69_;
639 _tmp72_ = vala_code_context_get ();
640 _tmp73_ = _tmp72_;
641 _tmp74_ = vala_code_context_get_since_check (_tmp73_);
642 _tmp75_ = _tmp74_;
643 _tmp76_ = _tmp75_;
644 _vala_code_context_unref0 (_tmp73_);
645 if (_tmp76_) {
646 const gchar* _tmp77_;
647 _tmp77_ = package_version;
648 _tmp71_ = _tmp77_ != NULL;
649 } else {
650 _tmp71_ = FALSE;
651 }
652 if (_tmp71_) {
653 const gchar* _tmp78_;
654 gchar* _tmp79_;
655 gchar* _tmp80_;
656 gchar* _tmp81_;
657 _tmp78_ = package_version;
658 _tmp79_ = vala_version_attribute_get_since (self);
659 _tmp80_ = _tmp79_;
660 _tmp81_ = _tmp80_;
661 _tmp70_ = vala_version_attribute_cmp_versions (_tmp78_, _tmp81_) < 0;
662 _g_free0 (_tmp81_);
663 } else {
664 _tmp70_ = FALSE;
665 }
666 if (_tmp70_) {
667 const gchar* filename = NULL;
668 ValaSymbol* _tmp82_;
669 ValaSourceReference* _tmp83_;
670 ValaSourceReference* _tmp84_;
671 ValaSourceFile* _tmp85_;
672 ValaSourceFile* _tmp86_;
673 const gchar* _tmp87_;
674 const gchar* _tmp88_;
675 gchar* pkg = NULL;
676 const gchar* _tmp89_;
677 const gchar* _tmp90_;
678 gchar* _tmp91_;
679 gchar* _tmp92_;
680 gchar* _tmp93_;
681 gchar* _tmp94_;
682 ValaSymbol* _tmp95_;
683 gchar* _tmp96_;
684 gchar* _tmp97_;
685 const gchar* _tmp98_;
686 const gchar* _tmp99_;
687 const gchar* _tmp100_;
688 gchar* _tmp101_;
689 gchar* _tmp102_;
690 gchar* _tmp103_;
691 gchar* _tmp104_;
692 gchar* _tmp105_;
693 _tmp82_ = self->priv->symbol;
694 _tmp83_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp82_);
695 _tmp84_ = _tmp83_;
696 _tmp85_ = vala_source_reference_get_file (_tmp84_);
697 _tmp86_ = _tmp85_;
698 _tmp87_ = vala_source_file_get_filename (_tmp86_);
699 _tmp88_ = _tmp87_;
700 filename = _tmp88_;
701 _tmp89_ = filename;
702 _tmp90_ = filename;
703 _tmp91_ = string_slice (_tmp89_, (glong) 0, (glong) string_last_index_of_char (_tmp90_, (gunichar) '.', 0));
704 _tmp92_ = _tmp91_;
705 _tmp93_ = g_path_get_basename (_tmp92_);
706 _tmp94_ = _tmp93_;
707 _g_free0 (_tmp92_);
708 pkg = _tmp94_;
709 _tmp95_ = self->priv->symbol;
710 _tmp96_ = vala_symbol_get_full_name (_tmp95_);
711 _tmp97_ = _tmp96_;
712 _tmp98_ = pkg;
713 _tmp99_ = package_version;
714 _tmp100_ = pkg;
715 _tmp101_ = vala_version_attribute_get_since (self);
716 _tmp102_ = _tmp101_;
717 _tmp103_ = _tmp102_;
718 _tmp104_ = g_strdup_printf ("`%s' is not available in %s %s. Use %s >= %s", _tmp97_, _tmp98_, _tmp99_, _tmp100_, _tmp103_);
719 _tmp105_ = _tmp104_;
720 vala_report_error (source_ref, _tmp105_);
721 _g_free0 (_tmp105_);
722 _g_free0 (_tmp103_);
723 _g_free0 (_tmp97_);
724 _g_free0 (pkg);
725 }
726 _result_ = TRUE;
727 _g_free0 (package_version);
728 }
729 _tmp107_ = self->priv->symbol;
730 _tmp108_ = vala_symbol_get_external_package (_tmp107_);
731 _tmp109_ = _tmp108_;
732 if (_tmp109_) {
733 gboolean _tmp110_;
734 gboolean _tmp111_;
735 _tmp110_ = vala_version_attribute_get_experimental (self);
736 _tmp111_ = _tmp110_;
737 _tmp106_ = _tmp111_;
738 } else {
739 _tmp106_ = FALSE;
740 }
741 if (_tmp106_) {
742 ValaCodeContext* _tmp112_;
743 ValaCodeContext* _tmp113_;
744 gboolean _tmp114_;
745 gboolean _tmp115_;
746 gboolean _tmp116_;
747 _tmp112_ = vala_code_context_get ();
748 _tmp113_ = _tmp112_;
749 _tmp114_ = vala_code_context_get_experimental (_tmp113_);
750 _tmp115_ = _tmp114_;
751 _tmp116_ = !_tmp115_;
752 _vala_code_context_unref0 (_tmp113_);
753 if (_tmp116_) {
754 gchar* package_version = NULL;
755 ValaSymbol* _tmp117_;
756 ValaSourceReference* _tmp118_;
757 ValaSourceReference* _tmp119_;
758 ValaSourceFile* _tmp120_;
759 ValaSourceFile* _tmp121_;
760 const gchar* _tmp122_;
761 const gchar* _tmp123_;
762 gchar* _tmp124_;
763 gchar* experimental_until = NULL;
764 gchar* _tmp125_;
765 gchar* _tmp126_;
766 gboolean _tmp127_ = FALSE;
767 gboolean _tmp128_ = FALSE;
768 const gchar* _tmp129_;
769 _tmp117_ = self->priv->symbol;
770 _tmp118_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp117_);
771 _tmp119_ = _tmp118_;
772 _tmp120_ = vala_source_reference_get_file (_tmp119_);
773 _tmp121_ = _tmp120_;
774 _tmp122_ = vala_source_file_get_installed_version (_tmp121_);
775 _tmp123_ = _tmp122_;
776 _tmp124_ = g_strdup (_tmp123_);
777 package_version = _tmp124_;
778 _tmp125_ = vala_version_attribute_get_experimental_until (self);
779 _tmp126_ = _tmp125_;
780 experimental_until = _tmp126_;
781 _tmp129_ = experimental_until;
782 if (_tmp129_ == NULL) {
783 _tmp128_ = TRUE;
784 } else {
785 const gchar* _tmp130_;
786 _tmp130_ = package_version;
787 _tmp128_ = _tmp130_ == NULL;
788 }
789 if (_tmp128_) {
790 _tmp127_ = TRUE;
791 } else {
792 const gchar* _tmp131_;
793 const gchar* _tmp132_;
794 _tmp131_ = package_version;
795 _tmp132_ = experimental_until;
796 _tmp127_ = vala_version_attribute_cmp_versions (_tmp131_, _tmp132_) < 0;
797 }
798 if (_tmp127_) {
799 gchar* _tmp133_ = NULL;
800 const gchar* _tmp134_;
801 ValaSymbol* _tmp138_;
802 gchar* _tmp139_;
803 gchar* _tmp140_;
804 gchar* _tmp141_;
805 gchar* _tmp142_;
806 _tmp134_ = experimental_until;
807 if (_tmp134_ != NULL) {
808 const gchar* _tmp135_;
809 gchar* _tmp136_;
810 _tmp135_ = experimental_until;
811 _tmp136_ = g_strdup_printf (" until %s", _tmp135_);
812 _g_free0 (_tmp133_);
813 _tmp133_ = _tmp136_;
814 } else {
815 gchar* _tmp137_;
816 _tmp137_ = g_strdup ("");
817 _g_free0 (_tmp133_);
818 _tmp133_ = _tmp137_;
819 }
820 _tmp138_ = self->priv->symbol;
821 _tmp139_ = vala_symbol_get_full_name (_tmp138_);
822 _tmp140_ = _tmp139_;
823 _tmp141_ = g_strdup_printf ("`%s' is experimental%s", _tmp140_, _tmp133_);
824 _tmp142_ = _tmp141_;
825 vala_report_experimental (source_ref, _tmp142_);
826 _g_free0 (_tmp142_);
827 _g_free0 (_tmp140_);
828 _g_free0 (_tmp133_);
829 }
830 _g_free0 (experimental_until);
831 _g_free0 (package_version);
832 }
833 _result_ = TRUE;
834 }
835 result = _result_;
836 return result;
837 }
838
839 /**
840 * A simple version comparison function.
841 *
842 * @param v1str a version number
843 * @param v2str a version number
844 * @return an integer less than, equal to, or greater than zero, if v1str is <, == or > than v2str
845 * @see GLib.CompareFunc
846 */
847 gint
vala_version_attribute_cmp_versions(const gchar * v1str,const gchar * v2str)848 vala_version_attribute_cmp_versions (const gchar* v1str,
849 const gchar* v2str)
850 {
851 gchar** v1arr = NULL;
852 gchar** _tmp0_;
853 gchar** _tmp1_;
854 gint v1arr_length1;
855 gint _v1arr_size_;
856 gchar** v2arr = NULL;
857 gchar** _tmp2_;
858 gchar** _tmp3_;
859 gint v2arr_length1;
860 gint _v2arr_size_;
861 gint i = 0;
862 gboolean _tmp15_ = FALSE;
863 gchar** _tmp16_;
864 gint _tmp16__length1;
865 const gchar* _tmp17_;
866 gboolean _tmp20_ = FALSE;
867 gchar** _tmp21_;
868 gint _tmp21__length1;
869 const gchar* _tmp22_;
870 gint result = 0;
871 g_return_val_if_fail (v1str != NULL, 0);
872 g_return_val_if_fail (v2str != NULL, 0);
873 _tmp1_ = _tmp0_ = g_strsplit (v1str, ".", 0);
874 v1arr = _tmp1_;
875 v1arr_length1 = _vala_array_length (_tmp0_);
876 _v1arr_size_ = v1arr_length1;
877 _tmp3_ = _tmp2_ = g_strsplit (v2str, ".", 0);
878 v2arr = _tmp3_;
879 v2arr_length1 = _vala_array_length (_tmp2_);
880 _v2arr_size_ = v2arr_length1;
881 i = 0;
882 while (TRUE) {
883 gboolean _tmp4_ = FALSE;
884 gchar** _tmp5_;
885 gint _tmp5__length1;
886 const gchar* _tmp6_;
887 gint v1num = 0;
888 gchar** _tmp9_;
889 gint _tmp9__length1;
890 const gchar* _tmp10_;
891 gint v2num = 0;
892 gchar** _tmp11_;
893 gint _tmp11__length1;
894 const gchar* _tmp12_;
895 gboolean _tmp13_ = FALSE;
896 gint _tmp14_;
897 _tmp5_ = v1arr;
898 _tmp5__length1 = v1arr_length1;
899 _tmp6_ = _tmp5_[i];
900 if (_tmp6_ != NULL) {
901 gchar** _tmp7_;
902 gint _tmp7__length1;
903 const gchar* _tmp8_;
904 _tmp7_ = v2arr;
905 _tmp7__length1 = v2arr_length1;
906 _tmp8_ = _tmp7_[i];
907 _tmp4_ = _tmp8_ != NULL;
908 } else {
909 _tmp4_ = FALSE;
910 }
911 if (!_tmp4_) {
912 break;
913 }
914 _tmp9_ = v1arr;
915 _tmp9__length1 = v1arr_length1;
916 _tmp10_ = _tmp9_[i];
917 v1num = atoi (_tmp10_);
918 _tmp11_ = v2arr;
919 _tmp11__length1 = v2arr_length1;
920 _tmp12_ = _tmp11_[i];
921 v2num = atoi (_tmp12_);
922 if (v1num < 0) {
923 _tmp13_ = TRUE;
924 } else {
925 _tmp13_ = v2num < 0;
926 }
927 if (_tmp13_) {
928 result = 0;
929 v2arr = (_vala_array_free (v2arr, v2arr_length1, (GDestroyNotify) g_free), NULL);
930 v1arr = (_vala_array_free (v1arr, v1arr_length1, (GDestroyNotify) g_free), NULL);
931 return result;
932 }
933 if (v1num > v2num) {
934 result = 1;
935 v2arr = (_vala_array_free (v2arr, v2arr_length1, (GDestroyNotify) g_free), NULL);
936 v1arr = (_vala_array_free (v1arr, v1arr_length1, (GDestroyNotify) g_free), NULL);
937 return result;
938 }
939 if (v1num < v2num) {
940 result = -1;
941 v2arr = (_vala_array_free (v2arr, v2arr_length1, (GDestroyNotify) g_free), NULL);
942 v1arr = (_vala_array_free (v1arr, v1arr_length1, (GDestroyNotify) g_free), NULL);
943 return result;
944 }
945 _tmp14_ = i;
946 i = _tmp14_ + 1;
947 }
948 _tmp16_ = v1arr;
949 _tmp16__length1 = v1arr_length1;
950 _tmp17_ = _tmp16_[i];
951 if (_tmp17_ != NULL) {
952 gchar** _tmp18_;
953 gint _tmp18__length1;
954 const gchar* _tmp19_;
955 _tmp18_ = v2arr;
956 _tmp18__length1 = v2arr_length1;
957 _tmp19_ = _tmp18_[i];
958 _tmp15_ = _tmp19_ == NULL;
959 } else {
960 _tmp15_ = FALSE;
961 }
962 if (_tmp15_) {
963 result = 1;
964 v2arr = (_vala_array_free (v2arr, v2arr_length1, (GDestroyNotify) g_free), NULL);
965 v1arr = (_vala_array_free (v1arr, v1arr_length1, (GDestroyNotify) g_free), NULL);
966 return result;
967 }
968 _tmp21_ = v1arr;
969 _tmp21__length1 = v1arr_length1;
970 _tmp22_ = _tmp21_[i];
971 if (_tmp22_ == NULL) {
972 gchar** _tmp23_;
973 gint _tmp23__length1;
974 const gchar* _tmp24_;
975 _tmp23_ = v2arr;
976 _tmp23__length1 = v2arr_length1;
977 _tmp24_ = _tmp23_[i];
978 _tmp20_ = _tmp24_ != NULL;
979 } else {
980 _tmp20_ = FALSE;
981 }
982 if (_tmp20_) {
983 result = -1;
984 v2arr = (_vala_array_free (v2arr, v2arr_length1, (GDestroyNotify) g_free), NULL);
985 v1arr = (_vala_array_free (v1arr, v1arr_length1, (GDestroyNotify) g_free), NULL);
986 return result;
987 }
988 result = 0;
989 v2arr = (_vala_array_free (v2arr, v2arr_length1, (GDestroyNotify) g_free), NULL);
990 v1arr = (_vala_array_free (v1arr, v1arr_length1, (GDestroyNotify) g_free), NULL);
991 return result;
992 }
993
994 static void
vala_value_version_attribute_init(GValue * value)995 vala_value_version_attribute_init (GValue* value)
996 {
997 value->data[0].v_pointer = NULL;
998 }
999
1000 static void
vala_value_version_attribute_free_value(GValue * value)1001 vala_value_version_attribute_free_value (GValue* value)
1002 {
1003 if (value->data[0].v_pointer) {
1004 vala_version_attribute_unref (value->data[0].v_pointer);
1005 }
1006 }
1007
1008 static void
vala_value_version_attribute_copy_value(const GValue * src_value,GValue * dest_value)1009 vala_value_version_attribute_copy_value (const GValue* src_value,
1010 GValue* dest_value)
1011 {
1012 if (src_value->data[0].v_pointer) {
1013 dest_value->data[0].v_pointer = vala_version_attribute_ref (src_value->data[0].v_pointer);
1014 } else {
1015 dest_value->data[0].v_pointer = NULL;
1016 }
1017 }
1018
1019 static gpointer
vala_value_version_attribute_peek_pointer(const GValue * value)1020 vala_value_version_attribute_peek_pointer (const GValue* value)
1021 {
1022 return value->data[0].v_pointer;
1023 }
1024
1025 static gchar*
vala_value_version_attribute_collect_value(GValue * value,guint n_collect_values,GTypeCValue * collect_values,guint collect_flags)1026 vala_value_version_attribute_collect_value (GValue* value,
1027 guint n_collect_values,
1028 GTypeCValue* collect_values,
1029 guint collect_flags)
1030 {
1031 if (collect_values[0].v_pointer) {
1032 ValaVersionAttribute * object;
1033 object = collect_values[0].v_pointer;
1034 if (object->parent_instance.g_class == NULL) {
1035 return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
1036 } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
1037 return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
1038 }
1039 value->data[0].v_pointer = vala_version_attribute_ref (object);
1040 } else {
1041 value->data[0].v_pointer = NULL;
1042 }
1043 return NULL;
1044 }
1045
1046 static gchar*
vala_value_version_attribute_lcopy_value(const GValue * value,guint n_collect_values,GTypeCValue * collect_values,guint collect_flags)1047 vala_value_version_attribute_lcopy_value (const GValue* value,
1048 guint n_collect_values,
1049 GTypeCValue* collect_values,
1050 guint collect_flags)
1051 {
1052 ValaVersionAttribute ** object_p;
1053 object_p = collect_values[0].v_pointer;
1054 if (!object_p) {
1055 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
1056 }
1057 if (!value->data[0].v_pointer) {
1058 *object_p = NULL;
1059 } else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
1060 *object_p = value->data[0].v_pointer;
1061 } else {
1062 *object_p = vala_version_attribute_ref (value->data[0].v_pointer);
1063 }
1064 return NULL;
1065 }
1066
1067 GParamSpec*
vala_param_spec_version_attribute(const gchar * name,const gchar * nick,const gchar * blurb,GType object_type,GParamFlags flags)1068 vala_param_spec_version_attribute (const gchar* name,
1069 const gchar* nick,
1070 const gchar* blurb,
1071 GType object_type,
1072 GParamFlags flags)
1073 {
1074 ValaParamSpecVersionAttribute* spec;
1075 g_return_val_if_fail (g_type_is_a (object_type, VALA_TYPE_VERSION_ATTRIBUTE), NULL);
1076 spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
1077 G_PARAM_SPEC (spec)->value_type = object_type;
1078 return G_PARAM_SPEC (spec);
1079 }
1080
1081 gpointer
vala_value_get_version_attribute(const GValue * value)1082 vala_value_get_version_attribute (const GValue* value)
1083 {
1084 g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALA_TYPE_VERSION_ATTRIBUTE), NULL);
1085 return value->data[0].v_pointer;
1086 }
1087
1088 void
vala_value_set_version_attribute(GValue * value,gpointer v_object)1089 vala_value_set_version_attribute (GValue* value,
1090 gpointer v_object)
1091 {
1092 ValaVersionAttribute * old;
1093 g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALA_TYPE_VERSION_ATTRIBUTE));
1094 old = value->data[0].v_pointer;
1095 if (v_object) {
1096 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, VALA_TYPE_VERSION_ATTRIBUTE));
1097 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
1098 value->data[0].v_pointer = v_object;
1099 vala_version_attribute_ref (value->data[0].v_pointer);
1100 } else {
1101 value->data[0].v_pointer = NULL;
1102 }
1103 if (old) {
1104 vala_version_attribute_unref (old);
1105 }
1106 }
1107
1108 void
vala_value_take_version_attribute(GValue * value,gpointer v_object)1109 vala_value_take_version_attribute (GValue* value,
1110 gpointer v_object)
1111 {
1112 ValaVersionAttribute * old;
1113 g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALA_TYPE_VERSION_ATTRIBUTE));
1114 old = value->data[0].v_pointer;
1115 if (v_object) {
1116 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, VALA_TYPE_VERSION_ATTRIBUTE));
1117 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
1118 value->data[0].v_pointer = v_object;
1119 } else {
1120 value->data[0].v_pointer = NULL;
1121 }
1122 if (old) {
1123 vala_version_attribute_unref (old);
1124 }
1125 }
1126
1127 static void
vala_version_attribute_class_init(ValaVersionAttributeClass * klass,gpointer klass_data)1128 vala_version_attribute_class_init (ValaVersionAttributeClass * klass,
1129 gpointer klass_data)
1130 {
1131 vala_version_attribute_parent_class = g_type_class_peek_parent (klass);
1132 ((ValaVersionAttributeClass *) klass)->finalize = vala_version_attribute_finalize;
1133 g_type_class_adjust_private_offset (klass, &ValaVersionAttribute_private_offset);
1134 }
1135
1136 static void
vala_version_attribute_instance_init(ValaVersionAttribute * self,gpointer klass)1137 vala_version_attribute_instance_init (ValaVersionAttribute * self,
1138 gpointer klass)
1139 {
1140 self->priv = vala_version_attribute_get_instance_private (self);
1141 self->ref_count = 1;
1142 }
1143
1144 static void
vala_version_attribute_finalize(ValaVersionAttribute * obj)1145 vala_version_attribute_finalize (ValaVersionAttribute * obj)
1146 {
1147 ValaVersionAttribute * self;
1148 self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALA_TYPE_VERSION_ATTRIBUTE, ValaVersionAttribute);
1149 g_signal_handlers_destroy (self);
1150 _g_free0 (self->priv->_deprecated);
1151 _g_free0 (self->priv->_experimental);
1152 }
1153
1154 /**
1155 * Represents a [Version] attribute
1156 */
1157 static GType
vala_version_attribute_get_type_once(void)1158 vala_version_attribute_get_type_once (void)
1159 {
1160 static const GTypeValueTable g_define_type_value_table = { vala_value_version_attribute_init, vala_value_version_attribute_free_value, vala_value_version_attribute_copy_value, vala_value_version_attribute_peek_pointer, "p", vala_value_version_attribute_collect_value, "p", vala_value_version_attribute_lcopy_value };
1161 static const GTypeInfo g_define_type_info = { sizeof (ValaVersionAttributeClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_version_attribute_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaVersionAttribute), 0, (GInstanceInitFunc) vala_version_attribute_instance_init, &g_define_type_value_table };
1162 static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
1163 GType vala_version_attribute_type_id;
1164 vala_version_attribute_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ValaVersionAttribute", &g_define_type_info, &g_define_type_fundamental_info, 0);
1165 ValaVersionAttribute_private_offset = g_type_add_instance_private (vala_version_attribute_type_id, sizeof (ValaVersionAttributePrivate));
1166 return vala_version_attribute_type_id;
1167 }
1168
1169 GType
vala_version_attribute_get_type(void)1170 vala_version_attribute_get_type (void)
1171 {
1172 static volatile gsize vala_version_attribute_type_id__volatile = 0;
1173 if (g_once_init_enter (&vala_version_attribute_type_id__volatile)) {
1174 GType vala_version_attribute_type_id;
1175 vala_version_attribute_type_id = vala_version_attribute_get_type_once ();
1176 g_once_init_leave (&vala_version_attribute_type_id__volatile, vala_version_attribute_type_id);
1177 }
1178 return vala_version_attribute_type_id__volatile;
1179 }
1180
1181 gpointer
vala_version_attribute_ref(gpointer instance)1182 vala_version_attribute_ref (gpointer instance)
1183 {
1184 ValaVersionAttribute * self;
1185 self = instance;
1186 g_atomic_int_inc (&self->ref_count);
1187 return instance;
1188 }
1189
1190 void
vala_version_attribute_unref(gpointer instance)1191 vala_version_attribute_unref (gpointer instance)
1192 {
1193 ValaVersionAttribute * self;
1194 self = instance;
1195 if (g_atomic_int_dec_and_test (&self->ref_count)) {
1196 VALA_VERSION_ATTRIBUTE_GET_CLASS (self)->finalize (self);
1197 g_type_free_instance ((GTypeInstance *) self);
1198 }
1199 }
1200
1201 static void
_vala_array_destroy(gpointer array,gint array_length,GDestroyNotify destroy_func)1202 _vala_array_destroy (gpointer array,
1203 gint array_length,
1204 GDestroyNotify destroy_func)
1205 {
1206 if ((array != NULL) && (destroy_func != NULL)) {
1207 gint i;
1208 for (i = 0; i < array_length; i = i + 1) {
1209 if (((gpointer*) array)[i] != NULL) {
1210 destroy_func (((gpointer*) array)[i]);
1211 }
1212 }
1213 }
1214 }
1215
1216 static void
_vala_array_free(gpointer array,gint array_length,GDestroyNotify destroy_func)1217 _vala_array_free (gpointer array,
1218 gint array_length,
1219 GDestroyNotify destroy_func)
1220 {
1221 _vala_array_destroy (array, array_length, destroy_func);
1222 g_free (array);
1223 }
1224
1225 static gint
_vala_array_length(gpointer array)1226 _vala_array_length (gpointer array)
1227 {
1228 gint length;
1229 length = 0;
1230 if (array) {
1231 while (((gpointer*) array)[length]) {
1232 length++;
1233 }
1234 }
1235 return length;
1236 }
1237
1238