← Back to branch summary

~ubuntu-branches/ubuntu/trusty/anjuta/trusty

« back to all changes in this revision

Viewing changes to plugins/language-support-vala/report.c

  • Committer: Package Import Robot
  • Author(s): Jeremy Bicha
  • Date: 2012-03-06 01:11:30 UTC
  • mfrom: (1.1.44)
  • Revision ID: package-import@ubuntu.com-20120306011130-yumg9s1nprogue2a
Tags: 2:3.3.91-0ubuntu1
* New upstream release.
* debian/control.in:
  - Bump minimum glade to 3.11 and vala to 0.16

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins/language-support-vala/report.c
1
 
/* report.c generated by valac 0.14.0, the Vala compiler
2
 
 * generated from report.vala, do not modify */
3
 
 
4
 
/*
5
 
 * Copyright (C) 2008-2009 Abderrahim Kitouni
6
 
 *
7
 
 * This program is free software; you can redistribute it and/or modify
8
 
 * it under the terms of the GNU General Public License as published by
9
 
 * the Free Software Foundation; either version 2 of the License, or
10
 
 * (at your option) any later version.
11
 
 *
12
 
 * This program is distributed in the hope that it will be useful,
13
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
 
 * GNU General Public License for more details.
16
 
 *
17
 
 * You should have received a copy of the GNU General Public License
18
 
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
19
 
 */
20
 
/* A Vala.Report subclass for reporting errors in Anjuta UI */
21
 
 
22
 
#include <glib.h>
23
 
#include <glib-object.h>
24
 
#include <vala.h>
25
 
#include <libanjuta/interfaces/libanjuta-interfaces.h>
26
 
#include <valagee.h>
27
 
#include <stdlib.h>
28
 
#include <string.h>
29
 
#include <gtk/gtk.h>
30
 
 
31
 
 
32
 
#define TYPE_ANJUTA_REPORT (anjuta_report_get_type ())
33
 
#define ANJUTA_REPORT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_ANJUTA_REPORT, AnjutaReport))
34
 
#define ANJUTA_REPORT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_ANJUTA_REPORT, AnjutaReportClass))
35
 
#define IS_ANJUTA_REPORT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_ANJUTA_REPORT))
36
 
#define IS_ANJUTA_REPORT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_ANJUTA_REPORT))
37
 
#define ANJUTA_REPORT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_ANJUTA_REPORT, AnjutaReportClass))
38
 
 
39
 
typedef struct _AnjutaReport AnjutaReport;
40
 
typedef struct _AnjutaReportClass AnjutaReportClass;
41
 
typedef struct _AnjutaReportPrivate AnjutaReportPrivate;
42
 
 
43
 
#define ANJUTA_REPORT_TYPE_ERROR (anjuta_report_error_get_type ())
44
 
typedef struct _AnjutaReportError AnjutaReportError;
45
 
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
46
 
#define _vala_iterable_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterable_unref (var), NULL)))
47
 
#define _anjuta_report_error_free0(var) ((var == NULL) ? NULL : (var = (anjuta_report_error_free (var), NULL)))
48
 
#define _g_list_free0(var) ((var == NULL) ? NULL : (var = (g_list_free (var), NULL)))
49
 
#define _vala_source_reference_unref0(var) ((var == NULL) ? NULL : (var = (vala_source_reference_unref (var), NULL)))
50
 
#define _g_free0(var) (var = (g_free (var), NULL))
51
 
 
52
 
struct _AnjutaReport {
53
 
        ValaReport parent_instance;
54
 
        AnjutaReportPrivate * priv;
55
 
};
56
 
 
57
 
struct _AnjutaReportClass {
58
 
        ValaReportClass parent_class;
59
 
};
60
 
 
61
 
struct _AnjutaReportError {
62
 
        ValaSourceReference* source;
63
 
        gboolean error;
64
 
        gchar* message;
65
 
};
66
 
 
67
 
struct _AnjutaReportPrivate {
68
 
        IAnjutaDocumentManager* _docman;
69
 
        ValaList* errors_list;
70
 
        GStaticRecMutex __lock_errors_list;
71
 
        gboolean general_error;
72
 
};
73
 
 
74
 
 
75
 
static gpointer anjuta_report_parent_class = NULL;
76
 
static GType anjuta_report_type_id = 0;
77
 
 
78
 
GType anjuta_report_get_type (void) G_GNUC_CONST;
79
 
GType anjuta_report_register_type (GTypeModule * module);
80
 
static GType anjuta_report_error_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
81
 
static AnjutaReportError* anjuta_report_error_dup (const AnjutaReportError* self);
82
 
static void anjuta_report_error_free (AnjutaReportError* self);
83
 
static void anjuta_report_error_copy (const AnjutaReportError* self, AnjutaReportError* dest);
84
 
static void anjuta_report_error_destroy (AnjutaReportError* self);
85
 
#define ANJUTA_REPORT_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_ANJUTA_REPORT, AnjutaReportPrivate))
86
 
enum  {
87
 
        ANJUTA_REPORT_DUMMY_PROPERTY,
88
 
        ANJUTA_REPORT_DOCMAN
89
 
};
90
 
void anjuta_report_update_errors (AnjutaReport* self, IAnjutaEditor* editor);
91
 
void anjuta_report_clear_error_indicators (AnjutaReport* self, ValaSourceFile* file);
92
 
IAnjutaDocumentManager* anjuta_report_get_docman (AnjutaReport* self);
93
 
static void anjuta_report_real_warn (ValaReport* base, ValaSourceReference* source, const gchar* message);
94
 
static void anjuta_report_real_err (ValaReport* base, ValaSourceReference* source, const gchar* message);
95
 
AnjutaReport* anjuta_report_new (void);
96
 
AnjutaReport* anjuta_report_construct (GType object_type);
97
 
