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