1 /* valaccodewriter.c generated by valac, the Vala compiler
2 * generated from valaccodewriter.vala, do not modify */
3
4 /* valaccodewriter.vala
5 *
6 * Copyright (C) 2006-2009 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 <stdio.h>
31 #include <glib/gstdio.h>
32 #include <vala.h>
33 #include <sys/types.h>
34 #include <utime.h>
35 #include <gobject/gvaluecollector.h>
36
37 #define _g_free0(var) (var = (g_free (var), NULL))
38 #define _fclose0(var) ((var == NULL) ? NULL : (var = (fclose (var), NULL)))
39 #define _g_mapped_file_unref0(var) ((var == NULL) ? NULL : (var = (g_mapped_file_unref (var), NULL)))
40 #define _g_regex_unref0(var) ((var == NULL) ? NULL : (var = (g_regex_unref (var), NULL)))
41 typedef struct _ValaParamSpecCCodeWriter ValaParamSpecCCodeWriter;
42 #define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
43 #define _vala_return_if_fail(expr, msg) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return; }
44 #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; }
45 #define _vala_warn_if_fail(expr, msg) if G_LIKELY (expr) ; else g_warn_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
46
47 struct _ValaCCodeWriterPrivate {
48 gchar* _filename;
49 gchar* source_filename;
50 gboolean _line_directives;
51 gchar* temp_filename;
52 gboolean file_exists;
53 FILE* stream;
54 gint indent;
55 gint current_line_number;
56 gboolean using_line_directive;
57 gboolean _bol;
58 gboolean _bael;
59 };
60
61 struct _ValaParamSpecCCodeWriter {
62 GParamSpec parent_instance;
63 };
64
65 static gint ValaCCodeWriter_private_offset;
66 static gpointer vala_ccode_writer_parent_class = NULL;
67 static GRegex* vala_ccode_writer_fix_indent_regex;
68 static GRegex* vala_ccode_writer_fix_indent_regex = NULL;
69
70 static void vala_ccode_writer_finalize (ValaCCodeWriter * obj);
71 static GType vala_ccode_writer_get_type_once (void);
72 static void _vala_array_destroy (gpointer array,
73 gint array_length,
74 GDestroyNotify destroy_func);
75 static void _vala_array_free (gpointer array,
76 gint array_length,
77 GDestroyNotify destroy_func);
78 static gint _vala_array_length (gpointer array);
79
80 static inline gpointer
vala_ccode_writer_get_instance_private(ValaCCodeWriter * self)81 vala_ccode_writer_get_instance_private (ValaCCodeWriter* self)
82 {
83 return G_STRUCT_MEMBER_P (self, ValaCCodeWriter_private_offset);
84 }
85
86 const gchar*
vala_ccode_writer_get_filename(ValaCCodeWriter * self)87 vala_ccode_writer_get_filename (ValaCCodeWriter* self)
88 {
89 const gchar* result;
90 const gchar* _tmp0_;
91 g_return_val_if_fail (self != NULL, NULL);
92 _tmp0_ = self->priv->_filename;
93 result = _tmp0_;
94 return result;
95 }
96
97 void
vala_ccode_writer_set_filename(ValaCCodeWriter * self,const gchar * value)98 vala_ccode_writer_set_filename (ValaCCodeWriter* self,
99 const gchar* value)
100 {
101 gchar* _tmp0_;
102 g_return_if_fail (self != NULL);
103 _tmp0_ = g_strdup (value);
104 _g_free0 (self->priv->_filename);
105 self->priv->_filename = _tmp0_;
106 }
107
108 gboolean
vala_ccode_writer_get_line_directives(ValaCCodeWriter * self)109 vala_ccode_writer_get_line_directives (ValaCCodeWriter* self)
110 {
111 gboolean result;
112 g_return_val_if_fail (self != NULL, FALSE);
113 result = self->priv->_line_directives;
114 return result;
115 }
116
117 void
vala_ccode_writer_set_line_directives(ValaCCodeWriter * self,gboolean value)118 vala_ccode_writer_set_line_directives (ValaCCodeWriter* self,
119 gboolean value)
120 {
121 g_return_if_fail (self != NULL);
122 self->priv->_line_directives = value;
123 }
124
125 gboolean
vala_ccode_writer_get_bol(ValaCCodeWriter * self)126 vala_ccode_writer_get_bol (ValaCCodeWriter* self)
127 {
128 gboolean result;
129 g_return_val_if_fail (self != NULL, FALSE);
130 result = self->priv->_bol;
131 return result;
132 }
133
134 ValaCCodeWriter*
vala_ccode_writer_construct(GType object_type,const gchar * filename,const gchar * source_filename)135 vala_ccode_writer_construct (GType object_type,
136 const gchar* filename,
137 const gchar* source_filename)
138 {
139 ValaCCodeWriter* self = NULL;
140 gchar* _tmp0_;
141 g_return_val_if_fail (filename != NULL, NULL);
142 self = (ValaCCodeWriter*) g_type_create_instance (object_type);
143 vala_ccode_writer_set_filename (self, filename);
144 _tmp0_ = g_strdup (source_filename);
145 _g_free0 (self->priv->source_filename);
146 self->priv->source_filename = _tmp0_;
147 return self;
148 }
149
150 ValaCCodeWriter*
vala_ccode_writer_new(const gchar * filename,const gchar * source_filename)151 vala_ccode_writer_new (const gchar* filename,
152 const gchar* source_filename)
153 {
154 return vala_ccode_writer_construct (VALA_TYPE_CCODE_WRITER, filename, source_filename);
155 }
156
157 /**
158 * Opens the file.
159 *
160 * @return true if the file has been opened successfully,
161 * false otherwise
162 */
163 gboolean
vala_ccode_writer_open(ValaCCodeWriter * self,gboolean write_version)164 vala_ccode_writer_open (ValaCCodeWriter* self,
165 gboolean write_version)
166 {
167 const gchar* _tmp0_;
168 FILE* _tmp10_;
169 gchar* _tmp11_ = NULL;
170 gchar* opening = NULL;
171 gchar* _tmp20_;
172 const gchar* _tmp21_;
173 const gchar* _tmp22_;
174 gboolean result = FALSE;
175 g_return_val_if_fail (self != NULL, FALSE);
176 _tmp0_ = self->priv->_filename;
177 self->priv->file_exists = g_file_test (_tmp0_, G_FILE_TEST_EXISTS);
178 if (self->priv->file_exists) {
179 const gchar* _tmp1_;
180 gchar* _tmp2_;
181 const gchar* _tmp3_;
182 FILE* _tmp4_;
183 _tmp1_ = self->priv->_filename;
184 _tmp2_ = g_strdup_printf ("%s.valatmp", _tmp1_);
185 _g_free0 (self->priv->temp_filename);
186 self->priv->temp_filename = _tmp2_;
187 _tmp3_ = self->priv->temp_filename;
188 _tmp4_ = g_fopen (_tmp3_, "w");
189 _fclose0 (self->priv->stream);
190 self->priv->stream = _tmp4_;
191 } else {
192 gchar* dirname = NULL;
193 const gchar* _tmp5_;
194 gchar* _tmp6_;
195 const gchar* _tmp7_;
196 const gchar* _tmp8_;
197 FILE* _tmp9_;
198 _tmp5_ = self->priv->_filename;
199 _tmp6_ = g_path_get_dirname (_tmp5_);
200 dirname = _tmp6_;
201 _tmp7_ = dirname;
202 g_mkdir_with_parents (_tmp7_, 0755);
203 _tmp8_ = self->priv->_filename;
204 _tmp9_ = g_fopen (_tmp8_, "w");
205 _fclose0 (self->priv->stream);
206 self->priv->stream = _tmp9_;
207 _g_free0 (dirname);
208 }
209 _tmp10_ = self->priv->stream;
210 if (_tmp10_ == NULL) {
211 result = FALSE;
212 return result;
213 }
214 if (write_version) {
215 const gchar* _tmp12_;
216 gchar* _tmp13_;
217 gchar* _tmp14_;
218 gchar* _tmp15_;
219 _tmp12_ = self->priv->_filename;
220 _tmp13_ = g_path_get_basename (_tmp12_);
221 _tmp14_ = _tmp13_;
222 _tmp15_ = g_strdup_printf ("/* %s generated by valac %s, the Vala compiler", _tmp14_, VALA_BUILD_VERSION);
223 _g_free0 (_tmp11_);
224 _tmp11_ = _tmp15_;
225 _g_free0 (_tmp14_);
226 } else {
227 const gchar* _tmp16_;
228 gchar* _tmp17_;
229 gchar* _tmp18_;
230 gchar* _tmp19_;
231 _tmp16_ = self->priv->_filename;
232 _tmp17_ = g_path_get_basename (_tmp16_);
233 _tmp18_ = _tmp17_;
234 _tmp19_ = g_strdup_printf ("/* %s generated by valac, the Vala compiler", _tmp18_);
235 _g_free0 (_tmp11_);
236 _tmp11_ = _tmp19_;
237 _g_free0 (_tmp18_);
238 }
239 _tmp20_ = g_strdup (_tmp11_);
240 opening = _tmp20_;
241 _tmp21_ = opening;
242 vala_ccode_writer_write_string (self, _tmp21_);
243 _tmp22_ = self->priv->source_filename;
244 if (_tmp22_ != NULL) {
245 const gchar* _tmp23_;
246 gchar* _tmp24_;
247 gchar* _tmp25_;
248 gchar* _tmp26_;
249 gchar* _tmp27_;
250 vala_ccode_writer_write_newline (self);
251 _tmp23_ = self->priv->source_filename;
252 _tmp24_ = g_path_get_basename (_tmp23_);
253 _tmp25_ = _tmp24_;
254 _tmp26_ = g_strdup_printf (" * generated from %s", _tmp25_);
255 _tmp27_ = _tmp26_;
256 vala_ccode_writer_write_string (self, _tmp27_);
257 _g_free0 (_tmp27_);
258 _g_free0 (_tmp25_);
259 }
260 vala_ccode_writer_write_string (self, ", do not modify */");
261 vala_ccode_writer_write_newline (self);
262 vala_ccode_writer_write_newline (self);
263 result = TRUE;
264 _g_free0 (opening);
265 _g_free0 (_tmp11_);
266 return result;
267 }
268
269 /**
270 * Closes the file.
271 */
272 void
vala_ccode_writer_close(ValaCCodeWriter * self)273 vala_ccode_writer_close (ValaCCodeWriter* self)
274 {
275 GError* _inner_error0_ = NULL;
276 g_return_if_fail (self != NULL);
277 _fclose0 (self->priv->stream);
278 self->priv->stream = NULL;
279 if (self->priv->file_exists) {
280 gboolean changed = FALSE;
281 changed = TRUE;
282 {
283 GMappedFile* old_file = NULL;
284 const gchar* _tmp0_;
285 GMappedFile* _tmp1_;
286 GMappedFile* new_file = NULL;
287 const gchar* _tmp2_;
288 GMappedFile* _tmp3_;
289 gsize len = 0UL;
290 GMappedFile* _tmp4_;
291 GMappedFile* _tmp5_;
292 _tmp0_ = self->priv->_filename;
293 _tmp1_ = g_mapped_file_new (_tmp0_, FALSE, &_inner_error0_);
294 old_file = _tmp1_;
295 if (G_UNLIKELY (_inner_error0_ != NULL)) {
296 if (_inner_error0_->domain == G_FILE_ERROR) {
297 goto __catch0_g_file_error;
298 }
299 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);
300 g_clear_error (&_inner_error0_);
301 return;
302 }
303 _tmp2_ = self->priv->temp_filename;
304 _tmp3_ = g_mapped_file_new (_tmp2_, FALSE, &_inner_error0_);
305 new_file = _tmp3_;
306 if (G_UNLIKELY (_inner_error0_ != NULL)) {
307 _g_mapped_file_unref0 (old_file);
308 if (_inner_error0_->domain == G_FILE_ERROR) {
309 goto __catch0_g_file_error;
310 }
311 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);
312 g_clear_error (&_inner_error0_);
313 return;
314 }
315 _tmp4_ = old_file;
316 len = g_mapped_file_get_length (_tmp4_);
317 _tmp5_ = new_file;
318 if (len == g_mapped_file_get_length (_tmp5_)) {
319 GMappedFile* _tmp6_;
320 gchar* _tmp7_;
321 GMappedFile* _tmp8_;
322 gchar* _tmp9_;
323 _tmp6_ = old_file;
324 _tmp7_ = g_mapped_file_get_contents (_tmp6_);
325 _tmp8_ = new_file;
326 _tmp9_ = g_mapped_file_get_contents (_tmp8_);
327 if (memcmp (_tmp7_, _tmp9_, len) == 0) {
328 changed = FALSE;
329 }
330 }
331 _g_mapped_file_unref0 (old_file);
332 old_file = NULL;
333 _g_mapped_file_unref0 (new_file);
334 new_file = NULL;
335 _g_mapped_file_unref0 (new_file);
336 _g_mapped_file_unref0 (old_file);
337 }
338 goto __finally0;
339 __catch0_g_file_error:
340 {
341 g_clear_error (&_inner_error0_);
342 }
343 __finally0:
344 if (G_UNLIKELY (_inner_error0_ != NULL)) {
345 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);
346 g_clear_error (&_inner_error0_);
347 return;
348 }
349 if (changed) {
350 const gchar* _tmp10_;
351 const gchar* _tmp11_;
352 _tmp10_ = self->priv->temp_filename;
353 _tmp11_ = self->priv->_filename;
354 g_rename (_tmp10_, _tmp11_);
355 } else {
356 const gchar* _tmp12_;
357 const gchar* _tmp13_;
358 _tmp12_ = self->priv->temp_filename;
359 g_unlink (_tmp12_);
360 _tmp13_ = self->priv->source_filename;
361 if (_tmp13_ != NULL) {
362 GStatBuf stats = {0};
363 const gchar* _tmp14_;
364 GStatBuf target_stats = {0};
365 const gchar* _tmp15_;
366 GStatBuf _tmp16_;
367 GStatBuf _tmp17_;
368 _tmp14_ = self->priv->source_filename;
369 g_stat (_tmp14_, &stats);
370 _tmp15_ = self->priv->_filename;
371 g_stat (_tmp15_, &target_stats);
372 _tmp16_ = stats;
373 _tmp17_ = target_stats;
374 if (_tmp16_.st_mtime >= _tmp17_.st_mtime) {
375 struct utimbuf timebuf = {0};
376 GStatBuf _tmp18_;
377 GStatBuf _tmp19_;
378 struct utimbuf _tmp20_ = {0};
379 const gchar* _tmp21_;
380 struct utimbuf _tmp22_;
381 _tmp18_ = stats;
382 _tmp19_ = stats;
383 _tmp20_.actime = _tmp18_.st_atime + 1;
384 _tmp20_.modtime = _tmp19_.st_mtime + 1;
385 timebuf = _tmp20_;
386 _tmp21_ = self->priv->_filename;
387 _tmp22_ = timebuf;
388 g_utime (_tmp21_, &_tmp22_);
389 }
390 }
391 }
392 }
393 }
394
395 /**
396 * Writes tabs according to the current indent level.
397 */
398 void
vala_ccode_writer_write_indent(ValaCCodeWriter * self,ValaCCodeLineDirective * line)399 vala_ccode_writer_write_indent (ValaCCodeWriter* self,
400 ValaCCodeLineDirective* line)
401 {
402 gboolean _tmp0_;
403 FILE* _tmp6_;
404 gchar* _tmp7_;
405 gchar* _tmp8_;
406 g_return_if_fail (self != NULL);
407 _tmp0_ = self->priv->_line_directives;
408 if (_tmp0_) {
409 if (line != NULL) {
410 vala_ccode_node_write ((ValaCCodeNode*) line, self);
411 self->priv->using_line_directive = TRUE;
412 } else {
413 if (self->priv->using_line_directive) {
414 const gchar* _tmp1_;
415 gchar* _tmp2_;
416 gchar* _tmp3_;
417 gchar* _tmp4_;
418 gchar* _tmp5_;
419 _tmp1_ = self->priv->_filename;
420 _tmp2_ = g_path_get_basename (_tmp1_);
421 _tmp3_ = _tmp2_;
422 _tmp4_ = g_strdup_printf ("#line %d \"%s\"", self->priv->current_line_number + 1, _tmp3_);
423 _tmp5_ = _tmp4_;
424 vala_ccode_writer_write_string (self, _tmp5_);
425 _g_free0 (_tmp5_);
426 _g_free0 (_tmp3_);
427 vala_ccode_writer_write_newline (self);
428 self->priv->using_line_directive = FALSE;
429 }
430 }
431 }
432 if (!self->priv->_bol) {
433 vala_ccode_writer_write_newline (self);
434 }
435 _tmp6_ = self->priv->stream;
436 _tmp7_ = g_strnfill ((gsize) self->priv->indent, '\t');
437 _tmp8_ = _tmp7_;
438 fputs (_tmp8_, _tmp6_);
439 _g_free0 (_tmp8_);
440 self->priv->_bol = FALSE;
441 }
442
443 /**
444 * Writes n spaces.
445 */
446 void
vala_ccode_writer_write_nspaces(ValaCCodeWriter * self,guint n)447 vala_ccode_writer_write_nspaces (ValaCCodeWriter* self,
448 guint n)
449 {
450 FILE* _tmp0_;
451 gchar* _tmp1_;
452 gchar* _tmp2_;
453 g_return_if_fail (self != NULL);
454 _tmp0_ = self->priv->stream;
455 _tmp1_ = g_strnfill ((gsize) n, ' ');
456 _tmp2_ = _tmp1_;
457 fputs (_tmp2_, _tmp0_);
458 _g_free0 (_tmp2_);
459 }
460
461 /**
462 * Writes the specified string.
463 *
464 * @param s a string
465 */
466 void
vala_ccode_writer_write_string(ValaCCodeWriter * self,const gchar * s)467 vala_ccode_writer_write_string (ValaCCodeWriter* self,
468 const gchar* s)
469 {
470 FILE* _tmp0_;
471 g_return_if_fail (self != NULL);
472 g_return_if_fail (s != NULL);
473 _tmp0_ = self->priv->stream;
474 fputs (s, _tmp0_);
475 self->priv->_bol = FALSE;
476 }
477
478 /**
479 * Writes a newline.
480 */
481 void
vala_ccode_writer_write_newline(ValaCCodeWriter * self)482 vala_ccode_writer_write_newline (ValaCCodeWriter* self)
483 {
484 FILE* _tmp0_;
485 gint _tmp1_;
486 g_return_if_fail (self != NULL);
487 if (!self->priv->_bol) {
488 self->priv->_bael = FALSE;
489 } else {
490 if (!self->priv->_bael) {
491 self->priv->_bael = TRUE;
492 } else {
493 return;
494 }
495 }
496 _tmp0_ = self->priv->stream;
497 fputc ('\n', _tmp0_);
498 _tmp1_ = self->priv->current_line_number;
499 self->priv->current_line_number = _tmp1_ + 1;
500 self->priv->_bol = TRUE;
501 }
502
503 /**
504 * Opens a new block, increasing the indent level.
505 */
506 void
vala_ccode_writer_write_begin_block(ValaCCodeWriter * self)507 vala_ccode_writer_write_begin_block (ValaCCodeWriter* self)
508 {
509 FILE* _tmp1_;
510 gint _tmp2_;
511 g_return_if_fail (self != NULL);
512 if (!self->priv->_bol) {
513 FILE* _tmp0_;
514 _tmp0_ = self->priv->stream;
515 fputc (' ', _tmp0_);
516 } else {
517 vala_ccode_writer_write_indent (self, NULL);
518 }
519 _tmp1_ = self->priv->stream;
520 fputc ('{', _tmp1_);
521 vala_ccode_writer_write_newline (self);
522 _tmp2_ = self->priv->indent;
523 self->priv->indent = _tmp2_ + 1;
524 }
525
526 /**
527 * Closes the current block, decreasing the indent level.
528 */
529 void
vala_ccode_writer_write_end_block(ValaCCodeWriter * self)530 vala_ccode_writer_write_end_block (ValaCCodeWriter* self)
531 {
532 gint _tmp0_;
533 FILE* _tmp1_;
534 g_return_if_fail (self != NULL);
535 _vala_assert (self->priv->indent > 0, "indent > 0");
536 _tmp0_ = self->priv->indent;
537 self->priv->indent = _tmp0_ - 1;
538 vala_ccode_writer_write_indent (self, NULL);
539 _tmp1_ = self->priv->stream;
540 fputc ('}', _tmp1_);
541 }
542
543 /**
544 * Writes the specified text as comment.
545 *
546 * @param text the comment text
547 */
548 void
vala_ccode_writer_write_comment(ValaCCodeWriter * self,const gchar * text)549 vala_ccode_writer_write_comment (ValaCCodeWriter* self,
550 const gchar* text)
551 {
552 GError* _inner_error0_ = NULL;
553 g_return_if_fail (self != NULL);
554 g_return_if_fail (text != NULL);
555 {
556 FILE* _tmp0_;
557 gboolean first = FALSE;
558 GRegex* _tmp1_;
559 gchar** _tmp5_;
560 gchar** _tmp6_;
561 FILE* _tmp23_;
562 vala_ccode_writer_write_indent (self, NULL);
563 _tmp0_ = self->priv->stream;
564 fputs ("/*", _tmp0_);
565 first = TRUE;
566 _tmp1_ = vala_ccode_writer_fix_indent_regex;
567 if (_tmp1_ == NULL) {
568 GRegex* _tmp2_ = NULL;
569 GRegex* _tmp3_;
570 GRegex* _tmp4_;
571 _tmp3_ = g_regex_new ("^\t+", 0, 0, &_inner_error0_);
572 _tmp2_ = _tmp3_;
573 if (G_UNLIKELY (_inner_error0_ != NULL)) {
574 if (_inner_error0_->domain == G_REGEX_ERROR) {
575 goto __catch0_g_regex_error;
576 }
577 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);
578 g_clear_error (&_inner_error0_);
579 return;
580 }
581 _tmp4_ = _tmp2_;
582 _tmp2_ = NULL;
583 _g_regex_unref0 (vala_ccode_writer_fix_indent_regex);
584 vala_ccode_writer_fix_indent_regex = _tmp4_;
585 _g_regex_unref0 (_tmp2_);
586 }
587 _tmp6_ = _tmp5_ = g_strsplit (text, "\n", 0);
588 {
589 gchar** line_collection = NULL;
590 gint line_collection_length1 = 0;
591 gint _line_collection_size_ = 0;
592 gint line_it = 0;
593 line_collection = _tmp6_;
594 line_collection_length1 = _vala_array_length (_tmp5_);
595 for (line_it = 0; line_it < line_collection_length1; line_it = line_it + 1) {
596 const gchar* line = NULL;
597 line = line_collection[line_it];
598 {
599 gchar* _tmp7_ = NULL;
600 GRegex* _tmp8_;
601 const gchar* _tmp9_;
602 gchar* _tmp10_;
603 gchar** lineparts = NULL;
604 gchar** _tmp11_;
605 gchar** _tmp12_;
606 gint lineparts_length1;
607 gint _lineparts_size_;
608 if (!first) {
609 vala_ccode_writer_write_indent (self, NULL);
610 } else {
611 first = FALSE;
612 }
613 _tmp8_ = vala_ccode_writer_fix_indent_regex;
614 _tmp9_ = line;
615 _tmp10_ = g_regex_replace_literal (_tmp8_, _tmp9_, (gssize) -1, 0, "", 0, &_inner_error0_);
616 _tmp7_ = _tmp10_;
617 if (G_UNLIKELY (_inner_error0_ != NULL)) {
618 line_collection = (_vala_array_free (line_collection, line_collection_length1, (GDestroyNotify) g_free), NULL);
619 if (_inner_error0_->domain == G_REGEX_ERROR) {
620 goto __catch0_g_regex_error;
621 }
622 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);
623 g_clear_error (&_inner_error0_);
624 return;
625 }
626 _tmp12_ = _tmp11_ = g_strsplit (_tmp7_, "*/", 0);
627 lineparts = _tmp12_;
628 lineparts_length1 = _vala_array_length (_tmp11_);
629 _lineparts_size_ = lineparts_length1;
630 {
631 gint i = 0;
632 i = 0;
633 {
634 gboolean _tmp13_ = FALSE;
635 _tmp13_ = TRUE;
636 while (TRUE) {
637 gchar** _tmp15_;
638 gint _tmp15__length1;
639 const gchar* _tmp16_;
640 FILE* _tmp17_;
641 gchar** _tmp18_;
642 gint _tmp18__length1;
643 const gchar* _tmp19_;
644 gchar** _tmp20_;
645 gint _tmp20__length1;
646 const gchar* _tmp21_;
647 if (!_tmp13_) {
648 gint _tmp14_;
649 _tmp14_ = i;
650 i = _tmp14_ + 1;
651 }
652 _tmp13_ = FALSE;
653 _tmp15_ = lineparts;
654 _tmp15__length1 = lineparts_length1;
655 _tmp16_ = _tmp15_[i];
656 if (!(_tmp16_ != NULL)) {
657 break;
658 }
659 _tmp17_ = self->priv->stream;
660 _tmp18_ = lineparts;
661 _tmp18__length1 = lineparts_length1;
662 _tmp19_ = _tmp18_[i];
663 fputs (_tmp19_, _tmp17_);
664 _tmp20_ = lineparts;
665 _tmp20__length1 = lineparts_length1;
666 _tmp21_ = _tmp20_[i + 1];
667 if (_tmp21_ != NULL) {
668 FILE* _tmp22_;
669 _tmp22_ = self->priv->stream;
670 fputs ("* /", _tmp22_);
671 }
672 }
673 }
674 }
675 lineparts = (_vala_array_free (lineparts, lineparts_length1, (GDestroyNotify) g_free), NULL);
676 _g_free0 (_tmp7_);
677 }
678 }
679 line_collection = (_vala_array_free (line_collection, line_collection_length1, (GDestroyNotify) g_free), NULL);
680 }
681 _tmp23_ = self->priv->stream;
682 fputs ("*/", _tmp23_);
683 vala_ccode_writer_write_newline (self);
684 }
685 goto __finally0;
686 __catch0_g_regex_error:
687 {
688 g_clear_error (&_inner_error0_);
689 }
690 __finally0:
691 if (G_UNLIKELY (_inner_error0_ != NULL)) {
692 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);
693 g_clear_error (&_inner_error0_);
694 return;
695 }
696 }
697
698 static void
vala_value_ccode_writer_init(GValue * value)699 vala_value_ccode_writer_init (GValue* value)
700 {
701 value->data[0].v_pointer = NULL;
702 }
703
704 static void
vala_value_ccode_writer_free_value(GValue * value)705 vala_value_ccode_writer_free_value (GValue* value)
706 {
707 if (value->data[0].v_pointer) {
708 vala_ccode_writer_unref (value->data[0].v_pointer);
709 }
710 }
711
712 static void
vala_value_ccode_writer_copy_value(const GValue * src_value,GValue * dest_value)713 vala_value_ccode_writer_copy_value (const GValue* src_value,
714 GValue* dest_value)
715 {
716 if (src_value->data[0].v_pointer) {
717 dest_value->data[0].v_pointer = vala_ccode_writer_ref (src_value->data[0].v_pointer);
718 } else {
719 dest_value->data[0].v_pointer = NULL;
720 }
721 }
722
723 static gpointer
vala_value_ccode_writer_peek_pointer(const GValue * value)724 vala_value_ccode_writer_peek_pointer (const GValue* value)
725 {
726 return value->data[0].v_pointer;
727 }
728
729 static gchar*
vala_value_ccode_writer_collect_value(GValue * value,guint n_collect_values,GTypeCValue * collect_values,guint collect_flags)730 vala_value_ccode_writer_collect_value (GValue* value,
731 guint n_collect_values,
732 GTypeCValue* collect_values,
733 guint collect_flags)
734 {
735 if (collect_values[0].v_pointer) {
736 ValaCCodeWriter * object;
737 object = collect_values[0].v_pointer;
738 if (object->parent_instance.g_class == NULL) {
739 return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
740 } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
741 return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
742 }
743 value->data[0].v_pointer = vala_ccode_writer_ref (object);
744 } else {
745 value->data[0].v_pointer = NULL;
746 }
747 return NULL;
748 }
749
750 static gchar*
vala_value_ccode_writer_lcopy_value(const GValue * value,guint n_collect_values,GTypeCValue * collect_values,guint collect_flags)751 vala_value_ccode_writer_lcopy_value (const GValue* value,
752 guint n_collect_values,
753 GTypeCValue* collect_values,
754 guint collect_flags)
755 {
756 ValaCCodeWriter ** object_p;
757 object_p = collect_values[0].v_pointer;
758 if (!object_p) {
759 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
760 }
761 if (!value->data[0].v_pointer) {
762 *object_p = NULL;
763 } else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
764 *object_p = value->data[0].v_pointer;
765 } else {
766 *object_p = vala_ccode_writer_ref (value->data[0].v_pointer);
767 }
768 return NULL;
769 }
770
771 GParamSpec*
vala_param_spec_ccode_writer(const gchar * name,const gchar * nick,const gchar * blurb,GType object_type,GParamFlags flags)772 vala_param_spec_ccode_writer (const gchar* name,
773 const gchar* nick,
774 const gchar* blurb,
775 GType object_type,
776 GParamFlags flags)
777 {
778 ValaParamSpecCCodeWriter* spec;
779 g_return_val_if_fail (g_type_is_a (object_type, VALA_TYPE_CCODE_WRITER), NULL);
780 spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
781 G_PARAM_SPEC (spec)->value_type = object_type;
782 return G_PARAM_SPEC (spec);
783 }
784
785 gpointer
vala_value_get_ccode_writer(const GValue * value)786 vala_value_get_ccode_writer (const GValue* value)
787 {
788 g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALA_TYPE_CCODE_WRITER), NULL);
789 return value->data[0].v_pointer;
790 }
791
792 void
vala_value_set_ccode_writer(GValue * value,gpointer v_object)793 vala_value_set_ccode_writer (GValue* value,
794 gpointer v_object)
795 {
796 ValaCCodeWriter * old;
797 g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALA_TYPE_CCODE_WRITER));
798 old = value->data[0].v_pointer;
799 if (v_object) {
800 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, VALA_TYPE_CCODE_WRITER));
801 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
802 value->data[0].v_pointer = v_object;
803 vala_ccode_writer_ref (value->data[0].v_pointer);
804 } else {
805 value->data[0].v_pointer = NULL;
806 }
807 if (old) {
808 vala_ccode_writer_unref (old);
809 }
810 }
811
812 void
vala_value_take_ccode_writer(GValue * value,gpointer v_object)813 vala_value_take_ccode_writer (GValue* value,
814 gpointer v_object)
815 {
816 ValaCCodeWriter * old;
817 g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALA_TYPE_CCODE_WRITER));
818 old = value->data[0].v_pointer;
819 if (v_object) {
820 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, VALA_TYPE_CCODE_WRITER));
821 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
822 value->data[0].v_pointer = v_object;
823 } else {
824 value->data[0].v_pointer = NULL;
825 }
826 if (old) {
827 vala_ccode_writer_unref (old);
828 }
829 }
830
831 static void
vala_ccode_writer_class_init(ValaCCodeWriterClass * klass,gpointer klass_data)832 vala_ccode_writer_class_init (ValaCCodeWriterClass * klass,
833 gpointer klass_data)
834 {
835 vala_ccode_writer_parent_class = g_type_class_peek_parent (klass);
836 ((ValaCCodeWriterClass *) klass)->finalize = vala_ccode_writer_finalize;
837 g_type_class_adjust_private_offset (klass, &ValaCCodeWriter_private_offset);
838 }
839
840 static void
vala_ccode_writer_instance_init(ValaCCodeWriter * self,gpointer klass)841 vala_ccode_writer_instance_init (ValaCCodeWriter * self,
842 gpointer klass)
843 {
844 self->priv = vala_ccode_writer_get_instance_private (self);
845 self->priv->current_line_number = 1;
846 self->priv->_bol = TRUE;
847 self->priv->_bael = FALSE;
848 self->ref_count = 1;
849 }
850
851 static void
vala_ccode_writer_finalize(ValaCCodeWriter * obj)852 vala_ccode_writer_finalize (ValaCCodeWriter * obj)
853 {
854 ValaCCodeWriter * self;
855 self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALA_TYPE_CCODE_WRITER, ValaCCodeWriter);
856 g_signal_handlers_destroy (self);
857 _g_free0 (self->priv->_filename);
858 _g_free0 (self->priv->source_filename);
859 _g_free0 (self->priv->temp_filename);
860 _fclose0 (self->priv->stream);
861 }
862
863 /**
864 * Represents a writer to write C source files.
865 */
866 static GType
vala_ccode_writer_get_type_once(void)867 vala_ccode_writer_get_type_once (void)
868 {
869 static const GTypeValueTable g_define_type_value_table = { vala_value_ccode_writer_init, vala_value_ccode_writer_free_value, vala_value_ccode_writer_copy_value, vala_value_ccode_writer_peek_pointer, "p", vala_value_ccode_writer_collect_value, "p", vala_value_ccode_writer_lcopy_value };
870 static const GTypeInfo g_define_type_info = { sizeof (ValaCCodeWriterClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_ccode_writer_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaCCodeWriter), 0, (GInstanceInitFunc) vala_ccode_writer_instance_init, &g_define_type_value_table };
871 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) };
872 GType vala_ccode_writer_type_id;
873 vala_ccode_writer_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ValaCCodeWriter", &g_define_type_info, &g_define_type_fundamental_info, 0);
874 ValaCCodeWriter_private_offset = g_type_add_instance_private (vala_ccode_writer_type_id, sizeof (ValaCCodeWriterPrivate));
875 return vala_ccode_writer_type_id;
876 }
877
878 GType
vala_ccode_writer_get_type(void)879 vala_ccode_writer_get_type (void)
880 {
881 static volatile gsize vala_ccode_writer_type_id__volatile = 0;
882 if (g_once_init_enter (&vala_ccode_writer_type_id__volatile)) {
883 GType vala_ccode_writer_type_id;
884 vala_ccode_writer_type_id = vala_ccode_writer_get_type_once ();
885 g_once_init_leave (&vala_ccode_writer_type_id__volatile, vala_ccode_writer_type_id);
886 }
887 return vala_ccode_writer_type_id__volatile;
888 }
889
890 gpointer
vala_ccode_writer_ref(gpointer instance)891 vala_ccode_writer_ref (gpointer instance)
892 {
893 ValaCCodeWriter * self;
894 self = instance;
895 g_atomic_int_inc (&self->ref_count);
896 return instance;
897 }
898
899 void
vala_ccode_writer_unref(gpointer instance)900 vala_ccode_writer_unref (gpointer instance)
901 {
902 ValaCCodeWriter * self;
903 self = instance;
904 if (g_atomic_int_dec_and_test (&self->ref_count)) {
905 VALA_CCODE_WRITER_GET_CLASS (self)->finalize (self);
906 g_type_free_instance ((GTypeInstance *) self);
907 }
908 }
909
910 static void
_vala_array_destroy(gpointer array,gint array_length,GDestroyNotify destroy_func)911 _vala_array_destroy (gpointer array,
912 gint array_length,
913 GDestroyNotify destroy_func)
914 {
915 if ((array != NULL) && (destroy_func != NULL)) {
916 gint i;
917 for (i = 0; i < array_length; i = i + 1) {
918 if (((gpointer*) array)[i] != NULL) {
919 destroy_func (((gpointer*) array)[i]);
920 }
921 }
922 }
923 }
924
925 static void
_vala_array_free(gpointer array,gint array_length,GDestroyNotify destroy_func)926 _vala_array_free (gpointer array,
927 gint array_length,
928 GDestroyNotify destroy_func)
929 {
930 _vala_array_destroy (array, array_length, destroy_func);
931 g_free (array);
932 }
933
934 static gint
_vala_array_length(gpointer array)935 _vala_array_length (gpointer array)
936 {
937 gint length;
938 length = 0;
939 if (array) {
940 while (((gpointer*) array)[length]) {
941 length++;
942 }
943 }
944 return length;
945 }
946
947