void anjuta_report_set_docman (AnjutaReport* self, IAnjutaDocumentManager* value);
98
 
static void anjuta_report_finalize (GObject* obj);
99
 
static void _vala_anjuta_report_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
100
 
static void _vala_anjuta_report_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
101
 
 
102
 
 
103
 
static gpointer _g_object_ref0 (gpointer self) {
104
 
        return self ? g_object_ref (self) : NULL;
105
 
}
106
 
 
107
 
 
108
 
static gpointer _vala_iterable_ref0 (gpointer self) {
109
 
        return self ? vala_iterable_ref (self) : NULL;
110
 
}
111
 
 
112
 
 
113
 
void anjuta_report_update_errors (AnjutaReport* self, IAnjutaEditor* editor) {
114
 
        IAnjutaEditor* _tmp0_;
115
 
        IAnjutaIndicable* _tmp1_;
116
 
        IAnjutaIndicable* ind;
117
 
        IAnjutaEditor* _tmp2_;
118
 
        IAnjutaMarkable* _tmp3_;
119
 
        IAnjutaMarkable* mark;
120
 
        gboolean _tmp4_ = FALSE;
121
 
        IAnjutaIndicable* _tmp5_;
122
 
        gboolean _tmp7_;
123
 
        IAnjutaIndicable* _tmp8_;
124
 
        IAnjutaMarkable* _tmp10_;
125
 
        GError * _inner_error_ = NULL;
126
 
        g_return_if_fail (self != NULL);
127
 
        g_return_if_fail (editor != NULL);
128
 
        _tmp0_ = editor;
129
 
        _tmp1_ = _g_object_ref0 (IANJUTA_IS_INDICABLE (_tmp0_) ? ((IAnjutaIndicable*) _tmp0_) : NULL);
130
 
        ind = _tmp1_;
131
 
        _tmp2_ = editor;
132
 
        _tmp3_ = _g_object_ref0 (IANJUTA_IS_MARKABLE (_tmp2_) ? ((IAnjutaMarkable*) _tmp2_) : NULL);
133
 
        mark = _tmp3_;
134
 
        _tmp5_ = ind;
135
 
        if (_tmp5_ == NULL) {
136
 
                IAnjutaMarkable* _tmp6_;
137
 
                _tmp6_ = mark;
138
 
                _tmp4_ = _tmp6_ == NULL;
139
 
        } else {
140
 
                _tmp4_ = FALSE;
141
 
        }
142
 
        _tmp7_ = _tmp4_;
143
 
        if (_tmp7_) {
144
 
                _g_object_unref0 (mark);
145
 
                _g_object_unref0 (ind);
146
 
                return;
147
 
        }
148
 
        _tmp8_ = ind;
149
 
        if (_tmp8_ != NULL) {
150
 
                IAnjutaIndicable* _tmp9_;
151
 
                _tmp9_ = ind;
152
 
                ianjuta_indicable_clear (_tmp9_, &_inner_error_);
153
 
                if (_inner_error_ != NULL) {
154
 
                        _g_object_unref0 (mark);
155
 
                        _g_object_unref0 (ind);
156
 
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
157
 
                        g_clear_error (&_inner_error_);
158
 
                        return;
159
 
                }
160
 
        }
161
 
        _tmp10_ = mark;
162
 
        if (_tmp10_ != NULL) {
163
 
                IAnjutaMarkable* _tmp11_;
164
 
                _tmp11_ = mark;
165
 
                ianjuta_markable_delete_all_markers (_tmp11_, IANJUTA_MARKABLE_MESSAGE, &_inner_error_);
166
 
                if (_inner_error_ != NULL) {
167
 
                        _g_object_unref0 (mark);
168
 
                        _g_object_unref0 (ind);
169
 
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
170
 
                        g_clear_error (&_inner_error_);
171
 
                        return;
172
 
                }
173
 
        }
174
 
        {
175
 
                ValaList* _tmp12_;
176
 
                ValaList* _tmp13_;
177
 
                ValaList* _e_list;
178
 
                ValaList* _tmp14_;
179
 
                gint _tmp15_;
180
 
                gint _tmp16_;
181
 
                gint _e_size;
182
 
                gint _e_index;
183
 
                _tmp12_ = self->priv->errors_list;
184
 
                _tmp13_ = _vala_iterable_ref0 (_tmp12_);
185
 
                _e_list = _tmp13_;
186
 
                _tmp14_ = _e_list;
187
 
                _tmp15_ = vala_collection_get_size ((ValaCollection*) _tmp14_);
188
 
                _tmp16_ = _tmp15_;
189
 
                _e_size = _tmp16_;
190
 
                _e_index = -1;
191
 
                while (TRUE) {
192
 
                        gint _tmp17_;
193
 
                        gint _tmp18_;
194
 
                        gint _tmp19_;
195
 
                        ValaList* _tmp20_;
196
 
                        gint _tmp21_;
197
 
                        gpointer _tmp22_ = NULL;
198
 
                        AnjutaReportError* e;
199
 
                        IAnjutaEditor* _tmp23_;
200
 
                        const gchar* _tmp24_ = NULL;
201
 
                        const gchar* _tmp25_;
202
 
                        AnjutaReportError* _tmp26_;
203
 
                        ValaSourceReference* _tmp27_;
204
 
                        ValaSourceFile* _tmp28_;
205
 
                        ValaSourceFile* _tmp29_;
206
 
                        const gchar* _tmp30_;
207
 
                        const gchar* _tmp31_;
208
 
                        gboolean _tmp32_ = FALSE;
209
 
                        _tmp17_ = _e_index;
210
 
                        _e_index = _tmp17_ + 1;
211
 
                        _tmp18_ = _e_index;
212
 
                        _tmp19_ = _e_size;
213
 
                        if (!(_tmp18_ < _tmp19_)) {
214
 
                                break;
215
 
                        }
216
 
                        _tmp20_ = _e_list;
217
 
                        _tmp21_ = _e_index;
218
 
                        _tmp22_ = vala_list_get (_tmp20_, _tmp21_);
219
 
                        e = (AnjutaReportError*) _tmp22_;
220
 
                        _tmp23_ = editor;
221
 
                        _tmp24_ = ianjuta_document_get_filename (IANJUTA_DOCUMENT (_tmp23_), &_inner_error_);
222
 
                        _tmp25_ = _tmp24_;
223
 
                        if (_inner_error_ != NULL) {
224
 
                                _anjuta_report_error_free0 (e);
225
 
                                _vala_iterable_unref0 (_e_list);
226
 
                                _g_object_unref0 (mark);
227
 
                                _g_object_unref0 (ind);
228
 
                                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
229
 
                                g_clear_error (&_inner_error_);
230
 
                                return;
231
 
                        }
232
 
                        _tmp26_ = e;
233
 
                        _tmp27_ = (*_tmp26_).source;
234
 
                        _tmp28_ = vala_source_reference_get_file (_tmp27_);
235
 
                        _tmp29_ = _tmp28_;
236
 
                        _tmp30_ = vala_source_file_get_filename (_tmp29_);
237
 
                        _tmp31_ = _tmp30_;
238
 
                        _tmp32_ = g_str_has_suffix (_tmp31_, _tmp25_);
239
 
                        if (_tmp32_) {
240
 
                                IAnjutaIndicable* _tmp33_;
241
 
                                IAnjutaEditor* _tmp71_;
242
 
                                _tmp33_ = ind;
243
 
                                if (_tmp33_ != NULL) {
244
 
                                        IAnjutaEditor* _tmp34_;
245
 
                                        AnjutaReportError* _tmp35_;
246
 
                                        ValaSourceReference* _tmp36_;
247
 
                                        gint _tmp37_;
248
 
                                        gint _tmp38_;
249
 
                                        IAnjutaIterable* _tmp39_ = NULL;
250
 
                                        IAnjutaIterable* begin_iter;
251
 
                                        IAnjutaEditor* _tmp49_;
252
 
                                        AnjutaReportError* _tmp50_;
253
 
                                        ValaSourceReference* _tmp51_;
254
 
                                        gint _tmp52_;
255
 
                                        gint _tmp53_;
256
 
                                        IAnjutaIterable* _tmp54_ = NULL;
257
 
                                        IAnjutaIterable* end_iter;
258
 
                                        IAnjutaIndicableIndicator _tmp64_ = 0;
259
 
                                        AnjutaReportError* _tmp65_;
260
 
                                        gboolean _tmp66_;
261
 
                                        IAnjutaIndicable* _tmp67_;
262
 
                                        IAnjutaIterable* _tmp68_;
263
 
                                        IAnjutaIterable* _tmp69_;
264
 
                                        IAnjutaIndicableIndicator _tmp70_;
265
 
                                        _tmp34_ = editor;
266
 
                                        _tmp35_ = e;
267
 
                                        _tmp36_ = (*_tmp35_).source;
268
 
                                        _tmp37_ = vala_source_reference_get_first_line (_tmp36_);
269
 
                                        _tmp38_ = _tmp37_;
270
 
                                        _tmp39_ = ianjuta_editor_get_line_begin_position (_tmp34_, _tmp38_, &_inner_error_);
271
 
                                        begin_iter = _tmp39_;
272
 
                                        if (_inner_error_ != NULL) {
273
 
                                                _anjuta_report_error_free0 (e);
274
 
                                                _vala_iterable_unref0 (_e_list);
275
 
                                                _g_object_unref0 (mark);
276
 
                                                _g_object_unref0 (ind);
277
 
                                                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
278
 
                                                g_clear_error (&_inner_error_);
279
 
                                                return;
280
 
                                        }
281
 
                                        {
282
 
                                                gint i;
283
 
                                                i = 1;
284
 
                                                {
285
 
                                                        gboolean _tmp40_;
286
 
                                                        _tmp40_ = TRUE;
287
 
                                                        while (TRUE) {
288
 
                                                                gboolean _tmp41_;
289
 
                                                                gint _tmp43_;
290
 
                                                                AnjutaReportError* _tmp44_;
291
 
                                                                ValaSourceReference* _tmp45_;
292
 
                                                                gint _tmp46_;
293
 
                                                                gint _tmp47_;
294
 
                                                                IAnjutaIterable* _tmp48_;
295
 
                                                                _tmp41_ = _tmp40_;
296
 
                                                                if (!_tmp41_) {
297
 
                                                                        gint _tmp42_;
298
 
                                                                        _tmp42_ = i;
299
 
                                                                        i = _tmp42_ + 1;
300
 
                                                                }
301
 
                                                                _tmp40_ = FALSE;
302
 
                                                                _tmp43_ = i;
303
 
                                                                _tmp44_ = e;
304
 
                                                                _tmp45_ = (*_tmp44_).source;
305
 
                                                                _tmp46_ = vala_source_reference_get_first_column (_tmp45_);
306
 
                                                                _tmp47_ = _tmp46_;
307
 
                                                                if (!(_tmp43_ < _tmp47_)) {
308
 
                                                                        break;
309
 
                                                                }
310
 
                                                                _tmp48_ = begin_iter;
311
 
                                                                ianjuta_iterable_next (_tmp48_, &_inner_error_);
312
 
                                                                if (_inner_error_ != NULL) {
313
 
                                                                        _g_object_unref0 (begin_iter);
314
 
                                                                        _anjuta_report_error_free0 (e);
315
 
                                                                        _vala_iterable_unref0 (_e_list);
316
 
                                                                        _g_object_unref0 (mark);
317
 
                                                                        _g_object_unref0 (ind);
318
 
                                                                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
319
 
                                                                        g_clear_error (&_inner_error_);
320
 
                                                                        return;
321
 
                                                                }
322
 
                                                        }
323
 
                                                }
324
 
                                        }
325
 
                                        _tmp49_ = editor;
326
 
                                        _tmp50_ = e;
327
 
                                        _tmp51_ = (*_tmp50_).source;
328
 
                                        _tmp52_ = vala_source_reference_get_last_line (_tmp51_);
329
 
                                        _tmp53_ = _tmp52_;
330
 
                                        _tmp54_ = ianjuta_editor_get_line_begin_position (_tmp49_, _tmp53_, &_inner_error_);
331
 
                                        end_iter = _tmp54_;
332
 
                                        if (_inner_error_ != NULL) {
333
 
                                                _g_object_unref0 (begin_iter);
334
 
                                                _anjuta_report_error_free0 (e);
335
 
                                                _vala_iterable_unref0 (_e_list);
336
 
                                                _g_object_unref0 (mark);
337
 
                                                _g_object_unref0 (ind);
338
 
                                                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
339
 
                                                g_clear_error (&_inner_error_);
340
 
                                                return;
341
 
                                        }
342
 
                                        {
343
 
                                                gint i;
344
 
                                                i = 0;
345
 
                                                {
346
 
                                                        gboolean _tmp55_;
347
 
                                                        _tmp55_ = TRUE;
348
 
                                                        while (TRUE) {
349
 
                                                                gboolean _tmp56_;
350
 
                                                                gint _tmp58_;
351
 
                                                                AnjutaReportError* _tmp59_;
352
 
                                                                ValaSourceReference* _tmp60_;
353
 
                                                                gint _tmp61_;
354
 
                                                                gint _tmp62_;
355
 
                                                                IAnjutaIterable* _tmp63_;
356
 
                                                                _tmp56_ = _tmp55_;
357
 
                                                                if (!_tmp56_) {
358
 
                                                                        gint _tmp57_;
359
 
                                                                        _tmp57_ = i;
360
 
                                                                        i = _tmp57_ + 1;
361
 
                                                                }
362
 
                                                                _tmp55_ = FALSE;
363
 
                                                                _tmp58_ = i;
364
 
                                                                _tmp59_ = e;
365
 
                                                                _tmp60_ = (*_tmp59_).source;
366
 
                                                                _tmp61_ = vala_source_reference_get_last_column (_tmp60_);
367
 
                                                                _tmp62_ = _tmp61_;
368
 
                                                                if (!(_tmp58_ < _tmp62_)) {
369
 
                                                                        break;
370
 
                                                                }
371
 
                                                                _tmp63_ = end_iter;
372
 
                                                                ianjuta_iterable_next (_tmp63_, &_inner_error_);
373
 
                                                                if (_inner_error_ != NULL) {
374
 
                                                                        _g_object_unref0 (end_iter);
375
 
                                                                        _g_object_unref0 (begin_iter);
376
 
                                                                        _anjuta_report_error_free0 (e);
377
 
                                                                        _vala_iterable_unref0 (_e_list);
378
 
                                                                        _g_object_unref0 (mark);
379
 
                                                                        _g_object_unref0 (ind);
380
 
                                                                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
381
 
                                                                        g_clear_error (&_inner_error_);
382
 
                                                                        return;
383
 
                                                                }
384
 
                                                        }
385
 
                                                }
386
 
                                        }
387
 
                                        _tmp65_ = e;
388
 
                                        _tmp66_ = (*_tmp65_).error;
389
 
                                        if (_tmp66_) {
390
 
                                                _tmp64_ = IANJUTA_INDICABLE_CRITICAL;
391
 
                                        } else {
392
 
                                                _tmp64_ = IANJUTA_INDICABLE_WARNING;
393
 
                                        }
394
 
                                        _tmp67_ = ind;
395
 
                                        _tmp68_ = begin_iter;
396
 
                                        _tmp69_ = end_iter;
397
 
                                        _tmp70_ = _tmp64_;
398
 
                                        ianjuta_indicable_set (_tmp67_, _tmp68_, _tmp69_, _tmp70_, &_inner_error_);
399
 
                                        if (_inner_error_ != NULL) {
400
 
                                                _g_object_unref0 (end_iter);
401
 
                                                _g_object_unref0 (begin_iter);
402
 
                                                _anjuta_report_error_free0 (e);
403
 
                                                _vala_iterable_unref0 (_e_list);
404
 
                                                _g_object_unref0 (mark);
405
 
                                                _g_object_unref0 (ind);
406
 
                                                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
407
 
                                                g_clear_error (&_inner_error_);
408
 
                                                return;
409
 
                                        }
410
 
                                        _g_object_unref0 (end_iter);
411
 
                                        _g_object_unref0 (begin_iter);
412
 
                                }
413
 
                                _tmp71_ = editor;
414
 
                                if (IANJUTA_IS_MARKABLE (_tmp71_)) {
415
 
                                        IAnjutaMarkable* _tmp72_;
416
 
                                        AnjutaReportError* _tmp73_;
417
 
                                        ValaSourceReference* _tmp74_;
418
 
                                        gint _tmp75_;
419
 
                                        gint _tmp76_;
420
 
                                        AnjutaReportError* _tmp77_;
421
 
                                        const gchar* _tmp78_;
422
 
                                        _tmp72_ = mark;
423
 
                                        _tmp73_ = e;
424
 
                                        _tmp74_ = (*_tmp73_).source;
425
 
                                        _tmp75_ = vala_source_reference_get_first_line (_tmp74_);
426
 
                                        _tmp76_ = _tmp75_;
427
 
                                        _tmp77_ = e;
428
 
                                        _tmp78_ = (*_tmp77_).message;
429
 
                                        ianjuta_markable_mark (_tmp72_, _tmp76_, IANJUTA_MARKABLE_MESSAGE, _tmp78_, &_inner_error_);
430
 
                                        if (_inner_error_ != NULL) {
431
 
                                                _anjuta_report_error_free0 (e);
432
 
                                                _vala_iterable_unref0 (_e_list);
433
 
                                                _g_object_unref0 (mark);
434
 
                                                _g_object_unref0 (ind);
435
 
                                                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
436
 
                                                g_clear_error (&_inner_error_);
437
 
                                                return;
438
 
                                        }
439
 
                                }
440
 
                        }
441
 
                        _anjuta_report_error_free0 (e);
442
 
                }
443
 
                _vala_iterable_unref0 (_e_list);
444
 
        }
445
 
        _g_object_unref0 (mark);
446
 
        _g_object_unref0 (ind);
447
 
}
448
 
 
449
 
 
450
 
