1 /* errorreporter.c generated by valac, the Vala compiler
2  * generated from errorreporter.vala, do not modify */
3 
4 /* errorreporter.vala
5  *
6  * Copyright (C) 2008-2011 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  * 	Brosch Florian <flo.brosch@gmail.com>
24  */
25 
26 #include "valadoc.h"
27 #include <glib.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <stdio.h>
31 #include <glib-object.h>
32 #include <gmodule.h>
33 #include <stdarg.h>
34 
35 enum  {
36 	VALADOC_ERROR_REPORTER_0_PROPERTY,
37 	VALADOC_ERROR_REPORTER_WARNINGS_OFFSET_PROPERTY,
38 	VALADOC_ERROR_REPORTER_ERRORS_OFFSET_PROPERTY,
39 	VALADOC_ERROR_REPORTER_STREAM_PROPERTY,
40 	VALADOC_ERROR_REPORTER_SETTINGS_PROPERTY,
41 	VALADOC_ERROR_REPORTER_ERRORS_PROPERTY,
42 	VALADOC_ERROR_REPORTER_WARNINGS_PROPERTY,
43 	VALADOC_ERROR_REPORTER_NUM_PROPERTIES
44 };
45 static GParamSpec* valadoc_error_reporter_properties[VALADOC_ERROR_REPORTER_NUM_PROPERTIES];
46 #define _g_free0(var) (var = (g_free (var), NULL))
47 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
48 #define _g_regex_unref0(var) ((var == NULL) ? NULL : (var = (g_regex_unref (var), NULL)))
49 #define _g_module_close0(var) ((var == NULL) ? NULL : (var = (g_module_close (var), NULL)))
50 typedef gint (*ValadocErrorReporterAttyFunc) (gint fd);
51 
52 struct _ValadocErrorReporterPrivate {
53 	gint _warnings;
54 	gint _errors;
55 	gchar* locus_color_start;
56 	const gchar* locus_color_end;
57 	gchar* warning_color_start;
58 	const gchar* warning_color_end;
59 	gchar* error_color_start;
60 	const gchar* error_color_end;
61 	gchar* note_color_start;
62 	const gchar* note_color_end;
63 	gchar* caret_color_start;
64 	const gchar* caret_color_end;
65 	gchar* quote_color_start;
66 	const gchar* quote_color_end;
67 	gint _warnings_offset;
68 	gint _errors_offset;
69 	FILE* _stream;
70 	ValadocSettings* _settings;
71 };
72 
73 static gint ValadocErrorReporter_private_offset;
74 static gpointer valadoc_error_reporter_parent_class = NULL;
75 
76 #define VALADOC_ERROR_REPORTER_ANSI_COLOR_END "\x1b[0m"
77 static gboolean valadoc_error_reporter_is_atty (ValadocErrorReporter* self,
78                                          gint fd);
79 static inline void valadoc_error_reporter_msg (ValadocErrorReporter* self,
80                                  const gchar* type,
81                                  const gchar* type_color_start,
82                                  const gchar* type_color_end,
83                                  const gchar* file,
84                                  glong line,
85                                  glong startpos,
86                                  glong endpos,
87                                  const gchar* errline,
88                                  const gchar* msg_format,
89                                  va_list args) G_GNUC_PRINTF(10,0);
90 static void valadoc_error_reporter_print_highlighted_message (ValadocErrorReporter* self,
91                                                        const gchar* message);
92 static void valadoc_error_reporter_finalize (GObject * obj);
93 static GType valadoc_error_reporter_get_type_once (void);
94 static void _vala_valadoc_error_reporter_get_property (GObject * object,
95                                                 guint property_id,
96                                                 GValue * value,
97                                                 GParamSpec * pspec);
98 static void _vala_valadoc_error_reporter_set_property (GObject * object,
99                                                 guint property_id,
100                                                 const GValue * value,
101                                                 GParamSpec * pspec);
102 static void _vala_array_destroy (gpointer array,
103                           gint array_length,
104                           GDestroyNotify destroy_func);
105 static void _vala_array_free (gpointer array,
106                        gint array_length,
107                        GDestroyNotify destroy_func);
108 static gint _vala_array_length (gpointer array);
109 
110 static inline gpointer
valadoc_error_reporter_get_instance_private(ValadocErrorReporter * self)111 valadoc_error_reporter_get_instance_private (ValadocErrorReporter* self)
112 {
113 	return G_STRUCT_MEMBER_P (self, ValadocErrorReporter_private_offset);
114 }
115 
116 gint
valadoc_error_reporter_get_warnings_offset(ValadocErrorReporter * self)117 valadoc_error_reporter_get_warnings_offset (ValadocErrorReporter* self)
118 {
119 	gint result;
120 	g_return_val_if_fail (self != NULL, 0);
121 	result = self->priv->_warnings_offset;
122 	return result;
123 }
124 
125 void
valadoc_error_reporter_set_warnings_offset(ValadocErrorReporter * self,gint value)126 valadoc_error_reporter_set_warnings_offset (ValadocErrorReporter* self,
127                                             gint value)
128 {
129 	gint old_value;
130 	g_return_if_fail (self != NULL);
131 	old_value = valadoc_error_reporter_get_warnings_offset (self);
132 	if (old_value != value) {
133 		self->priv->_warnings_offset = value;
134 		g_object_notify_by_pspec ((GObject *) self, valadoc_error_reporter_properties[VALADOC_ERROR_REPORTER_WARNINGS_OFFSET_PROPERTY]);
135 	}
136 }
137 
138 gint
valadoc_error_reporter_get_errors_offset(ValadocErrorReporter * self)139 valadoc_error_reporter_get_errors_offset (ValadocErrorReporter* self)
140 {
141 	gint result;
142 	g_return_val_if_fail (self != NULL, 0);
143 	result = self->priv->_errors_offset;
144 	return result;
145 }
146 
147 void
valadoc_error_reporter_set_errors_offset(ValadocErrorReporter * self,gint value)148 valadoc_error_reporter_set_errors_offset (ValadocErrorReporter* self,
149                                           gint value)
150 {
151 	gint old_value;
152 	g_return_if_fail (self != NULL);
153 	old_value = valadoc_error_reporter_get_errors_offset (self);
154 	if (old_value != value) {
155 		self->priv->_errors_offset = value;
156 		g_object_notify_by_pspec ((GObject *) self, valadoc_error_reporter_properties[VALADOC_ERROR_REPORTER_ERRORS_OFFSET_PROPERTY]);
157 	}
158 }
159 
160 FILE*
valadoc_error_reporter_get_stream(ValadocErrorReporter * self)161 valadoc_error_reporter_get_stream (ValadocErrorReporter* self)
162 {
163 	FILE* result;
164 	FILE* _tmp0_;
165 	g_return_val_if_fail (self != NULL, NULL);
166 	_tmp0_ = self->priv->_stream;
167 	result = _tmp0_;
168 	return result;
169 }
170 
171 void
valadoc_error_reporter_set_stream(ValadocErrorReporter * self,FILE * value)172 valadoc_error_reporter_set_stream (ValadocErrorReporter* self,
173                                    FILE* value)
174 {
175 	FILE* old_value;
176 	g_return_if_fail (self != NULL);
177 	old_value = valadoc_error_reporter_get_stream (self);
178 	if (old_value != value) {
179 		self->priv->_stream = value;
180 		g_object_notify_by_pspec ((GObject *) self, valadoc_error_reporter_properties[VALADOC_ERROR_REPORTER_STREAM_PROPERTY]);
181 	}
182 }
183 
184 ValadocSettings*
valadoc_error_reporter_get_settings(ValadocErrorReporter * self)185 valadoc_error_reporter_get_settings (ValadocErrorReporter* self)
186 {
187 	ValadocSettings* result;
188 	ValadocSettings* _tmp0_;
189 	g_return_val_if_fail (self != NULL, NULL);
190 	_tmp0_ = self->priv->_settings;
191 	result = _tmp0_;
192 	return result;
193 }
194 
195 static gpointer
_g_object_ref0(gpointer self)196 _g_object_ref0 (gpointer self)
197 {
198 	return self ? g_object_ref (self) : NULL;
199 }
200 
201 void
valadoc_error_reporter_set_settings(ValadocErrorReporter * self,ValadocSettings * value)202 valadoc_error_reporter_set_settings (ValadocErrorReporter* self,
203                                      ValadocSettings* value)
204 {
205 	ValadocSettings* old_value;
206 	g_return_if_fail (self != NULL);
207 	old_value = valadoc_error_reporter_get_settings (self);
208 	if (old_value != value) {
209 		ValadocSettings* _tmp0_;
210 		_tmp0_ = _g_object_ref0 (value);
211 		_g_object_unref0 (self->priv->_settings);
212 		self->priv->_settings = _tmp0_;
213 		g_object_notify_by_pspec ((GObject *) self, valadoc_error_reporter_properties[VALADOC_ERROR_REPORTER_SETTINGS_PROPERTY]);
214 	}
215 }
216 
217 gint
valadoc_error_reporter_get_errors(ValadocErrorReporter * self)218 valadoc_error_reporter_get_errors (ValadocErrorReporter* self)
219 {
220 	gint result;
221 	gint _tmp0_;
222 	g_return_val_if_fail (self != NULL, 0);
223 	_tmp0_ = self->priv->_errors_offset;
224 	result = self->priv->_errors + _tmp0_;
225 	return result;
226 }
227 
228 gint
valadoc_error_reporter_get_warnings(ValadocErrorReporter * self)229 valadoc_error_reporter_get_warnings (ValadocErrorReporter* self)
230 {
231 	gint result;
232 	gint _tmp0_;
233 	g_return_val_if_fail (self != NULL, 0);
234 	_tmp0_ = self->priv->_warnings_offset;
235 	result = self->priv->_warnings + _tmp0_;
236 	return result;
237 }
238 
239 ValadocErrorReporter*
valadoc_error_reporter_construct(GType object_type,ValadocSettings * settings)240 valadoc_error_reporter_construct (GType object_type,
241                                   ValadocSettings* settings)
242 {
243 	ValadocErrorReporter * self = NULL;
244 	FILE* _tmp0_;
245 	self = (ValadocErrorReporter*) g_object_new (object_type, NULL);
246 	_tmp0_ = stderr;
247 	valadoc_error_reporter_set_stream (self, _tmp0_);
248 	valadoc_error_reporter_set_settings (self, settings);
249 	return self;
250 }
251 
252 ValadocErrorReporter*
valadoc_error_reporter_new(ValadocSettings * settings)253 valadoc_error_reporter_new (ValadocSettings* settings)
254 {
255 	return valadoc_error_reporter_construct (VALADOC_TYPE_ERROR_REPORTER, settings);
256 }
257 
258 /**
259  * Set all colors by string
260  *
261  * {{{
262  *   "error=01;31:warning=01;35:note=01;36:caret=01;32:locus=01:quote=01"
263  * }}}
264  */
265 gboolean
valadoc_error_reporter_set_colors(ValadocErrorReporter * self,const gchar * str)266 valadoc_error_reporter_set_colors (ValadocErrorReporter* self,
267                                    const gchar* str)
268 {
269 	GRegex* val_regex = NULL;
270 	gchar* error_color = NULL;
271 	gchar* warning_color = NULL;
272 	gchar* note_color = NULL;
273 	gchar* caret_color = NULL;
274 	gchar* locus_color = NULL;
275 	gchar* quote_color = NULL;
276 	gchar** fragments = NULL;
277 	gchar** _tmp5_;
278 	gchar** _tmp6_;
279 	gint fragments_length1;
280 	gint _fragments_size_;
281 	gchar** _tmp7_;
282 	gint _tmp7__length1;
283 	FILE* _tmp36_;
284 	GError* _inner_error0_ = NULL;
285 	gboolean result = FALSE;
286 	g_return_val_if_fail (self != NULL, FALSE);
287 	g_return_val_if_fail (str != NULL, FALSE);
288 	{
289 		GRegex* _tmp0_ = NULL;
290 		GRegex* _tmp1_;
291 		GRegex* _tmp3_;
292 		_tmp1_ = g_regex_new ("^\\s*[0-9]+(;[0-9]*)*\\s*$", 0, 0, &_inner_error0_);
293 		_tmp0_ = _tmp1_;
294 		if (G_UNLIKELY (_inner_error0_ != NULL)) {
295 			gboolean _tmp2_ = FALSE;
296 			if (_inner_error0_->domain == G_REGEX_ERROR) {
297 				goto __catch0_g_regex_error;
298 			}
299 			_g_regex_unref0 (val_regex);
300 			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);
301 			g_clear_error (&_inner_error0_);
302 			return _tmp2_;
303 		}
304 		_tmp3_ = _tmp0_;
305 		_tmp0_ = NULL;
306 		_g_regex_unref0 (val_regex);
307 		val_regex = _tmp3_;
308 		_g_regex_unref0 (_tmp0_);
309 	}
310 	goto __finally0;
311 	__catch0_g_regex_error:
312 	{
313 		g_clear_error (&_inner_error0_);
314 		g_assert_not_reached ();
315 	}
316 	__finally0:
317 	if (G_UNLIKELY (_inner_error0_ != NULL)) {
318 		gboolean _tmp4_ = FALSE;
319 		_g_regex_unref0 (val_regex);
320 		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);
321 		g_clear_error (&_inner_error0_);
322 		return _tmp4_;
323 	}
324 	error_color = NULL;
325 	warning_color = NULL;
326 	note_color = NULL;
327 	caret_color = NULL;
328 	locus_color = NULL;
329 	quote_color = NULL;
330 	_tmp6_ = _tmp5_ = g_strsplit (str, ":", 0);
331 	fragments = _tmp6_;
332 	fragments_length1 = _vala_array_length (_tmp5_);
333 	_fragments_size_ = fragments_length1;
334 	_tmp7_ = fragments;
335 	_tmp7__length1 = fragments_length1;
336 	{
337 		gchar** fragment_collection = NULL;
338 		gint fragment_collection_length1 = 0;
339 		gint _fragment_collection_size_ = 0;
340 		gint fragment_it = 0;
341 		fragment_collection = _tmp7_;
342 		fragment_collection_length1 = _tmp7__length1;
343 		for (fragment_it = 0; fragment_it < fragment_collection_length1; fragment_it = fragment_it + 1) {
344 			const gchar* fragment = NULL;
345 			fragment = fragment_collection[fragment_it];
346 			{
347 				gchar** eq = NULL;
348 				const gchar* _tmp8_;
349 				gchar** _tmp9_;
350 				gchar** _tmp10_;
351 				gint eq_length1;
352 				gint _eq_size_;
353 				gchar** _tmp11_;
354 				gint _tmp11__length1;
355 				GRegex* _tmp12_;
356 				gchar** _tmp13_;
357 				gint _tmp13__length1;
358 				const gchar* _tmp14_;
359 				const gchar* checked_value = NULL;
360 				gchar** _tmp15_;
361 				gint _tmp15__length1;
362 				const gchar* _tmp16_;
363 				const gchar* _tmp17_;
364 				gchar** _tmp18_;
365 				gint _tmp18__length1;
366 				const gchar* _tmp19_;
367 				const gchar* _tmp20_;
368 				const gchar* _tmp21_;
369 				GQuark _tmp23_ = 0U;
370 				static GQuark _tmp22_label0 = 0;
371 				static GQuark _tmp22_label1 = 0;
372 				static GQuark _tmp22_label2 = 0;
373 				static GQuark _tmp22_label3 = 0;
374 				static GQuark _tmp22_label4 = 0;
375 				static GQuark _tmp22_label5 = 0;
376 				_tmp8_ = fragment;
377 				_tmp10_ = _tmp9_ = g_strsplit (_tmp8_, "=", 2);
378 				eq = _tmp10_;
379 				eq_length1 = _vala_array_length (_tmp9_);
380 				_eq_size_ = eq_length1;
381 				_tmp11_ = eq;
382 				_tmp11__length1 = eq_length1;
383 				if (_tmp11__length1 != 2) {
384 					result = FALSE;
385 					eq = (_vala_array_free (eq, eq_length1, (GDestroyNotify) g_free), NULL);
386 					fragments = (_vala_array_free (fragments, fragments_length1, (GDestroyNotify) g_free), NULL);
387 					_g_free0 (quote_color);
388 					_g_free0 (locus_color);
389 					_g_free0 (caret_color);
390 					_g_free0 (note_color);
391 					_g_free0 (warning_color);
392 					_g_free0 (error_color);
393 					_g_regex_unref0 (val_regex);
394 					return result;
395 				}
396 				_tmp12_ = val_regex;
397 				_tmp13_ = eq;
398 				_tmp13__length1 = eq_length1;
399 				_tmp14_ = _tmp13_[1];
400 				if (!g_regex_match (_tmp12_, _tmp14_, 0, NULL)) {
401 					result = FALSE;
402 					eq = (_vala_array_free (eq, eq_length1, (GDestroyNotify) g_free), NULL);
403 					fragments = (_vala_array_free (fragments, fragments_length1, (GDestroyNotify) g_free), NULL);
404 					_g_free0 (quote_color);
405 					_g_free0 (locus_color);
406 					_g_free0 (caret_color);
407 					_g_free0 (note_color);
408 					_g_free0 (warning_color);
409 					_g_free0 (error_color);
410 					_g_regex_unref0 (val_regex);
411 					return result;
412 				}
413 				_tmp15_ = eq;
414 				_tmp15__length1 = eq_length1;
415 				_tmp16_ = _tmp15_[1];
416 				_tmp17_ = g_strstrip (_tmp16_);
417 				checked_value = _tmp17_;
418 				_tmp18_ = eq;
419 				_tmp18__length1 = eq_length1;
420 				_tmp19_ = _tmp18_[0];
421 				_tmp20_ = g_strstrip (_tmp19_);
422 				_tmp21_ = _tmp20_;
423 				_tmp23_ = (NULL == _tmp21_) ? 0 : g_quark_from_string (_tmp21_);
424 				if (_tmp23_ == ((0 != _tmp22_label0) ? _tmp22_label0 : (_tmp22_label0 = g_quark_from_static_string ("error")))) {
425 					switch (0) {
426 						default:
427 						{
428 							const gchar* _tmp24_;
429 							gchar* _tmp25_;
430 							_tmp24_ = checked_value;
431 							_tmp25_ = g_strdup (_tmp24_);
432 							_g_free0 (error_color);
433 							error_color = _tmp25_;
434 							break;
435 						}
436 					}
437 				} else if (_tmp23_ == ((0 != _tmp22_label1) ? _tmp22_label1 : (_tmp22_label1 = g_quark_from_static_string ("warning")))) {
438 					switch (0) {
439 						default:
440 						{
441 							const gchar* _tmp26_;
442 							gchar* _tmp27_;
443 							_tmp26_ = checked_value;
444 							_tmp27_ = g_strdup (_tmp26_);
445 							_g_free0 (warning_color);
446 							warning_color = _tmp27_;
447 							break;
448 						}
449 					}
450 				} else if (_tmp23_ == ((0 != _tmp22_label2) ? _tmp22_label2 : (_tmp22_label2 = g_quark_from_static_string ("note")))) {
451 					switch (0) {
452 						default:
453 						{
454 							const gchar* _tmp28_;
455 							gchar* _tmp29_;
456 							_tmp28_ = checked_value;
457 							_tmp29_ = g_strdup (_tmp28_);
458 							_g_free0 (note_color);
459 							note_color = _tmp29_;
460 							break;
461 						}
462 					}
463 				} else if (_tmp23_ == ((0 != _tmp22_label3) ? _tmp22_label3 : (_tmp22_label3 = g_quark_from_static_string ("caret")))) {
464 					switch (0) {
465 						default:
466 						{
467 							const gchar* _tmp30_;
468 							gchar* _tmp31_;
469 							_tmp30_ = checked_value;
470 							_tmp31_ = g_strdup (_tmp30_);
471 							_g_free0 (caret_color);
472 							caret_color = _tmp31_;
473 							break;
474 						}
475 					}
476 				} else if (_tmp23_ == ((0 != _tmp22_label4) ? _tmp22_label4 : (_tmp22_label4 = g_quark_from_static_string ("locus")))) {
477 					switch (0) {
478 						default:
479 						{
480 							const gchar* _tmp32_;
481 							gchar* _tmp33_;
482 							_tmp32_ = checked_value;
483 							_tmp33_ = g_strdup (_tmp32_);
484 							_g_free0 (locus_color);
485 							locus_color = _tmp33_;
486 							break;
487 						}
488 					}
489 				} else if (_tmp23_ == ((0 != _tmp22_label5) ? _tmp22_label5 : (_tmp22_label5 = g_quark_from_static_string ("quote")))) {
490 					switch (0) {
491 						default:
492 						{
493 							const gchar* _tmp34_;
494 							gchar* _tmp35_;
495 							_tmp34_ = checked_value;
496 							_tmp35_ = g_strdup (_tmp34_);
497 							_g_free0 (quote_color);
498 							quote_color = _tmp35_;
499 							break;
500 						}
501 					}
502 				} else {
503 					switch (0) {
504 						default:
505 						{
506 							result = FALSE;
507 							eq = (_vala_array_free (eq, eq_length1, (GDestroyNotify) g_free), NULL);
508 							fragments = (_vala_array_free (fragments, fragments_length1, (GDestroyNotify) g_free), NULL);
509 							_g_free0 (quote_color);
510 							_g_free0 (locus_color);
511 							_g_free0 (caret_color);
512 							_g_free0 (note_color);
513 							_g_free0 (warning_color);
514 							_g_free0 (error_color);
515 							_g_regex_unref0 (val_regex);
516 							return result;
517 						}
518 					}
519 				}
520 				eq = (_vala_array_free (eq, eq_length1, (GDestroyNotify) g_free), NULL);
521 			}
522 		}
523 	}
524 	_tmp36_ = self->priv->_stream;
525 	if (valadoc_error_reporter_is_atty (self, fileno (_tmp36_))) {
526 		const gchar* _tmp37_;
527 		const gchar* _tmp42_;
528 		const gchar* _tmp47_;
529 		const gchar* _tmp52_;
530 		const gchar* _tmp57_;
531 		const gchar* _tmp62_;
532 		_tmp37_ = error_color;
533 		if (_tmp37_ != NULL) {
534 			const gchar* _tmp38_;
535 			gchar* _tmp39_;
536 			gchar* _tmp40_;
537 			gchar* _tmp41_;
538 			_tmp38_ = error_color;
539 			_tmp39_ = g_strconcat ("\x1b[0", _tmp38_, NULL);
540 			_tmp40_ = _tmp39_;
541 			_tmp41_ = g_strconcat (_tmp40_, "m", NULL);
542 			_g_free0 (self->priv->error_color_start);
543 			self->priv->error_color_start = _tmp41_;
544 			_g_free0 (_tmp40_);
545 			self->priv->error_color_end = VALADOC_ERROR_REPORTER_ANSI_COLOR_END;
546 		}
547 		_tmp42_ = warning_color;
548 		if (_tmp42_ != NULL) {
549 			const gchar* _tmp43_;
550 			gchar* _tmp44_;
551 			gchar* _tmp45_;
552 			gchar* _tmp46_;
553 			_tmp43_ = warning_color;
554 			_tmp44_ = g_strconcat ("\x1b[0", _tmp43_, NULL);
555 			_tmp45_ = _tmp44_;
556 			_tmp46_ = g_strconcat (_tmp45_, "m", NULL);
557 			_g_free0 (self->priv->warning_color_start);
558 			self->priv->warning_color_start = _tmp46_;
559 			_g_free0 (_tmp45_);
560 			self->priv->warning_color_end = VALADOC_ERROR_REPORTER_ANSI_COLOR_END;
561 		}
562 		_tmp47_ = note_color;
563 		if (_tmp47_ != NULL) {
564 			const gchar* _tmp48_;
565 			gchar* _tmp49_;
566 			gchar* _tmp50_;
567 			gchar* _tmp51_;
568 			_tmp48_ = note_color;
569 			_tmp49_ = g_strconcat ("\x1b[0", _tmp48_, NULL);
570 			_tmp50_ = _tmp49_;
571 			_tmp51_ = g_strconcat (_tmp50_, "m", NULL);
572 			_g_free0 (self->priv->note_color_start);
573 			self->priv->note_color_start = _tmp51_;
574 			_g_free0 (_tmp50_);
575 			self->priv->note_color_end = VALADOC_ERROR_REPORTER_ANSI_COLOR_END;
576 		}
577 		_tmp52_ = caret_color;
578 		if (_tmp52_ != NULL) {
579 			const gchar* _tmp53_;
580 			gchar* _tmp54_;
581 			gchar* _tmp55_;
582 			gchar* _tmp56_;
583 			_tmp53_ = caret_color;
584 			_tmp54_ = g_strconcat ("\x1b[0", _tmp53_, NULL);
585 			_tmp55_ = _tmp54_;
586 			_tmp56_ = g_strconcat (_tmp55_, "m", NULL);
587 			_g_free0 (self->priv->caret_color_start);
588 			self->priv->caret_color_start = _tmp56_;
589 			_g_free0 (_tmp55_);
590 			self->priv->caret_color_end = VALADOC_ERROR_REPORTER_ANSI_COLOR_END;
591 		}
592 		_tmp57_ = locus_color;
593 		if (_tmp57_ != NULL) {
594 			const gchar* _tmp58_;
595 			gchar* _tmp59_;
596 			gchar* _tmp60_;
597 			gchar* _tmp61_;
598 			_tmp58_ = locus_color;
599 			_tmp59_ = g_strconcat ("\x1b[0", _tmp58_, NULL);
600 			_tmp60_ = _tmp59_;
601 			_tmp61_ = g_strconcat (_tmp60_, "m", NULL);
602 			_g_free0 (self->priv->locus_color_start);
603 			self->priv->locus_color_start = _tmp61_;
604 			_g_free0 (_tmp60_);
605 			self->priv->locus_color_end = VALADOC_ERROR_REPORTER_ANSI_COLOR_END;
606 		}
607 		_tmp62_ = quote_color;
608 		if (_tmp62_ != NULL) {
609 			const gchar* _tmp63_;
610 			gchar* _tmp64_;
611 			gchar* _tmp65_;
612 			gchar* _tmp66_;
613 			_tmp63_ = quote_color;
614 			_tmp64_ = g_strconcat ("\x1b[0", _tmp63_, NULL);
615 			_tmp65_ = _tmp64_;
616 			_tmp66_ = g_strconcat (_tmp65_, "m", NULL);
617 			_g_free0 (self->priv->quote_color_start);
618 			self->priv->quote_color_start = _tmp66_;
619 			_g_free0 (_tmp65_);
620 			self->priv->quote_color_end = VALADOC_ERROR_REPORTER_ANSI_COLOR_END;
621 		}
622 	}
623 	result = TRUE;
624 	fragments = (_vala_array_free (fragments, fragments_length1, (GDestroyNotify) g_free), NULL);
625 	_g_free0 (quote_color);
626 	_g_free0 (locus_color);
627 	_g_free0 (caret_color);
628 	_g_free0 (note_color);
629 	_g_free0 (warning_color);
630 	_g_free0 (error_color);
631 	_g_regex_unref0 (val_regex);
632 	return result;
633 }
634 
635 static gboolean
valadoc_error_reporter_is_atty(ValadocErrorReporter * self,gint fd)636 valadoc_error_reporter_is_atty (ValadocErrorReporter* self,
637                                 gint fd)
638 {
639 	GModule* module = NULL;
640 	GModule* _tmp0_;
641 	GModule* _tmp1_;
642 	void* _func = NULL;
643 	GModule* _tmp2_;
644 	void* _tmp3_ = NULL;
645 	void* _tmp4_;
646 	ValadocErrorReporterAttyFunc func = NULL;
647 	void* _tmp5_;
648 	ValadocErrorReporterAttyFunc _tmp6_;
649 	gboolean result = FALSE;
650 	g_return_val_if_fail (self != NULL, FALSE);
651 	_tmp0_ = g_module_open (NULL, G_MODULE_BIND_LAZY);
652 	module = _tmp0_;
653 	_tmp1_ = module;
654 	if (_tmp1_ == NULL) {
655 		result = FALSE;
656 		_g_module_close0 (module);
657 		return result;
658 	}
659 	_tmp2_ = module;
660 	g_module_symbol (_tmp2_, "isatty", &_tmp3_);
661 	_func = _tmp3_;
662 	_tmp4_ = _func;
663 	if (_tmp4_ == NULL) {
664 		result = FALSE;
665 		_g_module_close0 (module);
666 		return result;
667 	}
668 	_tmp5_ = _func;
669 	func = (ValadocErrorReporterAttyFunc) _tmp5_;
670 	_tmp6_ = func;
671 	result = _tmp6_ (fd) == 1;
672 	_g_module_close0 (module);
673 	return result;
674 }
675 
676 static gchar
string_get(const gchar * self,glong index)677 string_get (const gchar* self,
678             glong index)
679 {
680 	gchar _tmp0_;
681 	gchar result = '\0';
682 	g_return_val_if_fail (self != NULL, '\0');
683 	_tmp0_ = ((gchar*) self)[index];
684 	result = _tmp0_;
685 	return result;
686 }
687 
688 static inline void
valadoc_error_reporter_msg(ValadocErrorReporter * self,const gchar * type,const gchar * type_color_start,const gchar * type_color_end,const gchar * file,glong line,glong startpos,glong endpos,const gchar * errline,const gchar * msg_format,va_list args)689 valadoc_error_reporter_msg (ValadocErrorReporter* self,
690                             const gchar* type,
691                             const gchar* type_color_start,
692                             const gchar* type_color_end,
693                             const gchar* file,
694                             glong line,
695                             glong startpos,
696                             glong endpos,
697                             const gchar* errline,
698                             const gchar* msg_format,
699                             va_list args)
700 {
701 	FILE* _tmp0_;
702 	const gchar* _tmp1_;
703 	const gchar* _tmp2_;
704 	gchar* _tmp3_;
705 	gchar* _tmp4_;
706 	FILE* _tmp5_;
707 	g_return_if_fail (self != NULL);
708 	g_return_if_fail (type != NULL);
709 	g_return_if_fail (type_color_start != NULL);
710 	g_return_if_fail (type_color_end != NULL);
711 	g_return_if_fail (file != NULL);
712 	g_return_if_fail (errline != NULL);
713 	g_return_if_fail (msg_format != NULL);
714 	_tmp0_ = self->priv->_stream;
715 	_tmp1_ = self->priv->locus_color_start;
716 	_tmp2_ = self->priv->locus_color_end;
717 	fprintf (_tmp0_, "%s%s:%lu.%lu-%lu.%lu:%s %s%s:%s ", _tmp1_, file, (gulong) line, (gulong) startpos, (gulong) line, (gulong) endpos, _tmp2_, type_color_start, type, type_color_end);
718 	_tmp3_ = g_strdup_vprintf (msg_format, args);
719 	_tmp4_ = _tmp3_;
720 	valadoc_error_reporter_print_highlighted_message (self, _tmp4_);
721 	_g_free0 (_tmp4_);
722 	_tmp5_ = self->priv->_stream;
723 	fputc ('\n', _tmp5_);
724 	if (startpos <= endpos) {
725 		FILE* _tmp6_;
726 		FILE* _tmp7_;
727 		const gchar* _tmp8_;
728 		FILE* _tmp15_;
729 		const gchar* _tmp16_;
730 		FILE* _tmp17_;
731 		_tmp6_ = self->priv->_stream;
732 		fprintf (_tmp6_, "%s\n", errline);
733 		_tmp7_ = self->priv->_stream;
734 		_tmp8_ = self->priv->caret_color_start;
735 		fputs (_tmp8_, _tmp7_);
736 		{
737 			gint i = 0;
738 			i = 0;
739 			{
740 				gboolean _tmp9_ = FALSE;
741 				_tmp9_ = TRUE;
742 				while (TRUE) {
743 					if (!_tmp9_) {
744 						gint _tmp10_;
745 						_tmp10_ = i;
746 						i = _tmp10_ + 1;
747 					}
748 					_tmp9_ = FALSE;
749 					if (!(i < (g_utf8_strlen (errline, (gssize) -1) + 1))) {
750 						break;
751 					}
752 					if (string_get (errline, (glong) i) == '\t') {
753 						FILE* _tmp11_;
754 						_tmp11_ = self->priv->_stream;
755 						fprintf (_tmp11_, "\t");
756 					} else {
757 						gboolean _tmp12_ = FALSE;
758 						if (((glong) i) >= (startpos - 1)) {
759 							_tmp12_ = ((glong) i) < (endpos - 1);
760 						} else {
761 							_tmp12_ = FALSE;
762 						}
763 						if (_tmp12_) {
764 							FILE* _tmp13_;
765 							_tmp13_ = self->priv->_stream;
766 							fprintf (_tmp13_, "^");
767 						} else {
768 							FILE* _tmp14_;
769 							_tmp14_ = self->priv->_stream;
770 							fprintf (_tmp14_, " ");
771 						}
772 					}
773 				}
774 			}
775 		}
776 		_tmp15_ = self->priv->_stream;
777 		_tmp16_ = self->priv->caret_color_end;
778 		fputs (_tmp16_, _tmp15_);
779 		_tmp17_ = self->priv->_stream;
780 		fprintf (_tmp17_, "\n");
781 	}
782 }
783 
784 static glong
string_strnlen(gchar * str,glong maxlen)785 string_strnlen (gchar* str,
786                 glong maxlen)
787 {
788 	gchar* end = NULL;
789 	gchar* _tmp0_;
790 	gchar* _tmp1_;
791 	glong result = 0L;
792 	_tmp0_ = memchr (str, 0, (gsize) maxlen);
793 	end = _tmp0_;
794 	_tmp1_ = end;
795 	if (_tmp1_ == NULL) {
796 		result = maxlen;
797 		return result;
798 	} else {
799 		gchar* _tmp2_;
800 		_tmp2_ = end;
801 		result = (glong) (_tmp2_ - str);
802 		return result;
803 	}
804 }
805 
806 static gchar*
string_substring(const gchar * self,glong offset,glong len)807 string_substring (const gchar* self,
808                   glong offset,
809                   glong len)
810 {
811 	glong string_length = 0L;
812 	gboolean _tmp0_ = FALSE;
813 	gchar* _tmp3_;
814 	gchar* result = NULL;
815 	g_return_val_if_fail (self != NULL, NULL);
816 	if (offset >= ((glong) 0)) {
817 		_tmp0_ = len >= ((glong) 0);
818 	} else {
819 		_tmp0_ = FALSE;
820 	}
821 	if (_tmp0_) {
822 		string_length = string_strnlen ((gchar*) self, offset + len);
823 	} else {
824 		gint _tmp1_;
825 		gint _tmp2_;
826 		_tmp1_ = strlen (self);
827 		_tmp2_ = _tmp1_;
828 		string_length = (glong) _tmp2_;
829 	}
830 	if (offset < ((glong) 0)) {
831 		offset = string_length + offset;
832 		g_return_val_if_fail (offset >= ((glong) 0), NULL);
833 	} else {
834 		g_return_val_if_fail (offset <= string_length, NULL);
835 	}
836 	if (len < ((glong) 0)) {
837 		len = string_length - offset;
838 	}
839 	g_return_val_if_fail ((offset + len) <= string_length, NULL);
840 	_tmp3_ = g_strndup (((gchar*) self) + offset, (gsize) len);
841 	result = _tmp3_;
842 	return result;
843 }
844 
845 static gint
string_index_of_char(const gchar * self,gunichar c,gint start_index)846 string_index_of_char (const gchar* self,
847                       gunichar c,
848                       gint start_index)
849 {
850 	gchar* _result_ = NULL;
851 	gchar* _tmp0_;
852 	gchar* _tmp1_;
853 	gint result = 0;
854 	g_return_val_if_fail (self != NULL, 0);
855 	_tmp0_ = g_utf8_strchr (((gchar*) self) + start_index, (gssize) -1, c);
856 	_result_ = _tmp0_;
857 	_tmp1_ = _result_;
858 	if (_tmp1_ != NULL) {
859 		gchar* _tmp2_;
860 		_tmp2_ = _result_;
861 		result = (gint) (_tmp2_ - ((gchar*) self));
862 		return result;
863 	} else {
864 		result = -1;
865 		return result;
866 	}
867 }
868 
869 static const gchar*
string_offset(const gchar * self,glong offset)870 string_offset (const gchar* self,
871                glong offset)
872 {
873 	const gchar* result = NULL;
874 	g_return_val_if_fail (self != NULL, NULL);
875 	result = (const gchar*) (((gchar*) self) + offset);
876 	return result;
877 }
878 
879 static void
valadoc_error_reporter_print_highlighted_message(ValadocErrorReporter * self,const gchar * message)880 valadoc_error_reporter_print_highlighted_message (ValadocErrorReporter* self,
881                                                   const gchar* message)
882 {
883 	gint start = 0;
884 	gint cur = 0;
885 	FILE* _tmp19_;
886 	const gchar* _tmp20_;
887 	g_return_if_fail (self != NULL);
888 	g_return_if_fail (message != NULL);
889 	start = 0;
890 	cur = 0;
891 	while (TRUE) {
892 		gboolean _tmp0_ = FALSE;
893 		if (!(string_get (message, (glong) cur) != '\0')) {
894 			break;
895 		}
896 		if (string_get (message, (glong) cur) == '\'') {
897 			_tmp0_ = TRUE;
898 		} else {
899 			_tmp0_ = string_get (message, (glong) cur) == '`';
900 		}
901 		if (_tmp0_) {
902 			const gchar* _tmp1_ = NULL;
903 			const gchar* end_chars = NULL;
904 			FILE* _tmp2_;
905 			gchar* _tmp3_;
906 			gchar* _tmp4_;
907 			gint _tmp5_;
908 			if (string_get (message, (glong) cur) == '`') {
909 				_tmp1_ = "`'";
910 			} else {
911 				_tmp1_ = "'";
912 			}
913 			end_chars = _tmp1_;
914 			_tmp2_ = self->priv->_stream;
915 			_tmp3_ = string_substring (message, (glong) start, (glong) (cur - start));
916 			_tmp4_ = _tmp3_;
917 			fputs (_tmp4_, _tmp2_);
918 			_g_free0 (_tmp4_);
919 			start = cur;
920 			_tmp5_ = cur;
921 			cur = _tmp5_ + 1;
922 			while (TRUE) {
923 				gboolean _tmp6_ = FALSE;
924 				gint _tmp8_;
925 				if (string_get (message, (glong) cur) != '\0') {
926 					const gchar* _tmp7_;
927 					_tmp7_ = end_chars;
928 					_tmp6_ = string_index_of_char (_tmp7_, (gunichar) string_get (message, (glong) cur), 0) < 0;
929 				} else {
930 					_tmp6_ = FALSE;
931 				}
932 				if (!_tmp6_) {
933 					break;
934 				}
935 				_tmp8_ = cur;
936 				cur = _tmp8_ + 1;
937 			}
938 			if (string_get (message, (glong) cur) == '\0') {
939 				FILE* _tmp9_;
940 				gchar* _tmp10_;
941 				gchar* _tmp11_;
942 				_tmp9_ = self->priv->_stream;
943 				_tmp10_ = string_substring (message, (glong) start, (glong) (cur - start));
944 				_tmp11_ = _tmp10_;
945 				fputs (_tmp11_, _tmp9_);
946 				_g_free0 (_tmp11_);
947 				start = cur;
948 			} else {
949 				gint _tmp12_;
950 				FILE* _tmp13_;
951 				const gchar* _tmp14_;
952 				gchar* _tmp15_;
953 				gchar* _tmp16_;
954 				const gchar* _tmp17_;
955 				_tmp12_ = cur;
956 				cur = _tmp12_ + 1;
957 				_tmp13_ = self->priv->_stream;
958 				_tmp14_ = self->priv->quote_color_start;
959 				_tmp15_ = string_substring (message, (glong) start, (glong) (cur - start));
960 				_tmp16_ = _tmp15_;
961 				_tmp17_ = self->priv->quote_color_end;
962 				fprintf (_tmp13_, "%s%s%s", _tmp14_, _tmp16_, _tmp17_);
963 				_g_free0 (_tmp16_);
964 				start = cur;
965 			}
966 		} else {
967 			gint _tmp18_;
968 			_tmp18_ = cur;
969 			cur = _tmp18_ + 1;
970 		}
971 	}
972 	_tmp19_ = self->priv->_stream;
973 	_tmp20_ = string_offset (message, (glong) start);
974 	fputs (_tmp20_, _tmp19_);
975 }
976 
977 void
valadoc_error_reporter_simple_warning(ValadocErrorReporter * self,const gchar * location,const gchar * msg_format,...)978 valadoc_error_reporter_simple_warning (ValadocErrorReporter* self,
979                                        const gchar* location,
980                                        const gchar* msg_format,
981                                        ...)
982 {
983 	va_list args = {0};
984 	FILE* _tmp6_;
985 	const gchar* _tmp7_;
986 	FILE* _tmp8_;
987 	FILE* _tmp9_;
988 	const gchar* _tmp10_;
989 	gchar* _tmp11_;
990 	gchar* _tmp12_;
991 	FILE* _tmp13_;
992 	gint _tmp14_;
993 	g_return_if_fail (self != NULL);
994 	g_return_if_fail (msg_format != NULL);
995 	va_start (args, msg_format);
996 	if (location != NULL) {
997 		FILE* _tmp0_;
998 		const gchar* _tmp1_;
999 		FILE* _tmp2_;
1000 		FILE* _tmp3_;
1001 		FILE* _tmp4_;
1002 		const gchar* _tmp5_;
1003 		_tmp0_ = self->priv->_stream;
1004 		_tmp1_ = self->priv->locus_color_start;
1005 		fputs (_tmp1_, _tmp0_);
1006 		_tmp2_ = self->priv->_stream;
1007 		fputs (location, _tmp2_);
1008 		_tmp3_ = self->priv->_stream;
1009 		fputs (": ", _tmp3_);
1010 		_tmp4_ = self->priv->_stream;
1011 		_tmp5_ = self->priv->locus_color_end;
1012 		fputs (_tmp5_, _tmp4_);
1013 	}
1014 	_tmp6_ = self->priv->_stream;
1015 	_tmp7_ = self->priv->warning_color_start;
1016 	fputs (_tmp7_, _tmp6_);
1017 	_tmp8_ = self->priv->_stream;
1018 	fputs ("warning: ", _tmp8_);
1019 	_tmp9_ = self->priv->_stream;
1020 	_tmp10_ = self->priv->warning_color_end;
1021 	fputs (_tmp10_, _tmp9_);
1022 	_tmp11_ = g_strdup_vprintf (msg_format, args);
1023 	_tmp12_ = _tmp11_;
1024 	valadoc_error_reporter_print_highlighted_message (self, _tmp12_);
1025 	_g_free0 (_tmp12_);
1026 	_tmp13_ = self->priv->_stream;
1027 	fputc ('\n', _tmp13_);
1028 	_tmp14_ = self->priv->_warnings;
1029 	self->priv->_warnings = _tmp14_ + 1;
1030 	va_end (args);
1031 }
1032 
1033 void
valadoc_error_reporter_simple_error(ValadocErrorReporter * self,const gchar * location,const gchar * msg_format,...)1034 valadoc_error_reporter_simple_error (ValadocErrorReporter* self,
1035                                      const gchar* location,
1036                                      const gchar* msg_format,
1037                                      ...)
1038 {
1039 	va_list args = {0};
1040 	FILE* _tmp7_;
1041 	const gchar* _tmp8_;
1042 	FILE* _tmp9_;
1043 	FILE* _tmp10_;
1044 	const gchar* _tmp11_;
1045 	gchar* _tmp12_;
1046 	gchar* _tmp13_;
1047 	FILE* _tmp14_;
1048 	gint _tmp15_;
1049 	g_return_if_fail (self != NULL);
1050 	g_return_if_fail (msg_format != NULL);
1051 	va_start (args, msg_format);
1052 	if (location != NULL) {
1053 		FILE* _tmp0_;
1054 		const gchar* _tmp1_;
1055 		FILE* _tmp2_;
1056 		FILE* _tmp3_;
1057 		FILE* _tmp4_;
1058 		const gchar* _tmp5_;
1059 		FILE* _tmp6_;
1060 		_tmp0_ = self->priv->_stream;
1061 		_tmp1_ = self->priv->locus_color_start;
1062 		fputs (_tmp1_, _tmp0_);
1063 		_tmp2_ = self->priv->_stream;
1064 		fputs (location, _tmp2_);
1065 		_tmp3_ = self->priv->_stream;
1066 		fputs (": ", _tmp3_);
1067 		_tmp4_ = self->priv->_stream;
1068 		_tmp5_ = self->priv->locus_color_end;
1069 		fputs (_tmp5_, _tmp4_);
1070 		_tmp6_ = self->priv->_stream;
1071 		fputc (' ', _tmp6_);
1072 	}
1073 	_tmp7_ = self->priv->_stream;
1074 	_tmp8_ = self->priv->error_color_start;
1075 	fputs (_tmp8_, _tmp7_);
1076 	_tmp9_ = self->priv->_stream;
1077 	fputs ("error: ", _tmp9_);
1078 	_tmp10_ = self->priv->_stream;
1079 	_tmp11_ = self->priv->error_color_end;
1080 	fputs (_tmp11_, _tmp10_);
1081 	_tmp12_ = g_strdup_vprintf (msg_format, args);
1082 	_tmp13_ = _tmp12_;
1083 	valadoc_error_reporter_print_highlighted_message (self, _tmp13_);
1084 	_g_free0 (_tmp13_);
1085 	_tmp14_ = self->priv->_stream;
1086 	fputc ('\n', _tmp14_);
1087 	_tmp15_ = self->priv->_errors;
1088 	self->priv->_errors = _tmp15_ + 1;
1089 	va_end (args);
1090 }
1091 
1092 void
valadoc_error_reporter_simple_note(ValadocErrorReporter * self,const gchar * location,const gchar * msg_format,...)1093 valadoc_error_reporter_simple_note (ValadocErrorReporter* self,
1094                                     const gchar* location,
1095                                     const gchar* msg_format,
1096                                     ...)
1097 {
1098 	gboolean _tmp0_ = FALSE;
1099 	ValadocSettings* _tmp1_;
1100 	g_return_if_fail (self != NULL);
1101 	g_return_if_fail (msg_format != NULL);
1102 	_tmp1_ = self->priv->_settings;
1103 	if (_tmp1_ == NULL) {
1104 		_tmp0_ = TRUE;
1105 	} else {
1106 		ValadocSettings* _tmp2_;
1107 		_tmp2_ = self->priv->_settings;
1108 		_tmp0_ = _tmp2_->verbose;
1109 	}
1110 	if (_tmp0_) {
1111 		va_list args = {0};
1112 		FILE* _tmp10_;
1113 		const gchar* _tmp11_;
1114 		FILE* _tmp12_;
1115 		FILE* _tmp13_;
1116 		const gchar* _tmp14_;
1117 		gchar* _tmp15_;
1118 		gchar* _tmp16_;
1119 		FILE* _tmp17_;
1120 		gint _tmp18_;
1121 		va_start (args, msg_format);
1122 		if (location != NULL) {
1123 			FILE* _tmp3_;
1124 			const gchar* _tmp4_;
1125 			FILE* _tmp5_;
1126 			FILE* _tmp6_;
1127 			FILE* _tmp7_;
1128 			const gchar* _tmp8_;
1129 			FILE* _tmp9_;
1130 			_tmp3_ = self->priv->_stream;
1131 			_tmp4_ = self->priv->locus_color_start;
1132 			fputs (_tmp4_, _tmp3_);
1133 			_tmp5_ = self->priv->_stream;
1134 			fputs (location, _tmp5_);
1135 			_tmp6_ = self->priv->_stream;
1136 			fputs (": ", _tmp6_);
1137 			_tmp7_ = self->priv->_stream;
1138 			_tmp8_ = self->priv->locus_color_end;
1139 			fputs (_tmp8_, _tmp7_);
1140 			_tmp9_ = self->priv->_stream;
1141 			fputc (' ', _tmp9_);
1142 		}
1143 		_tmp10_ = self->priv->_stream;
1144 		_tmp11_ = self->priv->note_color_start;
1145 		fputs (_tmp11_, _tmp10_);
1146 		_tmp12_ = self->priv->_stream;
1147 		fputs ("note: ", _tmp12_);
1148 		_tmp13_ = self->priv->_stream;
1149 		_tmp14_ = self->priv->note_color_end;
1150 		fputs (_tmp14_, _tmp13_);
1151 		_tmp15_ = g_strdup_vprintf (msg_format, args);
1152 		_tmp16_ = _tmp15_;
1153 		valadoc_error_reporter_print_highlighted_message (self, _tmp16_);
1154 		_g_free0 (_tmp16_);
1155 		_tmp17_ = self->priv->_stream;
1156 		fputc ('\n', _tmp17_);
1157 		_tmp18_ = self->priv->_warnings;
1158 		self->priv->_warnings = _tmp18_ + 1;
1159 		va_end (args);
1160 	}
1161 }
1162 
1163 void
valadoc_error_reporter_error(ValadocErrorReporter * self,const gchar * file,glong line,glong startpos,glong endpos,const gchar * errline,const gchar * msg_format,...)1164 valadoc_error_reporter_error (ValadocErrorReporter* self,
1165                               const gchar* file,
1166                               glong line,
1167                               glong startpos,
1168                               glong endpos,
1169                               const gchar* errline,
1170                               const gchar* msg_format,
1171                               ...)
1172 {
1173 	va_list args = {0};
1174 	const gchar* _tmp0_;
1175 	const gchar* _tmp1_;
1176 	gint _tmp2_;
1177 	g_return_if_fail (self != NULL);
1178 	g_return_if_fail (file != NULL);
1179 	g_return_if_fail (errline != NULL);
1180 	g_return_if_fail (msg_format != NULL);
1181 	va_start (args, msg_format);
1182 	_tmp0_ = self->priv->error_color_start;
1183 	_tmp1_ = self->priv->error_color_end;
1184 	valadoc_error_reporter_msg (self, "error", _tmp0_, _tmp1_, file, line, startpos, endpos, errline, msg_format, args);
1185 	_tmp2_ = self->priv->_errors;
1186 	self->priv->_errors = _tmp2_ + 1;
1187 	va_end (args);
1188 }
1189 
1190 void
valadoc_error_reporter_warning(ValadocErrorReporter * self,const gchar * file,glong line,glong startpos,glong endpos,const gchar * errline,const gchar * msg_format,...)1191 valadoc_error_reporter_warning (ValadocErrorReporter* self,
1192                                 const gchar* file,
1193                                 glong line,
1194                                 glong startpos,
1195                                 glong endpos,
1196                                 const gchar* errline,
1197                                 const gchar* msg_format,
1198                                 ...)
1199 {
1200 	va_list args = {0};
1201 	const gchar* _tmp0_;
1202 	const gchar* _tmp1_;
1203 	gint _tmp2_;
1204 	g_return_if_fail (self != NULL);
1205 	g_return_if_fail (file != NULL);
1206 	g_return_if_fail (errline != NULL);
1207 	g_return_if_fail (msg_format != NULL);
1208 	va_start (args, msg_format);
1209 	_tmp0_ = self->priv->warning_color_start;
1210 	_tmp1_ = self->priv->warning_color_end;
1211 	valadoc_error_reporter_msg (self, "warning", _tmp0_, _tmp1_, file, line, startpos, endpos, errline, msg_format, args);
1212 	_tmp2_ = self->priv->_warnings;
1213 	self->priv->_warnings = _tmp2_ + 1;
1214 	va_end (args);
1215 }
1216 
1217 static void
valadoc_error_reporter_class_init(ValadocErrorReporterClass * klass,gpointer klass_data)1218 valadoc_error_reporter_class_init (ValadocErrorReporterClass * klass,
1219                                    gpointer klass_data)
1220 {
1221 	valadoc_error_reporter_parent_class = g_type_class_peek_parent (klass);
1222 	g_type_class_adjust_private_offset (klass, &ValadocErrorReporter_private_offset);
1223 	G_OBJECT_CLASS (klass)->get_property = _vala_valadoc_error_reporter_get_property;
1224 	G_OBJECT_CLASS (klass)->set_property = _vala_valadoc_error_reporter_set_property;
1225 	G_OBJECT_CLASS (klass)->finalize = valadoc_error_reporter_finalize;
1226 	g_object_class_install_property (G_OBJECT_CLASS (klass), VALADOC_ERROR_REPORTER_WARNINGS_OFFSET_PROPERTY, valadoc_error_reporter_properties[VALADOC_ERROR_REPORTER_WARNINGS_OFFSET_PROPERTY] = g_param_spec_int ("warnings-offset", "warnings-offset", "warnings-offset", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
1227 	g_object_class_install_property (G_OBJECT_CLASS (klass), VALADOC_ERROR_REPORTER_ERRORS_OFFSET_PROPERTY, valadoc_error_reporter_properties[VALADOC_ERROR_REPORTER_ERRORS_OFFSET_PROPERTY] = g_param_spec_int ("errors-offset", "errors-offset", "errors-offset", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
1228 	g_object_class_install_property (G_OBJECT_CLASS (klass), VALADOC_ERROR_REPORTER_STREAM_PROPERTY, valadoc_error_reporter_properties[VALADOC_ERROR_REPORTER_STREAM_PROPERTY] = g_param_spec_pointer ("stream", "stream", "stream", G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
1229 	g_object_class_install_property (G_OBJECT_CLASS (klass), VALADOC_ERROR_REPORTER_SETTINGS_PROPERTY, valadoc_error_reporter_properties[VALADOC_ERROR_REPORTER_SETTINGS_PROPERTY] = g_param_spec_object ("settings", "settings", "settings", VALADOC_TYPE_SETTINGS, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
1230 	g_object_class_install_property (G_OBJECT_CLASS (klass), VALADOC_ERROR_REPORTER_ERRORS_PROPERTY, valadoc_error_reporter_properties[VALADOC_ERROR_REPORTER_ERRORS_PROPERTY] = g_param_spec_int ("errors", "errors", "errors", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
1231 	g_object_class_install_property (G_OBJECT_CLASS (klass), VALADOC_ERROR_REPORTER_WARNINGS_PROPERTY, valadoc_error_reporter_properties[VALADOC_ERROR_REPORTER_WARNINGS_PROPERTY] = g_param_spec_int ("warnings", "warnings", "warnings", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
1232 }
1233 
1234 static void
valadoc_error_reporter_instance_init(ValadocErrorReporter * self,gpointer klass)1235 valadoc_error_reporter_instance_init (ValadocErrorReporter * self,
1236                                       gpointer klass)
1237 {
1238 	gchar* _tmp0_;
1239 	gchar* _tmp1_;
1240 	gchar* _tmp2_;
1241 	gchar* _tmp3_;
1242 	gchar* _tmp4_;
1243 	gchar* _tmp5_;
1244 	self->priv = valadoc_error_reporter_get_instance_private (self);
1245 	self->priv->_warnings = 0;
1246 	self->priv->_errors = 0;
1247 	_tmp0_ = g_strdup ("");
1248 	self->priv->locus_color_start = _tmp0_;
1249 	self->priv->locus_color_end = "";
1250 	_tmp1_ = g_strdup ("");
1251 	self->priv->warning_color_start = _tmp1_;
1252 	self->priv->warning_color_end = "";
1253 	_tmp2_ = g_strdup ("");
1254 	self->priv->error_color_start = _tmp2_;
1255 	self->priv->error_color_end = "";
1256 	_tmp3_ = g_strdup ("");
1257 	self->priv->note_color_start = _tmp3_;
1258 	self->priv->note_color_end = "";
1259 	_tmp4_ = g_strdup ("");
1260 	self->priv->caret_color_start = _tmp4_;
1261 	self->priv->caret_color_end = "";
1262 	_tmp5_ = g_strdup ("");
1263 	self->priv->quote_color_start = _tmp5_;
1264 	self->priv->quote_color_end = "";
1265 }
1266 
1267 static void
valadoc_error_reporter_finalize(GObject * obj)1268 valadoc_error_reporter_finalize (GObject * obj)
1269 {
1270 	ValadocErrorReporter * self;
1271 	self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALADOC_TYPE_ERROR_REPORTER, ValadocErrorReporter);
1272 	_g_free0 (self->priv->locus_color_start);
1273 	_g_free0 (self->priv->warning_color_start);
1274 	_g_free0 (self->priv->error_color_start);
1275 	_g_free0 (self->priv->note_color_start);
1276 	_g_free0 (self->priv->caret_color_start);
1277 	_g_free0 (self->priv->quote_color_start);
1278 	_g_object_unref0 (self->priv->_settings);
1279 	G_OBJECT_CLASS (valadoc_error_reporter_parent_class)->finalize (obj);
1280 }
1281 
1282 static GType
valadoc_error_reporter_get_type_once(void)1283 valadoc_error_reporter_get_type_once (void)
1284 {
1285 	static const GTypeInfo g_define_type_info = { sizeof (ValadocErrorReporterClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) valadoc_error_reporter_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValadocErrorReporter), 0, (GInstanceInitFunc) valadoc_error_reporter_instance_init, NULL };
1286 	GType valadoc_error_reporter_type_id;
1287 	valadoc_error_reporter_type_id = g_type_register_static (G_TYPE_OBJECT, "ValadocErrorReporter", &g_define_type_info, 0);
1288 	ValadocErrorReporter_private_offset = g_type_add_instance_private (valadoc_error_reporter_type_id, sizeof (ValadocErrorReporterPrivate));
1289 	return valadoc_error_reporter_type_id;
1290 }
1291 
1292 GType
valadoc_error_reporter_get_type(void)1293 valadoc_error_reporter_get_type (void)
1294 {
1295 	static volatile gsize valadoc_error_reporter_type_id__volatile = 0;
1296 	if (g_once_init_enter (&valadoc_error_reporter_type_id__volatile)) {
1297 		GType valadoc_error_reporter_type_id;
1298 		valadoc_error_reporter_type_id = valadoc_error_reporter_get_type_once ();
1299 		g_once_init_leave (&valadoc_error_reporter_type_id__volatile, valadoc_error_reporter_type_id);
1300 	}
1301 	return valadoc_error_reporter_type_id__volatile;
1302 }
1303 
1304 static void
_vala_valadoc_error_reporter_get_property(GObject * object,guint property_id,GValue * value,GParamSpec * pspec)1305 _vala_valadoc_error_reporter_get_property (GObject * object,
1306                                            guint property_id,
1307                                            GValue * value,
1308                                            GParamSpec * pspec)
1309 {
1310 	ValadocErrorReporter * self;
1311 	self = G_TYPE_CHECK_INSTANCE_CAST (object, VALADOC_TYPE_ERROR_REPORTER, ValadocErrorReporter);
1312 	switch (property_id) {
1313 		case VALADOC_ERROR_REPORTER_WARNINGS_OFFSET_PROPERTY:
1314 		g_value_set_int (value, valadoc_error_reporter_get_warnings_offset (self));
1315 		break;
1316 		case VALADOC_ERROR_REPORTER_ERRORS_OFFSET_PROPERTY:
1317 		g_value_set_int (value, valadoc_error_reporter_get_errors_offset (self));
1318 		break;
1319 		case VALADOC_ERROR_REPORTER_STREAM_PROPERTY:
1320 		g_value_set_pointer (value, valadoc_error_reporter_get_stream (self));
1321 		break;
1322 		case VALADOC_ERROR_REPORTER_SETTINGS_PROPERTY:
1323 		g_value_set_object (value, valadoc_error_reporter_get_settings (self));
1324 		break;
1325 		case VALADOC_ERROR_REPORTER_ERRORS_PROPERTY:
1326 		g_value_set_int (value, valadoc_error_reporter_get_errors (self));
1327 		break;
1328 		case VALADOC_ERROR_REPORTER_WARNINGS_PROPERTY:
1329 		g_value_set_int (value, valadoc_error_reporter_get_warnings (self));
1330 		break;
1331 		default:
1332 		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
1333 		break;
1334 	}
1335 }
1336 
1337 static void
_vala_valadoc_error_reporter_set_property(GObject * object,guint property_id,const GValue * value,GParamSpec * pspec)1338 _vala_valadoc_error_reporter_set_property (GObject * object,
1339                                            guint property_id,
1340                                            const GValue * value,
1341                                            GParamSpec * pspec)
1342 {
1343 	ValadocErrorReporter * self;
1344 	self = G_TYPE_CHECK_INSTANCE_CAST (object, VALADOC_TYPE_ERROR_REPORTER, ValadocErrorReporter);
1345 	switch (property_id) {
1346 		case VALADOC_ERROR_REPORTER_WARNINGS_OFFSET_PROPERTY:
1347 		valadoc_error_reporter_set_warnings_offset (self, g_value_get_int (value));
1348 		break;
1349 		case VALADOC_ERROR_REPORTER_ERRORS_OFFSET_PROPERTY:
1350 		valadoc_error_reporter_set_errors_offset (self, g_value_get_int (value));
1351 		break;
1352 		case VALADOC_ERROR_REPORTER_STREAM_PROPERTY:
1353 		valadoc_error_reporter_set_stream (self, g_value_get_pointer (value));
1354 		break;
1355 		case VALADOC_ERROR_REPORTER_SETTINGS_PROPERTY:
1356 		valadoc_error_reporter_set_settings (self, g_value_get_object (value));
1357 		break;
1358 		default:
1359 		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
1360 		break;
1361 	}
1362 }
1363 
1364 static void
_vala_array_destroy(gpointer array,gint array_length,GDestroyNotify destroy_func)1365 _vala_array_destroy (gpointer array,
1366                      gint array_length,
1367                      GDestroyNotify destroy_func)
1368 {
1369 	if ((array != NULL) && (destroy_func != NULL)) {
1370 		gint i;
1371 		for (i = 0; i < array_length; i = i + 1) {
1372 			if (((gpointer*) array)[i] != NULL) {
1373 				destroy_func (((gpointer*) array)[i]);
1374 			}
1375 		}
1376 	}
1377 }
1378 
1379 static void
_vala_array_free(gpointer array,gint array_length,GDestroyNotify destroy_func)1380 _vala_array_free (gpointer array,
1381                   gint array_length,
1382                   GDestroyNotify destroy_func)
1383 {
1384 	_vala_array_destroy (array, array_length, destroy_func);
1385 	g_free (array);
1386 }
1387 
1388 static gint
_vala_array_length(gpointer array)1389 _vala_array_length (gpointer array)
1390 {
1391 	gint length;
1392 	length = 0;
1393 	if (array) {
1394 		while (((gpointer*) array)[length]) {
1395 			length++;
1396 		}
1397 	}
1398 	return length;
1399 }
1400 
1401