1 /* manyrule.c generated by valac, the Vala compiler
2  * generated from manyrule.vala, do not modify */
3 
4 /* manyrule.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 <glib-object.h>
28 #include <glib.h>
29 #include <stdlib.h>
30 #include <string.h>
31 
32 #define VALADOC_TYPE_MANY_RULE (valadoc_many_rule_get_type ())
33 #define VALADOC_MANY_RULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALADOC_TYPE_MANY_RULE, ValadocManyRule))
34 #define VALADOC_MANY_RULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALADOC_TYPE_MANY_RULE, ValadocManyRuleClass))
35 #define VALADOC_IS_MANY_RULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALADOC_TYPE_MANY_RULE))
36 #define VALADOC_IS_MANY_RULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALADOC_TYPE_MANY_RULE))
37 #define VALADOC_MANY_RULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALADOC_TYPE_MANY_RULE, ValadocManyRuleClass))
38 
39 typedef struct _ValadocManyRule ValadocManyRule;
40 typedef struct _ValadocManyRuleClass ValadocManyRuleClass;
41 typedef struct _ValadocManyRulePrivate ValadocManyRulePrivate;
42 enum  {
43 	VALADOC_MANY_RULE_0_PROPERTY,
44 	VALADOC_MANY_RULE_NUM_PROPERTIES
45 };
46 static GParamSpec* valadoc_many_rule_properties[VALADOC_MANY_RULE_NUM_PROPERTIES];
47 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
48 
49 #define VALADOC_MANY_RULE_TYPE_STATE (valadoc_many_rule_state_get_type ())
50 #define VALADOC_MANY_RULE_STATE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALADOC_MANY_RULE_TYPE_STATE, ValadocManyRuleState))
51 #define VALADOC_MANY_RULE_STATE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALADOC_MANY_RULE_TYPE_STATE, ValadocManyRuleStateClass))
52 #define VALADOC_MANY_RULE_IS_STATE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALADOC_MANY_RULE_TYPE_STATE))
53 #define VALADOC_MANY_RULE_IS_STATE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALADOC_MANY_RULE_TYPE_STATE))
54 #define VALADOC_MANY_RULE_STATE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALADOC_MANY_RULE_TYPE_STATE, ValadocManyRuleStateClass))
55 
56 typedef struct _ValadocManyRuleState ValadocManyRuleState;
57 typedef struct _ValadocManyRuleStateClass ValadocManyRuleStateClass;
58 typedef struct _ValadocManyRuleStatePrivate ValadocManyRuleStatePrivate;
59 #define _g_free0(var) (var = (g_free (var), NULL))
60 enum  {
61 	VALADOC_MANY_RULE_STATE_0_PROPERTY,
62 	VALADOC_MANY_RULE_STATE_NUM_PROPERTIES
63 };
64 static GParamSpec* valadoc_many_rule_state_properties[VALADOC_MANY_RULE_STATE_NUM_PROPERTIES];
65 
66 struct _ValadocManyRule {
67 	ValadocRule parent_instance;
68 	ValadocManyRulePrivate * priv;
69 };
70 
71 struct _ValadocManyRuleClass {
72 	ValadocRuleClass parent_class;
73 };
74 
75 struct _ValadocManyRulePrivate {
76 	GObject* _scheme;
77 };
78 
79 struct _ValadocManyRuleState {
80 	GObject parent_instance;
81 	gboolean started;
82 	gboolean done_one;
83 	ValadocManyRuleStatePrivate * priv;
84 };
85 
86 struct _ValadocManyRuleStateClass {
87 	GObjectClass parent_class;
88 };
89 
90 static gint ValadocManyRule_private_offset;
91 static gpointer valadoc_many_rule_parent_class = NULL;
92 static gpointer valadoc_many_rule_state_parent_class = NULL;
93 
94 G_GNUC_INTERNAL GType valadoc_many_rule_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
95 G_GNUC_INTERNAL ValadocManyRule* valadoc_many_rule_new (GObject* scheme);
96 G_GNUC_INTERNAL ValadocManyRule* valadoc_many_rule_construct (GType object_type,
97                                               GObject* scheme);
98 static gboolean valadoc_many_rule_real_is_optional (ValadocRule* base);
99 static gboolean valadoc_many_rule_real_starts_with_token (ValadocRule* base,
100                                                    ValadocToken* token);
101 static gboolean valadoc_many_rule_real_accept_token (ValadocRule* base,
102                                               ValadocToken* token,
103                                               ValadocParserCallback* parser,
104                                               ValadocRuleForward forward,
105                                               GError** error);
106 static GType valadoc_many_rule_state_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
107 static ValadocManyRuleState* valadoc_many_rule_state_new (void);
108 static ValadocManyRuleState* valadoc_many_rule_state_construct (GType object_type);
109 static gboolean valadoc_many_rule_real_would_accept_token (ValadocRule* base,
110                                                     ValadocToken* token,
111                                                     GObject* state);
112 static gboolean valadoc_many_rule_real_would_reduce (ValadocRule* base,
113                                               ValadocToken* token,
114                                               GObject* rule_state);
115 static gchar* valadoc_many_rule_real_to_string (ValadocRule* base,
116                                          GObject* rule_state);
117 static void valadoc_many_rule_state_finalize (GObject * obj);
118 static GType valadoc_many_rule_state_get_type_once (void);
119 static void valadoc_many_rule_finalize (GObject * obj);
120 static GType valadoc_many_rule_get_type_once (void);
121 
122 static inline gpointer
valadoc_many_rule_get_instance_private(ValadocManyRule * self)123 valadoc_many_rule_get_instance_private (ValadocManyRule* self)
124 {
125 	return G_STRUCT_MEMBER_P (self, ValadocManyRule_private_offset);
126 }
127 
128 static gpointer
_g_object_ref0(gpointer self)129 _g_object_ref0 (gpointer self)
130 {
131 	return self ? g_object_ref (self) : NULL;
132 }
133 
134 G_GNUC_INTERNAL ValadocManyRule*
valadoc_many_rule_construct(GType object_type,GObject * scheme)135 valadoc_many_rule_construct (GType object_type,
136                              GObject* scheme)
137 {
138 	ValadocManyRule * self = NULL;
139 	GObject* _tmp0_;
140 	g_return_val_if_fail (scheme != NULL, NULL);
141 	self = (ValadocManyRule*) valadoc_rule_construct (object_type);
142 	_tmp0_ = _g_object_ref0 (scheme);
143 	_g_object_unref0 (self->priv->_scheme);
144 	self->priv->_scheme = _tmp0_;
145 	return self;
146 }
147 
148 G_GNUC_INTERNAL ValadocManyRule*
valadoc_many_rule_new(GObject * scheme)149 valadoc_many_rule_new (GObject* scheme)
150 {
151 	return valadoc_many_rule_construct (VALADOC_TYPE_MANY_RULE, scheme);
152 }
153 
154 static gboolean
valadoc_many_rule_real_is_optional(ValadocRule * base)155 valadoc_many_rule_real_is_optional (ValadocRule* base)
156 {
157 	ValadocManyRule * self;
158 	GObject* _tmp0_;
159 	gboolean result = FALSE;
160 	self = (ValadocManyRule*) base;
161 	_tmp0_ = self->priv->_scheme;
162 	result = valadoc_rule_is_optional_rule ((ValadocRule*) self, _tmp0_);
163 	return result;
164 }
165 
166 static gboolean
valadoc_many_rule_real_starts_with_token(ValadocRule * base,ValadocToken * token)167 valadoc_many_rule_real_starts_with_token (ValadocRule* base,
168                                           ValadocToken* token)
169 {
170 	ValadocManyRule * self;
171 	GObject* _tmp0_;
172 	gboolean result = FALSE;
173 	self = (ValadocManyRule*) base;
174 	g_return_val_if_fail (token != NULL, FALSE);
175 	_tmp0_ = self->priv->_scheme;
176 	if (valadoc_rule_has_start_token ((ValadocRule*) self, _tmp0_, token)) {
177 		result = TRUE;
178 		return result;
179 	}
180 	result = FALSE;
181 	return result;
182 }
183 
184 static gboolean
valadoc_many_rule_real_accept_token(ValadocRule * base,ValadocToken * token,ValadocParserCallback * parser,ValadocRuleForward forward,GError ** error)185 valadoc_many_rule_real_accept_token (ValadocRule* base,
186                                      ValadocToken* token,
187                                      ValadocParserCallback* parser,
188                                      ValadocRuleForward forward,
189                                      GError** error)
190 {
191 	ValadocManyRule * self;
192 	ValadocManyRuleState* state = NULL;
193 	GObject* _tmp0_;
194 	ValadocManyRuleState* _tmp1_;
195 	ValadocManyRuleState* _tmp2_;
196 	ValadocManyRuleState* _tmp5_;
197 	gboolean _tmp9_ = FALSE;
198 	ValadocManyRuleState* _tmp10_;
199 	gboolean handled = FALSE;
200 	gboolean _tmp15_ = FALSE;
201 	GObject* _tmp16_;
202 	gboolean _tmp17_ = FALSE;
203 	gboolean _tmp18_;
204 	GObject* _tmp24_;
205 	GError* _inner_error0_ = NULL;
206 	gboolean result = FALSE;
207 	self = (ValadocManyRule*) base;
208 	g_return_val_if_fail (token != NULL, FALSE);
209 	g_return_val_if_fail (parser != NULL, FALSE);
210 	_tmp0_ = valadoc_parser_callback_get_rule_state (parser);
211 	_tmp1_ = VALADOC_MANY_RULE_IS_STATE (_tmp0_) ? ((ValadocManyRuleState*) _tmp0_) : NULL;
212 	if (_tmp1_ == NULL) {
213 		_g_object_unref0 (_tmp0_);
214 	}
215 	state = _tmp1_;
216 	_tmp2_ = state;
217 	if (_tmp2_ == NULL) {
218 		ValadocManyRuleState* _tmp3_;
219 		ValadocManyRuleState* _tmp4_;
220 		_tmp3_ = valadoc_many_rule_state_new ();
221 		_g_object_unref0 (state);
222 		state = _tmp3_;
223 		_tmp4_ = state;
224 		valadoc_parser_callback_set_rule_state (parser, (GObject*) _tmp4_);
225 	}
226 	_tmp5_ = state;
227 	if (!_tmp5_->started) {
228 		ValadocManyRuleState* _tmp8_;
229 		valadoc_rule_do_start ((ValadocRule*) self, parser, &_inner_error0_);
230 		if (G_UNLIKELY (_inner_error0_ != NULL)) {
231 			if (_inner_error0_->domain == VALADOC_PARSER_ERROR) {
232 				gboolean _tmp6_ = FALSE;
233 				g_propagate_error (error, _inner_error0_);
234 				_g_object_unref0 (state);
235 				return _tmp6_;
236 			} else {
237 				gboolean _tmp7_ = FALSE;
238 				_g_object_unref0 (state);
239 				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);
240 				g_clear_error (&_inner_error0_);
241 				return _tmp7_;
242 			}
243 		}
244 		_tmp8_ = state;
245 		_tmp8_->started = TRUE;
246 	}
247 	_tmp10_ = state;
248 	if (_tmp10_->done_one) {
249 		_tmp9_ = valadoc_parser_callback_would_parent_accept_token (parser, token);
250 	} else {
251 		_tmp9_ = FALSE;
252 	}
253 	if (_tmp9_) {
254 		valadoc_rule_do_reduce ((ValadocRule*) self, parser, &_inner_error0_);
255 		if (G_UNLIKELY (_inner_error0_ != NULL)) {
256 			if (_inner_error0_->domain == VALADOC_PARSER_ERROR) {
257 				gboolean _tmp11_ = FALSE;
258 				g_propagate_error (error, _inner_error0_);
259 				_g_object_unref0 (state);
260 				return _tmp11_;
261 			} else {
262 				gboolean _tmp12_ = FALSE;
263 				_g_object_unref0 (state);
264 				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);
265 				g_clear_error (&_inner_error0_);
266 				return _tmp12_;
267 			}
268 		}
269 		result = FALSE;
270 		_g_object_unref0 (state);
271 		return result;
272 	}
273 	if (valadoc_parser_callback_would_parent_reduce_to_rule (parser, token, (ValadocRule*) self)) {
274 		valadoc_rule_do_reduce ((ValadocRule*) self, parser, &_inner_error0_);
275 		if (G_UNLIKELY (_inner_error0_ != NULL)) {
276 			if (_inner_error0_->domain == VALADOC_PARSER_ERROR) {
277 				gboolean _tmp13_ = FALSE;
278 				g_propagate_error (error, _inner_error0_);
279 				_g_object_unref0 (state);
280 				return _tmp13_;
281 			} else {
282 				gboolean _tmp14_ = FALSE;
283 				_g_object_unref0 (state);
284 				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);
285 				g_clear_error (&_inner_error0_);
286 				return _tmp14_;
287 			}
288 		}
289 		result = FALSE;
290 		_g_object_unref0 (state);
291 		return result;
292 	}
293 	_tmp16_ = self->priv->_scheme;
294 	_tmp18_ = valadoc_rule_try_to_apply ((ValadocRule*) self, _tmp16_, token, parser, &_tmp17_, &_inner_error0_);
295 	handled = _tmp17_;
296 	_tmp15_ = _tmp18_;
297 	if (G_UNLIKELY (_inner_error0_ != NULL)) {
298 		if (_inner_error0_->domain == VALADOC_PARSER_ERROR) {
299 			gboolean _tmp19_ = FALSE;
300 			g_propagate_error (error, _inner_error0_);
301 			_g_object_unref0 (state);
302 			return _tmp19_;
303 		} else {
304 			gboolean _tmp20_ = FALSE;
305 			_g_object_unref0 (state);
306 			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);
307 			g_clear_error (&_inner_error0_);
308 			return _tmp20_;
309 		}
310 	}
311 	if (_tmp15_) {
312 		ValadocManyRuleState* _tmp21_;
313 		_tmp21_ = state;
314 		_tmp21_->done_one = TRUE;
315 		result = handled;
316 		_g_object_unref0 (state);
317 		return result;
318 	}
319 	if (valadoc_parser_callback_would_parent_accept_token (parser, token)) {
320 		valadoc_rule_do_reduce ((ValadocRule*) self, parser, &_inner_error0_);
321 		if (G_UNLIKELY (_inner_error0_ != NULL)) {
322 			if (_inner_error0_->domain == VALADOC_PARSER_ERROR) {
323 				gboolean _tmp22_ = FALSE;
324 				g_propagate_error (error, _inner_error0_);
325 				_g_object_unref0 (state);
326 				return _tmp22_;
327 			} else {
328 				gboolean _tmp23_ = FALSE;
329 				_g_object_unref0 (state);
330 				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);
331 				g_clear_error (&_inner_error0_);
332 				return _tmp23_;
333 			}
334 		}
335 		result = FALSE;
336 		_g_object_unref0 (state);
337 		return result;
338 	}
339 	_tmp24_ = self->priv->_scheme;
340 	if (VALADOC_IS_TOKEN_TYPE (_tmp24_)) {
341 		GObject* _tmp25_;
342 		const gchar* _tmp26_;
343 		gchar* _tmp27_;
344 		gchar* _tmp28_;
345 		_tmp25_ = self->priv->_scheme;
346 		_tmp26_ = valadoc_token_type_to_pretty_string (G_TYPE_CHECK_INSTANCE_CAST (_tmp25_, VALADOC_TYPE_TOKEN_TYPE, ValadocTokenType));
347 		_tmp27_ = g_strdup_printf ("expected %s", _tmp26_);
348 		_tmp28_ = _tmp27_;
349 		valadoc_parser_callback_error (parser, NULL, _tmp28_, &_inner_error0_);
350 		_g_free0 (_tmp28_);
351 		if (G_UNLIKELY (_inner_error0_ != NULL)) {
352 			if (_inner_error0_->domain == VALADOC_PARSER_ERROR) {
353 				gboolean _tmp29_ = FALSE;
354 				g_propagate_error (error, _inner_error0_);
355 				_g_object_unref0 (state);
356 				return _tmp29_;
357 			} else {
358 				gboolean _tmp30_ = FALSE;
359 				_g_object_unref0 (state);
360 				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);
361 				g_clear_error (&_inner_error0_);
362 				return _tmp30_;
363 			}
364 		}
365 	} else {
366 		valadoc_parser_callback_error (parser, token, "unexpected token", &_inner_error0_);
367 		if (G_UNLIKELY (_inner_error0_ != NULL)) {
368 			if (_inner_error0_->domain == VALADOC_PARSER_ERROR) {
369 				gboolean _tmp31_ = FALSE;
370 				g_propagate_error (error, _inner_error0_);
371 				_g_object_unref0 (state);
372 				return _tmp31_;
373 			} else {
374 				gboolean _tmp32_ = FALSE;
375 				_g_object_unref0 (state);
376 				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);
377 				g_clear_error (&_inner_error0_);
378 				return _tmp32_;
379 			}
380 		}
381 	}
382 	g_assert_not_reached ();
383 	_g_object_unref0 (state);
384 }
385 
386 static gboolean
valadoc_many_rule_real_would_accept_token(ValadocRule * base,ValadocToken * token,GObject * state)387 valadoc_many_rule_real_would_accept_token (ValadocRule* base,
388                                            ValadocToken* token,
389                                            GObject* state)
390 {
391 	ValadocManyRule * self;
392 	GObject* _tmp0_;
393 	gboolean result = FALSE;
394 	self = (ValadocManyRule*) base;
395 	g_return_val_if_fail (token != NULL, FALSE);
396 	_tmp0_ = self->priv->_scheme;
397 	if (valadoc_rule_has_start_token ((ValadocRule*) self, _tmp0_, token)) {
398 		result = TRUE;
399 		return result;
400 	}
401 	result = FALSE;
402 	return result;
403 }
404 
405 static gboolean
valadoc_many_rule_real_would_reduce(ValadocRule * base,ValadocToken * token,GObject * rule_state)406 valadoc_many_rule_real_would_reduce (ValadocRule* base,
407                                      ValadocToken* token,
408                                      GObject* rule_state)
409 {
410 	ValadocManyRule * self;
411 	ValadocManyRuleState* state = NULL;
412 	ValadocManyRuleState* _tmp0_;
413 	gboolean _tmp1_ = FALSE;
414 	ValadocManyRuleState* _tmp2_;
415 	gboolean result = FALSE;
416 	self = (ValadocManyRule*) base;
417 	g_return_val_if_fail (token != NULL, FALSE);
418 	_tmp0_ = _g_object_ref0 (VALADOC_MANY_RULE_IS_STATE (rule_state) ? ((ValadocManyRuleState*) rule_state) : NULL);
419 	state = _tmp0_;
420 	_tmp2_ = state;
421 	if (_tmp2_->done_one) {
422 		_tmp1_ = TRUE;
423 	} else {
424 		GObject* _tmp3_;
425 		_tmp3_ = self->priv->_scheme;
426 		_tmp1_ = valadoc_rule_is_optional_rule ((ValadocRule*) self, _tmp3_);
427 	}
428 	result = _tmp1_;
429 	_g_object_unref0 (state);
430 	return result;
431 }
432 
433 static gchar*
bool_to_string(gboolean self)434 bool_to_string (gboolean self)
435 {
436 	gchar* result = NULL;
437 	if (self) {
438 		gchar* _tmp0_;
439 		_tmp0_ = g_strdup ("true");
440 		result = _tmp0_;
441 		return result;
442 	} else {
443 		gchar* _tmp1_;
444 		_tmp1_ = g_strdup ("false");
445 		result = _tmp1_;
446 		return result;
447 	}
448 }
449 
450 static gchar*
valadoc_many_rule_real_to_string(ValadocRule * base,GObject * rule_state)451 valadoc_many_rule_real_to_string (ValadocRule* base,
452                                   GObject* rule_state)
453 {
454 	ValadocManyRule * self;
455 	ValadocManyRuleState* state = NULL;
456 	ValadocManyRuleState* _tmp0_;
457 	ValadocManyRuleState* _tmp1_;
458 	const gchar* _tmp3_ = NULL;
459 	const gchar* _tmp4_;
460 	const gchar* _tmp5_;
461 	ValadocManyRuleState* _tmp8_;
462 	gchar* _tmp9_;
463 	gchar* _tmp10_;
464 	ValadocManyRuleState* _tmp11_;
465 	gchar* _tmp12_;
466 	gchar* _tmp13_;
467 	gchar* _tmp14_;
468 	gchar* _tmp15_;
469 	gchar* result = NULL;
470 	self = (ValadocManyRule*) base;
471 	_tmp0_ = _g_object_ref0 (VALADOC_MANY_RULE_IS_STATE (rule_state) ? ((ValadocManyRuleState*) rule_state) : NULL);
472 	state = _tmp0_;
473 	_tmp1_ = state;
474 	if (_tmp1_ == NULL) {
475 		ValadocManyRuleState* _tmp2_;
476 		_tmp2_ = valadoc_many_rule_state_new ();
477 		_g_object_unref0 (state);
478 		state = _tmp2_;
479 	}
480 	_tmp4_ = valadoc_rule_get_name ((ValadocRule*) self);
481 	_tmp5_ = _tmp4_;
482 	if (_tmp5_ != NULL) {
483 		const gchar* _tmp6_;
484 		const gchar* _tmp7_;
485 		_tmp6_ = valadoc_rule_get_name ((ValadocRule*) self);
486 		_tmp7_ = _tmp6_;
487 		_tmp3_ = _tmp7_;
488 	} else {
489 		_tmp3_ = " ";
490 	}
491 	_tmp8_ = state;
492 	_tmp9_ = bool_to_string (_tmp8_->started);
493 	_tmp10_ = _tmp9_;
494 	_tmp11_ = state;
495 	_tmp12_ = bool_to_string (_tmp11_->done_one);
496 	_tmp13_ = _tmp12_;
497 	_tmp14_ = g_strdup_printf ("%-15s%-15s(started=%s;done_one=%s)", _tmp3_, "[many]", _tmp10_, _tmp13_);
498 	_tmp15_ = _tmp14_;
499 	_g_free0 (_tmp13_);
500 	_g_free0 (_tmp10_);
501 	result = _tmp15_;
502 	_g_object_unref0 (state);
503 	return result;
504 }
505 
506 static ValadocManyRuleState*
valadoc_many_rule_state_construct(GType object_type)507 valadoc_many_rule_state_construct (GType object_type)
508 {
509 	ValadocManyRuleState * self = NULL;
510 	self = (ValadocManyRuleState*) g_object_new (object_type, NULL);
511 	return self;
512 }
513 
514 static ValadocManyRuleState*
valadoc_many_rule_state_new(void)515 valadoc_many_rule_state_new (void)
516 {
517 	return valadoc_many_rule_state_construct (VALADOC_MANY_RULE_TYPE_STATE);
518 }
519 
520 static void
valadoc_many_rule_state_class_init(ValadocManyRuleStateClass * klass,gpointer klass_data)521 valadoc_many_rule_state_class_init (ValadocManyRuleStateClass * klass,
522                                     gpointer klass_data)
523 {
524 	valadoc_many_rule_state_parent_class = g_type_class_peek_parent (klass);
525 	G_OBJECT_CLASS (klass)->finalize = valadoc_many_rule_state_finalize;
526 }
527 
528 static void
valadoc_many_rule_state_instance_init(ValadocManyRuleState * self,gpointer klass)529 valadoc_many_rule_state_instance_init (ValadocManyRuleState * self,
530                                        gpointer klass)
531 {
532 	self->started = FALSE;
533 	self->done_one = FALSE;
534 }
535 
536 static void
valadoc_many_rule_state_finalize(GObject * obj)537 valadoc_many_rule_state_finalize (GObject * obj)
538 {
539 	ValadocManyRuleState * self;
540 	self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALADOC_MANY_RULE_TYPE_STATE, ValadocManyRuleState);
541 	G_OBJECT_CLASS (valadoc_many_rule_state_parent_class)->finalize (obj);
542 }
543 
544 static GType
valadoc_many_rule_state_get_type_once(void)545 valadoc_many_rule_state_get_type_once (void)
546 {
547 	static const GTypeInfo g_define_type_info = { sizeof (ValadocManyRuleStateClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) valadoc_many_rule_state_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValadocManyRuleState), 0, (GInstanceInitFunc) valadoc_many_rule_state_instance_init, NULL };
548 	GType valadoc_many_rule_state_type_id;
549 	valadoc_many_rule_state_type_id = g_type_register_static (G_TYPE_OBJECT, "ValadocManyRuleState", &g_define_type_info, 0);
550 	return valadoc_many_rule_state_type_id;
551 }
552 
553 static GType
valadoc_many_rule_state_get_type(void)554 valadoc_many_rule_state_get_type (void)
555 {
556 	static volatile gsize valadoc_many_rule_state_type_id__volatile = 0;
557 	if (g_once_init_enter (&valadoc_many_rule_state_type_id__volatile)) {
558 		GType valadoc_many_rule_state_type_id;
559 		valadoc_many_rule_state_type_id = valadoc_many_rule_state_get_type_once ();
560 		g_once_init_leave (&valadoc_many_rule_state_type_id__volatile, valadoc_many_rule_state_type_id);
561 	}
562 	return valadoc_many_rule_state_type_id__volatile;
563 }
564 
565 static void
valadoc_many_rule_class_init(ValadocManyRuleClass * klass,gpointer klass_data)566 valadoc_many_rule_class_init (ValadocManyRuleClass * klass,
567                               gpointer klass_data)
568 {
569 	valadoc_many_rule_parent_class = g_type_class_peek_parent (klass);
570 	g_type_class_adjust_private_offset (klass, &ValadocManyRule_private_offset);
571 	((ValadocRuleClass *) klass)->is_optional = (gboolean (*) (ValadocRule*)) valadoc_many_rule_real_is_optional;
572 	((ValadocRuleClass *) klass)->starts_with_token = (gboolean (*) (ValadocRule*, ValadocToken*)) valadoc_many_rule_real_starts_with_token;
573 	((ValadocRuleClass *) klass)->accept_token = (gboolean (*) (ValadocRule*, ValadocToken*, ValadocParserCallback*, ValadocRuleForward, GError**)) valadoc_many_rule_real_accept_token;
574 	((ValadocRuleClass *) klass)->would_accept_token = (gboolean (*) (ValadocRule*, ValadocToken*, GObject*)) valadoc_many_rule_real_would_accept_token;
575 	((ValadocRuleClass *) klass)->would_reduce = (gboolean (*) (ValadocRule*, ValadocToken*, GObject*)) valadoc_many_rule_real_would_reduce;
576 	((ValadocRuleClass *) klass)->to_string = (gchar* (*) (ValadocRule*, GObject*)) valadoc_many_rule_real_to_string;
577 	G_OBJECT_CLASS (klass)->finalize = valadoc_many_rule_finalize;
578 }
579 
580 static void
valadoc_many_rule_instance_init(ValadocManyRule * self,gpointer klass)581 valadoc_many_rule_instance_init (ValadocManyRule * self,
582                                  gpointer klass)
583 {
584 	self->priv = valadoc_many_rule_get_instance_private (self);
585 }
586 
587 static void
valadoc_many_rule_finalize(GObject * obj)588 valadoc_many_rule_finalize (GObject * obj)
589 {
590 	ValadocManyRule * self;
591 	self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALADOC_TYPE_MANY_RULE, ValadocManyRule);
592 	_g_object_unref0 (self->priv->_scheme);
593 	G_OBJECT_CLASS (valadoc_many_rule_parent_class)->finalize (obj);
594 }
595 
596 static GType
valadoc_many_rule_get_type_once(void)597 valadoc_many_rule_get_type_once (void)
598 {
599 	static const GTypeInfo g_define_type_info = { sizeof (ValadocManyRuleClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) valadoc_many_rule_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValadocManyRule), 0, (GInstanceInitFunc) valadoc_many_rule_instance_init, NULL };
600 	GType valadoc_many_rule_type_id;
601 	valadoc_many_rule_type_id = g_type_register_static (VALADOC_TYPE_RULE, "ValadocManyRule", &g_define_type_info, 0);
602 	ValadocManyRule_private_offset = g_type_add_instance_private (valadoc_many_rule_type_id, sizeof (ValadocManyRulePrivate));
603 	return valadoc_many_rule_type_id;
604 }
605 
606 G_GNUC_INTERNAL GType
valadoc_many_rule_get_type(void)607 valadoc_many_rule_get_type (void)
608 {
609 	static volatile gsize valadoc_many_rule_type_id__volatile = 0;
610 	if (g_once_init_enter (&valadoc_many_rule_type_id__volatile)) {
611 		GType valadoc_many_rule_type_id;
612 		valadoc_many_rule_type_id = valadoc_many_rule_get_type_once ();
613 		g_once_init_leave (&valadoc_many_rule_type_id__volatile, valadoc_many_rule_type_id);
614 	}
615 	return valadoc_many_rule_type_id__volatile;
616 }
617 
618