void anjuta_report_clear_error_indicators (AnjutaReport* self, ValaSourceFile* file) {
451
 
        ValaSourceFile* _tmp0_;
452
 
        IAnjutaDocumentManager* _tmp35_;
453
 
        GList* _tmp36_ = NULL;
454
 
        GList* _tmp37_;
455
 
        GError * _inner_error_ = NULL;
456
 
        g_return_if_fail (self != NULL);
457
 
        _tmp0_ = file;
458
 
        if (_tmp0_ == NULL) {
459
 
                GEqualFunc _tmp1_;
460
 
                ValaArrayList* _tmp2_;
461
 
                _tmp1_ = g_direct_equal;
462
 
                _tmp2_ = vala_array_list_new (ANJUTA_REPORT_TYPE_ERROR, (GBoxedCopyFunc) anjuta_report_error_dup, anjuta_report_error_free, _tmp1_);
463
 
                _vala_iterable_unref0 (self->priv->errors_list);
464
 
                self->priv->errors_list = (ValaList*) _tmp2_;
465
 
                ((ValaReport*) self)->errors = 0;
466
 
        } else {
467
 
                ValaList* _tmp30_;
468
 
                gint _tmp31_;
469
 
                gint _tmp32_;
470
 
                gint _tmp33_;
471
 
                gint _tmp34_;
472
 
                {
473
 
                        gint i;
474
 
                        i = 0;
475
 
                        {
476
 
                                gboolean _tmp3_;
477
 
                                _tmp3_ = TRUE;
478
 
                                while (TRUE) {
479
 
                                        gboolean _tmp4_;
480
 
                                        gint _tmp6_;
481
 
                                        ValaList* _tmp7_;
482
 
                                        gint _tmp8_;
483
 
                                        gint _tmp9_;
484
 
                                        ValaList* _tmp10_;
485
 
                                        gint _tmp11_;
486
 
                                        gpointer _tmp12_ = NULL;
487
 
                                        AnjutaReportError* _tmp13_;
488
 
                                        ValaSourceReference* _tmp14_;
489
 
                                        ValaSourceFile* _tmp15_;
490
 
                                        ValaSourceFile* _tmp16_;
491
 
                                        ValaSourceFile* _tmp17_;
492
 
                                        gboolean _tmp18_;
493
 
                                        _tmp4_ = _tmp3_;
494
 
                                        if (!_tmp4_) {
495
 
                                                gint _tmp5_;
496
 
                                                _tmp5_ = i;
497
 
                                                i = _tmp5_ + 1;
498
 
                                        }
499
 
                                        _tmp3_ = FALSE;
500
 
                                        _tmp6_ = i;
501
 
                                        _tmp7_ = self->priv->errors_list;
502
 
                                        _tmp8_ = vala_collection_get_size ((ValaCollection*) _tmp7_);
503
 
                                        _tmp9_ = _tmp8_;
504
 
                                        if (!(_tmp6_ < _tmp9_)) {
505
 
                                                break;
506
 
                                        }
507
 
                                        _tmp10_ = self->priv->errors_list;
508
 
                                        _tmp11_ = i;
509
 
                                        _tmp12_ = vala_list_get (_tmp10_, _tmp11_);
510
 
                                        _tmp13_ = (AnjutaReportError*) _tmp12_;
511
 
                                        _tmp14_ = (*_tmp13_).source;
512
 
                                        _tmp15_ = vala_source_reference_get_file (_tmp14_);
513
 
                                        _tmp16_ = _tmp15_;
514
 
                                        _tmp17_ = file;
515
 
                                        _tmp18_ = _tmp16_ == _tmp17_;
516
 
                                        _anjuta_report_error_free0 (_tmp13_);
517
 
                                        if (_tmp18_) {
518
 
                                                ValaList* _tmp19_;
519
 
                                                gint _tmp20_;
520
 
                                                gpointer _tmp21_ = NULL;
521
 
                                                AnjutaReportError* _tmp22_;
522
 
                                                gboolean _tmp23_;
523
 
                                                gboolean _tmp24_;
524
 
                                                ValaList* _tmp27_;
525
 
                                                gint _tmp28_;
526
 
                                                gint _tmp29_;
527
 
                                                _tmp19_ = self->priv->errors_list;
528
 
                                                _tmp20_ = i;
529
 
                                                _tmp21_ = vala_list_get (_tmp19_, _tmp20_);
530
 
                                                _tmp22_ = (AnjutaReportError*) _tmp21_;
531
 
                                                _tmp23_ = (*_tmp22_).error;
532
 
                                                _tmp24_ = _tmp23_;
533
 
                                                _anjuta_report_error_free0 (_tmp22_);
534
 
                                                if (_tmp24_) {
535
 
                                                        gint _tmp25_;
536
 
                                                        _tmp25_ = ((ValaReport*) self)->errors;
537
 
                                                        ((ValaReport*) self)->errors = _tmp25_ - 1;
538
 
                                                } else {
539
 
                                                        gint _tmp26_;
540
 
                                                        _tmp26_ = ((ValaReport*) self)->warnings;
541
 
                                                        ((ValaReport*) self)->warnings = _tmp26_ - 1;
542
 
                                                }
543
 
                                                _tmp27_ = self->priv->errors_list;
544
 
                                                _tmp28_ = i;
545
 
                                                vala_list_remove_at (_tmp27_, _tmp28_);
546
 
                                                _tmp29_ = i;
547
 
                                                i = _tmp29_ - 1;
548
 
                                        }
549
 
                                }
550
 
                        }
551
 
                }
552
 
                _tmp30_ = self->priv->errors_list;
553
 
                _tmp31_ = vala_collection_get_size ((ValaCollection*) _tmp30_);
554
 
                _tmp32_ = _tmp31_;
555
 
                _tmp33_ = ((ValaReport*) self)->errors;
556
 
                _tmp34_ = ((ValaReport*) self)->warnings;
557
 
                g_assert (_tmp32_ <= (_tmp33_ + _tmp34_));
558
 
        }
559
 
        _tmp35_ = self->priv->_docman;
560
 
        _tmp36_ = ianjuta_document_manager_get_doc_widgets (_tmp35_, &_inner_error_);
561
 
        _tmp37_ = _tmp36_;
562
 
        if (_inner_error_ != NULL) {
563
 
                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
564
 
                g_clear_error (&_inner_error_);
565
 
                return;
566
 
        }
567
 
        {
568
 
                GList* doc_collection = NULL;
569
 
                GList* doc_it = NULL;
570
 
                doc_collection = _tmp37_;
571
 
                for (doc_it = doc_collection; doc_it != NULL; doc_it = doc_it->next) {
572
 
                        GtkWidget* doc = NULL;
573
 
                        doc = (GtkWidget*) doc_it->data;
574
 
                        {
575
 
                                GtkWidget* _tmp38_;
576
 
                                GtkWidget* _tmp40_;
577
 
                                _tmp38_ = doc;
578
 
                                if (IANJUTA_IS_INDICABLE (_tmp38_)) {
579
 
                                        GtkWidget* _tmp39_;
580
 
                                        _tmp39_ = doc;
581
 
                                        ianjuta_indicable_clear (IANJUTA_INDICABLE (_tmp39_), &_inner_error_);
582
 
                                        if (_inner_error_ != NULL) {
583
 
                                                _g_list_free0 (doc_collection);
584
 
                                                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
585
 
                                                g_clear_error (&_inner_error_);
586
 
                                                return;
587
 
                                        }
588
 
                                }
589
 
                                _tmp40_ = doc;
590
 
                                if (IANJUTA_IS_MARKABLE (_tmp40_)) {
591
 
                                        GtkWidget* _tmp41_;
592
 
                                        _tmp41_ = doc;
593
 
                                        ianjuta_markable_delete_all_markers (IANJUTA_MARKABLE (_tmp41_), IANJUTA_MARKABLE_MESSAGE, &_inner_error_);
594
 
                                        if (_inner_error_ != NULL) {
595
 
                                                _g_list_free0 (doc_collection);
596
 
                                                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
597
 
                                                g_clear_error (&_inner_error_);
598
 
                                                return;
599
 
                                        }
600
 
                                }
601
 
                        }
602
 
                }
603
 
                _g_list_free0 (doc_collection);
604
 
        }
605
 
}
606
 
 
607
 
 
608
 
