1 /* parser.c generated by valac, the Vala compiler
2  * generated from parser.vala, do not modify */
3 
4 /* parser.vala
5  *
6  * Copyright (C) 2008-2009 Florian Brosch, Didier Villevalois
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  * 	Didier 'Ptitjes Villevalois <ptitjes@free.fr>
24  */
25 
26 #include "valadoc.h"
27 #include <stdlib.h>
28 #include <string.h>
29 #include <glib.h>
30 #include <valagee.h>
31 #include <glib-object.h>
32 #include <gobject/gvaluecollector.h>
33 
34 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
35 #define _g_free0(var) (var = (g_free (var), NULL))
36 #define _vala_iterable_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterable_unref (var), NULL)))
37 #define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
38 typedef struct _ValadocParamSpecParser ValadocParamSpecParser;
39 #define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
40 #define _vala_return_if_fail(expr, msg) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return; }
41 #define _vala_return_val_if_fail(expr, msg, val) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return val; }
42 #define _vala_warn_if_fail(expr, msg) if G_LIKELY (expr) ; else g_warn_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
43 
44 struct _ValadocParserPrivate {
45 	ValadocSettings* _settings;
46 	ValadocScanner* _scanner;
47 	ValadocErrorReporter* _reporter;
48 	ValadocRule* _root_rule;
49 	gchar* _filename;
50 	gint _first_line;
51 	gint _first_column;
52 	ValadocToken* _current_token;
53 	ValaArrayList* rule_stack;
54 	ValaArrayList* rule_state_stack;
55 };
56 
57 struct _ValadocParamSpecParser {
58 	GParamSpec parent_instance;
59 };
60 
61 static gint ValadocParser_private_offset;
62 static gpointer valadoc_parser_parent_class = NULL;
63 static ValadocParserCallbackIface * valadoc_parser_valadoc_parser_callback_parent_iface = NULL;
64 
65 G_GNUC_INTERNAL void valadoc_token_type_init_token_types (void);
66 static ValadocRule* valadoc_parser_peek_rule (ValadocParser* self,
67                                        gint offset);
68 static ValadocRule* valadoc_parser_pop_rule (ValadocParser* self);
69 static void valadoc_parser_real_push_rule (ValadocParserCallback* base,
70                                     ValadocRule* rule);
71 static GObject* valadoc_parser_peek_state (ValadocParser* self,
72                                     gint offset);
73 static GObject* valadoc_parser_real_get_rule_state (ValadocParserCallback* base);
74 static void valadoc_parser_real_set_rule_state (ValadocParserCallback* base,
75                                          GObject* state);
76 static void valadoc_parser_real_reduce (ValadocParserCallback* base);
77 static gboolean valadoc_parser_real_would_parent_accept_token (ValadocParserCallback* base,
78                                                         ValadocToken* token);
79 static gboolean valadoc_parser_real_would_parent_reduce_to_rule (ValadocParserCallback* base,
80                                                           ValadocToken* token,
81                                                           ValadocRule* rule);
82 static void valadoc_parser_real_warning (ValadocParserCallback* base,
83                                   ValadocToken* token,
84                                   const gchar* message);
85 static gint valadoc_parser_get_line (ValadocParser* self,
86                               ValadocToken* token);
87 static gint valadoc_parser_get_start_column (ValadocParser* self,
88                                       ValadocToken* token);
89 static gint valadoc_parser_get_end_column (ValadocParser* self,
90                                     ValadocToken* token);
91 static void valadoc_parser_real_error (ValadocParserCallback* base,
92                                 ValadocToken* token,
93                                 const gchar* message,
94                                 GError** error);
95 static void valadoc_parser_finalize (ValadocParser * obj);
96 static GType valadoc_parser_get_type_once (void);
97 
98 GQuark
valadoc_parser_error_quark(void)99 valadoc_parser_error_quark (void)
100 {
101 	return g_quark_from_static_string ("valadoc-parser-error-quark");
102 }
103 
104 static inline gpointer
valadoc_parser_get_instance_private(ValadocParser * self)105 valadoc_parser_get_instance_private (ValadocParser* self)
106 {
107 	return G_STRUCT_MEMBER_P (self, ValadocParser_private_offset);
108 }
109 
110 static gpointer
_g_object_ref0(gpointer self)111 _g_object_ref0 (gpointer self)
112 {
113 	return self ? g_object_ref (self) : NULL;
114 }
115 
116 ValadocParser*
valadoc_parser_construct(GType object_type,ValadocSettings * settings,ValadocScanner * scanner,ValadocErrorReporter * reporter)117 valadoc_parser_construct (GType object_type,
118                           ValadocSettings* settings,
119                           ValadocScanner* scanner,
120                           ValadocErrorReporter* reporter)
121 {
122 	ValadocParser* self = NULL;
123 	ValadocSettings* _tmp0_;
124 	ValadocScanner* _tmp1_;
125 	ValadocErrorReporter* _tmp2_;
126 	g_return_val_if_fail (settings != NULL, NULL);
127 	g_return_val_if_fail (scanner != NULL, NULL);
128 	g_return_val_if_fail (reporter != NULL, NULL);
129 	self = (ValadocParser*) g_type_create_instance (object_type);
130 	_tmp0_ = _g_object_ref0 (settings);
131 	_g_object_unref0 (self->priv->_settings);
132 	self->priv->_settings = _tmp0_;
133 	_tmp1_ = _g_object_ref0 (scanner);
134 	_g_object_unref0 (self->priv->_scanner);
135 	self->priv->_scanner = _tmp1_;
136 	_tmp2_ = _g_object_ref0 (reporter);
137 	_g_object_unref0 (self->priv->_reporter);
138 	self->priv->_reporter = _tmp2_;
139 	valadoc_token_type_init_token_types ();
140 	return self;
141 }
142 
143 ValadocParser*
valadoc_parser_new(ValadocSettings * settings,ValadocScanner * scanner,ValadocErrorReporter * reporter)144 valadoc_parser_new (ValadocSettings* settings,
145                     ValadocScanner* scanner,
146                     ValadocErrorReporter* reporter)
147 {
148 	return valadoc_parser_construct (VALADOC_TYPE_PARSER, settings, scanner, reporter);
149 }
150 
151 void
valadoc_parser_set_root_rule(ValadocParser * self,ValadocRule * root_rule)152 valadoc_parser_set_root_rule (ValadocParser* self,
153                               ValadocRule* root_rule)
154 {
155 	ValadocRule* _tmp0_;
156 	g_return_if_fail (self != NULL);
157 	g_return_if_fail (root_rule != NULL);
158 	_tmp0_ = _g_object_ref0 (root_rule);
159 	_g_object_unref0 (self->priv->_root_rule);
160 	self->priv->_root_rule = _tmp0_;
161 }
162 
163 static gpointer
_g_error_copy0(gpointer self)164 _g_error_copy0 (gpointer self)
165 {
166 	return self ? g_error_copy (self) : NULL;
167 }
168 
169 void
valadoc_parser_parse(ValadocParser * self,const gchar * content,const gchar * filename,gint first_line,gint first_column,GError ** error)170 valadoc_parser_parse (ValadocParser* self,
171                       const gchar* content,
172                       const gchar* filename,
173                       gint first_line,
174                       gint first_column,
175                       GError** error)
176 {
177 	gchar* _tmp0_;
178 	ValaArrayList* _tmp1_;
179 	ValaArrayList* _tmp2_;
180 	GError* _inner_error0_ = NULL;
181 	g_return_if_fail (self != NULL);
182 	g_return_if_fail (content != NULL);
183 	g_return_if_fail (filename != NULL);
184 	_tmp0_ = g_strdup (filename);
185 	_g_free0 (self->priv->_filename);
186 	self->priv->_filename = _tmp0_;
187 	self->priv->_first_line = first_line;
188 	self->priv->_first_column = first_column;
189 	_tmp1_ = self->priv->rule_stack;
190 	vala_collection_clear ((ValaCollection*) _tmp1_);
191 	_tmp2_ = self->priv->rule_state_stack;
192 	vala_collection_clear ((ValaCollection*) _tmp2_);
193 	{
194 		ValadocRule* _tmp3_;
195 		ValadocScanner* _tmp4_;
196 		ValadocScanner* _tmp5_;
197 		ValadocScanner* _tmp6_;
198 		ValaArrayList* _tmp7_;
199 		gint _tmp8_;
200 		gint _tmp9_;
201 		_tmp3_ = self->priv->_root_rule;
202 		valadoc_parser_callback_push_rule ((ValadocParserCallback*) self, _tmp3_);
203 		_tmp4_ = self->priv->_scanner;
204 		valadoc_scanner_reset (_tmp4_);
205 		_tmp5_ = self->priv->_scanner;
206 		valadoc_scanner_scan (_tmp5_, content, &_inner_error0_);
207 		if (G_UNLIKELY (_inner_error0_ != NULL)) {
208 			if (_inner_error0_->domain == VALADOC_PARSER_ERROR) {
209 				goto __catch0_valadoc_parser_error;
210 			}
211 			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);
212 			g_clear_error (&_inner_error0_);
213 			return;
214 		}
215 		_tmp6_ = self->priv->_scanner;
216 		valadoc_scanner_end (_tmp6_, &_inner_error0_);
217 		if (G_UNLIKELY (_inner_error0_ != NULL)) {
218 			if (_inner_error0_->domain == VALADOC_PARSER_ERROR) {
219 				goto __catch0_valadoc_parser_error;
220 			}
221 			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);
222 			g_clear_error (&_inner_error0_);
223 			return;
224 		}
225 		_tmp7_ = self->priv->rule_stack;
226 		_tmp8_ = vala_collection_get_size ((ValaCollection*) _tmp7_);
227 		_tmp9_ = _tmp8_;
228 		if (_tmp9_ != 0) {
229 			valadoc_parser_callback_error ((ValadocParserCallback*) self, NULL, "Rule stack is not empty!", &_inner_error0_);
230 			if (G_UNLIKELY (_inner_error0_ != NULL)) {
231 				if (_inner_error0_->domain == VALADOC_PARSER_ERROR) {
232 					goto __catch0_valadoc_parser_error;
233 				}
234 				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);
235 				g_clear_error (&_inner_error0_);
236 				return;
237 			}
238 		}
239 	}
240 	goto __finally0;
241 	__catch0_valadoc_parser_error:
242 	{
243 		GError* e = NULL;
244 		GError* _tmp10_;
245 		GError* _tmp11_;
246 		e = _inner_error0_;
247 		_inner_error0_ = NULL;
248 		_tmp10_ = e;
249 		_tmp11_ = _g_error_copy0 (_tmp10_);
250 		_inner_error0_ = _tmp11_;
251 		_g_error_free0 (e);
252 		goto __finally0;
253 	}
254 	__finally0:
255 	if (G_UNLIKELY (_inner_error0_ != NULL)) {
256 		if (_inner_error0_->domain == VALADOC_PARSER_ERROR) {
257 			g_propagate_error (error, _inner_error0_);
258 			return;
259 		} else {
260 			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);
261 			g_clear_error (&_inner_error0_);
262 			return;
263 		}
264 	}
265 }
266 
267 void
valadoc_parser_accept_token(ValadocParser * self,ValadocToken * token,GError ** error)268 valadoc_parser_accept_token (ValadocParser* self,
269                              ValadocToken* token,
270                              GError** error)
271 {
272 	ValadocToken* _tmp0_;
273 	gint rule_depth = 0;
274 	ValaArrayList* _tmp1_;
275 	gint _tmp2_;
276 	gint _tmp3_;
277 	ValadocRuleForward forward = 0;
278 	ValadocRule* rule = NULL;
279 	ValadocRule* _tmp4_;
280 	ValadocRule* _tmp5_;
281 	GError* _inner_error0_ = NULL;
282 	g_return_if_fail (self != NULL);
283 	g_return_if_fail (token != NULL);
284 	_tmp0_ = _g_object_ref0 (token);
285 	_g_object_unref0 (self->priv->_current_token);
286 	self->priv->_current_token = _tmp0_;
287 	_tmp1_ = self->priv->rule_stack;
288 	_tmp2_ = vala_collection_get_size ((ValaCollection*) _tmp1_);
289 	_tmp3_ = _tmp2_;
290 	rule_depth = _tmp3_;
291 	forward = VALADOC_RULE_FORWARD_NONE;
292 	_tmp4_ = valadoc_parser_peek_rule (self, -1);
293 	rule = _tmp4_;
294 	_tmp5_ = rule;
295 	if (_tmp5_ == NULL) {
296 		GError* _tmp6_;
297 		_tmp6_ = g_error_new_literal (VALADOC_PARSER_ERROR, VALADOC_PARSER_ERROR_INTERNAL_ERROR, "Rule stack is empty!");
298 		_inner_error0_ = _tmp6_;
299 		if (_inner_error0_->domain == VALADOC_PARSER_ERROR) {
300 			g_propagate_error (error, _inner_error0_);
301 			_g_object_unref0 (rule);
302 			return;
303 		} else {
304 			_g_object_unref0 (rule);
305 			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);
306 			g_clear_error (&_inner_error0_);
307 			return;
308 		}
309 	}
310 	while (TRUE) {
311 		ValadocRule* _tmp7_;
312 		gboolean _tmp8_ = FALSE;
313 		ValadocRule* _tmp9_;
314 		ValadocRuleForward _tmp10_;
315 		gboolean _tmp11_ = FALSE;
316 		ValaArrayList* _tmp12_;
317 		gint _tmp13_;
318 		gint _tmp14_;
319 		ValadocRule* _tmp18_;
320 		ValadocRuleForward _tmp19_ = 0;
321 		ValaArrayList* _tmp20_;
322 		gint _tmp21_;
323 		gint _tmp22_;
324 		ValaArrayList* _tmp23_;
325 		gint _tmp24_;
326 		gint _tmp25_;
327 		_tmp7_ = rule;
328 		if (!(_tmp7_ != NULL)) {
329 			break;
330 		}
331 		_tmp9_ = rule;
332 		_tmp10_ = forward;
333 		_tmp8_ = valadoc_rule_accept_token (_tmp9_, token, (ValadocParserCallback*) self, _tmp10_, &_inner_error0_);
334 		if (G_UNLIKELY (_inner_error0_ != NULL)) {
335 			if (_inner_error0_->domain == VALADOC_PARSER_ERROR) {
336 				g_propagate_error (error, _inner_error0_);
337 				_g_object_unref0 (rule);
338 				return;
339 			} else {
340 				_g_object_unref0 (rule);
341 				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);
342 				g_clear_error (&_inner_error0_);
343 				return;
344 			}
345 		}
346 		if (_tmp8_) {
347 			break;
348 		}
349 		_tmp12_ = self->priv->rule_stack;
350 		_tmp13_ = vala_collection_get_size ((ValaCollection*) _tmp12_);
351 		_tmp14_ = _tmp13_;
352 		if (rule_depth != _tmp14_) {
353 			ValadocRule* _tmp15_;
354 			ValadocRule* _tmp16_;
355 			ValadocRule* _tmp17_;
356 			_tmp15_ = valadoc_parser_peek_rule (self, -1);
357 			_tmp16_ = _tmp15_;
358 			_tmp17_ = rule;
359 			_tmp11_ = _tmp16_ == _tmp17_;
360 			_g_object_unref0 (_tmp16_);
361 		} else {
362 			_tmp11_ = FALSE;
363 		}
364 		if (_tmp11_) {
365 			valadoc_parser_callback_error ((ValadocParserCallback*) self, NULL, "Parser state error", &_inner_error0_);
366 			if (G_UNLIKELY (_inner_error0_ != NULL)) {
367 				if (_inner_error0_->domain == VALADOC_PARSER_ERROR) {
368 					g_propagate_error (error, _inner_error0_);
369 					_g_object_unref0 (rule);
370 					return;
371 				} else {
372 					_g_object_unref0 (rule);
373 					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);
374 					g_clear_error (&_inner_error0_);
375 					return;
376 				}
377 			}
378 			break;
379 		}
380 		_tmp18_ = valadoc_parser_peek_rule (self, -1);
381 		_g_object_unref0 (rule);
382 		rule = _tmp18_;
383 		_tmp20_ = self->priv->rule_stack;
384 		_tmp21_ = vala_collection_get_size ((ValaCollection*) _tmp20_);
385 		_tmp22_ = _tmp21_;
386 		if (rule_depth > _tmp22_) {
387 			_tmp19_ = VALADOC_RULE_FORWARD_CHILD;
388 		} else {
389 			_tmp19_ = VALADOC_RULE_FORWARD_PARENT;
390 		}
391 		forward = _tmp19_;
392 		_tmp23_ = self->priv->rule_stack;
393 		_tmp24_ = vala_collection_get_size ((ValaCollection*) _tmp23_);
394 		_tmp25_ = _tmp24_;
395 		rule_depth = _tmp25_;
396 	}
397 	_g_object_unref0 (rule);
398 }
399 
400 static ValadocRule*
valadoc_parser_peek_rule(ValadocParser * self,gint offset)401 valadoc_parser_peek_rule (ValadocParser* self,
402                           gint offset)
403 {
404 	ValaArrayList* _tmp0_;
405 	gint _tmp1_;
406 	gint _tmp2_;
407 	ValaArrayList* _tmp3_;
408 	ValaArrayList* _tmp4_;
409 	gint _tmp5_;
410 	gint _tmp6_;
411 	gpointer _tmp7_;
412 	ValadocRule* result = NULL;
413 	g_return_val_if_fail (self != NULL, NULL);
414 	_vala_assert (offset < 0, "offset < 0");
415 	_tmp0_ = self->priv->rule_stack;
416 	_tmp1_ = vala_collection_get_size ((ValaCollection*) _tmp0_);
417 	_tmp2_ = _tmp1_;
418 	if ((_tmp2_ + offset) < 0) {
419 		result = NULL;
420 		return result;
421 	}
422 	_tmp3_ = self->priv->rule_stack;
423 	_tmp4_ = self->priv->rule_stack;
424 	_tmp5_ = vala_collection_get_size ((ValaCollection*) _tmp4_);
425 	_tmp6_ = _tmp5_;
426 	_tmp7_ = vala_list_get ((ValaList*) _tmp3_, _tmp6_ + offset);
427 	result = (ValadocRule*) _tmp7_;
428 	return result;
429 }
430 
431 static ValadocRule*
valadoc_parser_pop_rule(ValadocParser * self)432 valadoc_parser_pop_rule (ValadocParser* self)
433 {
434 	gint last_index = 0;
435 	ValaArrayList* _tmp0_;
436 	gint _tmp1_;
437 	gint _tmp2_;
438 	ValadocRule* rule = NULL;
439 	ValaArrayList* _tmp3_;
440 	gpointer _tmp4_;
441 	ValaArrayList* _tmp5_;
442 	gpointer _tmp6_;
443 	ValadocRule* _tmp7_;
444 	ValaArrayList* _tmp8_;
445 	gpointer _tmp9_;
446 	GObject* _tmp10_;
447 	ValadocRule* result = NULL;
448 	g_return_val_if_fail (self != NULL, NULL);
449 	_tmp0_ = self->priv->rule_stack;
450 	_tmp1_ = vala_collection_get_size ((ValaCollection*) _tmp0_);
451 	_tmp2_ = _tmp1_;
452 	last_index = _tmp2_ - 1;
453 	_tmp3_ = self->priv->rule_stack;
454 	_tmp4_ = vala_list_get ((ValaList*) _tmp3_, last_index);
455 	rule = (ValadocRule*) _tmp4_;
456 	_tmp5_ = self->priv->rule_stack;
457 	_tmp6_ = vala_list_remove_at ((ValaList*) _tmp5_, last_index);
458 	_tmp7_ = (ValadocRule*) _tmp6_;
459 	_g_object_unref0 (_tmp7_);
460 	_tmp8_ = self->priv->rule_state_stack;
461 	_tmp9_ = vala_list_remove_at ((ValaList*) _tmp8_, last_index);
462 	_tmp10_ = (GObject*) _tmp9_;
463 	_g_object_unref0 (_tmp10_);
464 	result = rule;
465 	return result;
466 }
467 
468 static void
valadoc_parser_real_push_rule(ValadocParserCallback * base,ValadocRule * rule)469 valadoc_parser_real_push_rule (ValadocParserCallback* base,
470                                ValadocRule* rule)
471 {
472 	ValadocParser * self;
473 	ValaArrayList* _tmp0_;
474 	ValaArrayList* _tmp1_;
475 	self = (ValadocParser*) base;
476 	g_return_if_fail (rule != NULL);
477 	_tmp0_ = self->priv->rule_stack;
478 	vala_collection_add ((ValaCollection*) _tmp0_, rule);
479 	_tmp1_ = self->priv->rule_state_stack;
480 	vala_collection_add ((ValaCollection*) _tmp1_, NULL);
481 }
482 
483 static GObject*
valadoc_parser_peek_state(ValadocParser * self,gint offset)484 valadoc_parser_peek_state (ValadocParser* self,
485                            gint offset)
486 {
487 	ValaArrayList* _tmp0_;
488 	gint _tmp1_;
489 	gint _tmp2_;
490 	ValaArrayList* _tmp3_;
491 	ValaArrayList* _tmp4_;
492 	gint _tmp5_;
493 	gint _tmp6_;
494 	gpointer _tmp7_;
495 	GObject* result = NULL;
496 	g_return_val_if_fail (self != NULL, NULL);
497 	_vala_assert (offset < 0, "offset < 0");
498 	_tmp0_ = self->priv->rule_state_stack;
499 	_tmp1_ = vala_collection_get_size ((ValaCollection*) _tmp0_);
500 	_tmp2_ = _tmp1_;
501 	if ((_tmp2_ + offset) < 0) {
502 		result = NULL;
503 		return result;
504 	}
505 	_tmp3_ = self->priv->rule_state_stack;
506 	_tmp4_ = self->priv->rule_state_stack;
507 	_tmp5_ = vala_collection_get_size ((ValaCollection*) _tmp4_);
508 	_tmp6_ = _tmp5_;
509 	_tmp7_ = vala_list_get ((ValaList*) _tmp3_, _tmp6_ + offset);
510 	result = (GObject*) _tmp7_;
511 	return result;
512 }
513 
514 static GObject*
valadoc_parser_real_get_rule_state(ValadocParserCallback * base)515 valadoc_parser_real_get_rule_state (ValadocParserCallback* base)
516 {
517 	ValadocParser * self;
518 	GObject* _tmp0_;
519 	GObject* result = NULL;
520 	self = (ValadocParser*) base;
521 	_tmp0_ = valadoc_parser_peek_state (self, -1);
522 	result = _tmp0_;
523 	return result;
524 }
525 
526 static void
valadoc_parser_real_set_rule_state(ValadocParserCallback * base,GObject * state)527 valadoc_parser_real_set_rule_state (ValadocParserCallback* base,
528                                     GObject* state)
529 {
530 	ValadocParser * self;
531 	gint last_index = 0;
532 	ValaArrayList* _tmp0_;
533 	gint _tmp1_;
534 	gint _tmp2_;
535 	ValaArrayList* _tmp3_;
536 	self = (ValadocParser*) base;
537 	g_return_if_fail (state != NULL);
538 	_tmp0_ = self->priv->rule_stack;
539 	_tmp1_ = vala_collection_get_size ((ValaCollection*) _tmp0_);
540 	_tmp2_ = _tmp1_;
541 	last_index = _tmp2_ - 1;
542 	_tmp3_ = self->priv->rule_state_stack;
543 	vala_list_set ((ValaList*) _tmp3_, last_index, state);
544 }
545 
546 static void
valadoc_parser_real_reduce(ValadocParserCallback * base)547 valadoc_parser_real_reduce (ValadocParserCallback* base)
548 {
549 	ValadocParser * self;
550 	ValadocRule* _tmp0_;
551 	ValadocRule* _tmp1_;
552 	self = (ValadocParser*) base;
553 	_tmp0_ = valadoc_parser_pop_rule (self);
554 	_tmp1_ = _tmp0_;
555 	_g_object_unref0 (_tmp1_);
556 }
557 
558 static gboolean
valadoc_parser_real_would_parent_accept_token(ValadocParserCallback * base,ValadocToken * token)559 valadoc_parser_real_would_parent_accept_token (ValadocParserCallback* base,
560                                                ValadocToken* token)
561 {
562 	ValadocParser * self;
563 	gint offset = 0;
564 	ValadocRule* parent_rule = NULL;
565 	ValadocRule* _tmp0_;
566 	GObject* state = NULL;
567 	GObject* _tmp1_;
568 	gboolean result = FALSE;
569 	self = (ValadocParser*) base;
570 	g_return_val_if_fail (token != NULL, FALSE);
571 	offset = -2;
572 	_tmp0_ = valadoc_parser_peek_rule (self, offset);
573 	parent_rule = _tmp0_;
574 	_tmp1_ = valadoc_parser_peek_state (self, offset);
575 	state = _tmp1_;
576 	while (TRUE) {
577 		ValadocRule* _tmp2_;
578 		ValadocRule* _tmp3_;
579 		GObject* _tmp4_;
580 		ValadocRule* _tmp5_;
581 		GObject* _tmp6_;
582 		gint _tmp7_;
583 		ValadocRule* _tmp8_;
584 		GObject* _tmp9_;
585 		_tmp2_ = parent_rule;
586 		if (!(_tmp2_ != NULL)) {
587 			break;
588 		}
589 		_tmp3_ = parent_rule;
590 		_tmp4_ = state;
591 		if (valadoc_rule_would_accept_token (_tmp3_, token, _tmp4_)) {
592 			result = TRUE;
593 			_g_object_unref0 (state);
594 			_g_object_unref0 (parent_rule);
595 			return result;
596 		}
597 		_tmp5_ = parent_rule;
598 		_tmp6_ = state;
599 		if (!valadoc_rule_would_reduce (_tmp5_, token, _tmp6_)) {
600 			result = FALSE;
601 			_g_object_unref0 (state);
602 			_g_object_unref0 (parent_rule);
603 			return result;
604 		}
605 		_tmp7_ = offset;
606 		offset = _tmp7_ - 1;
607 		_tmp8_ = valadoc_parser_peek_rule (self, offset);
608 		_g_object_unref0 (parent_rule);
609 		parent_rule = _tmp8_;
610 		_tmp9_ = valadoc_parser_peek_state (self, offset);
611 		_g_object_unref0 (state);
612 		state = _tmp9_;
613 	}
614 	result = FALSE;
615 	_g_object_unref0 (state);
616 	_g_object_unref0 (parent_rule);
617 	return result;
618 }
619 
620 static gboolean
valadoc_parser_real_would_parent_reduce_to_rule(ValadocParserCallback * base,ValadocToken * token,ValadocRule * rule)621 valadoc_parser_real_would_parent_reduce_to_rule (ValadocParserCallback* base,
622                                                  ValadocToken* token,
623                                                  ValadocRule* rule)
624 {
625 	ValadocParser * self;
626 	gint offset = 0;
627 	ValadocRule* parent_rule = NULL;
628 	ValadocRule* _tmp0_;
629 	GObject* state = NULL;
630 	GObject* _tmp1_;
631 	gboolean _tmp8_ = FALSE;
632 	gboolean _tmp9_ = FALSE;
633 	ValadocRule* _tmp10_;
634 	gboolean result = FALSE;
635 	self = (ValadocParser*) base;
636 	g_return_val_if_fail (token != NULL, FALSE);
637 	g_return_val_if_fail (rule != NULL, FALSE);
638 	offset = -2;
639 	_tmp0_ = valadoc_parser_peek_rule (self, offset);
640 	parent_rule = _tmp0_;
641 	_tmp1_ = valadoc_parser_peek_state (self, offset);
642 	state = _tmp1_;
643 	while (TRUE) {
644 		ValadocRule* _tmp2_;
645 		ValadocRule* _tmp3_;
646 		GObject* _tmp4_;
647 		gint _tmp5_;
648 		ValadocRule* _tmp6_;
649 		GObject* _tmp7_;
650 		_tmp2_ = parent_rule;
651 		if (!(_tmp2_ != NULL)) {
652 			break;
653 		}
654 		_tmp3_ = parent_rule;
655 		_tmp4_ = state;
656 		if (!valadoc_rule_would_reduce (_tmp3_, token, _tmp4_)) {
657 			break;
658 		}
659 		_tmp5_ = offset;
660 		offset = _tmp5_ - 1;
661 		_tmp6_ = valadoc_parser_peek_rule (self, offset);
662 		_g_object_unref0 (parent_rule);
663 		parent_rule = _tmp6_;
664 		_tmp7_ = valadoc_parser_peek_state (self, offset);
665 		_g_object_unref0 (state);
666 		state = _tmp7_;
667 	}
668 	_tmp10_ = parent_rule;
669 	if (_tmp10_ != NULL) {
670 		ValadocRule* _tmp11_;
671 		GObject* _tmp12_;
672 		_tmp11_ = parent_rule;
673 		_tmp12_ = state;
674 		_tmp9_ = valadoc_rule_would_accept_token (_tmp11_, token, _tmp12_);
675 	} else {
676 		_tmp9_ = FALSE;
677 	}
678 	if (_tmp9_) {
679 		_tmp8_ = TRUE;
680 	} else {
681 		gboolean _tmp13_ = FALSE;
682 		ValadocRule* _tmp14_;
683 		_tmp14_ = parent_rule;
684 		if (_tmp14_ == NULL) {
685 			ValadocTokenType* _tmp15_;
686 			_tmp15_ = valadoc_token_type_EOF;
687 			_tmp13_ = valadoc_token_type_matches (_tmp15_, token);
688 		} else {
689 			_tmp13_ = FALSE;
690 		}
691 		_tmp8_ = _tmp13_;
692 	}
693 	if (_tmp8_) {
694 		result = TRUE;
695 		_g_object_unref0 (state);
696 		_g_object_unref0 (parent_rule);
697 		return result;
698 	}
699 	result = FALSE;
700 	_g_object_unref0 (state);
701 	_g_object_unref0 (parent_rule);
702 	return result;
703 }
704 
705 static void
valadoc_parser_real_warning(ValadocParserCallback * base,ValadocToken * token,const gchar * message)706 valadoc_parser_real_warning (ValadocParserCallback* base,
707                              ValadocToken* token,
708                              const gchar* message)
709 {
710 	ValadocParser * self;
711 	gchar* error_message = NULL;
712 	ValadocErrorReporter* _tmp5_;
713 	const gchar* _tmp6_;
714 	ValadocScanner* _tmp7_;
715 	gchar* _tmp8_;
716 	gchar* _tmp9_;
717 	const gchar* _tmp10_;
718 	self = (ValadocParser*) base;
719 	g_return_if_fail (message != NULL);
720 	if (token != NULL) {
721 		gchar* _tmp0_;
722 		gchar* _tmp1_;
723 		const gchar* _tmp2_;
724 		gchar* _tmp3_;
725 		_tmp0_ = g_strconcat (message, ": ", NULL);
726 		_tmp1_ = _tmp0_;
727 		_tmp2_ = valadoc_token_to_pretty_string (token);
728 		_tmp3_ = g_strconcat (_tmp1_, _tmp2_, NULL);
729 		_g_free0 (error_message);
730 		error_message = _tmp3_;
731 		_g_free0 (_tmp1_);
732 	} else {
733 		gchar* _tmp4_;
734 		_tmp4_ = g_strdup (message);
735 		_g_free0 (error_message);
736 		error_message = _tmp4_;
737 	}
738 	_tmp5_ = self->priv->_reporter;
739 	_tmp6_ = self->priv->_filename;
740 	_tmp7_ = self->priv->_scanner;
741 	_tmp8_ = valadoc_scanner_get_line_content (_tmp7_);
742 	_tmp9_ = _tmp8_;
743 	_tmp10_ = error_message;
744 	valadoc_error_reporter_warning (_tmp5_, _tmp6_, (glong) valadoc_parser_get_line (self, token), (glong) valadoc_parser_get_start_column (self, token), (glong) valadoc_parser_get_end_column (self, token), _tmp9_, "%s", _tmp10_);
745 	_g_free0 (_tmp9_);
746 	_g_free0 (error_message);
747 }
748 
749 static void
valadoc_parser_real_error(ValadocParserCallback * base,ValadocToken * token,const gchar * message,GError ** error)750 valadoc_parser_real_error (ValadocParserCallback* base,
751                            ValadocToken* token,
752                            const gchar* message,
753                            GError** error)
754 {
755 	ValadocParser * self;
756 	gchar* error_message = NULL;
757 	ValadocErrorReporter* _tmp5_;
758 	const gchar* _tmp6_;
759 	ValadocScanner* _tmp7_;
760 	gchar* _tmp8_;
761 	gchar* _tmp9_;
762 	const gchar* _tmp10_;
763 	const gchar* _tmp11_;
764 	GError* _tmp12_;
765 	GError* _inner_error0_ = NULL;
766 	self = (ValadocParser*) base;
767 	g_return_if_fail (message != NULL);
768 	if (token != NULL) {
769 		gchar* _tmp0_;
770 		gchar* _tmp1_;
771 		const gchar* _tmp2_;
772 		gchar* _tmp3_;
773 		_tmp0_ = g_strconcat (message, ": ", NULL);
774 		_tmp1_ = _tmp0_;
775 		_tmp2_ = valadoc_token_to_pretty_string (token);
776 		_tmp3_ = g_strconcat (_tmp1_, _tmp2_, NULL);
777 		_g_free0 (error_message);
778 		error_message = _tmp3_;
779 		_g_free0 (_tmp1_);
780 	} else {
781 		gchar* _tmp4_;
782 		_tmp4_ = g_strdup (message);
783 		_g_free0 (error_message);
784 		error_message = _tmp4_;
785 	}
786 	_tmp5_ = self->priv->_reporter;
787 	_tmp6_ = self->priv->_filename;
788 	_tmp7_ = self->priv->_scanner;
789 	_tmp8_ = valadoc_scanner_get_line_content (_tmp7_);
790 	_tmp9_ = _tmp8_;
791 	_tmp10_ = error_message;
792 	valadoc_error_reporter_error (_tmp5_, _tmp6_, (glong) valadoc_parser_get_line (self, token), (glong) valadoc_parser_get_start_column (self, token), (glong) valadoc_parser_get_end_column (self, token), _tmp9_, "%s", _tmp10_);
793 	_g_free0 (_tmp9_);
794 	_tmp11_ = error_message;
795 	_tmp12_ = g_error_new_literal (VALADOC_PARSER_ERROR, VALADOC_PARSER_ERROR_UNEXPECTED_TOKEN, _tmp11_);
796 	_inner_error0_ = _tmp12_;
797 	if (_inner_error0_->domain == VALADOC_PARSER_ERROR) {
798 		g_propagate_error (error, _inner_error0_);
799 		_g_free0 (error_message);
800 		return;
801 	} else {
802 		_g_free0 (error_message);
803 		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);
804 		g_clear_error (&_inner_error0_);
805 		return;
806 	}
807 	_g_free0 (error_message);
808 }
809 
810 static gint
valadoc_parser_get_line(ValadocParser * self,ValadocToken * token)811 valadoc_parser_get_line (ValadocParser* self,
812                          ValadocToken* token)
813 {
814 	ValaSourceLocation _tmp1_ = {0};
815 	ValaSourceLocation _tmp2_;
816 	gint result = 0;
817 	g_return_val_if_fail (self != NULL, 0);
818 	if (token == NULL) {
819 		ValadocToken* _tmp0_;
820 		_tmp0_ = self->priv->_current_token;
821 		token = _tmp0_;
822 	}
823 	valadoc_token_get_begin (token, &_tmp1_);
824 	_tmp2_ = _tmp1_;
825 	result = _tmp2_.line + self->priv->_first_line;
826 	return result;
827 }
828 
829 static gint
valadoc_parser_get_start_column(ValadocParser * self,ValadocToken * token)830 valadoc_parser_get_start_column (ValadocParser* self,
831                                  ValadocToken* token)
832 {
833 	ValaSourceLocation _tmp1_ = {0};
834 	ValaSourceLocation _tmp2_;
835 	gint result = 0;
836 	g_return_val_if_fail (self != NULL, 0);
837 	if (token == NULL) {
838 		ValadocToken* _tmp0_;
839 		_tmp0_ = self->priv->_current_token;
840 		token = _tmp0_;
841 	}
842 	valadoc_token_get_begin (token, &_tmp1_);
843 	_tmp2_ = _tmp1_;
844 	if (_tmp2_.line == 0) {
845 		ValaSourceLocation _tmp3_ = {0};
846 		ValaSourceLocation _tmp4_;
847 		valadoc_token_get_begin (token, &_tmp3_);
848 		_tmp4_ = _tmp3_;
849 		result = (_tmp4_.column + self->priv->_first_column) + 1;
850 		return result;
851 	} else {
852 		ValaSourceLocation _tmp5_ = {0};
853 		ValaSourceLocation _tmp6_;
854 		valadoc_token_get_begin (token, &_tmp5_);
855 		_tmp6_ = _tmp5_;
856 		result = _tmp6_.column + 1;
857 		return result;
858 	}
859 }
860 
861 static gint
valadoc_parser_get_end_column(ValadocParser * self,ValadocToken * token)862 valadoc_parser_get_end_column (ValadocParser* self,
863                                ValadocToken* token)
864 {
865 	ValaSourceLocation _tmp1_ = {0};
866 	ValaSourceLocation _tmp2_;
867 	gint result = 0;
868 	g_return_val_if_fail (self != NULL, 0);
869 	if (token == NULL) {
870 		ValadocToken* _tmp0_;
871 		_tmp0_ = self->priv->_current_token;
872 		token = _tmp0_;
873 	}
874 	valadoc_token_get_end (token, &_tmp1_);
875 	_tmp2_ = _tmp1_;
876 	if (_tmp2_.line == 0) {
877 		ValaSourceLocation _tmp3_ = {0};
878 		ValaSourceLocation _tmp4_;
879 		valadoc_token_get_end (token, &_tmp3_);
880 		_tmp4_ = _tmp3_;
881 		result = (_tmp4_.column + self->priv->_first_column) + 1;
882 		return result;
883 	} else {
884 		ValaSourceLocation _tmp5_ = {0};
885 		ValaSourceLocation _tmp6_;
886 		valadoc_token_get_end (token, &_tmp5_);
887 		_tmp6_ = _tmp5_;
888 		result = _tmp6_.column + 1;
889 		return result;
890 	}
891 }
892 
893 static void
valadoc_value_parser_init(GValue * value)894 valadoc_value_parser_init (GValue* value)
895 {
896 	value->data[0].v_pointer = NULL;
897 }
898 
899 static void
valadoc_value_parser_free_value(GValue * value)900 valadoc_value_parser_free_value (GValue* value)
901 {
902 	if (value->data[0].v_pointer) {
903 		valadoc_parser_unref (value->data[0].v_pointer);
904 	}
905 }
906 
907 static void
valadoc_value_parser_copy_value(const GValue * src_value,GValue * dest_value)908 valadoc_value_parser_copy_value (const GValue* src_value,
909                                  GValue* dest_value)
910 {
911 	if (src_value->data[0].v_pointer) {
912 		dest_value->data[0].v_pointer = valadoc_parser_ref (src_value->data[0].v_pointer);
913 	} else {
914 		dest_value->data[0].v_pointer = NULL;
915 	}
916 }
917 
918 static gpointer
valadoc_value_parser_peek_pointer(const GValue * value)919 valadoc_value_parser_peek_pointer (const GValue* value)
920 {
921 	return value->data[0].v_pointer;
922 }
923 
924 static gchar*
valadoc_value_parser_collect_value(GValue * value,guint n_collect_values,GTypeCValue * collect_values,guint collect_flags)925 valadoc_value_parser_collect_value (GValue* value,
926                                     guint n_collect_values,
927                                     GTypeCValue* collect_values,
928                                     guint collect_flags)
929 {
930 	if (collect_values[0].v_pointer) {
931 		ValadocParser * object;
932 		object = collect_values[0].v_pointer;
933 		if (object->parent_instance.g_class == NULL) {
934 			return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
935 		} else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
936 			return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
937 		}
938 		value->data[0].v_pointer = valadoc_parser_ref (object);
939 	} else {
940 		value->data[0].v_pointer = NULL;
941 	}
942 	return NULL;
943 }
944 
945 static gchar*
valadoc_value_parser_lcopy_value(const GValue * value,guint n_collect_values,GTypeCValue * collect_values,guint collect_flags)946 valadoc_value_parser_lcopy_value (const GValue* value,
947                                   guint n_collect_values,
948                                   GTypeCValue* collect_values,
949                                   guint collect_flags)
950 {
951 	ValadocParser ** object_p;
952 	object_p = collect_values[0].v_pointer;
953 	if (!object_p) {
954 		return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
955 	}
956 	if (!value->data[0].v_pointer) {
957 		*object_p = NULL;
958 	} else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
959 		*object_p = value->data[0].v_pointer;
960 	} else {
961 		*object_p = valadoc_parser_ref (value->data[0].v_pointer);
962 	}
963 	return NULL;
964 }
965 
966 GParamSpec*
valadoc_param_spec_parser(const gchar * name,const gchar * nick,const gchar * blurb,GType object_type,GParamFlags flags)967 valadoc_param_spec_parser (const gchar* name,
968                            const gchar* nick,
969                            const gchar* blurb,
970                            GType object_type,
971                            GParamFlags flags)
972 {
973 	ValadocParamSpecParser* spec;
974 	g_return_val_if_fail (g_type_is_a (object_type, VALADOC_TYPE_PARSER), NULL);
975 	spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
976 	G_PARAM_SPEC (spec)->value_type = object_type;
977 	return G_PARAM_SPEC (spec);
978 }
979 
980 gpointer
valadoc_value_get_parser(const GValue * value)981 valadoc_value_get_parser (const GValue* value)
982 {
983 	g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALADOC_TYPE_PARSER), NULL);
984 	return value->data[0].v_pointer;
985 }
986 
987 void
valadoc_value_set_parser(GValue * value,gpointer v_object)988 valadoc_value_set_parser (GValue* value,
989                           gpointer v_object)
990 {
991 	ValadocParser * old;
992 	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALADOC_TYPE_PARSER));
993 	old = value->data[0].v_pointer;
994 	if (v_object) {
995 		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, VALADOC_TYPE_PARSER));
996 		g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
997 		value->data[0].v_pointer = v_object;
998 		valadoc_parser_ref (value->data[0].v_pointer);
999 	} else {
1000 		value->data[0].v_pointer = NULL;
1001 	}
1002 	if (old) {
1003 		valadoc_parser_unref (old);
1004 	}
1005 }
1006 
1007 void
valadoc_value_take_parser(GValue * value,gpointer v_object)1008 valadoc_value_take_parser (GValue* value,
1009                            gpointer v_object)
1010 {
1011 	ValadocParser * old;
1012 	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALADOC_TYPE_PARSER));
1013 	old = value->data[0].v_pointer;
1014 	if (v_object) {
1015 		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, VALADOC_TYPE_PARSER));
1016 		g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
1017 		value->data[0].v_pointer = v_object;
1018 	} else {
1019 		value->data[0].v_pointer = NULL;
1020 	}
1021 	if (old) {
1022 		valadoc_parser_unref (old);
1023 	}
1024 }
1025 
1026 static void
valadoc_parser_class_init(ValadocParserClass * klass,gpointer klass_data)1027 valadoc_parser_class_init (ValadocParserClass * klass,
1028                            gpointer klass_data)
1029 {
1030 	valadoc_parser_parent_class = g_type_class_peek_parent (klass);
1031 	((ValadocParserClass *) klass)->finalize = valadoc_parser_finalize;
1032 	g_type_class_adjust_private_offset (klass, &ValadocParser_private_offset);
1033 }
1034 
1035 static void
valadoc_parser_valadoc_parser_callback_interface_init(ValadocParserCallbackIface * iface,gpointer iface_data)1036 valadoc_parser_valadoc_parser_callback_interface_init (ValadocParserCallbackIface * iface,
1037                                                        gpointer iface_data)
1038 {
1039 	valadoc_parser_valadoc_parser_callback_parent_iface = g_type_interface_peek_parent (iface);
1040 	iface->push_rule = (void (*) (ValadocParserCallback*, ValadocRule*)) valadoc_parser_real_push_rule;
1041 	iface->get_rule_state = (GObject* (*) (ValadocParserCallback*)) valadoc_parser_real_get_rule_state;
1042 	iface->set_rule_state = (void (*) (ValadocParserCallback*, GObject*)) valadoc_parser_real_set_rule_state;
1043 	iface->reduce = (void (*) (ValadocParserCallback*)) valadoc_parser_real_reduce;
1044 	iface->would_parent_accept_token = (gboolean (*) (ValadocParserCallback*, ValadocToken*)) valadoc_parser_real_would_parent_accept_token;
1045 	iface->would_parent_reduce_to_rule = (gboolean (*) (ValadocParserCallback*, ValadocToken*, ValadocRule*)) valadoc_parser_real_would_parent_reduce_to_rule;
1046 	iface->warning = (void (*) (ValadocParserCallback*, ValadocToken*, const gchar*)) valadoc_parser_real_warning;
1047 	iface->error = (void (*) (ValadocParserCallback*, ValadocToken*, const gchar*, GError**)) valadoc_parser_real_error;
1048 }
1049 
1050 static void
valadoc_parser_instance_init(ValadocParser * self,gpointer klass)1051 valadoc_parser_instance_init (ValadocParser * self,
1052                               gpointer klass)
1053 {
1054 	GEqualFunc _tmp0_;
1055 	ValaArrayList* _tmp1_;
1056 	GEqualFunc _tmp2_;
1057 	ValaArrayList* _tmp3_;
1058 	self->priv = valadoc_parser_get_instance_private (self);
1059 	_tmp0_ = g_direct_equal;
1060 	_tmp1_ = vala_array_list_new (VALADOC_TYPE_RULE, (GBoxedCopyFunc) g_object_ref, (GDestroyNotify) g_object_unref, _tmp0_);
1061 	self->priv->rule_stack = _tmp1_;
1062 	_tmp2_ = g_direct_equal;
1063 	_tmp3_ = vala_array_list_new (G_TYPE_OBJECT, (GBoxedCopyFunc) g_object_ref, (GDestroyNotify) g_object_unref, _tmp2_);
1064 	self->priv->rule_state_stack = _tmp3_;
1065 	self->ref_count = 1;
1066 }
1067 
1068 static void
valadoc_parser_finalize(ValadocParser * obj)1069 valadoc_parser_finalize (ValadocParser * obj)
1070 {
1071 	ValadocParser * self;
1072 	self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALADOC_TYPE_PARSER, ValadocParser);
1073 	g_signal_handlers_destroy (self);
1074 	_g_object_unref0 (self->priv->_settings);
1075 	_g_object_unref0 (self->priv->_scanner);
1076 	_g_object_unref0 (self->priv->_reporter);
1077 	_g_object_unref0 (self->priv->_root_rule);
1078 	_g_free0 (self->priv->_filename);
1079 	_g_object_unref0 (self->priv->_current_token);
1080 	_vala_iterable_unref0 (self->priv->rule_stack);
1081 	_vala_iterable_unref0 (self->priv->rule_state_stack);
1082 }
1083 
1084 static GType
valadoc_parser_get_type_once(void)1085 valadoc_parser_get_type_once (void)
1086 {
1087 	static const GTypeValueTable g_define_type_value_table = { valadoc_value_parser_init, valadoc_value_parser_free_value, valadoc_value_parser_copy_value, valadoc_value_parser_peek_pointer, "p", valadoc_value_parser_collect_value, "p", valadoc_value_parser_lcopy_value };
1088 	static const GTypeInfo g_define_type_info = { sizeof (ValadocParserClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) valadoc_parser_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValadocParser), 0, (GInstanceInitFunc) valadoc_parser_instance_init, &g_define_type_value_table };
1089 	static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
1090 	static const GInterfaceInfo valadoc_parser_callback_info = { (GInterfaceInitFunc) valadoc_parser_valadoc_parser_callback_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
1091 	GType valadoc_parser_type_id;
1092 	valadoc_parser_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ValadocParser", &g_define_type_info, &g_define_type_fundamental_info, 0);
1093 	g_type_add_interface_static (valadoc_parser_type_id, VALADOC_TYPE_PARSER_CALLBACK, &valadoc_parser_callback_info);
1094 	ValadocParser_private_offset = g_type_add_instance_private (valadoc_parser_type_id, sizeof (ValadocParserPrivate));
1095 	return valadoc_parser_type_id;
1096 }
1097 
1098 GType
valadoc_parser_get_type(void)1099 valadoc_parser_get_type (void)
1100 {
1101 	static volatile gsize valadoc_parser_type_id__volatile = 0;
1102 	if (g_once_init_enter (&valadoc_parser_type_id__volatile)) {
1103 		GType valadoc_parser_type_id;
1104 		valadoc_parser_type_id = valadoc_parser_get_type_once ();
1105 		g_once_init_leave (&valadoc_parser_type_id__volatile, valadoc_parser_type_id);
1106 	}
1107 	return valadoc_parser_type_id__volatile;
1108 }
1109 
1110 gpointer
valadoc_parser_ref(gpointer instance)1111 valadoc_parser_ref (gpointer instance)
1112 {
1113 	ValadocParser * self;
1114 	self = instance;
1115 	g_atomic_int_inc (&self->ref_count);
1116 	return instance;
1117 }
1118 
1119 void
valadoc_parser_unref(gpointer instance)1120 valadoc_parser_unref (gpointer instance)
1121 {
1122 	ValadocParser * self;
1123 	self = instance;
1124 	if (g_atomic_int_dec_and_test (&self->ref_count)) {
1125 		VALADOC_PARSER_GET_CLASS (self)->finalize (self);
1126 		g_type_free_instance ((GTypeInstance *) self);
1127 	}
1128 }
1129 
1130