1 /* valadocdocumentationimporterscanner.c generated by valac, the Vala compiler
2 * generated from valadocdocumentationimporterscanner.vala, do not modify */
3
4 /* valadodocumentationscanner.vala
5 *
6 * Copyright (C) 2010 Florian Brosch
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 * Florian Brosch <flo.brosch@gmail.com>
24 */
25
26 #include "valadoc.h"
27 #include <stdlib.h>
28 #include <string.h>
29 #include <glib.h>
30 #include <glib-object.h>
31 #include <vala.h>
32
33 enum {
34 VALADOC_IMPORTER_VALADOC_DOCUMENTATION_SCANNER_0_PROPERTY,
35 VALADOC_IMPORTER_VALADOC_DOCUMENTATION_SCANNER_NUM_PROPERTIES
36 };
37 static GParamSpec* valadoc_importer_valadoc_documentation_scanner_properties[VALADOC_IMPORTER_VALADOC_DOCUMENTATION_SCANNER_NUM_PROPERTIES];
38 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
39 #define _valadoc_parser_unref0(var) ((var == NULL) ? NULL : (var = (valadoc_parser_unref (var), NULL)))
40 #define _g_free0(var) (var = (g_free (var), NULL))
41 #define _g_string_free0(var) ((var == NULL) ? NULL : (var = (g_string_free (var, TRUE), NULL)))
42
43 struct _ValadocImporterValadocDocumentationScannerPrivate {
44 ValadocSettings* _settings;
45 ValadocParser* _parser;
46 gchar* _content;
47 const gchar* _index;
48 gboolean _stop;
49 gint _last_line;
50 gint _last_column;
51 gint _line;
52 gint _column;
53 gunichar _last_char;
54 gint _skip;
55 GString* _current_string;
56 };
57
58 static gint ValadocImporterValadocDocumentationScanner_private_offset;
59 static gpointer valadoc_importer_valadoc_documentation_scanner_parent_class = NULL;
60 static ValadocScannerIface * valadoc_importer_valadoc_documentation_scanner_valadoc_scanner_parent_iface = NULL;
61
62 static void valadoc_importer_valadoc_documentation_scanner_real_set_parser (ValadocScanner* base,
63 ValadocParser* parser);
64 static void valadoc_importer_valadoc_documentation_scanner_real_reset (ValadocImporterValadocDocumentationScanner* self);
65 static void valadoc_importer_valadoc_documentation_scanner_real_scan (ValadocScanner* base,
66 const gchar* content,
67 GError** error);
68 static void valadoc_importer_valadoc_documentation_scanner_real_end (ValadocScanner* base,
69 GError** error);
70 static void valadoc_importer_valadoc_documentation_scanner_emit_token (ValadocImporterValadocDocumentationScanner* self,
71 ValadocTokenType* type,
72 GError** error);
73 static void valadoc_importer_valadoc_documentation_scanner_real_stop (ValadocImporterValadocDocumentationScanner* self);
74 static gchar* valadoc_importer_valadoc_documentation_scanner_real_get_line_content (ValadocImporterValadocDocumentationScanner* self);
75 static void valadoc_importer_valadoc_documentation_scanner_append_char (ValadocImporterValadocDocumentationScanner* self,
76 gunichar c);
77 static gint valadoc_importer_valadoc_documentation_scanner_real_get_line_start_column (ValadocImporterValadocDocumentationScanner* self);
78 static void valadoc_importer_valadoc_documentation_scanner_get_begin (ValadocImporterValadocDocumentationScanner* self,
79 ValaSourceLocation* result);
80 static void valadoc_importer_valadoc_documentation_scanner_get_end (ValadocImporterValadocDocumentationScanner* self,
81 gint offset,
82 ValaSourceLocation* result);
83 static void valadoc_importer_valadoc_documentation_scanner_emit_current_word (ValadocImporterValadocDocumentationScanner* self,
84 GError** error);
85 static void valadoc_importer_valadoc_documentation_scanner_finalize (GObject * obj);
86 static GType valadoc_importer_valadoc_documentation_scanner_get_type_once (void);
87
88 static inline gpointer
valadoc_importer_valadoc_documentation_scanner_get_instance_private(ValadocImporterValadocDocumentationScanner * self)89 valadoc_importer_valadoc_documentation_scanner_get_instance_private (ValadocImporterValadocDocumentationScanner* self)
90 {
91 return G_STRUCT_MEMBER_P (self, ValadocImporterValadocDocumentationScanner_private_offset);
92 }
93
94 static gpointer
_g_object_ref0(gpointer self)95 _g_object_ref0 (gpointer self)
96 {
97 return self ? g_object_ref (self) : NULL;
98 }
99
100 ValadocImporterValadocDocumentationScanner*
valadoc_importer_valadoc_documentation_scanner_construct(GType object_type,ValadocSettings * settings)101 valadoc_importer_valadoc_documentation_scanner_construct (GType object_type,
102 ValadocSettings* settings)
103 {
104 ValadocImporterValadocDocumentationScanner * self = NULL;
105 ValadocSettings* _tmp0_;
106 g_return_val_if_fail (settings != NULL, NULL);
107 self = (ValadocImporterValadocDocumentationScanner*) g_object_new (object_type, NULL);
108 _tmp0_ = _g_object_ref0 (settings);
109 _g_object_unref0 (self->priv->_settings);
110 self->priv->_settings = _tmp0_;
111 return self;
112 }
113
114 ValadocImporterValadocDocumentationScanner*
valadoc_importer_valadoc_documentation_scanner_new(ValadocSettings * settings)115 valadoc_importer_valadoc_documentation_scanner_new (ValadocSettings* settings)
116 {
117 return valadoc_importer_valadoc_documentation_scanner_construct (VALADOC_IMPORTER_TYPE_VALADOC_DOCUMENTATION_SCANNER, settings);
118 }
119
120 static gpointer
_valadoc_parser_ref0(gpointer self)121 _valadoc_parser_ref0 (gpointer self)
122 {
123 return self ? valadoc_parser_ref (self) : NULL;
124 }
125
126 static void
valadoc_importer_valadoc_documentation_scanner_real_set_parser(ValadocScanner * base,ValadocParser * parser)127 valadoc_importer_valadoc_documentation_scanner_real_set_parser (ValadocScanner* base,
128 ValadocParser* parser)
129 {
130 ValadocImporterValadocDocumentationScanner * self;
131 ValadocParser* _tmp0_;
132 self = (ValadocImporterValadocDocumentationScanner*) base;
133 g_return_if_fail (parser != NULL);
134 _tmp0_ = _valadoc_parser_ref0 (parser);
135 _valadoc_parser_unref0 (self->priv->_parser);
136 self->priv->_parser = _tmp0_;
137 }
138
139 static void
valadoc_importer_valadoc_documentation_scanner_real_reset(ValadocImporterValadocDocumentationScanner * self)140 valadoc_importer_valadoc_documentation_scanner_real_reset (ValadocImporterValadocDocumentationScanner* self)
141 {
142 GString* _tmp0_;
143 self->priv->_stop = FALSE;
144 self->priv->_last_line = 0;
145 self->priv->_last_column = 0;
146 self->priv->_line = 0;
147 self->priv->_column = 0;
148 self->priv->_last_char = (gunichar) 0;
149 self->priv->_skip = 0;
150 _tmp0_ = self->priv->_current_string;
151 g_string_erase (_tmp0_, (gssize) 0, (gssize) -1);
152 }
153
154 void
valadoc_importer_valadoc_documentation_scanner_reset(ValadocImporterValadocDocumentationScanner * self)155 valadoc_importer_valadoc_documentation_scanner_reset (ValadocImporterValadocDocumentationScanner* self)
156 {
157 g_return_if_fail (self != NULL);
158 VALADOC_IMPORTER_VALADOC_DOCUMENTATION_SCANNER_GET_CLASS (self)->reset (self);
159 }
160
161 static gunichar
string_get_char(const gchar * self,glong index)162 string_get_char (const gchar* self,
163 glong index)
164 {
165 gunichar result = 0U;
166 g_return_val_if_fail (self != NULL, 0U);
167 result = g_utf8_get_char (((gchar*) self) + index);
168 return result;
169 }
170
171 static void
valadoc_importer_valadoc_documentation_scanner_real_scan(ValadocScanner * base,const gchar * content,GError ** error)172 valadoc_importer_valadoc_documentation_scanner_real_scan (ValadocScanner* base,
173 const gchar* content,
174 GError** error)
175 {
176 ValadocImporterValadocDocumentationScanner * self;
177 gchar* _tmp0_;
178 GError* _inner_error0_ = NULL;
179 self = (ValadocImporterValadocDocumentationScanner*) base;
180 g_return_if_fail (content != NULL);
181 _tmp0_ = g_strdup (content);
182 _g_free0 (self->priv->_content);
183 self->priv->_content = _tmp0_;
184 {
185 const gchar* _tmp1_;
186 gboolean _tmp2_ = FALSE;
187 _tmp1_ = self->priv->_content;
188 self->priv->_index = _tmp1_;
189 _tmp2_ = TRUE;
190 while (TRUE) {
191 gboolean _tmp5_ = FALSE;
192 gunichar c = 0U;
193 const gchar* _tmp7_;
194 if (!_tmp2_) {
195 const gchar* _tmp3_;
196 const gchar* _tmp4_;
197 _tmp3_ = self->priv->_index;
198 _tmp4_ = g_utf8_next_char (_tmp3_);
199 self->priv->_index = _tmp4_;
200 }
201 _tmp2_ = FALSE;
202 if (!self->priv->_stop) {
203 const gchar* _tmp6_;
204 _tmp6_ = self->priv->_index;
205 _tmp5_ = string_get_char (_tmp6_, (glong) 0) != ((gunichar) 0);
206 } else {
207 _tmp5_ = FALSE;
208 }
209 if (!_tmp5_) {
210 break;
211 }
212 _tmp7_ = self->priv->_index;
213 c = string_get_char (_tmp7_, (glong) 0);
214 valadoc_importer_valadoc_documentation_scanner_accept (self, c, &_inner_error0_);
215 if (G_UNLIKELY (_inner_error0_ != NULL)) {
216 if (_inner_error0_->domain == VALADOC_PARSER_ERROR) {
217 g_propagate_error (error, _inner_error0_);
218 return;
219 } else {
220 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);
221 g_clear_error (&_inner_error0_);
222 return;
223 }
224 }
225 }
226 }
227 }
228
229 static void
valadoc_importer_valadoc_documentation_scanner_real_end(ValadocScanner * base,GError ** error)230 valadoc_importer_valadoc_documentation_scanner_real_end (ValadocScanner* base,
231 GError** error)
232 {
233 ValadocImporterValadocDocumentationScanner * self;
234 ValadocTokenType* _tmp0_;
235 GError* _inner_error0_ = NULL;
236 self = (ValadocImporterValadocDocumentationScanner*) base;
237 _tmp0_ = valadoc_token_type_EOF;
238 valadoc_importer_valadoc_documentation_scanner_emit_token (self, _tmp0_, &_inner_error0_);
239 if (G_UNLIKELY (_inner_error0_ != NULL)) {
240 if (_inner_error0_->domain == VALADOC_PARSER_ERROR) {
241 g_propagate_error (error, _inner_error0_);
242 return;
243 } else {
244 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);
245 g_clear_error (&_inner_error0_);
246 return;
247 }
248 }
249 }
250
251 static void
valadoc_importer_valadoc_documentation_scanner_real_stop(ValadocImporterValadocDocumentationScanner * self)252 valadoc_importer_valadoc_documentation_scanner_real_stop (ValadocImporterValadocDocumentationScanner* self)
253 {
254 self->priv->_stop = TRUE;
255 }
256
257 void
valadoc_importer_valadoc_documentation_scanner_stop(ValadocImporterValadocDocumentationScanner * self)258 valadoc_importer_valadoc_documentation_scanner_stop (ValadocImporterValadocDocumentationScanner* self)
259 {
260 g_return_if_fail (self != NULL);
261 VALADOC_IMPORTER_VALADOC_DOCUMENTATION_SCANNER_GET_CLASS (self)->stop (self);
262 }
263
264 gint
valadoc_importer_valadoc_documentation_scanner_get_line(ValadocImporterValadocDocumentationScanner * self)265 valadoc_importer_valadoc_documentation_scanner_get_line (ValadocImporterValadocDocumentationScanner* self)
266 {
267 gint result = 0;
268 g_return_val_if_fail (self != NULL, 0);
269 result = self->priv->_line;
270 return result;
271 }
272
273 static gchar*
valadoc_importer_valadoc_documentation_scanner_real_get_line_content(ValadocImporterValadocDocumentationScanner * self)274 valadoc_importer_valadoc_documentation_scanner_real_get_line_content (ValadocImporterValadocDocumentationScanner* self)
275 {
276 GString* builder = NULL;
277 GString* _tmp0_;
278 const gchar* line_start = NULL;
279 const gchar* _tmp1_;
280 gunichar c = 0U;
281 GString* _tmp15_;
282 const gchar* _tmp16_;
283 gchar* _tmp17_;
284 gchar* result = NULL;
285 _tmp0_ = g_string_new ("");
286 builder = _tmp0_;
287 _tmp1_ = self->priv->_index;
288 line_start = _tmp1_;
289 while (TRUE) {
290 gboolean _tmp2_ = FALSE;
291 const gchar* _tmp3_;
292 const gchar* _tmp4_;
293 const gchar* _tmp7_;
294 const gchar* _tmp8_;
295 _tmp3_ = line_start;
296 _tmp4_ = self->priv->_content;
297 if (((gchar*) _tmp3_) > ((gchar*) _tmp4_)) {
298 const gchar* _tmp5_;
299 const gchar* _tmp6_;
300 _tmp5_ = line_start;
301 _tmp6_ = g_utf8_prev_char (_tmp5_);
302 _tmp2_ = string_get_char (_tmp6_, (glong) 0) != ((gunichar) '\n');
303 } else {
304 _tmp2_ = FALSE;
305 }
306 if (!_tmp2_) {
307 break;
308 }
309 _tmp7_ = line_start;
310 _tmp8_ = g_utf8_prev_char (_tmp7_);
311 line_start = _tmp8_;
312 }
313 while (TRUE) {
314 gboolean _tmp9_ = FALSE;
315 const gchar* _tmp10_;
316 const gchar* _tmp13_;
317 const gchar* _tmp14_;
318 _tmp10_ = line_start;
319 c = string_get_char (_tmp10_, (glong) 0);
320 if (c != ((gunichar) '\n')) {
321 _tmp9_ = c != ((gunichar) '\0');
322 } else {
323 _tmp9_ = FALSE;
324 }
325 if (!_tmp9_) {
326 break;
327 }
328 if (c == ((gunichar) '\t')) {
329 GString* _tmp11_;
330 _tmp11_ = builder;
331 g_string_append_c (_tmp11_, ' ');
332 } else {
333 GString* _tmp12_;
334 _tmp12_ = builder;
335 g_string_append_unichar (_tmp12_, c);
336 }
337 _tmp13_ = line_start;
338 _tmp14_ = g_utf8_next_char (_tmp13_);
339 line_start = _tmp14_;
340 }
341 _tmp15_ = builder;
342 _tmp16_ = _tmp15_->str;
343 _tmp17_ = g_strdup (_tmp16_);
344 result = _tmp17_;
345 _g_string_free0 (builder);
346 return result;
347 }
348
349 gchar*
valadoc_importer_valadoc_documentation_scanner_get_line_content(ValadocImporterValadocDocumentationScanner * self)350 valadoc_importer_valadoc_documentation_scanner_get_line_content (ValadocImporterValadocDocumentationScanner* self)
351 {
352 g_return_val_if_fail (self != NULL, NULL);
353 return VALADOC_IMPORTER_VALADOC_DOCUMENTATION_SCANNER_GET_CLASS (self)->get_line_content (self);
354 }
355
356 static gint
string_index_of_nth_char(const gchar * self,glong c)357 string_index_of_nth_char (const gchar* self,
358 glong c)
359 {
360 gchar* _tmp0_;
361 gint result = 0;
362 g_return_val_if_fail (self != NULL, 0);
363 _tmp0_ = g_utf8_offset_to_pointer (self, c);
364 result = (gint) (_tmp0_ - ((gchar*) self));
365 return result;
366 }
367
368 gunichar
valadoc_importer_valadoc_documentation_scanner_get_next_char(ValadocImporterValadocDocumentationScanner * self,gint offset)369 valadoc_importer_valadoc_documentation_scanner_get_next_char (ValadocImporterValadocDocumentationScanner* self,
370 gint offset)
371 {
372 const gchar* _tmp0_;
373 const gchar* _tmp1_;
374 gunichar result = 0U;
375 g_return_val_if_fail (self != NULL, 0U);
376 _tmp0_ = self->priv->_index;
377 _tmp1_ = self->priv->_index;
378 result = string_get_char (_tmp0_, (glong) string_index_of_nth_char (_tmp1_, (glong) offset));
379 return result;
380 }
381
382 void
valadoc_importer_valadoc_documentation_scanner_accept(ValadocImporterValadocDocumentationScanner * self,gunichar c,GError ** error)383 valadoc_importer_valadoc_documentation_scanner_accept (ValadocImporterValadocDocumentationScanner* self,
384 gunichar c,
385 GError** error)
386 {
387 gint _tmp0_;
388 GError* _inner_error0_ = NULL;
389 g_return_if_fail (self != NULL);
390 _tmp0_ = self->priv->_column;
391 self->priv->_column = _tmp0_ + 1;
392 if (self->priv->_skip == 0) {
393 switch (c) {
394 case '/':
395 {
396 if (valadoc_importer_valadoc_documentation_scanner_get_next_char (self, 1) == ((gunichar) '*')) {
397 ValadocTokenType* _tmp1_;
398 _tmp1_ = valadoc_token_type_VALADOC_COMMENT_START;
399 valadoc_importer_valadoc_documentation_scanner_emit_token (self, _tmp1_, &_inner_error0_);
400 if (G_UNLIKELY (_inner_error0_ != NULL)) {
401 if (_inner_error0_->domain == VALADOC_PARSER_ERROR) {
402 g_propagate_error (error, _inner_error0_);
403 return;
404 } else {
405 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);
406 g_clear_error (&_inner_error0_);
407 return;
408 }
409 }
410 self->priv->_skip = 1;
411 } else {
412 valadoc_importer_valadoc_documentation_scanner_append_char (self, c);
413 }
414 break;
415 }
416 case '*':
417 {
418 if (valadoc_importer_valadoc_documentation_scanner_get_next_char (self, 1) == ((gunichar) '/')) {
419 ValadocTokenType* _tmp2_;
420 _tmp2_ = valadoc_token_type_VALADOC_COMMENT_END;
421 valadoc_importer_valadoc_documentation_scanner_emit_token (self, _tmp2_, &_inner_error0_);
422 if (G_UNLIKELY (_inner_error0_ != NULL)) {
423 if (_inner_error0_->domain == VALADOC_PARSER_ERROR) {
424 g_propagate_error (error, _inner_error0_);
425 return;
426 } else {
427 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);
428 g_clear_error (&_inner_error0_);
429 return;
430 }
431 }
432 self->priv->_skip = 1;
433 } else {
434 valadoc_importer_valadoc_documentation_scanner_append_char (self, c);
435 }
436 break;
437 }
438 case '\t':
439 {
440 ValadocTokenType* _tmp3_;
441 _tmp3_ = valadoc_token_type_VALADOC_TAB;
442 valadoc_importer_valadoc_documentation_scanner_emit_token (self, _tmp3_, &_inner_error0_);
443 if (G_UNLIKELY (_inner_error0_ != NULL)) {
444 if (_inner_error0_->domain == VALADOC_PARSER_ERROR) {
445 g_propagate_error (error, _inner_error0_);
446 return;
447 } else {
448 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);
449 g_clear_error (&_inner_error0_);
450 return;
451 }
452 }
453 break;
454 }
455 case ' ':
456 {
457 ValadocTokenType* _tmp4_;
458 _tmp4_ = valadoc_token_type_VALADOC_SPACE;
459 valadoc_importer_valadoc_documentation_scanner_emit_token (self, _tmp4_, &_inner_error0_);
460 if (G_UNLIKELY (_inner_error0_ != NULL)) {
461 if (_inner_error0_->domain == VALADOC_PARSER_ERROR) {
462 g_propagate_error (error, _inner_error0_);
463 return;
464 } else {
465 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);
466 g_clear_error (&_inner_error0_);
467 return;
468 }
469 }
470 break;
471 }
472 case '\n':
473 {
474 ValadocTokenType* _tmp5_;
475 gint _tmp6_;
476 _tmp5_ = valadoc_token_type_VALADOC_EOL;
477 valadoc_importer_valadoc_documentation_scanner_emit_token (self, _tmp5_, &_inner_error0_);
478 if (G_UNLIKELY (_inner_error0_ != NULL)) {
479 if (_inner_error0_->domain == VALADOC_PARSER_ERROR) {
480 g_propagate_error (error, _inner_error0_);
481 return;
482 } else {
483 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);
484 g_clear_error (&_inner_error0_);
485 return;
486 }
487 }
488 _tmp6_ = self->priv->_line;
489 self->priv->_line = _tmp6_ + 1;
490 self->priv->_column = 0;
491 self->priv->_last_column = 0;
492 break;
493 }
494 default:
495 {
496 valadoc_importer_valadoc_documentation_scanner_append_char (self, c);
497 break;
498 }
499 }
500 } else {
501 gint _tmp7_;
502 _tmp7_ = self->priv->_skip;
503 self->priv->_skip = _tmp7_ - 1;
504 }
505 self->priv->_last_char = c;
506 }
507
508 static void
valadoc_importer_valadoc_documentation_scanner_append_char(ValadocImporterValadocDocumentationScanner * self,gunichar c)509 valadoc_importer_valadoc_documentation_scanner_append_char (ValadocImporterValadocDocumentationScanner* self,
510 gunichar c)
511 {
512 GString* _tmp0_;
513 g_return_if_fail (self != NULL);
514 _tmp0_ = self->priv->_current_string;
515 g_string_append_unichar (_tmp0_, c);
516 }
517
518 static gint
valadoc_importer_valadoc_documentation_scanner_real_get_line_start_column(ValadocImporterValadocDocumentationScanner * self)519 valadoc_importer_valadoc_documentation_scanner_real_get_line_start_column (ValadocImporterValadocDocumentationScanner* self)
520 {
521 gint result = 0;
522 result = 0;
523 return result;
524 }
525
526 gint
valadoc_importer_valadoc_documentation_scanner_get_line_start_column(ValadocImporterValadocDocumentationScanner * self)527 valadoc_importer_valadoc_documentation_scanner_get_line_start_column (ValadocImporterValadocDocumentationScanner* self)
528 {
529 g_return_val_if_fail (self != NULL, 0);
530 return VALADOC_IMPORTER_VALADOC_DOCUMENTATION_SCANNER_GET_CLASS (self)->get_line_start_column (self);
531 }
532
533 static void
valadoc_importer_valadoc_documentation_scanner_get_begin(ValadocImporterValadocDocumentationScanner * self,ValaSourceLocation * result)534 valadoc_importer_valadoc_documentation_scanner_get_begin (ValadocImporterValadocDocumentationScanner* self,
535 ValaSourceLocation* result)
536 {
537 const gchar* _tmp0_;
538 ValaSourceLocation _tmp1_ = {0};
539 g_return_if_fail (self != NULL);
540 _tmp0_ = self->priv->_index;
541 vala_source_location_init (&_tmp1_, _tmp0_, self->priv->_last_line, valadoc_importer_valadoc_documentation_scanner_get_line_start_column (self) + self->priv->_last_column);
542 *result = _tmp1_;
543 return;
544 }
545
546 static void
valadoc_importer_valadoc_documentation_scanner_get_end(ValadocImporterValadocDocumentationScanner * self,gint offset,ValaSourceLocation * result)547 valadoc_importer_valadoc_documentation_scanner_get_end (ValadocImporterValadocDocumentationScanner* self,
548 gint offset,
549 ValaSourceLocation* result)
550 {
551 const gchar* _tmp0_;
552 ValaSourceLocation _tmp1_ = {0};
553 g_return_if_fail (self != NULL);
554 _tmp0_ = self->priv->_index;
555 vala_source_location_init (&_tmp1_, _tmp0_, self->priv->_line, (valadoc_importer_valadoc_documentation_scanner_get_line_start_column (self) + self->priv->_column) + offset);
556 *result = _tmp1_;
557 return;
558 }
559
560 static void
valadoc_importer_valadoc_documentation_scanner_emit_current_word(ValadocImporterValadocDocumentationScanner * self,GError ** error)561 valadoc_importer_valadoc_documentation_scanner_emit_current_word (ValadocImporterValadocDocumentationScanner* self,
562 GError** error)
563 {
564 GString* _tmp0_;
565 GError* _inner_error0_ = NULL;
566 g_return_if_fail (self != NULL);
567 _tmp0_ = self->priv->_current_string;
568 if (_tmp0_->len > ((gssize) 0)) {
569 ValadocParser* _tmp1_;
570 GString* _tmp2_;
571 const gchar* _tmp3_;
572 ValaSourceLocation _tmp4_ = {0};
573 ValaSourceLocation _tmp5_ = {0};
574 ValadocToken* _tmp6_;
575 ValadocToken* _tmp7_;
576 GString* _tmp8_;
577 _tmp1_ = self->priv->_parser;
578 _tmp2_ = self->priv->_current_string;
579 _tmp3_ = _tmp2_->str;
580 valadoc_importer_valadoc_documentation_scanner_get_begin (self, &_tmp4_);
581 valadoc_importer_valadoc_documentation_scanner_get_end (self, -1, &_tmp5_);
582 _tmp6_ = valadoc_token_new_from_word (_tmp3_, &_tmp4_, &_tmp5_);
583 _tmp7_ = _tmp6_;
584 valadoc_parser_accept_token (_tmp1_, _tmp7_, &_inner_error0_);
585 _g_object_unref0 (_tmp7_);
586 if (G_UNLIKELY (_inner_error0_ != NULL)) {
587 if (_inner_error0_->domain == VALADOC_PARSER_ERROR) {
588 g_propagate_error (error, _inner_error0_);
589 return;
590 } else {
591 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);
592 g_clear_error (&_inner_error0_);
593 return;
594 }
595 }
596 _tmp8_ = self->priv->_current_string;
597 g_string_erase (_tmp8_, (gssize) 0, (gssize) -1);
598 self->priv->_last_line = self->priv->_line;
599 self->priv->_last_column = self->priv->_column - 1;
600 }
601 }
602
603 static void
valadoc_importer_valadoc_documentation_scanner_emit_token(ValadocImporterValadocDocumentationScanner * self,ValadocTokenType * type,GError ** error)604 valadoc_importer_valadoc_documentation_scanner_emit_token (ValadocImporterValadocDocumentationScanner* self,
605 ValadocTokenType* type,
606 GError** error)
607 {
608 ValadocParser* _tmp0_;
609 ValaSourceLocation _tmp1_ = {0};
610 ValaSourceLocation _tmp2_ = {0};
611 ValadocToken* _tmp3_;
612 ValadocToken* _tmp4_;
613 GError* _inner_error0_ = NULL;
614 g_return_if_fail (self != NULL);
615 g_return_if_fail (type != NULL);
616 valadoc_importer_valadoc_documentation_scanner_emit_current_word (self, &_inner_error0_);
617 if (G_UNLIKELY (_inner_error0_ != NULL)) {
618 if (_inner_error0_->domain == VALADOC_PARSER_ERROR) {
619 g_propagate_error (error, _inner_error0_);
620 return;
621 } else {
622 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);
623 g_clear_error (&_inner_error0_);
624 return;
625 }
626 }
627 _tmp0_ = self->priv->_parser;
628 valadoc_importer_valadoc_documentation_scanner_get_begin (self, &_tmp1_);
629 valadoc_importer_valadoc_documentation_scanner_get_end (self, self->priv->_skip, &_tmp2_);
630 _tmp3_ = valadoc_token_new_from_type (type, &_tmp1_, &_tmp2_, NULL);
631 _tmp4_ = _tmp3_;
632 valadoc_parser_accept_token (_tmp0_, _tmp4_, &_inner_error0_);
633 _g_object_unref0 (_tmp4_);
634 if (G_UNLIKELY (_inner_error0_ != NULL)) {
635 if (_inner_error0_->domain == VALADOC_PARSER_ERROR) {
636 g_propagate_error (error, _inner_error0_);
637 return;
638 } else {
639 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);
640 g_clear_error (&_inner_error0_);
641 return;
642 }
643 }
644 self->priv->_last_line = self->priv->_line;
645 self->priv->_last_column = self->priv->_column;
646 }
647
648 static void
valadoc_importer_valadoc_documentation_scanner_class_init(ValadocImporterValadocDocumentationScannerClass * klass,gpointer klass_data)649 valadoc_importer_valadoc_documentation_scanner_class_init (ValadocImporterValadocDocumentationScannerClass * klass,
650 gpointer klass_data)
651 {
652 valadoc_importer_valadoc_documentation_scanner_parent_class = g_type_class_peek_parent (klass);
653 g_type_class_adjust_private_offset (klass, &ValadocImporterValadocDocumentationScanner_private_offset);
654 ((ValadocImporterValadocDocumentationScannerClass *) klass)->reset = (void (*) (ValadocImporterValadocDocumentationScanner*)) valadoc_importer_valadoc_documentation_scanner_real_reset;
655 ((ValadocImporterValadocDocumentationScannerClass *) klass)->stop = (void (*) (ValadocImporterValadocDocumentationScanner*)) valadoc_importer_valadoc_documentation_scanner_real_stop;
656 ((ValadocImporterValadocDocumentationScannerClass *) klass)->get_line_content = (gchar* (*) (ValadocImporterValadocDocumentationScanner*)) valadoc_importer_valadoc_documentation_scanner_real_get_line_content;
657 ((ValadocImporterValadocDocumentationScannerClass *) klass)->get_line_start_column = (gint (*) (ValadocImporterValadocDocumentationScanner*)) valadoc_importer_valadoc_documentation_scanner_real_get_line_start_column;
658 G_OBJECT_CLASS (klass)->finalize = valadoc_importer_valadoc_documentation_scanner_finalize;
659 }
660
661 static void
valadoc_importer_valadoc_documentation_scanner_valadoc_scanner_interface_init(ValadocScannerIface * iface,gpointer iface_data)662 valadoc_importer_valadoc_documentation_scanner_valadoc_scanner_interface_init (ValadocScannerIface * iface,
663 gpointer iface_data)
664 {
665 valadoc_importer_valadoc_documentation_scanner_valadoc_scanner_parent_iface = g_type_interface_peek_parent (iface);
666 iface->set_parser = (void (*) (ValadocScanner*, ValadocParser*)) valadoc_importer_valadoc_documentation_scanner_real_set_parser;
667 iface->reset = (void (*) (ValadocScanner*)) valadoc_importer_valadoc_documentation_scanner_reset;
668 iface->scan = (void (*) (ValadocScanner*, const gchar*, GError**)) valadoc_importer_valadoc_documentation_scanner_real_scan;
669 iface->end = (void (*) (ValadocScanner*, GError**)) valadoc_importer_valadoc_documentation_scanner_real_end;
670 iface->stop = (void (*) (ValadocScanner*)) valadoc_importer_valadoc_documentation_scanner_stop;
671 iface->get_line_content = (gchar* (*) (ValadocScanner*)) valadoc_importer_valadoc_documentation_scanner_get_line_content;
672 }
673
674 static void
valadoc_importer_valadoc_documentation_scanner_instance_init(ValadocImporterValadocDocumentationScanner * self,gpointer klass)675 valadoc_importer_valadoc_documentation_scanner_instance_init (ValadocImporterValadocDocumentationScanner * self,
676 gpointer klass)
677 {
678 GString* _tmp0_;
679 self->priv = valadoc_importer_valadoc_documentation_scanner_get_instance_private (self);
680 _tmp0_ = g_string_new ("");
681 self->priv->_current_string = _tmp0_;
682 }
683
684 static void
valadoc_importer_valadoc_documentation_scanner_finalize(GObject * obj)685 valadoc_importer_valadoc_documentation_scanner_finalize (GObject * obj)
686 {
687 ValadocImporterValadocDocumentationScanner * self;
688 self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALADOC_IMPORTER_TYPE_VALADOC_DOCUMENTATION_SCANNER, ValadocImporterValadocDocumentationScanner);
689 _g_object_unref0 (self->priv->_settings);
690 _valadoc_parser_unref0 (self->priv->_parser);
691 _g_free0 (self->priv->_content);
692 _g_string_free0 (self->priv->_current_string);
693 G_OBJECT_CLASS (valadoc_importer_valadoc_documentation_scanner_parent_class)->finalize (obj);
694 }
695
696 static GType
valadoc_importer_valadoc_documentation_scanner_get_type_once(void)697 valadoc_importer_valadoc_documentation_scanner_get_type_once (void)
698 {
699 static const GTypeInfo g_define_type_info = { sizeof (ValadocImporterValadocDocumentationScannerClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) valadoc_importer_valadoc_documentation_scanner_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValadocImporterValadocDocumentationScanner), 0, (GInstanceInitFunc) valadoc_importer_valadoc_documentation_scanner_instance_init, NULL };
700 static const GInterfaceInfo valadoc_scanner_info = { (GInterfaceInitFunc) valadoc_importer_valadoc_documentation_scanner_valadoc_scanner_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
701 GType valadoc_importer_valadoc_documentation_scanner_type_id;
702 valadoc_importer_valadoc_documentation_scanner_type_id = g_type_register_static (G_TYPE_OBJECT, "ValadocImporterValadocDocumentationScanner", &g_define_type_info, 0);
703 g_type_add_interface_static (valadoc_importer_valadoc_documentation_scanner_type_id, VALADOC_TYPE_SCANNER, &valadoc_scanner_info);
704 ValadocImporterValadocDocumentationScanner_private_offset = g_type_add_instance_private (valadoc_importer_valadoc_documentation_scanner_type_id, sizeof (ValadocImporterValadocDocumentationScannerPrivate));
705 return valadoc_importer_valadoc_documentation_scanner_type_id;
706 }
707
708 GType
valadoc_importer_valadoc_documentation_scanner_get_type(void)709 valadoc_importer_valadoc_documentation_scanner_get_type (void)
710 {
711 static volatile gsize valadoc_importer_valadoc_documentation_scanner_type_id__volatile = 0;
712 if (g_once_init_enter (&valadoc_importer_valadoc_documentation_scanner_type_id__volatile)) {
713 GType valadoc_importer_valadoc_documentation_scanner_type_id;
714 valadoc_importer_valadoc_documentation_scanner_type_id = valadoc_importer_valadoc_documentation_scanner_get_type_once ();
715 g_once_init_leave (&valadoc_importer_valadoc_documentation_scanner_type_id__volatile, valadoc_importer_valadoc_documentation_scanner_type_id);
716 }
717 return valadoc_importer_valadoc_documentation_scanner_type_id__volatile;
718 }
719
720