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