1 /* rule.c generated by valac, the Vala compiler
2 * generated from rule.vala, do not modify */
3
4 /* rule.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 <glib-object.h>
31
32 enum {
33 VALADOC_RULE_0_PROPERTY,
34 VALADOC_RULE_NAME_PROPERTY,
35 VALADOC_RULE_NUM_PROPERTIES
36 };
37 static GParamSpec* valadoc_rule_properties[VALADOC_RULE_NUM_PROPERTIES];
38
39 #define VALADOC_TYPE_SEQUENCE_RULE (valadoc_sequence_rule_get_type ())
40 #define VALADOC_SEQUENCE_RULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALADOC_TYPE_SEQUENCE_RULE, ValadocSequenceRule))
41 #define VALADOC_SEQUENCE_RULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALADOC_TYPE_SEQUENCE_RULE, ValadocSequenceRuleClass))
42 #define VALADOC_IS_SEQUENCE_RULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALADOC_TYPE_SEQUENCE_RULE))
43 #define VALADOC_IS_SEQUENCE_RULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALADOC_TYPE_SEQUENCE_RULE))
44 #define VALADOC_SEQUENCE_RULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALADOC_TYPE_SEQUENCE_RULE, ValadocSequenceRuleClass))
45
46 typedef struct _ValadocSequenceRule ValadocSequenceRule;
47 typedef struct _ValadocSequenceRuleClass ValadocSequenceRuleClass;
48
49 #define VALADOC_TYPE_ONE_OF_RULE (valadoc_one_of_rule_get_type ())
50 #define VALADOC_ONE_OF_RULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALADOC_TYPE_ONE_OF_RULE, ValadocOneOfRule))
51 #define VALADOC_ONE_OF_RULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALADOC_TYPE_ONE_OF_RULE, ValadocOneOfRuleClass))
52 #define VALADOC_IS_ONE_OF_RULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALADOC_TYPE_ONE_OF_RULE))
53 #define VALADOC_IS_ONE_OF_RULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALADOC_TYPE_ONE_OF_RULE))
54 #define VALADOC_ONE_OF_RULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALADOC_TYPE_ONE_OF_RULE, ValadocOneOfRuleClass))
55
56 typedef struct _ValadocOneOfRule ValadocOneOfRule;
57 typedef struct _ValadocOneOfRuleClass ValadocOneOfRuleClass;
58
59 #define VALADOC_TYPE_MANY_RULE (valadoc_many_rule_get_type ())
60 #define VALADOC_MANY_RULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALADOC_TYPE_MANY_RULE, ValadocManyRule))
61 #define VALADOC_MANY_RULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALADOC_TYPE_MANY_RULE, ValadocManyRuleClass))
62 #define VALADOC_IS_MANY_RULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALADOC_TYPE_MANY_RULE))
63 #define VALADOC_IS_MANY_RULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALADOC_TYPE_MANY_RULE))
64 #define VALADOC_MANY_RULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALADOC_TYPE_MANY_RULE, ValadocManyRuleClass))
65
66 typedef struct _ValadocManyRule ValadocManyRule;
67 typedef struct _ValadocManyRuleClass ValadocManyRuleClass;
68 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
69
70 #define VALADOC_TYPE_OPTIONAL_RULE (valadoc_optional_rule_get_type ())
71 #define VALADOC_OPTIONAL_RULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALADOC_TYPE_OPTIONAL_RULE, ValadocOptionalRule))
72 #define VALADOC_OPTIONAL_RULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALADOC_TYPE_OPTIONAL_RULE, ValadocOptionalRuleClass))
73 #define VALADOC_IS_OPTIONAL_RULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALADOC_TYPE_OPTIONAL_RULE))
74 #define VALADOC_IS_OPTIONAL_RULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALADOC_TYPE_OPTIONAL_RULE))
75 #define VALADOC_OPTIONAL_RULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALADOC_TYPE_OPTIONAL_RULE, ValadocOptionalRuleClass))
76
77 typedef struct _ValadocOptionalRule ValadocOptionalRule;
78 typedef struct _ValadocOptionalRuleClass ValadocOptionalRuleClass;
79 #define _g_free0(var) (var = (g_free (var), NULL))
80 typedef struct _Block3Data Block3Data;
81 typedef struct _Block4Data Block4Data;
82 typedef struct _Block5Data Block5Data;
83
84 struct _ValadocRulePrivate {
85 gchar* _name;
86 ValadocRuleAction _start_action;
87 gpointer _start_action_target;
88 GDestroyNotify _start_action_target_destroy_notify;
89 ValadocRuleAction _reduce_action;
90 gpointer _reduce_action_target;
91 GDestroyNotify _reduce_action_target_destroy_notify;
92 ValadocRuleAction _skip_action;
93 gpointer _skip_action_target;
94 GDestroyNotify _skip_action_target_destroy_notify;
95 };
96
97 struct _Block3Data {
98 int _ref_count_;
99 ValadocRule* self;
100 ValadocRuleAction action;
101 gpointer action_target;
102 };
103
104 struct _Block4Data {
105 int _ref_count_;
106 ValadocRule* self;
107 ValadocRuleAction action;
108 gpointer action_target;
109 };
110
111 struct _Block5Data {
112 int _ref_count_;
113 ValadocRule* self;
114 ValadocRuleAction action;
115 gpointer action_target;
116 };
117
118 static gint ValadocRule_private_offset;
119 static gpointer valadoc_rule_parent_class = NULL;
120
121 G_GNUC_INTERNAL ValadocSequenceRule* valadoc_sequence_rule_new (GObject** scheme,
122 gint scheme_length1);
123 G_GNUC_INTERNAL ValadocSequenceRule* valadoc_sequence_rule_construct (GType object_type,
124 GObject** scheme,
125 gint scheme_length1);
126 G_GNUC_INTERNAL GType valadoc_sequence_rule_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
127 G_GNUC_INTERNAL ValadocOneOfRule* valadoc_one_of_rule_new (GObject** scheme,
128 gint scheme_length1);
129 G_GNUC_INTERNAL ValadocOneOfRule* valadoc_one_of_rule_construct (GType object_type,
130 GObject** scheme,
131 gint scheme_length1);
132 G_GNUC_INTERNAL GType valadoc_one_of_rule_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
133 G_GNUC_INTERNAL ValadocManyRule* valadoc_many_rule_new (GObject* scheme);
134 G_GNUC_INTERNAL ValadocManyRule* valadoc_many_rule_construct (GType object_type,
135 GObject* scheme);
136 G_GNUC_INTERNAL GType valadoc_many_rule_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
137 G_GNUC_INTERNAL ValadocOptionalRule* valadoc_optional_rule_new (GObject* scheme);
138 G_GNUC_INTERNAL ValadocOptionalRule* valadoc_optional_rule_construct (GType object_type,
139 GObject* scheme);
140 G_GNUC_INTERNAL GType valadoc_optional_rule_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
141 static Block3Data* block3_data_ref (Block3Data* _data3_);
142 static void block3_data_unref (void * _userdata_);
143 static void __lambda5_ (Block3Data* _data3_,
144 GError** error);
145 static void ___lambda5__valadoc_rule_action (gpointer self,
146 GError** error);
147 static Block4Data* block4_data_ref (Block4Data* _data4_);
148 static void block4_data_unref (void * _userdata_);
149 static void __lambda6_ (Block4Data* _data4_,
150 GError** error);
151 static void ___lambda6__valadoc_rule_action (gpointer self,
152 GError** error);
153 static Block5Data* block5_data_ref (Block5Data* _data5_);
154 static void block5_data_unref (void * _userdata_);
155 static void __lambda7_ (Block5Data* _data5_,
156 GError** error);
157 static void ___lambda7__valadoc_rule_action (gpointer self,
158 GError** error);
159 static gboolean valadoc_rule_real_is_optional (ValadocRule* self);
160 static gboolean valadoc_rule_real_starts_with_token (ValadocRule* self,
161 ValadocToken* token);
162 static gboolean valadoc_rule_real_accept_token (ValadocRule* self,
163 ValadocToken* token,
164 ValadocParserCallback* parser,
165 ValadocRuleForward forward,
166 GError** error);
167 static gboolean valadoc_rule_real_would_accept_token (ValadocRule* self,
168 ValadocToken* token,
169 GObject* state);
170 static gboolean valadoc_rule_real_would_reduce (ValadocRule* self,
171 ValadocToken* token,
172 GObject* state);
173 static gchar* valadoc_rule_real_to_string (ValadocRule* self,
174 GObject* state);
175 static void valadoc_rule_finalize (GObject * obj);
176 static GType valadoc_rule_get_type_once (void);
177 static void _vala_valadoc_rule_get_property (GObject * object,
178 guint property_id,
179 GValue * value,
180 GParamSpec * pspec);
181
182 static inline gpointer
valadoc_rule_get_instance_private(ValadocRule * self)183 valadoc_rule_get_instance_private (ValadocRule* self)
184 {
185 return G_STRUCT_MEMBER_P (self, ValadocRule_private_offset);
186 }
187
188 static GType
valadoc_rule_forward_get_type_once(void)189 valadoc_rule_forward_get_type_once (void)
190 {
191 static const GEnumValue values[] = {{VALADOC_RULE_FORWARD_NONE, "VALADOC_RULE_FORWARD_NONE", "none"}, {VALADOC_RULE_FORWARD_PARENT, "VALADOC_RULE_FORWARD_PARENT", "parent"}, {VALADOC_RULE_FORWARD_CHILD, "VALADOC_RULE_FORWARD_CHILD", "child"}, {0, NULL, NULL}};
192 GType valadoc_rule_forward_type_id;
193 valadoc_rule_forward_type_id = g_enum_register_static ("ValadocRuleForward", values);
194 return valadoc_rule_forward_type_id;
195 }
196
197 GType
valadoc_rule_forward_get_type(void)198 valadoc_rule_forward_get_type (void)
199 {
200 static volatile gsize valadoc_rule_forward_type_id__volatile = 0;
201 if (g_once_init_enter (&valadoc_rule_forward_type_id__volatile)) {
202 GType valadoc_rule_forward_type_id;
203 valadoc_rule_forward_type_id = valadoc_rule_forward_get_type_once ();
204 g_once_init_leave (&valadoc_rule_forward_type_id__volatile, valadoc_rule_forward_type_id);
205 }
206 return valadoc_rule_forward_type_id__volatile;
207 }
208
209 ValadocRule*
valadoc_rule_seq(GObject ** scheme,gint scheme_length1)210 valadoc_rule_seq (GObject** scheme,
211 gint scheme_length1)
212 {
213 ValadocSequenceRule* _tmp0_;
214 ValadocRule* result = NULL;
215 _tmp0_ = valadoc_sequence_rule_new (scheme, scheme_length1);
216 result = (ValadocRule*) _tmp0_;
217 return result;
218 }
219
220 ValadocRule*
valadoc_rule_one_of(GObject ** scheme,gint scheme_length1)221 valadoc_rule_one_of (GObject** scheme,
222 gint scheme_length1)
223 {
224 ValadocOneOfRule* _tmp0_;
225 ValadocRule* result = NULL;
226 _tmp0_ = valadoc_one_of_rule_new (scheme, scheme_length1);
227 result = (ValadocRule*) _tmp0_;
228 return result;
229 }
230
231 ValadocRule*
valadoc_rule_many(GObject ** scheme,gint scheme_length1)232 valadoc_rule_many (GObject** scheme,
233 gint scheme_length1)
234 {
235 ValadocRule* result = NULL;
236 if (scheme_length1 == 1) {
237 GObject* _tmp0_;
238 ValadocManyRule* _tmp1_;
239 _tmp0_ = scheme[0];
240 _tmp1_ = valadoc_many_rule_new (_tmp0_);
241 result = (ValadocRule*) _tmp1_;
242 return result;
243 } else {
244 ValadocSequenceRule* _tmp2_;
245 ValadocSequenceRule* _tmp3_;
246 ValadocManyRule* _tmp4_;
247 ValadocRule* _tmp5_;
248 _tmp2_ = valadoc_sequence_rule_new (scheme, scheme_length1);
249 _tmp3_ = _tmp2_;
250 _tmp4_ = valadoc_many_rule_new ((GObject*) _tmp3_);
251 _tmp5_ = (ValadocRule*) _tmp4_;
252 _g_object_unref0 (_tmp3_);
253 result = _tmp5_;
254 return result;
255 }
256 }
257
258 ValadocRule*
valadoc_rule_option(GObject ** scheme,gint scheme_length1)259 valadoc_rule_option (GObject** scheme,
260 gint scheme_length1)
261 {
262 ValadocRule* result = NULL;
263 if (scheme_length1 == 1) {
264 GObject* _tmp0_;
265 ValadocOptionalRule* _tmp1_;
266 _tmp0_ = scheme[0];
267 _tmp1_ = valadoc_optional_rule_new (_tmp0_);
268 result = (ValadocRule*) _tmp1_;
269 return result;
270 } else {
271 ValadocSequenceRule* _tmp2_;
272 ValadocSequenceRule* _tmp3_;
273 ValadocOptionalRule* _tmp4_;
274 ValadocRule* _tmp5_;
275 _tmp2_ = valadoc_sequence_rule_new (scheme, scheme_length1);
276 _tmp3_ = _tmp2_;
277 _tmp4_ = valadoc_optional_rule_new ((GObject*) _tmp3_);
278 _tmp5_ = (ValadocRule*) _tmp4_;
279 _g_object_unref0 (_tmp3_);
280 result = _tmp5_;
281 return result;
282 }
283 }
284
285 ValadocRule*
valadoc_rule_construct(GType object_type)286 valadoc_rule_construct (GType object_type)
287 {
288 ValadocRule * self = NULL;
289 self = (ValadocRule*) g_object_new (object_type, NULL);
290 return self;
291 }
292
293 const gchar*
valadoc_rule_get_name(ValadocRule * self)294 valadoc_rule_get_name (ValadocRule* self)
295 {
296 const gchar* result;
297 const gchar* _tmp0_;
298 g_return_val_if_fail (self != NULL, NULL);
299 _tmp0_ = self->priv->_name;
300 result = _tmp0_;
301 return result;
302 }
303
304 static gpointer
_g_object_ref0(gpointer self)305 _g_object_ref0 (gpointer self)
306 {
307 return self ? g_object_ref (self) : NULL;
308 }
309
310 ValadocRule*
valadoc_rule_set_name(ValadocRule * self,const gchar * name)311 valadoc_rule_set_name (ValadocRule* self,
312 const gchar* name)
313 {
314 gchar* _tmp0_;
315 ValadocRule* _tmp1_;
316 ValadocRule* result = NULL;
317 g_return_val_if_fail (self != NULL, NULL);
318 g_return_val_if_fail (name != NULL, NULL);
319 _tmp0_ = g_strdup (name);
320 _g_free0 (self->priv->_name);
321 self->priv->_name = _tmp0_;
322 _tmp1_ = _g_object_ref0 (self);
323 result = _tmp1_;
324 return result;
325 }
326
327 static Block3Data*
block3_data_ref(Block3Data * _data3_)328 block3_data_ref (Block3Data* _data3_)
329 {
330 g_atomic_int_inc (&_data3_->_ref_count_);
331 return _data3_;
332 }
333
334 static void
block3_data_unref(void * _userdata_)335 block3_data_unref (void * _userdata_)
336 {
337 Block3Data* _data3_;
338 _data3_ = (Block3Data*) _userdata_;
339 if (g_atomic_int_dec_and_test (&_data3_->_ref_count_)) {
340 ValadocRule* self;
341 self = _data3_->self;
342 _g_object_unref0 (self);
343 g_slice_free (Block3Data, _data3_);
344 }
345 }
346
347 static void
__lambda5_(Block3Data * _data3_,GError ** error)348 __lambda5_ (Block3Data* _data3_,
349 GError** error)
350 {
351 ValadocRule* self;
352 GError* _inner_error0_ = NULL;
353 self = _data3_->self;
354 _data3_->action (_data3_->action_target, &_inner_error0_);
355 if (G_UNLIKELY (_inner_error0_ != NULL)) {
356 if (_inner_error0_->domain == VALADOC_PARSER_ERROR) {
357 g_propagate_error (error, _inner_error0_);
358 return;
359 } else {
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;
363 }
364 }
365 }
366
367 static void
___lambda5__valadoc_rule_action(gpointer self,GError ** error)368 ___lambda5__valadoc_rule_action (gpointer self,
369 GError** error)
370 {
371 __lambda5_ (self, error);
372 }
373
374 ValadocRule*
valadoc_rule_set_start(ValadocRule * self,ValadocRuleAction action,gpointer action_target)375 valadoc_rule_set_start (ValadocRule* self,
376 ValadocRuleAction action,
377 gpointer action_target)
378 {
379 Block3Data* _data3_;
380 ValadocRule* _tmp0_;
381 ValadocRule* result = NULL;
382 g_return_val_if_fail (self != NULL, NULL);
383 _data3_ = g_slice_new0 (Block3Data);
384 _data3_->_ref_count_ = 1;
385 _data3_->self = g_object_ref (self);
386 _data3_->action = action;
387 _data3_->action_target = action_target;
388 (self->priv->_start_action_target_destroy_notify == NULL) ? NULL : (self->priv->_start_action_target_destroy_notify (self->priv->_start_action_target), NULL);
389 self->priv->_start_action = NULL;
390 self->priv->_start_action_target = NULL;
391 self->priv->_start_action_target_destroy_notify = NULL;
392 self->priv->_start_action = ___lambda5__valadoc_rule_action;
393 self->priv->_start_action_target = block3_data_ref (_data3_);
394 self->priv->_start_action_target_destroy_notify = block3_data_unref;
395 _tmp0_ = _g_object_ref0 (self);
396 result = _tmp0_;
397 block3_data_unref (_data3_);
398 _data3_ = NULL;
399 return result;
400 }
401
402 static Block4Data*
block4_data_ref(Block4Data * _data4_)403 block4_data_ref (Block4Data* _data4_)
404 {
405 g_atomic_int_inc (&_data4_->_ref_count_);
406 return _data4_;
407 }
408
409 static void
block4_data_unref(void * _userdata_)410 block4_data_unref (void * _userdata_)
411 {
412 Block4Data* _data4_;
413 _data4_ = (Block4Data*) _userdata_;
414 if (g_atomic_int_dec_and_test (&_data4_->_ref_count_)) {
415 ValadocRule* self;
416 self = _data4_->self;
417 _g_object_unref0 (self);
418 g_slice_free (Block4Data, _data4_);
419 }
420 }
421
422 static void
__lambda6_(Block4Data * _data4_,GError ** error)423 __lambda6_ (Block4Data* _data4_,
424 GError** error)
425 {
426 ValadocRule* self;
427 GError* _inner_error0_ = NULL;
428 self = _data4_->self;
429 _data4_->action (_data4_->action_target, &_inner_error0_);
430 if (G_UNLIKELY (_inner_error0_ != NULL)) {
431 if (_inner_error0_->domain == VALADOC_PARSER_ERROR) {
432 g_propagate_error (error, _inner_error0_);
433 return;
434 } else {
435 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);
436 g_clear_error (&_inner_error0_);
437 return;
438 }
439 }
440 }
441
442 static void
___lambda6__valadoc_rule_action(gpointer self,GError ** error)443 ___lambda6__valadoc_rule_action (gpointer self,
444 GError** error)
445 {
446 __lambda6_ (self, error);
447 }
448
449 ValadocRule*
valadoc_rule_set_reduce(ValadocRule * self,ValadocRuleAction action,gpointer action_target)450 valadoc_rule_set_reduce (ValadocRule* self,
451 ValadocRuleAction action,
452 gpointer action_target)
453 {
454 Block4Data* _data4_;
455 ValadocRule* _tmp0_;
456 ValadocRule* result = NULL;
457 g_return_val_if_fail (self != NULL, NULL);
458 _data4_ = g_slice_new0 (Block4Data);
459 _data4_->_ref_count_ = 1;
460 _data4_->self = g_object_ref (self);
461 _data4_->action = action;
462 _data4_->action_target = action_target;
463 (self->priv->_reduce_action_target_destroy_notify == NULL) ? NULL : (self->priv->_reduce_action_target_destroy_notify (self->priv->_reduce_action_target), NULL);
464 self->priv->_reduce_action = NULL;
465 self->priv->_reduce_action_target = NULL;
466 self->priv->_reduce_action_target_destroy_notify = NULL;
467 self->priv->_reduce_action = ___lambda6__valadoc_rule_action;
468 self->priv->_reduce_action_target = block4_data_ref (_data4_);
469 self->priv->_reduce_action_target_destroy_notify = block4_data_unref;
470 _tmp0_ = _g_object_ref0 (self);
471 result = _tmp0_;
472 block4_data_unref (_data4_);
473 _data4_ = NULL;
474 return result;
475 }
476
477 static Block5Data*
block5_data_ref(Block5Data * _data5_)478 block5_data_ref (Block5Data* _data5_)
479 {
480 g_atomic_int_inc (&_data5_->_ref_count_);
481 return _data5_;
482 }
483
484 static void
block5_data_unref(void * _userdata_)485 block5_data_unref (void * _userdata_)
486 {
487 Block5Data* _data5_;
488 _data5_ = (Block5Data*) _userdata_;
489 if (g_atomic_int_dec_and_test (&_data5_->_ref_count_)) {
490 ValadocRule* self;
491 self = _data5_->self;
492 _g_object_unref0 (self);
493 g_slice_free (Block5Data, _data5_);
494 }
495 }
496
497 static void
__lambda7_(Block5Data * _data5_,GError ** error)498 __lambda7_ (Block5Data* _data5_,
499 GError** error)
500 {
501 ValadocRule* self;
502 GError* _inner_error0_ = NULL;
503 self = _data5_->self;
504 _data5_->action (_data5_->action_target, &_inner_error0_);
505 if (G_UNLIKELY (_inner_error0_ != NULL)) {
506 if (_inner_error0_->domain == VALADOC_PARSER_ERROR) {
507 g_propagate_error (error, _inner_error0_);
508 return;
509 } else {
510 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);
511 g_clear_error (&_inner_error0_);
512 return;
513 }
514 }
515 }
516
517 static void
___lambda7__valadoc_rule_action(gpointer self,GError ** error)518 ___lambda7__valadoc_rule_action (gpointer self,
519 GError** error)
520 {
521 __lambda7_ (self, error);
522 }
523
524 ValadocRule*
valadoc_rule_set_skip(ValadocRule * self,ValadocRuleAction action,gpointer action_target)525 valadoc_rule_set_skip (ValadocRule* self,
526 ValadocRuleAction action,
527 gpointer action_target)
528 {
529 Block5Data* _data5_;
530 ValadocRule* _tmp0_;
531 ValadocRule* result = NULL;
532 g_return_val_if_fail (self != NULL, NULL);
533 _data5_ = g_slice_new0 (Block5Data);
534 _data5_->_ref_count_ = 1;
535 _data5_->self = g_object_ref (self);
536 _data5_->action = action;
537 _data5_->action_target = action_target;
538 (self->priv->_skip_action_target_destroy_notify == NULL) ? NULL : (self->priv->_skip_action_target_destroy_notify (self->priv->_skip_action_target), NULL);
539 self->priv->_skip_action = NULL;
540 self->priv->_skip_action_target = NULL;
541 self->priv->_skip_action_target_destroy_notify = NULL;
542 self->priv->_skip_action = ___lambda7__valadoc_rule_action;
543 self->priv->_skip_action_target = block5_data_ref (_data5_);
544 self->priv->_skip_action_target_destroy_notify = block5_data_unref;
545 _tmp0_ = _g_object_ref0 (self);
546 result = _tmp0_;
547 block5_data_unref (_data5_);
548 _data5_ = NULL;
549 return result;
550 }
551
552 static gboolean
valadoc_rule_real_is_optional(ValadocRule * self)553 valadoc_rule_real_is_optional (ValadocRule* self)
554 {
555 gboolean _tmp0_ = FALSE;
556 g_critical ("Type `%s' does not implement abstract method `valadoc_rule_is_optional'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
557 return _tmp0_;
558 }
559
560 gboolean
valadoc_rule_is_optional(ValadocRule * self)561 valadoc_rule_is_optional (ValadocRule* self)
562 {
563 g_return_val_if_fail (self != NULL, FALSE);
564 return VALADOC_RULE_GET_CLASS (self)->is_optional (self);
565 }
566
567 static gboolean
valadoc_rule_real_starts_with_token(ValadocRule * self,ValadocToken * token)568 valadoc_rule_real_starts_with_token (ValadocRule* self,
569 ValadocToken* token)
570 {
571 gboolean _tmp0_ = FALSE;
572 g_critical ("Type `%s' does not implement abstract method `valadoc_rule_starts_with_token'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
573 return _tmp0_;
574 }
575
576 gboolean
valadoc_rule_starts_with_token(ValadocRule * self,ValadocToken * token)577 valadoc_rule_starts_with_token (ValadocRule* self,
578 ValadocToken* token)
579 {
580 g_return_val_if_fail (self != NULL, FALSE);
581 return VALADOC_RULE_GET_CLASS (self)->starts_with_token (self, token);
582 }
583
584 static gboolean
valadoc_rule_real_accept_token(ValadocRule * self,ValadocToken * token,ValadocParserCallback * parser,ValadocRuleForward forward,GError ** error)585 valadoc_rule_real_accept_token (ValadocRule* self,
586 ValadocToken* token,
587 ValadocParserCallback* parser,
588 ValadocRuleForward forward,
589 GError** error)
590 {
591 gboolean _tmp0_ = FALSE;
592 g_critical ("Type `%s' does not implement abstract method `valadoc_rule_accept_token'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
593 return _tmp0_;
594 }
595
596 gboolean
valadoc_rule_accept_token(ValadocRule * self,ValadocToken * token,ValadocParserCallback * parser,ValadocRuleForward forward,GError ** error)597 valadoc_rule_accept_token (ValadocRule* self,
598 ValadocToken* token,
599 ValadocParserCallback* parser,
600 ValadocRuleForward forward,
601 GError** error)
602 {
603 g_return_val_if_fail (self != NULL, FALSE);
604 return VALADOC_RULE_GET_CLASS (self)->accept_token (self, token, parser, forward, error);
605 }
606
607 static gboolean
valadoc_rule_real_would_accept_token(ValadocRule * self,ValadocToken * token,GObject * state)608 valadoc_rule_real_would_accept_token (ValadocRule* self,
609 ValadocToken* token,
610 GObject* state)
611 {
612 gboolean _tmp0_ = FALSE;
613 g_critical ("Type `%s' does not implement abstract method `valadoc_rule_would_accept_token'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
614 return _tmp0_;
615 }
616
617 gboolean
valadoc_rule_would_accept_token(ValadocRule * self,ValadocToken * token,GObject * state)618 valadoc_rule_would_accept_token (ValadocRule* self,
619 ValadocToken* token,
620 GObject* state)
621 {
622 g_return_val_if_fail (self != NULL, FALSE);
623 return VALADOC_RULE_GET_CLASS (self)->would_accept_token (self, token, state);
624 }
625
626 static gboolean
valadoc_rule_real_would_reduce(ValadocRule * self,ValadocToken * token,GObject * state)627 valadoc_rule_real_would_reduce (ValadocRule* self,
628 ValadocToken* token,
629 GObject* state)
630 {
631 gboolean _tmp0_ = FALSE;
632 g_critical ("Type `%s' does not implement abstract method `valadoc_rule_would_reduce'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
633 return _tmp0_;
634 }
635
636 gboolean
valadoc_rule_would_reduce(ValadocRule * self,ValadocToken * token,GObject * state)637 valadoc_rule_would_reduce (ValadocRule* self,
638 ValadocToken* token,
639 GObject* state)
640 {
641 g_return_val_if_fail (self != NULL, FALSE);
642 return VALADOC_RULE_GET_CLASS (self)->would_reduce (self, token, state);
643 }
644
645 static gchar*
valadoc_rule_real_to_string(ValadocRule * self,GObject * state)646 valadoc_rule_real_to_string (ValadocRule* self,
647 GObject* state)
648 {
649 g_critical ("Type `%s' does not implement abstract method `valadoc_rule_to_string'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
650 return NULL;
651 }
652
653 gchar*
valadoc_rule_to_string(ValadocRule * self,GObject * state)654 valadoc_rule_to_string (ValadocRule* self,
655 GObject* state)
656 {
657 g_return_val_if_fail (self != NULL, NULL);
658 return VALADOC_RULE_GET_CLASS (self)->to_string (self, state);
659 }
660
661 gboolean
valadoc_rule_is_optional_rule(ValadocRule * self,GObject * scheme_element)662 valadoc_rule_is_optional_rule (ValadocRule* self,
663 GObject* scheme_element)
664 {
665 ValadocRule* scheme_rule = NULL;
666 ValadocRule* _tmp0_;
667 ValadocRule* _tmp1_;
668 gboolean result = FALSE;
669 g_return_val_if_fail (self != NULL, FALSE);
670 _tmp0_ = _g_object_ref0 (VALADOC_IS_RULE (scheme_element) ? ((ValadocRule*) scheme_element) : NULL);
671 scheme_rule = _tmp0_;
672 _tmp1_ = scheme_rule;
673 if (_tmp1_ != NULL) {
674 ValadocRule* _tmp2_;
675 _tmp2_ = scheme_rule;
676 result = valadoc_rule_is_optional (_tmp2_);
677 _g_object_unref0 (scheme_rule);
678 return result;
679 }
680 result = FALSE;
681 _g_object_unref0 (scheme_rule);
682 return result;
683 }
684
685 gboolean
valadoc_rule_has_start_token(ValadocRule * self,GObject * scheme_element,ValadocToken * token)686 valadoc_rule_has_start_token (ValadocRule* self,
687 GObject* scheme_element,
688 ValadocToken* token)
689 {
690 ValadocTokenType* scheme_token_type = NULL;
691 ValadocTokenType* _tmp0_;
692 ValadocTokenType* _tmp1_;
693 ValadocRule* scheme_rule = NULL;
694 ValadocRule* _tmp3_;
695 ValadocRule* _tmp4_;
696 gboolean result = FALSE;
697 g_return_val_if_fail (self != NULL, FALSE);
698 g_return_val_if_fail (token != NULL, FALSE);
699 _tmp0_ = _g_object_ref0 (VALADOC_IS_TOKEN_TYPE (scheme_element) ? ((ValadocTokenType*) scheme_element) : NULL);
700 scheme_token_type = _tmp0_;
701 _tmp1_ = scheme_token_type;
702 if (_tmp1_ != NULL) {
703 ValadocTokenType* _tmp2_;
704 _tmp2_ = scheme_token_type;
705 result = valadoc_token_type_matches (_tmp2_, token);
706 _g_object_unref0 (scheme_token_type);
707 return result;
708 }
709 _tmp3_ = _g_object_ref0 (VALADOC_IS_RULE (scheme_element) ? ((ValadocRule*) scheme_element) : NULL);
710 scheme_rule = _tmp3_;
711 _tmp4_ = scheme_rule;
712 if (_tmp4_ != NULL) {
713 ValadocRule* _tmp5_;
714 _tmp5_ = scheme_rule;
715 result = valadoc_rule_starts_with_token (_tmp5_, token);
716 _g_object_unref0 (scheme_rule);
717 _g_object_unref0 (scheme_token_type);
718 return result;
719 }
720 result = FALSE;
721 _g_object_unref0 (scheme_rule);
722 _g_object_unref0 (scheme_token_type);
723 return result;
724 }
725
726 gboolean
valadoc_rule_try_to_apply(ValadocRule * self,GObject * scheme_element,ValadocToken * token,ValadocParserCallback * parser,gboolean * handled,GError ** error)727 valadoc_rule_try_to_apply (ValadocRule* self,
728 GObject* scheme_element,
729 ValadocToken* token,
730 ValadocParserCallback* parser,
731 gboolean* handled,
732 GError** error)
733 {
734 gboolean _vala_handled = FALSE;
735 ValadocTokenType* scheme_token_type = NULL;
736 ValadocTokenType* _tmp0_;
737 gboolean _tmp1_ = FALSE;
738 ValadocTokenType* _tmp2_;
739 ValadocRule* scheme_rule = NULL;
740 ValadocRule* _tmp7_;
741 gboolean _tmp8_ = FALSE;
742 ValadocRule* _tmp9_;
743 GError* _inner_error0_ = NULL;
744 gboolean result = FALSE;
745 g_return_val_if_fail (self != NULL, FALSE);
746 g_return_val_if_fail (token != NULL, FALSE);
747 g_return_val_if_fail (parser != NULL, FALSE);
748 _tmp0_ = _g_object_ref0 (VALADOC_IS_TOKEN_TYPE (scheme_element) ? ((ValadocTokenType*) scheme_element) : NULL);
749 scheme_token_type = _tmp0_;
750 _tmp2_ = scheme_token_type;
751 if (_tmp2_ != NULL) {
752 ValadocTokenType* _tmp3_;
753 _tmp3_ = scheme_token_type;
754 _tmp1_ = valadoc_token_type_matches (_tmp3_, token);
755 } else {
756 _tmp1_ = FALSE;
757 }
758 if (_tmp1_) {
759 ValadocTokenType* _tmp4_;
760 _tmp4_ = scheme_token_type;
761 valadoc_token_type_do_action (_tmp4_, token, &_inner_error0_);
762 if (G_UNLIKELY (_inner_error0_ != NULL)) {
763 if (_inner_error0_->domain == VALADOC_PARSER_ERROR) {
764 gboolean _tmp5_ = FALSE;
765 g_propagate_error (error, _inner_error0_);
766 _g_object_unref0 (scheme_token_type);
767 return _tmp5_;
768 } else {
769 gboolean _tmp6_ = FALSE;
770 _g_object_unref0 (scheme_token_type);
771 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);
772 g_clear_error (&_inner_error0_);
773 return _tmp6_;
774 }
775 }
776 _vala_handled = TRUE;
777 result = TRUE;
778 _g_object_unref0 (scheme_token_type);
779 if (handled) {
780 *handled = _vala_handled;
781 }
782 return result;
783 }
784 _tmp7_ = _g_object_ref0 (VALADOC_IS_RULE (scheme_element) ? ((ValadocRule*) scheme_element) : NULL);
785 scheme_rule = _tmp7_;
786 _tmp9_ = scheme_rule;
787 if (_tmp9_ != NULL) {
788 ValadocRule* _tmp10_;
789 _tmp10_ = scheme_rule;
790 _tmp8_ = valadoc_rule_starts_with_token (_tmp10_, token);
791 } else {
792 _tmp8_ = FALSE;
793 }
794 if (_tmp8_) {
795 ValadocRule* _tmp11_;
796 _tmp11_ = scheme_rule;
797 valadoc_parser_callback_push_rule (parser, _tmp11_);
798 _vala_handled = FALSE;
799 result = TRUE;
800 _g_object_unref0 (scheme_rule);
801 _g_object_unref0 (scheme_token_type);
802 if (handled) {
803 *handled = _vala_handled;
804 }
805 return result;
806 }
807 _vala_handled = FALSE;
808 result = FALSE;
809 _g_object_unref0 (scheme_rule);
810 _g_object_unref0 (scheme_token_type);
811 if (handled) {
812 *handled = _vala_handled;
813 }
814 return result;
815 }
816
817 void
valadoc_rule_do_start(ValadocRule * self,ValadocParserCallback * parser,GError ** error)818 valadoc_rule_do_start (ValadocRule* self,
819 ValadocParserCallback* parser,
820 GError** error)
821 {
822 ValadocRuleAction _tmp0_;
823 gpointer _tmp0__target;
824 GError* _inner_error0_ = NULL;
825 g_return_if_fail (self != NULL);
826 g_return_if_fail (parser != NULL);
827 _tmp0_ = self->priv->_start_action;
828 _tmp0__target = self->priv->_start_action_target;
829 if (_tmp0_ != NULL) {
830 ValadocRuleAction _tmp1_;
831 gpointer _tmp1__target;
832 _tmp1_ = self->priv->_start_action;
833 _tmp1__target = self->priv->_start_action_target;
834 _tmp1_ (_tmp1__target, &_inner_error0_);
835 if (G_UNLIKELY (_inner_error0_ != NULL)) {
836 if (_inner_error0_->domain == VALADOC_PARSER_ERROR) {
837 g_propagate_error (error, _inner_error0_);
838 return;
839 } else {
840 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);
841 g_clear_error (&_inner_error0_);
842 return;
843 }
844 }
845 }
846 }
847
848 void
valadoc_rule_do_reduce(ValadocRule * self,ValadocParserCallback * parser,GError ** error)849 valadoc_rule_do_reduce (ValadocRule* self,
850 ValadocParserCallback* parser,
851 GError** error)
852 {
853 ValadocRuleAction _tmp0_;
854 gpointer _tmp0__target;
855 GError* _inner_error0_ = NULL;
856 g_return_if_fail (self != NULL);
857 g_return_if_fail (parser != NULL);
858 _tmp0_ = self->priv->_reduce_action;
859 _tmp0__target = self->priv->_reduce_action_target;
860 if (_tmp0_ != NULL) {
861 ValadocRuleAction _tmp1_;
862 gpointer _tmp1__target;
863 _tmp1_ = self->priv->_reduce_action;
864 _tmp1__target = self->priv->_reduce_action_target;
865 _tmp1_ (_tmp1__target, &_inner_error0_);
866 if (G_UNLIKELY (_inner_error0_ != NULL)) {
867 if (_inner_error0_->domain == VALADOC_PARSER_ERROR) {
868 g_propagate_error (error, _inner_error0_);
869 return;
870 } else {
871 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);
872 g_clear_error (&_inner_error0_);
873 return;
874 }
875 }
876 }
877 valadoc_parser_callback_reduce (parser);
878 }
879
880 void
valadoc_rule_do_skip(ValadocRule * self,ValadocParserCallback * parser,GError ** error)881 valadoc_rule_do_skip (ValadocRule* self,
882 ValadocParserCallback* parser,
883 GError** error)
884 {
885 ValadocRuleAction _tmp0_;
886 gpointer _tmp0__target;
887 GError* _inner_error0_ = NULL;
888 g_return_if_fail (self != NULL);
889 g_return_if_fail (parser != NULL);
890 _tmp0_ = self->priv->_skip_action;
891 _tmp0__target = self->priv->_skip_action_target;
892 if (_tmp0_ != NULL) {
893 ValadocRuleAction _tmp1_;
894 gpointer _tmp1__target;
895 _tmp1_ = self->priv->_skip_action;
896 _tmp1__target = self->priv->_skip_action_target;
897 _tmp1_ (_tmp1__target, &_inner_error0_);
898 if (G_UNLIKELY (_inner_error0_ != NULL)) {
899 if (_inner_error0_->domain == VALADOC_PARSER_ERROR) {
900 g_propagate_error (error, _inner_error0_);
901 return;
902 } else {
903 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);
904 g_clear_error (&_inner_error0_);
905 return;
906 }
907 }
908 }
909 }
910
911 static void
valadoc_rule_class_init(ValadocRuleClass * klass,gpointer klass_data)912 valadoc_rule_class_init (ValadocRuleClass * klass,
913 gpointer klass_data)
914 {
915 valadoc_rule_parent_class = g_type_class_peek_parent (klass);
916 g_type_class_adjust_private_offset (klass, &ValadocRule_private_offset);
917 ((ValadocRuleClass *) klass)->is_optional = (gboolean (*) (ValadocRule*)) valadoc_rule_real_is_optional;
918 ((ValadocRuleClass *) klass)->starts_with_token = (gboolean (*) (ValadocRule*, ValadocToken*)) valadoc_rule_real_starts_with_token;
919 ((ValadocRuleClass *) klass)->accept_token = (gboolean (*) (ValadocRule*, ValadocToken*, ValadocParserCallback*, ValadocRuleForward, GError**)) valadoc_rule_real_accept_token;
920 ((ValadocRuleClass *) klass)->would_accept_token = (gboolean (*) (ValadocRule*, ValadocToken*, GObject*)) valadoc_rule_real_would_accept_token;
921 ((ValadocRuleClass *) klass)->would_reduce = (gboolean (*) (ValadocRule*, ValadocToken*, GObject*)) valadoc_rule_real_would_reduce;
922 ((ValadocRuleClass *) klass)->to_string = (gchar* (*) (ValadocRule*, GObject*)) valadoc_rule_real_to_string;
923 G_OBJECT_CLASS (klass)->get_property = _vala_valadoc_rule_get_property;
924 G_OBJECT_CLASS (klass)->finalize = valadoc_rule_finalize;
925 g_object_class_install_property (G_OBJECT_CLASS (klass), VALADOC_RULE_NAME_PROPERTY, valadoc_rule_properties[VALADOC_RULE_NAME_PROPERTY] = g_param_spec_string ("name", "name", "name", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
926 }
927
928 static void
valadoc_rule_instance_init(ValadocRule * self,gpointer klass)929 valadoc_rule_instance_init (ValadocRule * self,
930 gpointer klass)
931 {
932 self->priv = valadoc_rule_get_instance_private (self);
933 self->priv->_name = NULL;
934 }
935
936 static void
valadoc_rule_finalize(GObject * obj)937 valadoc_rule_finalize (GObject * obj)
938 {
939 ValadocRule * self;
940 self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALADOC_TYPE_RULE, ValadocRule);
941 _g_free0 (self->priv->_name);
942 (self->priv->_start_action_target_destroy_notify == NULL) ? NULL : (self->priv->_start_action_target_destroy_notify (self->priv->_start_action_target), NULL);
943 self->priv->_start_action = NULL;
944 self->priv->_start_action_target = NULL;
945 self->priv->_start_action_target_destroy_notify = NULL;
946 (self->priv->_reduce_action_target_destroy_notify == NULL) ? NULL : (self->priv->_reduce_action_target_destroy_notify (self->priv->_reduce_action_target), NULL);
947 self->priv->_reduce_action = NULL;
948 self->priv->_reduce_action_target = NULL;
949 self->priv->_reduce_action_target_destroy_notify = NULL;
950 (self->priv->_skip_action_target_destroy_notify == NULL) ? NULL : (self->priv->_skip_action_target_destroy_notify (self->priv->_skip_action_target), NULL);
951 self->priv->_skip_action = NULL;
952 self->priv->_skip_action_target = NULL;
953 self->priv->_skip_action_target_destroy_notify = NULL;
954 G_OBJECT_CLASS (valadoc_rule_parent_class)->finalize (obj);
955 }
956
957 static GType
valadoc_rule_get_type_once(void)958 valadoc_rule_get_type_once (void)
959 {
960 static const GTypeInfo g_define_type_info = { sizeof (ValadocRuleClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) valadoc_rule_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValadocRule), 0, (GInstanceInitFunc) valadoc_rule_instance_init, NULL };
961 GType valadoc_rule_type_id;
962 valadoc_rule_type_id = g_type_register_static (G_TYPE_OBJECT, "ValadocRule", &g_define_type_info, G_TYPE_FLAG_ABSTRACT);
963 ValadocRule_private_offset = g_type_add_instance_private (valadoc_rule_type_id, sizeof (ValadocRulePrivate));
964 return valadoc_rule_type_id;
965 }
966
967 GType
valadoc_rule_get_type(void)968 valadoc_rule_get_type (void)
969 {
970 static volatile gsize valadoc_rule_type_id__volatile = 0;
971 if (g_once_init_enter (&valadoc_rule_type_id__volatile)) {
972 GType valadoc_rule_type_id;
973 valadoc_rule_type_id = valadoc_rule_get_type_once ();
974 g_once_init_leave (&valadoc_rule_type_id__volatile, valadoc_rule_type_id);
975 }
976 return valadoc_rule_type_id__volatile;
977 }
978
979 static void
_vala_valadoc_rule_get_property(GObject * object,guint property_id,GValue * value,GParamSpec * pspec)980 _vala_valadoc_rule_get_property (GObject * object,
981 guint property_id,
982 GValue * value,
983 GParamSpec * pspec)
984 {
985 ValadocRule * self;
986 self = G_TYPE_CHECK_INSTANCE_CAST (object, VALADOC_TYPE_RULE, ValadocRule);
987 switch (property_id) {
988 case VALADOC_RULE_NAME_PROPERTY:
989 g_value_set_string (value, valadoc_rule_get_name (self));
990 break;
991 default:
992 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
993 break;
994 }
995 }
996
997