static gpointer _vala_source_reference_ref0 (gpointer self) {
609
 
        return self ? vala_source_reference_ref (self) : NULL;
610
 
}
611
 
 
612
 
 
613
 
static void anjuta_report_real_warn (ValaReport* base, ValaSourceReference* source, const gchar* message) {
614
 
        AnjutaReport * self;
615
 
        gint _tmp0_;
616
 
        ValaSourceReference* _tmp1_;
617
 
        GError * _inner_error_ = NULL;
618
 
        self = (AnjutaReport*) base;
619
 
        g_return_if_fail (message != NULL);
620
 
        _tmp0_ = ((ValaReport*) self)->warnings;
621
 
        ((ValaReport*) self)->warnings = _tmp0_ + 1;
622
 
        _tmp1_ = source;
623
 
        if (_tmp1_ == NULL) {
624
 
                return;
625
 
        }
626
 
        {
627
 
                ValaList* _tmp2_;
628
 
                _tmp2_ = self->priv->errors_list;
629
 
                g_static_rec_mutex_lock (&self->priv->__lock_errors_list);
630
 
                {
631
 
                        ValaList* _tmp3_;
632
 
                        ValaSourceReference* _tmp4_;
633
 
                        ValaSourceReference* _tmp5_;
634
 
                        const gchar* _tmp6_;
635
 
                        gchar* _tmp7_;
636
 
                        AnjutaReportError _tmp8_ = {0};
637
 
                        AnjutaReportError _tmp9_;
638
 
                        AnjutaReportError _tmp10_;
639
 
                        _tmp3_ = self->priv->errors_list;
640
 
                        _tmp4_ = source;
641
 
                        _tmp5_ = _vala_source_reference_ref0 (_tmp4_);
642
 
                        _tmp6_ = message;
643
 
                        _tmp7_ = g_strdup (_tmp6_);
644
 
                        memset (&_tmp8_, 0, sizeof (AnjutaReportError));
645
 
                        _vala_source_reference_unref0 (_tmp8_.source);
646
 
                        _tmp8_.source = _tmp5_;
647
 
                        _g_free0 (_tmp8_.message);
648
 
                        _tmp8_.message = _tmp7_;
649
 
                        _tmp8_.error = FALSE;
650
 
                        _tmp9_ = _tmp8_;
651
 
                        _tmp10_ = _tmp9_;
652
 
                        vala_collection_add ((ValaCollection*) _tmp3_, &_tmp10_);
653
 
                        anjuta_report_error_destroy (&_tmp9_);
654
 
                }
655
 
                __finally10:
656
 
                {
657
 
                        ValaList* _tmp11_;
658
 
                        _tmp11_ = self->priv->errors_list;
659
 
                        g_static_rec_mutex_unlock (&self->priv->__lock_errors_list);
660
 
                }
661
 
                if (_inner_error_ != NULL) {
662
 
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
663
 
                        g_clear_error (&_inner_error_);
664
 
                        return;
665
 
                }
666
 
        }
667
 
}
668
 
 
669
 
 
670
 
