1 /* valaccodefunction.c generated by valac, the Vala compiler
2  * generated from valaccodefunction.vala, do not modify */
3 
4 /* valaccodefunction.vala
5  *
6  * Copyright (C) 2006-2012  Jürg Billeter
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12 
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17 
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this library; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
21  *
22  * Author:
23  * 	Jürg Billeter <j@bitron.ch>
24  */
25 
26 #include "valaccode.h"
27 #include <stdlib.h>
28 #include <string.h>
29 #include <glib.h>
30 #include <valagee.h>
31 #include <glib-object.h>
32 
33 #define _g_free0(var) (var = (g_free (var), NULL))
34 #define _vala_ccode_node_unref0(var) ((var == NULL) ? NULL : (var = (vala_ccode_node_unref (var), NULL)))
35 #define _vala_iterable_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterable_unref (var), NULL)))
36 #define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
37 #define _vala_return_if_fail(expr, msg) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return; }
38 #define _vala_return_val_if_fail(expr, msg, val) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return val; }
39 #define _vala_warn_if_fail(expr, msg) if G_LIKELY (expr) ; else g_warn_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
40 
41 struct _ValaCCodeFunctionPrivate {
42 	gchar* _name;
43 	gchar* _return_type;
44 	gboolean _is_declaration;
45 	ValaCCodeBlock* _block;
46 	ValaCCodeLineDirective* _current_line;
47 	ValaCCodeBlock* _current_block;
48 	ValaList* parameters;
49 	ValaList* statement_stack;
50 };
51 
52 static gint ValaCCodeFunction_private_offset;
53 static gpointer vala_ccode_function_parent_class = NULL;
54 
55 static void vala_ccode_function_real_write (ValaCCodeNode* base,
56                                      ValaCCodeWriter* writer);
57 static void vala_ccode_function_finalize (ValaCCodeNode * obj);
58 static GType vala_ccode_function_get_type_once (void);
59 
60 static inline gpointer
vala_ccode_function_get_instance_private(ValaCCodeFunction * self)61 vala_ccode_function_get_instance_private (ValaCCodeFunction* self)
62 {
63 	return G_STRUCT_MEMBER_P (self, ValaCCodeFunction_private_offset);
64 }
65 
66 const gchar*
vala_ccode_function_get_name(ValaCCodeFunction * self)67 vala_ccode_function_get_name (ValaCCodeFunction* self)
68 {
69 	const gchar* result;
70 	const gchar* _tmp0_;
71 	g_return_val_if_fail (self != NULL, NULL);
72 	_tmp0_ = self->priv->_name;
73 	result = _tmp0_;
74 	return result;
75 }
76 
77 void
vala_ccode_function_set_name(ValaCCodeFunction * self,const gchar * value)78 vala_ccode_function_set_name (ValaCCodeFunction* self,
79                               const gchar* value)
80 {
81 	gchar* _tmp0_;
82 	g_return_if_fail (self != NULL);
83 	_tmp0_ = g_strdup (value);
84 	_g_free0 (self->priv->_name);
85 	self->priv->_name = _tmp0_;
86 }
87 
88 const gchar*
vala_ccode_function_get_return_type(ValaCCodeFunction * self)89 vala_ccode_function_get_return_type (ValaCCodeFunction* self)
90 {
91 	const gchar* result;
92 	const gchar* _tmp0_;
93 	g_return_val_if_fail (self != NULL, NULL);
94 	_tmp0_ = self->priv->_return_type;
95 	result = _tmp0_;
96 	return result;
97 }
98 
99 void
vala_ccode_function_set_return_type(ValaCCodeFunction * self,const gchar * value)100 vala_ccode_function_set_return_type (ValaCCodeFunction* self,
101                                      const gchar* value)
102 {
103 	gchar* _tmp0_;
104 	g_return_if_fail (self != NULL);
105 	_tmp0_ = g_strdup (value);
106 	_g_free0 (self->priv->_return_type);
107 	self->priv->_return_type = _tmp0_;
108 }
109 
110 gboolean
vala_ccode_function_get_is_declaration(ValaCCodeFunction * self)111 vala_ccode_function_get_is_declaration (ValaCCodeFunction* self)
112 {
113 	gboolean result;
114 	g_return_val_if_fail (self != NULL, FALSE);
115 	result = self->priv->_is_declaration;
116 	return result;
117 }
118 
119 void
vala_ccode_function_set_is_declaration(ValaCCodeFunction * self,gboolean value)120 vala_ccode_function_set_is_declaration (ValaCCodeFunction* self,
121                                         gboolean value)
122 {
123 	g_return_if_fail (self != NULL);
124 	self->priv->_is_declaration = value;
125 }
126 
127 ValaCCodeBlock*
vala_ccode_function_get_block(ValaCCodeFunction * self)128 vala_ccode_function_get_block (ValaCCodeFunction* self)
129 {
130 	ValaCCodeBlock* result;
131 	ValaCCodeBlock* _tmp0_;
132 	g_return_val_if_fail (self != NULL, NULL);
133 	_tmp0_ = self->priv->_block;
134 	result = _tmp0_;
135 	return result;
136 }
137 
138 static gpointer
_vala_ccode_node_ref0(gpointer self)139 _vala_ccode_node_ref0 (gpointer self)
140 {
141 	return self ? vala_ccode_node_ref (self) : NULL;
142 }
143 
144 void
vala_ccode_function_set_block(ValaCCodeFunction * self,ValaCCodeBlock * value)145 vala_ccode_function_set_block (ValaCCodeFunction* self,
146                                ValaCCodeBlock* value)
147 {
148 	ValaCCodeBlock* _tmp0_;
149 	g_return_if_fail (self != NULL);
150 	_tmp0_ = _vala_ccode_node_ref0 (value);
151 	_vala_ccode_node_unref0 (self->priv->_block);
152 	self->priv->_block = _tmp0_;
153 }
154 
155 ValaCCodeLineDirective*
vala_ccode_function_get_current_line(ValaCCodeFunction * self)156 vala_ccode_function_get_current_line (ValaCCodeFunction* self)
157 {
158 	ValaCCodeLineDirective* result;
159 	ValaCCodeLineDirective* _tmp0_;
160 	g_return_val_if_fail (self != NULL, NULL);
161 	_tmp0_ = self->priv->_current_line;
162 	result = _tmp0_;
163 	return result;
164 }
165 
166 void
vala_ccode_function_set_current_line(ValaCCodeFunction * self,ValaCCodeLineDirective * value)167 vala_ccode_function_set_current_line (ValaCCodeFunction* self,
168                                       ValaCCodeLineDirective* value)
169 {
170 	ValaCCodeLineDirective* _tmp0_;
171 	g_return_if_fail (self != NULL);
172 	_tmp0_ = _vala_ccode_node_ref0 (value);
173 	_vala_ccode_node_unref0 (self->priv->_current_line);
174 	self->priv->_current_line = _tmp0_;
175 }
176 
177 ValaCCodeBlock*
vala_ccode_function_get_current_block(ValaCCodeFunction * self)178 vala_ccode_function_get_current_block (ValaCCodeFunction* self)
179 {
180 	ValaCCodeBlock* result;
181 	ValaCCodeBlock* _tmp0_;
182 	g_return_val_if_fail (self != NULL, NULL);
183 	_tmp0_ = self->priv->_current_block;
184 	result = _tmp0_;
185 	return result;
186 }
187 
188 void
vala_ccode_function_set_current_block(ValaCCodeFunction * self,ValaCCodeBlock * value)189 vala_ccode_function_set_current_block (ValaCCodeFunction* self,
190                                        ValaCCodeBlock* value)
191 {
192 	ValaCCodeBlock* _tmp0_;
193 	g_return_if_fail (self != NULL);
194 	_tmp0_ = _vala_ccode_node_ref0 (value);
195 	_vala_ccode_node_unref0 (self->priv->_current_block);
196 	self->priv->_current_block = _tmp0_;
197 }
198 
199 ValaCCodeFunction*
vala_ccode_function_construct(GType object_type,const gchar * name,const gchar * return_type)200 vala_ccode_function_construct (GType object_type,
201                                const gchar* name,
202                                const gchar* return_type)
203 {
204 	ValaCCodeFunction* self = NULL;
205 	ValaCCodeBlock* _tmp0_;
206 	ValaCCodeBlock* _tmp1_;
207 	ValaCCodeBlock* _tmp2_;
208 	g_return_val_if_fail (name != NULL, NULL);
209 	g_return_val_if_fail (return_type != NULL, NULL);
210 	self = (ValaCCodeFunction*) vala_ccode_node_construct (object_type);
211 	vala_ccode_function_set_name (self, name);
212 	vala_ccode_function_set_return_type (self, return_type);
213 	_tmp0_ = vala_ccode_block_new ();
214 	_tmp1_ = _tmp0_;
215 	vala_ccode_function_set_block (self, _tmp1_);
216 	_vala_ccode_node_unref0 (_tmp1_);
217 	_tmp2_ = self->priv->_block;
218 	vala_ccode_function_set_current_block (self, _tmp2_);
219 	return self;
220 }
221 
222 ValaCCodeFunction*
vala_ccode_function_new(const gchar * name,const gchar * return_type)223 vala_ccode_function_new (const gchar* name,
224                          const gchar* return_type)
225 {
226 	return vala_ccode_function_construct (VALA_TYPE_CCODE_FUNCTION, name, return_type);
227 }
228 
229 /**
230  * Appends the specified parameter to the list of function parameters.
231  *
232  * @param param a formal parameter
233  */
234 void
vala_ccode_function_add_parameter(ValaCCodeFunction * self,ValaCCodeParameter * param)235 vala_ccode_function_add_parameter (ValaCCodeFunction* self,
236                                    ValaCCodeParameter* param)
237 {
238 	ValaList* _tmp0_;
239 	g_return_if_fail (self != NULL);
240 	g_return_if_fail (param != NULL);
241 	_tmp0_ = self->priv->parameters;
242 	vala_collection_add ((ValaCollection*) _tmp0_, param);
243 }
244 
245 void
vala_ccode_function_insert_parameter(ValaCCodeFunction * self,gint position,ValaCCodeParameter * param)246 vala_ccode_function_insert_parameter (ValaCCodeFunction* self,
247                                       gint position,
248                                       ValaCCodeParameter* param)
249 {
250 	ValaList* _tmp0_;
251 	g_return_if_fail (self != NULL);
252 	g_return_if_fail (param != NULL);
253 	_tmp0_ = self->priv->parameters;
254 	vala_list_insert (_tmp0_, position, param);
255 }
256 
257 gint
vala_ccode_function_get_parameter_count(ValaCCodeFunction * self)258 vala_ccode_function_get_parameter_count (ValaCCodeFunction* self)
259 {
260 	ValaList* _tmp0_;
261 	gint _tmp1_;
262 	gint _tmp2_;
263 	gint result = 0;
264 	g_return_val_if_fail (self != NULL, 0);
265 	_tmp0_ = self->priv->parameters;
266 	_tmp1_ = vala_collection_get_size ((ValaCollection*) _tmp0_);
267 	_tmp2_ = _tmp1_;
268 	result = _tmp2_;
269 	return result;
270 }
271 
272 ValaCCodeParameter*
vala_ccode_function_get_parameter(ValaCCodeFunction * self,gint position)273 vala_ccode_function_get_parameter (ValaCCodeFunction* self,
274                                    gint position)
275 {
276 	ValaList* _tmp0_;
277 	gpointer _tmp1_;
278 	ValaCCodeParameter* result = NULL;
279 	g_return_val_if_fail (self != NULL, NULL);
280 	_tmp0_ = self->priv->parameters;
281 	_tmp1_ = vala_list_get (_tmp0_, position);
282 	result = (ValaCCodeParameter*) _tmp1_;
283 	return result;
284 }
285 
286 /**
287  * Returns a copy of this function.
288  *
289  * @return copied function
290  */
291 static gpointer
_vala_iterable_ref0(gpointer self)292 _vala_iterable_ref0 (gpointer self)
293 {
294 	return self ? vala_iterable_ref (self) : NULL;
295 }
296 
297 ValaCCodeFunction*
vala_ccode_function_copy(ValaCCodeFunction * self)298 vala_ccode_function_copy (ValaCCodeFunction* self)
299 {
300 	ValaCCodeFunction* func = NULL;
301 	const gchar* _tmp0_;
302 	const gchar* _tmp1_;
303 	ValaCCodeFunction* _tmp2_;
304 	ValaCCodeFunction* _tmp3_;
305 	ValaCCodeModifiers _tmp4_;
306 	ValaCCodeModifiers _tmp5_;
307 	ValaCCodeFunction* _tmp18_;
308 	gboolean _tmp19_;
309 	ValaCCodeFunction* _tmp20_;
310 	ValaCCodeBlock* _tmp21_;
311 	ValaCCodeFunction* result = NULL;
312 	g_return_val_if_fail (self != NULL, NULL);
313 	_tmp0_ = self->priv->_name;
314 	_tmp1_ = self->priv->_return_type;
315 	_tmp2_ = vala_ccode_function_new (_tmp0_, _tmp1_);
316 	func = _tmp2_;
317 	_tmp3_ = func;
318 	_tmp4_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) self);
319 	_tmp5_ = _tmp4_;
320 	vala_ccode_node_set_modifiers ((ValaCCodeNode*) _tmp3_, _tmp5_);
321 	{
322 		ValaList* _param_list = NULL;
323 		ValaList* _tmp6_;
324 		ValaList* _tmp7_;
325 		gint _param_size = 0;
326 		ValaList* _tmp8_;
327 		gint _tmp9_;
328 		gint _tmp10_;
329 		gint _param_index = 0;
330 		_tmp6_ = self->priv->parameters;
331 		_tmp7_ = _vala_iterable_ref0 (_tmp6_);
332 		_param_list = _tmp7_;
333 		_tmp8_ = _param_list;
334 		_tmp9_ = vala_collection_get_size ((ValaCollection*) _tmp8_);
335 		_tmp10_ = _tmp9_;
336 		_param_size = _tmp10_;
337 		_param_index = -1;
338 		while (TRUE) {
339 			gint _tmp11_;
340 			gint _tmp12_;
341 			ValaCCodeParameter* param = NULL;
342 			ValaList* _tmp13_;
343 			gpointer _tmp14_;
344 			ValaCCodeFunction* _tmp15_;
345 			ValaList* _tmp16_;
346 			ValaCCodeParameter* _tmp17_;
347 			_param_index = _param_index + 1;
348 			_tmp11_ = _param_index;
349 			_tmp12_ = _param_size;
350 			if (!(_tmp11_ < _tmp12_)) {
351 				break;
352 			}
353 			_tmp13_ = _param_list;
354 			_tmp14_ = vala_list_get (_tmp13_, _param_index);
355 			param = (ValaCCodeParameter*) _tmp14_;
356 			_tmp15_ = func;
357 			_tmp16_ = _tmp15_->priv->parameters;
358 			_tmp17_ = param;
359 			vala_collection_add ((ValaCollection*) _tmp16_, _tmp17_);
360 			_vala_ccode_node_unref0 (param);
361 		}
362 		_vala_iterable_unref0 (_param_list);
363 	}
364 	_tmp18_ = func;
365 	_tmp19_ = self->priv->_is_declaration;
366 	vala_ccode_function_set_is_declaration (_tmp18_, _tmp19_);
367 	_tmp20_ = func;
368 	_tmp21_ = self->priv->_block;
369 	vala_ccode_function_set_block (_tmp20_, _tmp21_);
370 	result = func;
371 	return result;
372 }
373 
374 static void
vala_ccode_function_real_write(ValaCCodeNode * base,ValaCCodeWriter * writer)375 vala_ccode_function_real_write (ValaCCodeNode* base,
376                                 ValaCCodeWriter* writer)
377 {
378 	ValaCCodeFunction * self;
379 	ValaCCodeLineDirective* _tmp0_;
380 	ValaCCodeLineDirective* _tmp1_;
381 	ValaCCodeModifiers _tmp2_;
382 	ValaCCodeModifiers _tmp3_;
383 	gboolean _tmp4_ = FALSE;
384 	gboolean _tmp5_;
385 	ValaCCodeModifiers _tmp8_;
386 	ValaCCodeModifiers _tmp9_;
387 	ValaCCodeModifiers _tmp10_;
388 	ValaCCodeModifiers _tmp11_;
389 	const gchar* _tmp12_;
390 	gboolean _tmp13_;
391 	const gchar* _tmp14_;
392 	gint _tmp15_ = 0;
393 	gboolean _tmp16_;
394 	gint param_pos_begin = 0;
395 	const gchar* _tmp18_;
396 	gboolean _tmp19_ = FALSE;
397 	ValaCCodeModifiers _tmp20_;
398 	ValaCCodeModifiers _tmp21_;
399 	gboolean has_args = FALSE;
400 	gint i = 0;
401 	gint format_arg_index = 0;
402 	gint args_index = 0;
403 	gboolean _tmp47_;
404 	self = (ValaCCodeFunction*) base;
405 	g_return_if_fail (writer != NULL);
406 	_tmp0_ = vala_ccode_node_get_line ((ValaCCodeNode*) self);
407 	_tmp1_ = _tmp0_;
408 	vala_ccode_writer_write_indent (writer, _tmp1_);
409 	_tmp2_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) self);
410 	_tmp3_ = _tmp2_;
411 	if ((_tmp3_ & VALA_CCODE_MODIFIERS_INTERNAL) == VALA_CCODE_MODIFIERS_INTERNAL) {
412 		vala_ccode_writer_write_string (writer, "G_GNUC_INTERNAL ");
413 	}
414 	_tmp5_ = self->priv->_is_declaration;
415 	if (!_tmp5_) {
416 		ValaCCodeModifiers _tmp6_;
417 		ValaCCodeModifiers _tmp7_;
418 		_tmp6_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) self);
419 		_tmp7_ = _tmp6_;
420 		_tmp4_ = (_tmp7_ & VALA_CCODE_MODIFIERS_NO_INLINE) == VALA_CCODE_MODIFIERS_NO_INLINE;
421 	} else {
422 		_tmp4_ = FALSE;
423 	}
424 	if (_tmp4_) {
425 		vala_ccode_writer_write_string (writer, "G_GNUC_NO_INLINE ");
426 	}
427 	_tmp8_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) self);
428 	_tmp9_ = _tmp8_;
429 	if ((_tmp9_ & VALA_CCODE_MODIFIERS_STATIC) == VALA_CCODE_MODIFIERS_STATIC) {
430 		vala_ccode_writer_write_string (writer, "static ");
431 	}
432 	_tmp10_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) self);
433 	_tmp11_ = _tmp10_;
434 	if ((_tmp11_ & VALA_CCODE_MODIFIERS_INLINE) == VALA_CCODE_MODIFIERS_INLINE) {
435 		vala_ccode_writer_write_string (writer, "inline ");
436 	}
437 	_tmp12_ = self->priv->_return_type;
438 	vala_ccode_writer_write_string (writer, _tmp12_);
439 	_tmp13_ = self->priv->_is_declaration;
440 	if (_tmp13_) {
441 		vala_ccode_writer_write_string (writer, " ");
442 	} else {
443 		vala_ccode_writer_write_newline (writer);
444 	}
445 	_tmp14_ = self->priv->_name;
446 	vala_ccode_writer_write_string (writer, _tmp14_);
447 	vala_ccode_writer_write_string (writer, " (");
448 	_tmp16_ = self->priv->_is_declaration;
449 	if (_tmp16_) {
450 		const gchar* _tmp17_;
451 		_tmp17_ = self->priv->_return_type;
452 		_tmp15_ = g_utf8_strlen (_tmp17_, (gssize) -1) + 1;
453 	} else {
454 		_tmp15_ = 0;
455 	}
456 	_tmp18_ = self->priv->_name;
457 	param_pos_begin = (_tmp15_ + g_utf8_strlen (_tmp18_, (gssize) -1)) + 2;
458 	_tmp20_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) self);
459 	_tmp21_ = _tmp20_;
460 	if ((_tmp21_ & VALA_CCODE_MODIFIERS_PRINTF) == VALA_CCODE_MODIFIERS_PRINTF) {
461 		_tmp19_ = TRUE;
462 	} else {
463 		ValaCCodeModifiers _tmp22_;
464 		ValaCCodeModifiers _tmp23_;
465 		_tmp22_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) self);
466 		_tmp23_ = _tmp22_;
467 		_tmp19_ = (_tmp23_ & VALA_CCODE_MODIFIERS_SCANF) == VALA_CCODE_MODIFIERS_SCANF;
468 	}
469 	has_args = _tmp19_;
470 	i = 0;
471 	format_arg_index = -1;
472 	args_index = -1;
473 	{
474 		ValaList* _param_list = NULL;
475 		ValaList* _tmp24_;
476 		ValaList* _tmp25_;
477 		gint _param_size = 0;
478 		ValaList* _tmp26_;
479 		gint _tmp27_;
480 		gint _tmp28_;
481 		gint _param_index = 0;
482 		_tmp24_ = self->priv->parameters;
483 		_tmp25_ = _vala_iterable_ref0 (_tmp24_);
484 		_param_list = _tmp25_;
485 		_tmp26_ = _param_list;
486 		_tmp27_ = vala_collection_get_size ((ValaCollection*) _tmp26_);
487 		_tmp28_ = _tmp27_;
488 		_param_size = _tmp28_;
489 		_param_index = -1;
490 		while (TRUE) {
491 			gint _tmp29_;
492 			gint _tmp30_;
493 			ValaCCodeParameter* param = NULL;
494 			ValaList* _tmp31_;
495 			gpointer _tmp32_;
496 			ValaCCodeParameter* _tmp33_;
497 			ValaCCodeParameter* _tmp34_;
498 			ValaCCodeModifiers _tmp35_;
499 			ValaCCodeModifiers _tmp36_;
500 			gboolean _tmp37_ = FALSE;
501 			gint _tmp46_;
502 			_param_index = _param_index + 1;
503 			_tmp29_ = _param_index;
504 			_tmp30_ = _param_size;
505 			if (!(_tmp29_ < _tmp30_)) {
506 				break;
507 			}
508 			_tmp31_ = _param_list;
509 			_tmp32_ = vala_list_get (_tmp31_, _param_index);
510 			param = (ValaCCodeParameter*) _tmp32_;
511 			if (i > 0) {
512 				vala_ccode_writer_write_string (writer, ",");
513 				vala_ccode_writer_write_newline (writer);
514 				vala_ccode_writer_write_nspaces (writer, (guint) param_pos_begin);
515 			}
516 			_tmp33_ = param;
517 			vala_ccode_node_write ((ValaCCodeNode*) _tmp33_, writer);
518 			_tmp34_ = param;
519 			_tmp35_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) _tmp34_);
520 			_tmp36_ = _tmp35_;
521 			if ((_tmp36_ & VALA_CCODE_MODIFIERS_FORMAT_ARG) == VALA_CCODE_MODIFIERS_FORMAT_ARG) {
522 				format_arg_index = i;
523 			}
524 			if (has_args) {
525 				ValaCCodeParameter* _tmp38_;
526 				gboolean _tmp39_;
527 				gboolean _tmp40_;
528 				_tmp38_ = param;
529 				_tmp39_ = vala_ccode_parameter_get_ellipsis (_tmp38_);
530 				_tmp40_ = _tmp39_;
531 				_tmp37_ = _tmp40_;
532 			} else {
533 				_tmp37_ = FALSE;
534 			}
535 			if (_tmp37_) {
536 				args_index = i;
537 			} else {
538 				gboolean _tmp41_ = FALSE;
539 				gboolean _tmp42_ = FALSE;
540 				if (has_args) {
541 					ValaCCodeParameter* _tmp43_;
542 					const gchar* _tmp44_;
543 					const gchar* _tmp45_;
544 					_tmp43_ = param;
545 					_tmp44_ = vala_ccode_parameter_get_type_name (_tmp43_);
546 					_tmp45_ = _tmp44_;
547 					_tmp42_ = g_strcmp0 (_tmp45_, "va_list") == 0;
548 				} else {
549 					_tmp42_ = FALSE;
550 				}
551 				if (_tmp42_) {
552 					_tmp41_ = format_arg_index < 0;
553 				} else {
554 					_tmp41_ = FALSE;
555 				}
556 				if (_tmp41_) {
557 					format_arg_index = i - 1;
558 				}
559 			}
560 			_tmp46_ = i;
561 			i = _tmp46_ + 1;
562 			_vala_ccode_node_unref0 (param);
563 		}
564 		_vala_iterable_unref0 (_param_list);
565 	}
566 	if (i == 0) {
567 		vala_ccode_writer_write_string (writer, "void");
568 	}
569 	vala_ccode_writer_write_string (writer, ")");
570 	_tmp47_ = self->priv->_is_declaration;
571 	if (_tmp47_) {
572 		ValaCCodeModifiers _tmp48_;
573 		ValaCCodeModifiers _tmp49_;
574 		ValaCCodeModifiers _tmp50_;
575 		ValaCCodeModifiers _tmp51_;
576 		ValaCCodeModifiers _tmp62_;
577 		ValaCCodeModifiers _tmp63_;
578 		ValaCCodeModifiers _tmp64_;
579 		ValaCCodeModifiers _tmp65_;
580 		ValaCCodeModifiers _tmp66_;
581 		ValaCCodeModifiers _tmp67_;
582 		_tmp48_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) self);
583 		_tmp49_ = _tmp48_;
584 		if ((_tmp49_ & VALA_CCODE_MODIFIERS_DEPRECATED) == VALA_CCODE_MODIFIERS_DEPRECATED) {
585 			vala_ccode_writer_write_string (writer, " G_GNUC_DEPRECATED");
586 		}
587 		_tmp50_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) self);
588 		_tmp51_ = _tmp50_;
589 		if ((_tmp51_ & VALA_CCODE_MODIFIERS_PRINTF) == VALA_CCODE_MODIFIERS_PRINTF) {
590 			gint _tmp52_ = 0;
591 			gchar* _tmp53_;
592 			gchar* _tmp54_;
593 			if (format_arg_index >= 0) {
594 				_tmp52_ = format_arg_index + 1;
595 			} else {
596 				_tmp52_ = args_index;
597 			}
598 			format_arg_index = _tmp52_;
599 			_tmp53_ = g_strdup_printf (" G_GNUC_PRINTF(%d,%d)", format_arg_index, args_index + 1);
600 			_tmp54_ = _tmp53_;
601 			vala_ccode_writer_write_string (writer, _tmp54_);
602 			_g_free0 (_tmp54_);
603 		} else {
604 			ValaCCodeModifiers _tmp55_;
605 			ValaCCodeModifiers _tmp56_;
606 			_tmp55_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) self);
607 			_tmp56_ = _tmp55_;
608 			if ((_tmp56_ & VALA_CCODE_MODIFIERS_SCANF) == VALA_CCODE_MODIFIERS_SCANF) {
609 				gint _tmp57_ = 0;
610 				gchar* _tmp58_;
611 				gchar* _tmp59_;
612 				if (format_arg_index >= 0) {
613 					_tmp57_ = format_arg_index + 1;
614 				} else {
615 					_tmp57_ = args_index;
616 				}
617 				format_arg_index = _tmp57_;
618 				_tmp58_ = g_strdup_printf (" G_GNUC_SCANF(%d,%d)", format_arg_index, args_index + 1);
619 				_tmp59_ = _tmp58_;
620 				vala_ccode_writer_write_string (writer, _tmp59_);
621 				_g_free0 (_tmp59_);
622 			} else {
623 				if (format_arg_index >= 0) {
624 					gchar* _tmp60_;
625 					gchar* _tmp61_;
626 					_tmp60_ = g_strdup_printf (" G_GNUC_FORMAT(%d)", format_arg_index + 1);
627 					_tmp61_ = _tmp60_;
628 					vala_ccode_writer_write_string (writer, _tmp61_);
629 					_g_free0 (_tmp61_);
630 				}
631 			}
632 		}
633 		_tmp62_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) self);
634 		_tmp63_ = _tmp62_;
635 		if ((_tmp63_ & VALA_CCODE_MODIFIERS_CONST) == VALA_CCODE_MODIFIERS_CONST) {
636 			vala_ccode_writer_write_string (writer, " G_GNUC_CONST");
637 		}
638 		_tmp64_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) self);
639 		_tmp65_ = _tmp64_;
640 		if ((_tmp65_ & VALA_CCODE_MODIFIERS_UNUSED) == VALA_CCODE_MODIFIERS_UNUSED) {
641 			vala_ccode_writer_write_string (writer, " G_GNUC_UNUSED");
642 		}
643 		_tmp66_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) self);
644 		_tmp67_ = _tmp66_;
645 		if ((_tmp67_ & VALA_CCODE_MODIFIERS_CONSTRUCTOR) == VALA_CCODE_MODIFIERS_CONSTRUCTOR) {
646 			vala_ccode_writer_write_string (writer, " __attribute__((constructor))");
647 		} else {
648 			ValaCCodeModifiers _tmp68_;
649 			ValaCCodeModifiers _tmp69_;
650 			_tmp68_ = vala_ccode_node_get_modifiers ((ValaCCodeNode*) self);
651 			_tmp69_ = _tmp68_;
652 			if ((_tmp69_ & VALA_CCODE_MODIFIERS_DESTRUCTOR) == VALA_CCODE_MODIFIERS_DESTRUCTOR) {
653 				vala_ccode_writer_write_string (writer, " __attribute__((destructor))");
654 			}
655 		}
656 		vala_ccode_writer_write_string (writer, ";");
657 	} else {
658 		ValaCCodeBlock* _tmp70_;
659 		vala_ccode_writer_write_newline (writer);
660 		_tmp70_ = self->priv->_block;
661 		vala_ccode_node_write ((ValaCCodeNode*) _tmp70_, writer);
662 		vala_ccode_writer_write_newline (writer);
663 	}
664 	vala_ccode_writer_write_newline (writer);
665 }
666 
667 void
vala_ccode_function_add_statement(ValaCCodeFunction * self,ValaCCodeNode * stmt)668 vala_ccode_function_add_statement (ValaCCodeFunction* self,
669                                    ValaCCodeNode* stmt)
670 {
671 	ValaCCodeLineDirective* _tmp0_;
672 	ValaCCodeBlock* _tmp1_;
673 	g_return_if_fail (self != NULL);
674 	g_return_if_fail (stmt != NULL);
675 	_tmp0_ = self->priv->_current_line;
676 	vala_ccode_node_set_line (stmt, _tmp0_);
677 	_tmp1_ = self->priv->_current_block;
678 	vala_ccode_block_add_statement (_tmp1_, stmt);
679 }
680 
681 void
vala_ccode_function_open_block(ValaCCodeFunction * self)682 vala_ccode_function_open_block (ValaCCodeFunction* self)
683 {
684 	ValaList* _tmp0_;
685 	ValaCCodeBlock* _tmp1_;
686 	ValaCCodeBlock* parent_block = NULL;
687 	ValaCCodeBlock* _tmp2_;
688 	ValaCCodeBlock* _tmp3_;
689 	ValaCCodeBlock* _tmp4_;
690 	ValaCCodeBlock* _tmp5_;
691 	ValaCCodeBlock* _tmp6_;
692 	g_return_if_fail (self != NULL);
693 	_tmp0_ = self->priv->statement_stack;
694 	_tmp1_ = self->priv->_current_block;
695 	vala_collection_add ((ValaCollection*) _tmp0_, (ValaCCodeStatement*) _tmp1_);
696 	_tmp2_ = self->priv->_current_block;
697 	_tmp3_ = _vala_ccode_node_ref0 (_tmp2_);
698 	parent_block = _tmp3_;
699 	_tmp4_ = vala_ccode_block_new ();
700 	_tmp5_ = _tmp4_;
701 	vala_ccode_function_set_current_block (self, _tmp5_);
702 	_vala_ccode_node_unref0 (_tmp5_);
703 	_tmp6_ = self->priv->_current_block;
704 	vala_ccode_block_add_statement (parent_block, (ValaCCodeNode*) _tmp6_);
705 	_vala_ccode_node_unref0 (parent_block);
706 }
707 
708 void
vala_ccode_function_open_if(ValaCCodeFunction * self,ValaCCodeExpression * condition)709 vala_ccode_function_open_if (ValaCCodeFunction* self,
710                              ValaCCodeExpression* condition)
711 {
712 	ValaList* _tmp0_;
713 	ValaCCodeBlock* _tmp1_;
714 	ValaCCodeBlock* parent_block = NULL;
715 	ValaCCodeBlock* _tmp2_;
716 	ValaCCodeBlock* _tmp3_;
717 	ValaCCodeBlock* _tmp4_;
718 	ValaCCodeBlock* _tmp5_;
719 	ValaCCodeIfStatement* cif = NULL;
720 	ValaCCodeBlock* _tmp6_;
721 	ValaCCodeIfStatement* _tmp7_;
722 	ValaCCodeLineDirective* _tmp8_;
723 	ValaList* _tmp9_;
724 	g_return_if_fail (self != NULL);
725 	g_return_if_fail (condition != NULL);
726 	_tmp0_ = self->priv->statement_stack;
727 	_tmp1_ = self->priv->_current_block;
728 	vala_collection_add ((ValaCollection*) _tmp0_, (ValaCCodeStatement*) _tmp1_);
729 	_tmp2_ = self->priv->_current_block;
730 	_tmp3_ = _vala_ccode_node_ref0 (_tmp2_);
731 	parent_block = _tmp3_;
732 	_tmp4_ = vala_ccode_block_new ();
733 	_tmp5_ = _tmp4_;
734 	vala_ccode_function_set_current_block (self, _tmp5_);
735 	_vala_ccode_node_unref0 (_tmp5_);
736 	_tmp6_ = self->priv->_current_block;
737 	_tmp7_ = vala_ccode_if_statement_new (condition, (ValaCCodeStatement*) _tmp6_, NULL);
738 	cif = _tmp7_;
739 	_tmp8_ = self->priv->_current_line;
740 	vala_ccode_node_set_line ((ValaCCodeNode*) cif, _tmp8_);
741 	_tmp9_ = self->priv->statement_stack;
742 	vala_collection_add ((ValaCollection*) _tmp9_, (ValaCCodeStatement*) cif);
743 	vala_ccode_block_add_statement (parent_block, (ValaCCodeNode*) cif);
744 	_vala_ccode_node_unref0 (cif);
745 	_vala_ccode_node_unref0 (parent_block);
746 }
747 
748 void
vala_ccode_function_add_else(ValaCCodeFunction * self)749 vala_ccode_function_add_else (ValaCCodeFunction* self)
750 {
751 	ValaCCodeBlock* _tmp0_;
752 	ValaCCodeBlock* _tmp1_;
753 	ValaCCodeIfStatement* cif = NULL;
754 	ValaList* _tmp2_;
755 	ValaList* _tmp3_;
756 	gint _tmp4_;
757 	gint _tmp5_;
758 	gpointer _tmp6_;
759 	ValaCCodeLineDirective* _tmp7_;
760 	ValaCCodeStatement* _tmp8_;
761 	ValaCCodeStatement* _tmp9_;
762 	ValaCCodeBlock* _tmp10_;
763 	g_return_if_fail (self != NULL);
764 	_tmp0_ = vala_ccode_block_new ();
765 	_tmp1_ = _tmp0_;
766 	vala_ccode_function_set_current_block (self, _tmp1_);
767 	_vala_ccode_node_unref0 (_tmp1_);
768 	_tmp2_ = self->priv->statement_stack;
769 	_tmp3_ = self->priv->statement_stack;
770 	_tmp4_ = vala_collection_get_size ((ValaCollection*) _tmp3_);
771 	_tmp5_ = _tmp4_;
772 	_tmp6_ = vala_list_get (_tmp2_, _tmp5_ - 1);
773 	cif = G_TYPE_CHECK_INSTANCE_CAST ((ValaCCodeStatement*) _tmp6_, VALA_TYPE_CCODE_IF_STATEMENT, ValaCCodeIfStatement);
774 	_tmp7_ = self->priv->_current_line;
775 	vala_ccode_node_set_line ((ValaCCodeNode*) cif, _tmp7_);
776 	_tmp8_ = vala_ccode_if_statement_get_false_statement (cif);
777 	_tmp9_ = _tmp8_;
778 	_vala_assert (_tmp9_ == NULL, "cif.false_statement == null");
779 	_tmp10_ = self->priv->_current_block;
780 	vala_ccode_if_statement_set_false_statement (cif, (ValaCCodeStatement*) _tmp10_);
781 	_vala_ccode_node_unref0 (cif);
782 }
783 
784 void
vala_ccode_function_else_if(ValaCCodeFunction * self,ValaCCodeExpression * condition)785 vala_ccode_function_else_if (ValaCCodeFunction* self,
786                              ValaCCodeExpression* condition)
787 {
788 	ValaCCodeIfStatement* parent_if = NULL;
789 	ValaList* _tmp0_;
790 	ValaList* _tmp1_;
791 	gint _tmp2_;
792 	gint _tmp3_;
793 	gpointer _tmp4_;
794 	ValaCCodeStatement* _tmp5_;
795 	ValaCCodeStatement* _tmp6_;
796 	ValaCCodeBlock* _tmp7_;
797 	ValaCCodeBlock* _tmp8_;
798 	ValaCCodeIfStatement* cif = NULL;
799 	ValaCCodeBlock* _tmp9_;
800 	ValaCCodeIfStatement* _tmp10_;
801 	ValaCCodeLineDirective* _tmp11_;
802 	ValaList* _tmp12_;
803 	g_return_if_fail (self != NULL);
804 	g_return_if_fail (condition != NULL);
805 	_tmp0_ = self->priv->statement_stack;
806 	_tmp1_ = self->priv->statement_stack;
807 	_tmp2_ = vala_collection_get_size ((ValaCollection*) _tmp1_);
808 	_tmp3_ = _tmp2_;
809 	_tmp4_ = vala_list_remove_at (_tmp0_, _tmp3_ - 1);
810 	parent_if = G_TYPE_CHECK_INSTANCE_CAST ((ValaCCodeStatement*) _tmp4_, VALA_TYPE_CCODE_IF_STATEMENT, ValaCCodeIfStatement);
811 	_tmp5_ = vala_ccode_if_statement_get_false_statement (parent_if);
812 	_tmp6_ = _tmp5_;
813 	_vala_assert (_tmp6_ == NULL, "parent_if.false_statement == null");
814 	_tmp7_ = vala_ccode_block_new ();
815 	_tmp8_ = _tmp7_;
816 	vala_ccode_function_set_current_block (self, _tmp8_);
817 	_vala_ccode_node_unref0 (_tmp8_);
818 	_tmp9_ = self->priv->_current_block;
819 	_tmp10_ = vala_ccode_if_statement_new (condition, (ValaCCodeStatement*) _tmp9_, NULL);
820 	cif = _tmp10_;
821 	_tmp11_ = self->priv->_current_line;
822 	vala_ccode_node_set_line ((ValaCCodeNode*) cif, _tmp11_);
823 	vala_ccode_if_statement_set_false_statement (parent_if, (ValaCCodeStatement*) cif);
824 	_tmp12_ = self->priv->statement_stack;
825 	vala_collection_add ((ValaCollection*) _tmp12_, (ValaCCodeStatement*) cif);
826 	_vala_ccode_node_unref0 (cif);
827 	_vala_ccode_node_unref0 (parent_if);
828 }
829 
830 void
vala_ccode_function_open_while(ValaCCodeFunction * self,ValaCCodeExpression * condition)831 vala_ccode_function_open_while (ValaCCodeFunction* self,
832                                 ValaCCodeExpression* condition)
833 {
834 	ValaList* _tmp0_;
835 	ValaCCodeBlock* _tmp1_;
836 	ValaCCodeBlock* parent_block = NULL;
837 	ValaCCodeBlock* _tmp2_;
838 	ValaCCodeBlock* _tmp3_;
839 	ValaCCodeBlock* _tmp4_;
840 	ValaCCodeBlock* _tmp5_;
841 	ValaCCodeWhileStatement* cwhile = NULL;
842 	ValaCCodeBlock* _tmp6_;
843 	ValaCCodeWhileStatement* _tmp7_;
844 	ValaCCodeLineDirective* _tmp8_;
845 	g_return_if_fail (self != NULL);
846 	g_return_if_fail (condition != NULL);
847 	_tmp0_ = self->priv->statement_stack;
848 	_tmp1_ = self->priv->_current_block;
849 	vala_collection_add ((ValaCollection*) _tmp0_, (ValaCCodeStatement*) _tmp1_);
850 	_tmp2_ = self->priv->_current_block;
851 	_tmp3_ = _vala_ccode_node_ref0 (_tmp2_);
852 	parent_block = _tmp3_;
853 	_tmp4_ = vala_ccode_block_new ();
854 	_tmp5_ = _tmp4_;
855 	vala_ccode_function_set_current_block (self, _tmp5_);
856 	_vala_ccode_node_unref0 (_tmp5_);
857 	_tmp6_ = self->priv->_current_block;
858 	_tmp7_ = vala_ccode_while_statement_new (condition, (ValaCCodeStatement*) _tmp6_);
859 	cwhile = _tmp7_;
860 	_tmp8_ = self->priv->_current_line;
861 	vala_ccode_node_set_line ((ValaCCodeNode*) cwhile, _tmp8_);
862 	vala_ccode_block_add_statement (parent_block, (ValaCCodeNode*) cwhile);
863 	_vala_ccode_node_unref0 (cwhile);
864 	_vala_ccode_node_unref0 (parent_block);
865 }
866 
867 void
vala_ccode_function_open_for(ValaCCodeFunction * self,ValaCCodeExpression * initializer,ValaCCodeExpression * condition,ValaCCodeExpression * iterator)868 vala_ccode_function_open_for (ValaCCodeFunction* self,
869                               ValaCCodeExpression* initializer,
870                               ValaCCodeExpression* condition,
871                               ValaCCodeExpression* iterator)
872 {
873 	ValaList* _tmp0_;
874 	ValaCCodeBlock* _tmp1_;
875 	ValaCCodeBlock* parent_block = NULL;
876 	ValaCCodeBlock* _tmp2_;
877 	ValaCCodeBlock* _tmp3_;
878 	ValaCCodeBlock* _tmp4_;
879 	ValaCCodeBlock* _tmp5_;
880 	ValaCCodeForStatement* cfor = NULL;
881 	ValaCCodeBlock* _tmp6_;
882 	ValaCCodeForStatement* _tmp7_;
883 	ValaCCodeForStatement* _tmp8_;
884 	ValaCCodeLineDirective* _tmp9_;
885 	ValaCCodeBlock* _tmp12_;
886 	ValaCCodeForStatement* _tmp13_;
887 	g_return_if_fail (self != NULL);
888 	g_return_if_fail (condition != NULL);
889 	_tmp0_ = self->priv->statement_stack;
890 	_tmp1_ = self->priv->_current_block;
891 	vala_collection_add ((ValaCollection*) _tmp0_, (ValaCCodeStatement*) _tmp1_);
892 	_tmp2_ = self->priv->_current_block;
893 	_tmp3_ = _vala_ccode_node_ref0 (_tmp2_);
894 	parent_block = _tmp3_;
895 	_tmp4_ = vala_ccode_block_new ();
896 	_tmp5_ = _tmp4_;
897 	vala_ccode_function_set_current_block (self, _tmp5_);
898 	_vala_ccode_node_unref0 (_tmp5_);
899 	_tmp6_ = self->priv->_current_block;
900 	_tmp7_ = vala_ccode_for_statement_new (condition, (ValaCCodeStatement*) _tmp6_);
901 	cfor = _tmp7_;
902 	_tmp8_ = cfor;
903 	_tmp9_ = self->priv->_current_line;
904 	vala_ccode_node_set_line ((ValaCCodeNode*) _tmp8_, _tmp9_);
905 	if (initializer != NULL) {
906 		ValaCCodeForStatement* _tmp10_;
907 		_tmp10_ = cfor;
908 		vala_ccode_for_statement_add_initializer (_tmp10_, initializer);
909 	}
910 	if (iterator != NULL) {
911 		ValaCCodeForStatement* _tmp11_;
912 		_tmp11_ = cfor;
913 		vala_ccode_for_statement_add_iterator (_tmp11_, iterator);
914 	}
915 	_tmp12_ = parent_block;
916 	_tmp13_ = cfor;
917 	vala_ccode_block_add_statement (_tmp12_, (ValaCCodeNode*) _tmp13_);
918 	_vala_ccode_node_unref0 (cfor);
919 	_vala_ccode_node_unref0 (parent_block);
920 }
921 
922 void
vala_ccode_function_open_switch(ValaCCodeFunction * self,ValaCCodeExpression * expression)923 vala_ccode_function_open_switch (ValaCCodeFunction* self,
924                                  ValaCCodeExpression* expression)
925 {
926 	ValaList* _tmp0_;
927 	ValaCCodeBlock* _tmp1_;
928 	ValaCCodeBlock* parent_block = NULL;
929 	ValaCCodeBlock* _tmp2_;
930 	ValaCCodeBlock* _tmp3_;
931 	ValaCCodeSwitchStatement* cswitch = NULL;
932 	ValaCCodeSwitchStatement* _tmp4_;
933 	ValaCCodeLineDirective* _tmp5_;
934 	g_return_if_fail (self != NULL);
935 	g_return_if_fail (expression != NULL);
936 	_tmp0_ = self->priv->statement_stack;
937 	_tmp1_ = self->priv->_current_block;
938 	vala_collection_add ((ValaCollection*) _tmp0_, (ValaCCodeStatement*) _tmp1_);
939 	_tmp2_ = self->priv->_current_block;
940 	_tmp3_ = _vala_ccode_node_ref0 (_tmp2_);
941 	parent_block = _tmp3_;
942 	_tmp4_ = vala_ccode_switch_statement_new (expression);
943 	cswitch = _tmp4_;
944 	_tmp5_ = self->priv->_current_line;
945 	vala_ccode_node_set_line ((ValaCCodeNode*) cswitch, _tmp5_);
946 	vala_ccode_function_set_current_block (self, (ValaCCodeBlock*) cswitch);
947 	vala_ccode_block_add_statement (parent_block, (ValaCCodeNode*) cswitch);
948 	_vala_ccode_node_unref0 (cswitch);
949 	_vala_ccode_node_unref0 (parent_block);
950 }
951 
952 void
vala_ccode_function_add_label(ValaCCodeFunction * self,const gchar * label)953 vala_ccode_function_add_label (ValaCCodeFunction* self,
954                                const gchar* label)
955 {
956 	ValaCCodeLabel* _tmp0_;
957 	ValaCCodeLabel* _tmp1_;
958 	g_return_if_fail (self != NULL);
959 	g_return_if_fail (label != NULL);
960 	_tmp0_ = vala_ccode_label_new (label);
961 	_tmp1_ = _tmp0_;
962 	vala_ccode_function_add_statement (self, (ValaCCodeNode*) _tmp1_);
963 	_vala_ccode_node_unref0 (_tmp1_);
964 }
965 
966 void
vala_ccode_function_add_case(ValaCCodeFunction * self,ValaCCodeExpression * expression)967 vala_ccode_function_add_case (ValaCCodeFunction* self,
968                               ValaCCodeExpression* expression)
969 {
970 	ValaCCodeCaseStatement* _tmp0_;
971 	ValaCCodeCaseStatement* _tmp1_;
972 	g_return_if_fail (self != NULL);
973 	g_return_if_fail (expression != NULL);
974 	_tmp0_ = vala_ccode_case_statement_new (expression);
975 	_tmp1_ = _tmp0_;
976 	vala_ccode_function_add_statement (self, (ValaCCodeNode*) _tmp1_);
977 	_vala_ccode_node_unref0 (_tmp1_);
978 }
979 
980 void
vala_ccode_function_add_default(ValaCCodeFunction * self)981 vala_ccode_function_add_default (ValaCCodeFunction* self)
982 {
983 	ValaCCodeLabel* _tmp0_;
984 	ValaCCodeLabel* _tmp1_;
985 	g_return_if_fail (self != NULL);
986 	_tmp0_ = vala_ccode_label_new ("default");
987 	_tmp1_ = _tmp0_;
988 	vala_ccode_function_add_statement (self, (ValaCCodeNode*) _tmp1_);
989 	_vala_ccode_node_unref0 (_tmp1_);
990 }
991 
992 void
vala_ccode_function_add_goto(ValaCCodeFunction * self,const gchar * target)993 vala_ccode_function_add_goto (ValaCCodeFunction* self,
994                               const gchar* target)
995 {
996 	ValaCCodeGotoStatement* _tmp0_;
997 	ValaCCodeGotoStatement* _tmp1_;
998 	g_return_if_fail (self != NULL);
999 	g_return_if_fail (target != NULL);
1000 	_tmp0_ = vala_ccode_goto_statement_new (target);
1001 	_tmp1_ = _tmp0_;
1002 	vala_ccode_function_add_statement (self, (ValaCCodeNode*) _tmp1_);
1003 	_vala_ccode_node_unref0 (_tmp1_);
1004 }
1005 
1006 void
vala_ccode_function_add_expression(ValaCCodeFunction * self,ValaCCodeExpression * expression)1007 vala_ccode_function_add_expression (ValaCCodeFunction* self,
1008                                     ValaCCodeExpression* expression)
1009 {
1010 	ValaCCodeExpressionStatement* _tmp0_;
1011 	ValaCCodeExpressionStatement* _tmp1_;
1012 	g_return_if_fail (self != NULL);
1013 	g_return_if_fail (expression != NULL);
1014 	_tmp0_ = vala_ccode_expression_statement_new (expression);
1015 	_tmp1_ = _tmp0_;
1016 	vala_ccode_function_add_statement (self, (ValaCCodeNode*) _tmp1_);
1017 	_vala_ccode_node_unref0 (_tmp1_);
1018 }
1019 
1020 void
vala_ccode_function_add_assignment(ValaCCodeFunction * self,ValaCCodeExpression * left,ValaCCodeExpression * right)1021 vala_ccode_function_add_assignment (ValaCCodeFunction* self,
1022                                     ValaCCodeExpression* left,
1023                                     ValaCCodeExpression* right)
1024 {
1025 	ValaCCodeAssignment* _tmp0_;
1026 	ValaCCodeAssignment* _tmp1_;
1027 	g_return_if_fail (self != NULL);
1028 	g_return_if_fail (left != NULL);
1029 	g_return_if_fail (right != NULL);
1030 	_tmp0_ = vala_ccode_assignment_new (left, right, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE);
1031 	_tmp1_ = _tmp0_;
1032 	vala_ccode_function_add_expression (self, (ValaCCodeExpression*) _tmp1_);
1033 	_vala_ccode_node_unref0 (_tmp1_);
1034 }
1035 
1036 void
vala_ccode_function_add_return(ValaCCodeFunction * self,ValaCCodeExpression * expression)1037 vala_ccode_function_add_return (ValaCCodeFunction* self,
1038                                 ValaCCodeExpression* expression)
1039 {
1040 	ValaCCodeReturnStatement* _tmp0_;
1041 	ValaCCodeReturnStatement* _tmp1_;
1042 	g_return_if_fail (self != NULL);
1043 	_tmp0_ = vala_ccode_return_statement_new (expression);
1044 	_tmp1_ = _tmp0_;
1045 	vala_ccode_function_add_statement (self, (ValaCCodeNode*) _tmp1_);
1046 	_vala_ccode_node_unref0 (_tmp1_);
1047 }
1048 
1049 void
vala_ccode_function_add_break(ValaCCodeFunction * self)1050 vala_ccode_function_add_break (ValaCCodeFunction* self)
1051 {
1052 	ValaCCodeBreakStatement* _tmp0_;
1053 	ValaCCodeBreakStatement* _tmp1_;
1054 	g_return_if_fail (self != NULL);
1055 	_tmp0_ = vala_ccode_break_statement_new ();
1056 	_tmp1_ = _tmp0_;
1057 	vala_ccode_function_add_statement (self, (ValaCCodeNode*) _tmp1_);
1058 	_vala_ccode_node_unref0 (_tmp1_);
1059 }
1060 
1061 void
vala_ccode_function_add_continue(ValaCCodeFunction * self)1062 vala_ccode_function_add_continue (ValaCCodeFunction* self)
1063 {
1064 	ValaCCodeContinueStatement* _tmp0_;
1065 	ValaCCodeContinueStatement* _tmp1_;
1066 	g_return_if_fail (self != NULL);
1067 	_tmp0_ = vala_ccode_continue_statement_new ();
1068 	_tmp1_ = _tmp0_;
1069 	vala_ccode_function_add_statement (self, (ValaCCodeNode*) _tmp1_);
1070 	_vala_ccode_node_unref0 (_tmp1_);
1071 }
1072 
1073 void
vala_ccode_function_add_declaration(ValaCCodeFunction * self,const gchar * type_name,ValaCCodeDeclarator * declarator,ValaCCodeModifiers modifiers)1074 vala_ccode_function_add_declaration (ValaCCodeFunction* self,
1075                                      const gchar* type_name,
1076                                      ValaCCodeDeclarator* declarator,
1077                                      ValaCCodeModifiers modifiers)
1078 {
1079 	ValaCCodeDeclaration* stmt = NULL;
1080 	ValaCCodeDeclaration* _tmp0_;
1081 	g_return_if_fail (self != NULL);
1082 	g_return_if_fail (type_name != NULL);
1083 	g_return_if_fail (declarator != NULL);
1084 	_tmp0_ = vala_ccode_declaration_new (type_name);
1085 	stmt = _tmp0_;
1086 	vala_ccode_declaration_add_declarator (stmt, declarator);
1087 	vala_ccode_node_set_modifiers ((ValaCCodeNode*) stmt, modifiers);
1088 	vala_ccode_function_add_statement (self, (ValaCCodeNode*) stmt);
1089 	_vala_ccode_node_unref0 (stmt);
1090 }
1091 
1092 void
vala_ccode_function_close(ValaCCodeFunction * self)1093 vala_ccode_function_close (ValaCCodeFunction* self)
1094 {
1095 	g_return_if_fail (self != NULL);
1096 	{
1097 		gboolean _tmp0_ = FALSE;
1098 		_tmp0_ = TRUE;
1099 		while (TRUE) {
1100 			ValaCCodeStatement* top = NULL;
1101 			ValaList* _tmp2_;
1102 			ValaList* _tmp3_;
1103 			gint _tmp4_;
1104 			gint _tmp5_;
1105 			gpointer _tmp6_;
1106 			ValaCCodeStatement* _tmp7_;
1107 			if (!_tmp0_) {
1108 				ValaCCodeBlock* _tmp1_;
1109 				_tmp1_ = self->priv->_current_block;
1110 				if (!(_tmp1_ == NULL)) {
1111 					break;
1112 				}
1113 			}
1114 			_tmp0_ = FALSE;
1115 			_tmp2_ = self->priv->statement_stack;
1116 			_tmp3_ = self->priv->statement_stack;
1117 			_tmp4_ = vala_collection_get_size ((ValaCollection*) _tmp3_);
1118 			_tmp5_ = _tmp4_;
1119 			_tmp6_ = vala_list_remove_at (_tmp2_, _tmp5_ - 1);
1120 			top = (ValaCCodeStatement*) _tmp6_;
1121 			_tmp7_ = top;
1122 			vala_ccode_function_set_current_block (self, VALA_IS_CCODE_BLOCK (_tmp7_) ? ((ValaCCodeBlock*) _tmp7_) : NULL);
1123 			_vala_ccode_node_unref0 (top);
1124 		}
1125 	}
1126 }
1127 
1128 static void
vala_ccode_function_class_init(ValaCCodeFunctionClass * klass,gpointer klass_data)1129 vala_ccode_function_class_init (ValaCCodeFunctionClass * klass,
1130                                 gpointer klass_data)
1131 {
1132 	vala_ccode_function_parent_class = g_type_class_peek_parent (klass);
1133 	((ValaCCodeNodeClass *) klass)->finalize = vala_ccode_function_finalize;
1134 	g_type_class_adjust_private_offset (klass, &ValaCCodeFunction_private_offset);
1135 	((ValaCCodeNodeClass *) klass)->write = (void (*) (ValaCCodeNode*, ValaCCodeWriter*)) vala_ccode_function_real_write;
1136 }
1137 
1138 static void
vala_ccode_function_instance_init(ValaCCodeFunction * self,gpointer klass)1139 vala_ccode_function_instance_init (ValaCCodeFunction * self,
1140                                    gpointer klass)
1141 {
1142 	GEqualFunc _tmp0_;
1143 	ValaArrayList* _tmp1_;
1144 	GEqualFunc _tmp2_;
1145 	ValaArrayList* _tmp3_;
1146 	self->priv = vala_ccode_function_get_instance_private (self);
1147 	_tmp0_ = g_direct_equal;
1148 	_tmp1_ = vala_array_list_new (VALA_TYPE_CCODE_PARAMETER, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp0_);
1149 	self->priv->parameters = (ValaList*) _tmp1_;
1150 	_tmp2_ = g_direct_equal;
1151 	_tmp3_ = vala_array_list_new (VALA_TYPE_CCODE_STATEMENT, (GBoxedCopyFunc) vala_ccode_node_ref, (GDestroyNotify) vala_ccode_node_unref, _tmp2_);
1152 	self->priv->statement_stack = (ValaList*) _tmp3_;
1153 }
1154 
1155 static void
vala_ccode_function_finalize(ValaCCodeNode * obj)1156 vala_ccode_function_finalize (ValaCCodeNode * obj)
1157 {
1158 	ValaCCodeFunction * self;
1159 	self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALA_TYPE_CCODE_FUNCTION, ValaCCodeFunction);
1160 	_g_free0 (self->priv->_name);
1161 	_g_free0 (self->priv->_return_type);
1162 	_vala_ccode_node_unref0 (self->priv->_block);
1163 	_vala_ccode_node_unref0 (self->priv->_current_line);
1164 	_vala_ccode_node_unref0 (self->priv->_current_block);
1165 	_vala_iterable_unref0 (self->priv->parameters);
1166 	_vala_iterable_unref0 (self->priv->statement_stack);
1167 	VALA_CCODE_NODE_CLASS (vala_ccode_function_parent_class)->finalize (obj);
1168 }
1169 
1170 /**
1171  * Represents a function declaration in the C code.
1172  */
1173 static GType
vala_ccode_function_get_type_once(void)1174 vala_ccode_function_get_type_once (void)
1175 {
1176 	static const GTypeInfo g_define_type_info = { sizeof (ValaCCodeFunctionClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_ccode_function_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaCCodeFunction), 0, (GInstanceInitFunc) vala_ccode_function_instance_init, NULL };
1177 	GType vala_ccode_function_type_id;
1178 	vala_ccode_function_type_id = g_type_register_static (VALA_TYPE_CCODE_NODE, "ValaCCodeFunction", &g_define_type_info, 0);
1179 	ValaCCodeFunction_private_offset = g_type_add_instance_private (vala_ccode_function_type_id, sizeof (ValaCCodeFunctionPrivate));
1180 	return vala_ccode_function_type_id;
1181 }
1182 
1183 GType
vala_ccode_function_get_type(void)1184 vala_ccode_function_get_type (void)
1185 {
1186 	static volatile gsize vala_ccode_function_type_id__volatile = 0;
1187 	if (g_once_init_enter (&vala_ccode_function_type_id__volatile)) {
1188 		GType vala_ccode_function_type_id;
1189 		vala_ccode_function_type_id = vala_ccode_function_get_type_once ();
1190 		g_once_init_leave (&vala_ccode_function_type_id__volatile, vala_ccode_function_type_id);
1191 	}
1192 	return vala_ccode_function_type_id__volatile;
1193 }
1194 
1195