static void anjuta_report_real_err (ValaReport* base, ValaSourceReference* source, const gchar* message) {
671
 
        AnjutaReport * self;
672
 
        gint _tmp0_;
673
 
        ValaSourceReference* _tmp1_;
674
 
        GError * _inner_error_ = NULL;
675
 
        self = (AnjutaReport*) base;
676
 
        g_return_if_fail (message != NULL);
677
 
        _tmp0_ = ((ValaReport*) self)->errors;
678
 
        ((ValaReport*) self)->errors = _tmp0_ + 1;
679
 
        _tmp1_ = source;
680
 
        if (_tmp1_ == NULL) {
681
 
                self->priv->general_error = TRUE;
682
 
                return;
683
 
        }
684
 
        {
685
 
                ValaList* _tmp2_;
686
 
                _tmp2_ = self->priv->errors_list;
687
 
                g_static_rec_mutex_lock (&self->priv->__lock_errors_list);
688
 
                {
689
 
                        ValaList* _tmp3_;
690
 
                        ValaSourceReference* _tmp4_;
691
 
                        ValaSourceReference* _tmp5_;
692
 
                        const gchar* _tmp6_;
693
 
                        gchar* _tmp7_;
694
 
                        AnjutaReportError _tmp8_ = {0};
695
 
                        AnjutaReportError _tmp9_;
696
 
                        AnjutaReportError _tmp10_;
697
 
                        _tmp3_ = self->priv->errors_list;
698
 
                        _tmp4_ = source;
699
 
                        _tmp5_ = _vala_source_reference_ref0 (_tmp4_);
700
 
                        _tmp6_ = message;
701
 
                        _tmp7_ = g_strdup (_tmp6_);
702
 
                        memset (&_tmp8_, 0, sizeof (AnjutaReportError));
703
 
                        _vala_source_reference_unref0 (_tmp8_.source);
704
 
                        _tmp8_.source = _tmp5_;
705
 
                        _g_free0 (_tmp8_.message);
706
 
                        _tmp8_.message = _tmp7_;
707
 
                        _tmp8_.error = TRUE;
708
 
                        _tmp9_ = _tmp8_;
709
 
                        _tmp10_ = _tmp9_;
710
 
                        vala_collection_add ((ValaCollection*) _tmp3_, &_tmp10_);
711
 
                        anjuta_report_error_destroy (&_tmp9_);
712
 
                }
713
 
                __finally11:
714
 
                {
715
 
                        ValaList* _tmp11_;
716
 
                        _tmp11_ = self->priv->errors_list;
717
 
                        g_static_rec_mutex_unlock (&self->priv->__lock_errors_list);
718
 
                }
719
 
                if (_inner_error_ != NULL) {
720
 
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
721
 
                        g_clear_error (&_inner_error_);
722
 
                        return;
723
 
                }
724
 
        }
725
 
}
726
 
 
727
 
 
728
 
AnjutaReport* anjuta_report_construct (GType object_type) {
729
 
        AnjutaReport * self = NULL;
730
 
        self = (AnjutaReport*) vala_report_construct (object_type);
731
 
        return self;
732
 
}
733
 
 
734
 
 
735
 
AnjutaReport* anjuta_report_new (void) {
736
 
        return anjuta_report_construct (TYPE_ANJUTA_REPORT);
737
 
}
738
 
 
739
 
 
740
 
IAnjutaDocumentManager* anjuta_report_get_docman (AnjutaReport* self) {
741
 
        IAnjutaDocumentManager* result;
742
 
        IAnjutaDocumentManager* _tmp0_;
743
 
        g_return_val_if_fail (self != NULL, NULL);
744
 
        _tmp0_ = self->priv->_docman;
745
 
        result = _tmp0_;
746
 
        return result;
747
 
}
748
 
 
749
 
 
750
 
void anjuta_report_set_docman (AnjutaReport* self, IAnjutaDocumentManager* value) {
751
 
        IAnjutaDocumentManager* _tmp0_;
752
 
        IAnjutaDocumentManager* _tmp1_;
753
 
        g_return_if_fail (self != NULL);
754
 
        _tmp0_ = value;
755
 
        _tmp1_ = _g_object_ref0 (_tmp0_);
756
 
        _g_object_unref0 (self->priv->_docman);
757
 
        self->priv->_docman = _tmp1_;
758
 
        g_object_notify ((GObject *) self, "docman");
759
 
}
760
 
 
761
 
 
762
 
static void anjuta_report_error_copy (const AnjutaReportError* self, AnjutaReportError* dest) {
763
 
        ValaSourceReference* _tmp0_;
764
 
        ValaSourceReference* _tmp1_;
765
 
        gboolean _tmp2_;
766
 
        const gchar* _tmp3_;
767
 
        const gchar* _tmp4_;
768
 
        _tmp0_ = (*self).source;
769
 
        _tmp1_ = _vala_source_reference_ref0 (_tmp0_);
770
 
        _vala_source_reference_unref0 ((*dest).source);
771
 
        (*dest).source = _tmp1_;
772
 
        _tmp2_ = (*self).error;
773
 
        (*dest).error = _tmp2_;
774
 
        _tmp3_ = (*self).message;
775
 
        _tmp4_ = g_strdup (_tmp3_);
776
 
        _g_free0 ((*dest).message);
777
 
        (*dest).message = _tmp4_;
778
 
}
779
 
 
780
 
 
781
 
static void anjuta_report_error_destroy (AnjutaReportError* self) {
782
 
        _vala_source_reference_unref0 ((*self).source);
783
 
        _g_free0 ((*self).message);
784
 
}
785
 
 
786
 
 
787
 
static AnjutaReportError* anjuta_report_error_dup (const AnjutaReportError* self) {
788
 
        AnjutaReportError* dup;
789
 
        dup = g_new0 (AnjutaReportError, 1);
790
 
        anjuta_report_error_copy (self, dup);
791
 
        return dup;
792
 
}
793
 
 
794
 
 
795
 
static void anjuta_report_error_free (AnjutaReportError* self) {
796
 
        anjuta_report_error_destroy (self);
797
 
        g_free (self);
798
 
}
799
 
 
800
 
 
801
 
static GType anjuta_report_error_get_type (void) {
802
 
        static volatile gsize anjuta_report_error_type_id__volatile = 0;
803
 
        if (g_once_init_enter (&anjuta_report_error_type_id__volatile)) {
804
 
                GType anjuta_report_error_type_id;
805
 
                anjuta_report_error_type_id = g_boxed_type_register_static ("AnjutaReportError", (GBoxedCopyFunc) anjuta_report_error_dup, (GBoxedFreeFunc) anjuta_report_error_free);
806
 
                g_once_init_leave (&anjuta_report_error_type_id__volatile, anjuta_report_error_type_id);
807
 
        }
808
 
        return anjuta_report_error_type_id__volatile;
809
 
}
810
 
 
811
 
 
812
 
static void anjuta_report_class_init (AnjutaReportClass * klass) {
813
 
        anjuta_report_parent_class = g_type_class_peek_parent (klass);
814
 
        g_type_class_add_private (klass, sizeof (AnjutaReportPrivate));
815
 
        VALA_REPORT_CLASS (klass)->warn = anjuta_report_real_warn;
816
 
        VALA_REPORT_CLASS (klass)->err = anjuta_report_real_err;
817
 
        G_OBJECT_CLASS (klass)->get_property = _vala_anjuta_report_get_property;
818
 
        G_OBJECT_CLASS (klass)->set_property = _vala_anjuta_report_set_property;
819
 
        G_OBJECT_CLASS (klass)->finalize = anjuta_report_finalize;
820
 
        g_object_class_install_property (G_OBJECT_CLASS (klass), ANJUTA_REPORT_DOCMAN, g_param_spec_object ("docman", "docman", "docman", ianjuta_document_manager_get_type (), G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE | G_PARAM_WRITABLE));
821
 
}
822
 
 
823
 
 
824
 
static void anjuta_report_instance_init (AnjutaReport * self) {
825
 
        GEqualFunc _tmp0_;
826
 
        ValaArrayList* _tmp1_;
827
 
        self->priv = ANJUTA_REPORT_GET_PRIVATE (self);
828
 
        g_static_rec_mutex_init (&self->priv->__lock_errors_list);
829
 
        _tmp0_ = g_direct_equal;
830
 
        _tmp1_ = vala_array_list_new (ANJUTA_REPORT_TYPE_ERROR, (GBoxedCopyFunc) anjuta_report_error_dup, anjuta_report_error_free, _tmp0_);
831
 
        self->priv->errors_list = (ValaList*) _tmp1_;
832
 
        self->priv->general_error = FALSE;
833
 
}
834
 
 
835
 
 
836
 
static void anjuta_report_finalize (GObject* obj) {
837
 
        AnjutaReport * self;
838
 
        self = ANJUTA_REPORT (obj);
839
 
        _g_object_unref0 (self->priv->_docman);
840
 
        g_static_rec_mutex_free (&self->priv->__lock_errors_list);
841
 
        _vala_iterable_unref0 (self->priv->errors_list);
842
 
        G_OBJECT_CLASS (anjuta_report_parent_class)->finalize (obj);
843
 
}
844
 
 
845
 
 
846
 
GType anjuta_report_get_type (void) {
847
 
        return anjuta_report_type_id;
848
 
}
849
 
 
850
 
 
851
 
GType anjuta_report_register_type (GTypeModule * module) {
852
 
        static const GTypeInfo g_define_type_info = { sizeof (AnjutaReportClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) anjuta_report_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (AnjutaReport), 0, (GInstanceInitFunc) anjuta_report_instance_init, NULL };
853
 
        anjuta_report_type_id = g_type_module_register_type (module, VALA_TYPE_REPORT, "AnjutaReport", &g_define_type_info, 0);
854
 
        return anjuta_report_type_id;
855
 
}
856
 
 
857
 
 
858
 
static void _vala_anjuta_report_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
859
 
        AnjutaReport * self;
860
 
        self = ANJUTA_REPORT (object);
861
 
        switch (property_id) {
862
 
                case ANJUTA_REPORT_DOCMAN:
863
 
                g_value_set_object (value, anjuta_report_get_docman (self));
864
 
                break;
865
 
                default:
866
 
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
867
 
                break;
868
 
        }
869
 
}
870
 
 
871
 
 
872
 
static void _vala_anjuta_report_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
873
 
        AnjutaReport * self;
874
 
        self = ANJUTA_REPORT (object);
875
 
        switch (property_id) {
876
 
                case ANJUTA_REPORT_DOCMAN:
877
 
                anjuta_report_set_docman (self, g_value_get_object (value));
878
 
                break;
879
 
                default:
880
 
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
881
 
                break;
882
 
        }
883
 
}
884
 
 
885
 
 
886