1 /* valamarkupreader.c generated by valac, the Vala compiler
2 * generated from valamarkupreader.vala, do not modify */
3
4 /* valamarkupreader.vala
5 *
6 * Copyright (C) 2008-2009 Jürg Billeter
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 * Jürg Billeter <j@bitron.ch>
24 */
25
26 #include "vala.h"
27 #include <stdlib.h>
28 #include <string.h>
29 #include <glib.h>
30 #include <valagee.h>
31 #include <glib-object.h>
32 #include <gobject/gvaluecollector.h>
33
34 #define _g_free0(var) (var = (g_free (var), NULL))
35 #define _g_mapped_file_unref0(var) ((var == NULL) ? NULL : (var = (g_mapped_file_unref (var), NULL)))
36 #define _vala_map_unref0(var) ((var == NULL) ? NULL : (var = (vala_map_unref (var), NULL)))
37 #define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
38 #define _vala_iterable_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterable_unref (var), NULL)))
39 #define _vala_iterator_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterator_unref (var), NULL)))
40 #define _g_string_free0(var) ((var == NULL) ? NULL : (var = (g_string_free (var, TRUE), NULL)))
41 typedef struct _ValaParamSpecMarkupReader ValaParamSpecMarkupReader;
42
43 struct _ValaMarkupReaderPrivate {
44 gchar* _filename;
45 gchar* _name;
46 gchar* _content;
47 GMappedFile* mapped_file;
48 gchar* begin;
49 gchar* current;
50 gchar* end;
51 gint line;
52 gint column;
53 ValaMap* attributes;
54 gboolean empty_element;
55 };
56
57 struct _ValaParamSpecMarkupReader {
58 GParamSpec parent_instance;
59 };
60
61 static gint ValaMarkupReader_private_offset;
62 static gpointer vala_markup_reader_parent_class = NULL;
63
64 static void vala_markup_reader_set_filename (ValaMarkupReader* self,
65 const gchar* value);
66 static void vala_markup_reader_set_name (ValaMarkupReader* self,
67 const gchar* value);
68 static void vala_markup_reader_set_content (ValaMarkupReader* self,
69 const gchar* value);
70 static gchar* vala_markup_reader_read_name (ValaMarkupReader* self);
71 static void vala_markup_reader_space (ValaMarkupReader* self);
72 static gchar* vala_markup_reader_text (ValaMarkupReader* self,
73 gchar end_char,
74 gboolean rm_trailing_whitespace);
75 static void vala_markup_reader_finalize (ValaMarkupReader * obj);
76 static GType vala_markup_reader_get_type_once (void);
77
78 static inline gpointer
vala_markup_reader_get_instance_private(ValaMarkupReader * self)79 vala_markup_reader_get_instance_private (ValaMarkupReader* self)
80 {
81 return G_STRUCT_MEMBER_P (self, ValaMarkupReader_private_offset);
82 }
83
84 const gchar*
vala_markup_reader_get_filename(ValaMarkupReader * self)85 vala_markup_reader_get_filename (ValaMarkupReader* self)
86 {
87 const gchar* result;
88 const gchar* _tmp0_;
89 g_return_val_if_fail (self != NULL, NULL);
90 _tmp0_ = self->priv->_filename;
91 result = _tmp0_;
92 return result;
93 }
94
95 static void
vala_markup_reader_set_filename(ValaMarkupReader * self,const gchar * value)96 vala_markup_reader_set_filename (ValaMarkupReader* self,
97 const gchar* value)
98 {
99 gchar* _tmp0_;
100 g_return_if_fail (self != NULL);
101 _tmp0_ = g_strdup (value);
102 _g_free0 (self->priv->_filename);
103 self->priv->_filename = _tmp0_;
104 }
105
106 const gchar*
vala_markup_reader_get_name(ValaMarkupReader * self)107 vala_markup_reader_get_name (ValaMarkupReader* self)
108 {
109 const gchar* result;
110 const gchar* _tmp0_;
111 g_return_val_if_fail (self != NULL, NULL);
112 _tmp0_ = self->priv->_name;
113 result = _tmp0_;
114 return result;
115 }
116
117 static void
vala_markup_reader_set_name(ValaMarkupReader * self,const gchar * value)118 vala_markup_reader_set_name (ValaMarkupReader* self,
119 const gchar* value)
120 {
121 gchar* _tmp0_;
122 g_return_if_fail (self != NULL);
123 _tmp0_ = g_strdup (value);
124 _g_free0 (self->priv->_name);
125 self->priv->_name = _tmp0_;
126 }
127
128 const gchar*
vala_markup_reader_get_content(ValaMarkupReader * self)129 vala_markup_reader_get_content (ValaMarkupReader* self)
130 {
131 const gchar* result;
132 const gchar* _tmp0_;
133 g_return_val_if_fail (self != NULL, NULL);
134 _tmp0_ = self->priv->_content;
135 result = _tmp0_;
136 return result;
137 }
138
139 static void
vala_markup_reader_set_content(ValaMarkupReader * self,const gchar * value)140 vala_markup_reader_set_content (ValaMarkupReader* self,
141 const gchar* value)
142 {
143 gchar* _tmp0_;
144 g_return_if_fail (self != NULL);
145 _tmp0_ = g_strdup (value);
146 _g_free0 (self->priv->_content);
147 self->priv->_content = _tmp0_;
148 }
149
150 ValaMarkupReader*
vala_markup_reader_construct(GType object_type,const gchar * filename)151 vala_markup_reader_construct (GType object_type,
152 const gchar* filename)
153 {
154 ValaMarkupReader* self = NULL;
155 GError* _inner_error0_ = NULL;
156 g_return_val_if_fail (filename != NULL, NULL);
157 self = (ValaMarkupReader*) g_type_create_instance (object_type);
158 vala_markup_reader_set_filename (self, filename);
159 {
160 GMappedFile* _tmp0_ = NULL;
161 GMappedFile* _tmp1_;
162 GMappedFile* _tmp2_;
163 GMappedFile* _tmp3_;
164 gchar* _tmp4_;
165 gchar* _tmp5_;
166 GMappedFile* _tmp6_;
167 gchar* _tmp7_;
168 _tmp1_ = g_mapped_file_new (filename, FALSE, &_inner_error0_);
169 _tmp0_ = _tmp1_;
170 if (G_UNLIKELY (_inner_error0_ != NULL)) {
171 if (_inner_error0_->domain == G_FILE_ERROR) {
172 goto __catch0_g_file_error;
173 }
174 g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
175 g_clear_error (&_inner_error0_);
176 return NULL;
177 }
178 _tmp2_ = _tmp0_;
179 _tmp0_ = NULL;
180 _g_mapped_file_unref0 (self->priv->mapped_file);
181 self->priv->mapped_file = _tmp2_;
182 _tmp3_ = self->priv->mapped_file;
183 _tmp4_ = g_mapped_file_get_contents (_tmp3_);
184 self->priv->begin = _tmp4_;
185 _tmp5_ = self->priv->begin;
186 _tmp6_ = self->priv->mapped_file;
187 self->priv->end = _tmp5_ + g_mapped_file_get_length (_tmp6_);
188 _tmp7_ = self->priv->begin;
189 self->priv->current = _tmp7_;
190 self->priv->line = 1;
191 self->priv->column = 1;
192 _g_mapped_file_unref0 (_tmp0_);
193 }
194 goto __finally0;
195 __catch0_g_file_error:
196 {
197 GError* e = NULL;
198 GError* _tmp8_;
199 const gchar* _tmp9_;
200 gchar* _tmp10_;
201 gchar* _tmp11_;
202 e = _inner_error0_;
203 _inner_error0_ = NULL;
204 _tmp8_ = e;
205 _tmp9_ = _tmp8_->message;
206 _tmp10_ = g_strdup_printf ("Unable to map file `%s': %s", filename, _tmp9_);
207 _tmp11_ = _tmp10_;
208 vala_report_error (NULL, _tmp11_);
209 _g_free0 (_tmp11_);
210 _g_error_free0 (e);
211 }
212 __finally0:
213 if (G_UNLIKELY (_inner_error0_ != NULL)) {
214 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);
215 g_clear_error (&_inner_error0_);
216 return NULL;
217 }
218 return self;
219 }
220
221 ValaMarkupReader*
vala_markup_reader_new(const gchar * filename)222 vala_markup_reader_new (const gchar* filename)
223 {
224 return vala_markup_reader_construct (VALA_TYPE_MARKUP_READER, filename);
225 }
226
227 ValaMarkupReader*
vala_markup_reader_construct_from_string(GType object_type,const gchar * filename,const gchar * content)228 vala_markup_reader_construct_from_string (GType object_type,
229 const gchar* filename,
230 const gchar* content)
231 {
232 ValaMarkupReader* self = NULL;
233 gchar* _tmp0_;
234 gint _tmp1_;
235 gint _tmp2_;
236 gchar* _tmp3_;
237 g_return_val_if_fail (filename != NULL, NULL);
238 g_return_val_if_fail (content != NULL, NULL);
239 self = (ValaMarkupReader*) g_type_create_instance (object_type);
240 vala_markup_reader_set_filename (self, filename);
241 self->priv->begin = content;
242 _tmp0_ = self->priv->begin;
243 _tmp1_ = strlen (content);
244 _tmp2_ = _tmp1_;
245 self->priv->end = _tmp0_ + _tmp2_;
246 _tmp3_ = self->priv->begin;
247 self->priv->current = _tmp3_;
248 self->priv->line = 1;
249 self->priv->column = 1;
250 return self;
251 }
252
253 ValaMarkupReader*
vala_markup_reader_new_from_string(const gchar * filename,const gchar * content)254 vala_markup_reader_new_from_string (const gchar* filename,
255 const gchar* content)
256 {
257 return vala_markup_reader_construct_from_string (VALA_TYPE_MARKUP_READER, filename, content);
258 }
259
260 gchar*
vala_markup_reader_get_attribute(ValaMarkupReader * self,const gchar * attr)261 vala_markup_reader_get_attribute (ValaMarkupReader* self,
262 const gchar* attr)
263 {
264 ValaMap* _tmp0_;
265 gpointer _tmp1_;
266 gchar* result = NULL;
267 g_return_val_if_fail (self != NULL, NULL);
268 g_return_val_if_fail (attr != NULL, NULL);
269 _tmp0_ = self->priv->attributes;
270 _tmp1_ = vala_map_get (_tmp0_, attr);
271 result = (gchar*) _tmp1_;
272 return result;
273 }
274
275 ValaMap*
vala_markup_reader_get_attributes(ValaMarkupReader * self)276 vala_markup_reader_get_attributes (ValaMarkupReader* self)
277 {
278 ValaHashMap* _result_ = NULL;
279 GHashFunc _tmp0_;
280 GEqualFunc _tmp1_;
281 GEqualFunc _tmp2_;
282 ValaHashMap* _tmp3_;
283 ValaMap* result = NULL;
284 g_return_val_if_fail (self != NULL, NULL);
285 _tmp0_ = g_str_hash;
286 _tmp1_ = g_str_equal;
287 _tmp2_ = g_direct_equal;
288 _tmp3_ = vala_hash_map_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, (GDestroyNotify) g_free, G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, (GDestroyNotify) g_free, _tmp0_, _tmp1_, _tmp2_);
289 _result_ = _tmp3_;
290 {
291 ValaIterator* _key_it = NULL;
292 ValaMap* _tmp4_;
293 ValaSet* _tmp5_;
294 ValaSet* _tmp6_;
295 ValaIterator* _tmp7_;
296 ValaIterator* _tmp8_;
297 _tmp4_ = self->priv->attributes;
298 _tmp5_ = vala_map_get_keys (_tmp4_);
299 _tmp6_ = _tmp5_;
300 _tmp7_ = vala_iterable_iterator ((ValaIterable*) _tmp6_);
301 _tmp8_ = _tmp7_;
302 _vala_iterable_unref0 (_tmp6_);
303 _key_it = _tmp8_;
304 while (TRUE) {
305 ValaIterator* _tmp9_;
306 gchar* key = NULL;
307 ValaIterator* _tmp10_;
308 gpointer _tmp11_;
309 ValaHashMap* _tmp12_;
310 const gchar* _tmp13_;
311 ValaMap* _tmp14_;
312 const gchar* _tmp15_;
313 gpointer _tmp16_;
314 gchar* _tmp17_;
315 _tmp9_ = _key_it;
316 if (!vala_iterator_next (_tmp9_)) {
317 break;
318 }
319 _tmp10_ = _key_it;
320 _tmp11_ = vala_iterator_get (_tmp10_);
321 key = (gchar*) _tmp11_;
322 _tmp12_ = _result_;
323 _tmp13_ = key;
324 _tmp14_ = self->priv->attributes;
325 _tmp15_ = key;
326 _tmp16_ = vala_map_get (_tmp14_, _tmp15_);
327 _tmp17_ = (gchar*) _tmp16_;
328 vala_map_set ((ValaMap*) _tmp12_, _tmp13_, _tmp17_);
329 _g_free0 (_tmp17_);
330 _g_free0 (key);
331 }
332 _vala_iterator_unref0 (_key_it);
333 }
334 result = (ValaMap*) _result_;
335 return result;
336 }
337
338 static glong
string_strnlen(gchar * str,glong maxlen)339 string_strnlen (gchar* str,
340 glong maxlen)
341 {
342 gchar* end = NULL;
343 gchar* _tmp0_;
344 gchar* _tmp1_;
345 glong result = 0L;
346 _tmp0_ = memchr (str, 0, (gsize) maxlen);
347 end = _tmp0_;
348 _tmp1_ = end;
349 if (_tmp1_ == NULL) {
350 result = maxlen;
351 return result;
352 } else {
353 gchar* _tmp2_;
354 _tmp2_ = end;
355 result = (glong) (_tmp2_ - str);
356 return result;
357 }
358 }
359
360 static gchar*
string_substring(const gchar * self,glong offset,glong len)361 string_substring (const gchar* self,
362 glong offset,
363 glong len)
364 {
365 glong string_length = 0L;
366 gboolean _tmp0_ = FALSE;
367 gchar* _tmp3_;
368 gchar* result = NULL;
369 g_return_val_if_fail (self != NULL, NULL);
370 if (offset >= ((glong) 0)) {
371 _tmp0_ = len >= ((glong) 0);
372 } else {
373 _tmp0_ = FALSE;
374 }
375 if (_tmp0_) {
376 string_length = string_strnlen ((gchar*) self, offset + len);
377 } else {
378 gint _tmp1_;
379 gint _tmp2_;
380 _tmp1_ = strlen (self);
381 _tmp2_ = _tmp1_;
382 string_length = (glong) _tmp2_;
383 }
384 if (offset < ((glong) 0)) {
385 offset = string_length + offset;
386 g_return_val_if_fail (offset >= ((glong) 0), NULL);
387 } else {
388 g_return_val_if_fail (offset <= string_length, NULL);
389 }
390 if (len < ((glong) 0)) {
391 len = string_length - offset;
392 }
393 g_return_val_if_fail ((offset + len) <= string_length, NULL);
394 _tmp3_ = g_strndup (((gchar*) self) + offset, (gsize) len);
395 result = _tmp3_;
396 return result;
397 }
398
399 static gchar*
vala_markup_reader_read_name(ValaMarkupReader * self)400 vala_markup_reader_read_name (ValaMarkupReader* self)
401 {
402 gchar* begin = NULL;
403 gchar* _tmp0_;
404 gchar* _tmp24_;
405 gchar* _tmp25_;
406 gchar* _tmp26_;
407 gchar* _tmp27_;
408 gchar* _tmp28_;
409 gchar* _tmp29_;
410 gchar* result = NULL;
411 g_return_val_if_fail (self != NULL, NULL);
412 _tmp0_ = self->priv->current;
413 begin = _tmp0_;
414 while (TRUE) {
415 gchar* _tmp1_;
416 gchar* _tmp2_;
417 gboolean _tmp3_ = FALSE;
418 gboolean _tmp4_ = FALSE;
419 gboolean _tmp5_ = FALSE;
420 gboolean _tmp6_ = FALSE;
421 gboolean _tmp7_ = FALSE;
422 gchar* _tmp8_;
423 gchar _tmp9_;
424 gunichar u = 0U;
425 gchar* _tmp20_;
426 gchar* _tmp21_;
427 gchar* _tmp22_;
428 _tmp1_ = self->priv->current;
429 _tmp2_ = self->priv->end;
430 if (!(_tmp1_ < _tmp2_)) {
431 break;
432 }
433 _tmp8_ = self->priv->current;
434 _tmp9_ = _tmp8_[0];
435 if (_tmp9_ == ' ') {
436 _tmp7_ = TRUE;
437 } else {
438 gchar* _tmp10_;
439 gchar _tmp11_;
440 _tmp10_ = self->priv->current;
441 _tmp11_ = _tmp10_[0];
442 _tmp7_ = _tmp11_ == '\t';
443 }
444 if (_tmp7_) {
445 _tmp6_ = TRUE;
446 } else {
447 gchar* _tmp12_;
448 gchar _tmp13_;
449 _tmp12_ = self->priv->current;
450 _tmp13_ = _tmp12_[0];
451 _tmp6_ = _tmp13_ == '>';
452 }
453 if (_tmp6_) {
454 _tmp5_ = TRUE;
455 } else {
456 gchar* _tmp14_;
457 gchar _tmp15_;
458 _tmp14_ = self->priv->current;
459 _tmp15_ = _tmp14_[0];
460 _tmp5_ = _tmp15_ == '/';
461 }
462 if (_tmp5_) {
463 _tmp4_ = TRUE;
464 } else {
465 gchar* _tmp16_;
466 gchar _tmp17_;
467 _tmp16_ = self->priv->current;
468 _tmp17_ = _tmp16_[0];
469 _tmp4_ = _tmp17_ == '=';
470 }
471 if (_tmp4_) {
472 _tmp3_ = TRUE;
473 } else {
474 gchar* _tmp18_;
475 gchar _tmp19_;
476 _tmp18_ = self->priv->current;
477 _tmp19_ = _tmp18_[0];
478 _tmp3_ = _tmp19_ == '\n';
479 }
480 if (_tmp3_) {
481 break;
482 }
483 _tmp20_ = self->priv->current;
484 _tmp21_ = self->priv->end;
485 _tmp22_ = self->priv->current;
486 u = g_utf8_get_char_validated ((const gchar*) _tmp20_, (gssize) ((glong) (_tmp21_ - _tmp22_)));
487 if (u != ((gunichar) -1)) {
488 gchar* _tmp23_;
489 _tmp23_ = self->priv->current;
490 self->priv->current = _tmp23_ + g_unichar_to_utf8 (u, NULL);
491 } else {
492 vala_report_error (NULL, "invalid UTF-8 character");
493 }
494 }
495 _tmp24_ = self->priv->current;
496 _tmp25_ = begin;
497 if (_tmp24_ == _tmp25_) {
498 }
499 _tmp26_ = begin;
500 _tmp27_ = self->priv->current;
501 _tmp28_ = begin;
502 _tmp29_ = string_substring ((const gchar*) _tmp26_, (glong) 0, (glong) ((gint) (_tmp27_ - _tmp28_)));
503 result = _tmp29_;
504 return result;
505 }
506
507 ValaMarkupTokenType
vala_markup_reader_read_token(ValaMarkupReader * self,ValaSourceLocation * token_begin,ValaSourceLocation * token_end)508 vala_markup_reader_read_token (ValaMarkupReader* self,
509 ValaSourceLocation* token_begin,
510 ValaSourceLocation* token_end)
511 {
512 ValaSourceLocation _vala_token_begin = {0};
513 ValaSourceLocation _vala_token_end = {0};
514 ValaMap* _tmp0_;
515 ValaMarkupTokenType type = 0;
516 gchar* begin = NULL;
517 gchar* _tmp3_;
518 gchar* _tmp4_;
519 gchar* _tmp5_;
520 gchar* _tmp6_;
521 gchar* _tmp109_;
522 ValaMarkupTokenType result = 0;
523 g_return_val_if_fail (self != NULL, 0);
524 _tmp0_ = self->priv->attributes;
525 vala_map_clear (_tmp0_);
526 if (self->priv->empty_element) {
527 gchar* _tmp1_;
528 gchar* _tmp2_;
529 self->priv->empty_element = FALSE;
530 _tmp1_ = self->priv->begin;
531 vala_source_location_init (&_vala_token_begin, _tmp1_, self->priv->line, self->priv->column);
532 _tmp2_ = self->priv->begin;
533 vala_source_location_init (&_vala_token_end, _tmp2_, self->priv->line, self->priv->column);
534 result = VALA_MARKUP_TOKEN_TYPE_END_ELEMENT;
535 if (token_begin) {
536 *token_begin = _vala_token_begin;
537 }
538 if (token_end) {
539 *token_end = _vala_token_end;
540 }
541 return result;
542 }
543 vala_markup_reader_set_content (self, NULL);
544 vala_markup_reader_set_name (self, NULL);
545 vala_markup_reader_space (self);
546 type = VALA_MARKUP_TOKEN_TYPE_NONE;
547 _tmp3_ = self->priv->current;
548 begin = _tmp3_;
549 _tmp4_ = begin;
550 vala_source_location_init (&_vala_token_begin, _tmp4_, self->priv->line, self->priv->column);
551 _tmp5_ = self->priv->current;
552 _tmp6_ = self->priv->end;
553 if (_tmp5_ >= _tmp6_) {
554 type = VALA_MARKUP_TOKEN_TYPE_EOF;
555 } else {
556 gchar* _tmp7_;
557 gchar _tmp8_;
558 _tmp7_ = self->priv->current;
559 _tmp8_ = _tmp7_[0];
560 if (_tmp8_ == '<') {
561 gchar* _tmp9_;
562 gchar* _tmp10_;
563 gchar* _tmp11_;
564 _tmp9_ = self->priv->current;
565 self->priv->current = _tmp9_ + 1;
566 _tmp10_ = self->priv->current;
567 _tmp11_ = self->priv->end;
568 if (_tmp10_ >= _tmp11_) {
569 } else {
570 gchar* _tmp12_;
571 gchar _tmp13_;
572 _tmp12_ = self->priv->current;
573 _tmp13_ = _tmp12_[0];
574 if (_tmp13_ == '?') {
575 } else {
576 gchar* _tmp14_;
577 gchar _tmp15_;
578 _tmp14_ = self->priv->current;
579 _tmp15_ = _tmp14_[0];
580 if (_tmp15_ == '!') {
581 gchar* _tmp16_;
582 gboolean _tmp17_ = FALSE;
583 gboolean _tmp18_ = FALSE;
584 gchar* _tmp19_;
585 gchar* _tmp20_;
586 _tmp16_ = self->priv->current;
587 self->priv->current = _tmp16_ + 1;
588 _tmp19_ = self->priv->current;
589 _tmp20_ = self->priv->end;
590 if (_tmp19_ < (_tmp20_ - 1)) {
591 gchar* _tmp21_;
592 gchar _tmp22_;
593 _tmp21_ = self->priv->current;
594 _tmp22_ = _tmp21_[0];
595 _tmp18_ = _tmp22_ == '-';
596 } else {
597 _tmp18_ = FALSE;
598 }
599 if (_tmp18_) {
600 gchar* _tmp23_;
601 gchar _tmp24_;
602 _tmp23_ = self->priv->current;
603 _tmp24_ = _tmp23_[1];
604 _tmp17_ = _tmp24_ == '-';
605 } else {
606 _tmp17_ = FALSE;
607 }
608 if (_tmp17_) {
609 gchar* _tmp25_;
610 ValaSourceLocation _tmp41_ = {0};
611 ValaSourceLocation _tmp42_ = {0};
612 ValaMarkupTokenType _tmp43_;
613 _tmp25_ = self->priv->current;
614 self->priv->current = _tmp25_ + 2;
615 while (TRUE) {
616 gchar* _tmp26_;
617 gchar* _tmp27_;
618 gboolean _tmp28_ = FALSE;
619 gboolean _tmp29_ = FALSE;
620 gchar* _tmp30_;
621 gchar _tmp31_;
622 gchar* _tmp40_;
623 _tmp26_ = self->priv->current;
624 _tmp27_ = self->priv->end;
625 if (!(_tmp26_ < (_tmp27_ - 2))) {
626 break;
627 }
628 _tmp30_ = self->priv->current;
629 _tmp31_ = _tmp30_[0];
630 if (_tmp31_ == '-') {
631 gchar* _tmp32_;
632 gchar _tmp33_;
633 _tmp32_ = self->priv->current;
634 _tmp33_ = _tmp32_[1];
635 _tmp29_ = _tmp33_ == '-';
636 } else {
637 _tmp29_ = FALSE;
638 }
639 if (_tmp29_) {
640 gchar* _tmp34_;
641 gchar _tmp35_;
642 _tmp34_ = self->priv->current;
643 _tmp35_ = _tmp34_[2];
644 _tmp28_ = _tmp35_ == '>';
645 } else {
646 _tmp28_ = FALSE;
647 }
648 if (_tmp28_) {
649 gchar* _tmp36_;
650 _tmp36_ = self->priv->current;
651 self->priv->current = _tmp36_ + 3;
652 break;
653 } else {
654 gchar* _tmp37_;
655 gchar _tmp38_;
656 _tmp37_ = self->priv->current;
657 _tmp38_ = _tmp37_[0];
658 if (_tmp38_ == '\n') {
659 gint _tmp39_;
660 _tmp39_ = self->priv->line;
661 self->priv->line = _tmp39_ + 1;
662 self->priv->column = 0;
663 }
664 }
665 _tmp40_ = self->priv->current;
666 self->priv->current = _tmp40_ + 1;
667 }
668 _tmp43_ = vala_markup_reader_read_token (self, &_tmp41_, &_tmp42_);
669 _vala_token_begin = _tmp41_;
670 _vala_token_end = _tmp42_;
671 result = _tmp43_;
672 if (token_begin) {
673 *token_begin = _vala_token_begin;
674 }
675 if (token_end) {
676 *token_end = _vala_token_end;
677 }
678 return result;
679 }
680 } else {
681 gchar* _tmp44_;
682 gchar _tmp45_;
683 _tmp44_ = self->priv->current;
684 _tmp45_ = _tmp44_[0];
685 if (_tmp45_ == '/') {
686 gchar* _tmp46_;
687 gchar* _tmp47_;
688 gchar* _tmp48_;
689 gboolean _tmp49_ = FALSE;
690 gchar* _tmp50_;
691 gchar* _tmp51_;
692 gchar* _tmp54_;
693 type = VALA_MARKUP_TOKEN_TYPE_END_ELEMENT;
694 _tmp46_ = self->priv->current;
695 self->priv->current = _tmp46_ + 1;
696 _tmp47_ = vala_markup_reader_read_name (self);
697 _tmp48_ = _tmp47_;
698 vala_markup_reader_set_name (self, _tmp48_);
699 _g_free0 (_tmp48_);
700 _tmp50_ = self->priv->current;
701 _tmp51_ = self->priv->end;
702 if (_tmp50_ >= _tmp51_) {
703 _tmp49_ = TRUE;
704 } else {
705 gchar* _tmp52_;
706 gchar _tmp53_;
707 _tmp52_ = self->priv->current;
708 _tmp53_ = _tmp52_[0];
709 _tmp49_ = _tmp53_ != '>';
710 }
711 if (_tmp49_) {
712 }
713 _tmp54_ = self->priv->current;
714 self->priv->current = _tmp54_ + 1;
715 } else {
716 gchar* _tmp55_;
717 gchar* _tmp56_;
718 gchar* _tmp93_;
719 gchar _tmp94_;
720 gboolean _tmp96_ = FALSE;
721 gchar* _tmp97_;
722 gchar* _tmp98_;
723 gchar* _tmp101_;
724 type = VALA_MARKUP_TOKEN_TYPE_START_ELEMENT;
725 _tmp55_ = vala_markup_reader_read_name (self);
726 _tmp56_ = _tmp55_;
727 vala_markup_reader_set_name (self, _tmp56_);
728 _g_free0 (_tmp56_);
729 vala_markup_reader_space (self);
730 while (TRUE) {
731 gboolean _tmp57_ = FALSE;
732 gboolean _tmp58_ = FALSE;
733 gchar* _tmp59_;
734 gchar* _tmp60_;
735 gchar* attr_name = NULL;
736 gchar* _tmp65_;
737 gboolean _tmp66_ = FALSE;
738 gchar* _tmp67_;
739 gchar* _tmp68_;
740 gchar* _tmp71_;
741 gboolean _tmp72_ = FALSE;
742 gboolean _tmp73_ = FALSE;
743 gchar* _tmp74_;
744 gchar* _tmp75_;
745 gchar quote = '\0';
746 gchar* _tmp80_;
747 gchar _tmp81_;
748 gchar* _tmp82_;
749 gchar* attr_value = NULL;
750 gchar* _tmp83_;
751 gboolean _tmp84_ = FALSE;
752 gchar* _tmp85_;
753 gchar* _tmp86_;
754 gchar* _tmp89_;
755 ValaMap* _tmp90_;
756 const gchar* _tmp91_;
757 const gchar* _tmp92_;
758 _tmp59_ = self->priv->current;
759 _tmp60_ = self->priv->end;
760 if (_tmp59_ < _tmp60_) {
761 gchar* _tmp61_;
762 gchar _tmp62_;
763 _tmp61_ = self->priv->current;
764 _tmp62_ = _tmp61_[0];
765 _tmp58_ = _tmp62_ != '>';
766 } else {
767 _tmp58_ = FALSE;
768 }
769 if (_tmp58_) {
770 gchar* _tmp63_;
771 gchar _tmp64_;
772 _tmp63_ = self->priv->current;
773 _tmp64_ = _tmp63_[0];
774 _tmp57_ = _tmp64_ != '/';
775 } else {
776 _tmp57_ = FALSE;
777 }
778 if (!_tmp57_) {
779 break;
780 }
781 _tmp65_ = vala_markup_reader_read_name (self);
782 attr_name = _tmp65_;
783 vala_markup_reader_space (self);
784 _tmp67_ = self->priv->current;
785 _tmp68_ = self->priv->end;
786 if (_tmp67_ >= _tmp68_) {
787 _tmp66_ = TRUE;
788 } else {
789 gchar* _tmp69_;
790 gchar _tmp70_;
791 _tmp69_ = self->priv->current;
792 _tmp70_ = _tmp69_[0];
793 _tmp66_ = _tmp70_ != '=';
794 }
795 if (_tmp66_) {
796 }
797 _tmp71_ = self->priv->current;
798 self->priv->current = _tmp71_ + 1;
799 vala_markup_reader_space (self);
800 _tmp74_ = self->priv->current;
801 _tmp75_ = self->priv->end;
802 if (_tmp74_ >= _tmp75_) {
803 _tmp73_ = TRUE;
804 } else {
805 gchar* _tmp76_;
806 gchar _tmp77_;
807 _tmp76_ = self->priv->current;
808 _tmp77_ = _tmp76_[0];
809 _tmp73_ = _tmp77_ != '"';
810 }
811 if (_tmp73_) {
812 _tmp72_ = TRUE;
813 } else {
814 gchar* _tmp78_;
815 gchar _tmp79_;
816 _tmp78_ = self->priv->current;
817 _tmp79_ = _tmp78_[0];
818 _tmp72_ = _tmp79_ != '\'';
819 }
820 if (_tmp72_) {
821 }
822 _tmp80_ = self->priv->current;
823 _tmp81_ = _tmp80_[0];
824 quote = _tmp81_;
825 _tmp82_ = self->priv->current;
826 self->priv->current = _tmp82_ + 1;
827 _tmp83_ = vala_markup_reader_text (self, quote, FALSE);
828 attr_value = _tmp83_;
829 _tmp85_ = self->priv->current;
830 _tmp86_ = self->priv->end;
831 if (_tmp85_ >= _tmp86_) {
832 _tmp84_ = TRUE;
833 } else {
834 gchar* _tmp87_;
835 gchar _tmp88_;
836 _tmp87_ = self->priv->current;
837 _tmp88_ = _tmp87_[0];
838 _tmp84_ = _tmp88_ != quote;
839 }
840 if (_tmp84_) {
841 }
842 _tmp89_ = self->priv->current;
843 self->priv->current = _tmp89_ + 1;
844 _tmp90_ = self->priv->attributes;
845 _tmp91_ = attr_name;
846 _tmp92_ = attr_value;
847 vala_map_set (_tmp90_, _tmp91_, _tmp92_);
848 vala_markup_reader_space (self);
849 _g_free0 (attr_value);
850 _g_free0 (attr_name);
851 }
852 _tmp93_ = self->priv->current;
853 _tmp94_ = _tmp93_[0];
854 if (_tmp94_ == '/') {
855 gchar* _tmp95_;
856 self->priv->empty_element = TRUE;
857 _tmp95_ = self->priv->current;
858 self->priv->current = _tmp95_ + 1;
859 vala_markup_reader_space (self);
860 } else {
861 self->priv->empty_element = FALSE;
862 }
863 _tmp97_ = self->priv->current;
864 _tmp98_ = self->priv->end;
865 if (_tmp97_ >= _tmp98_) {
866 _tmp96_ = TRUE;
867 } else {
868 gchar* _tmp99_;
869 gchar _tmp100_;
870 _tmp99_ = self->priv->current;
871 _tmp100_ = _tmp99_[0];
872 _tmp96_ = _tmp100_ != '>';
873 }
874 if (_tmp96_) {
875 }
876 _tmp101_ = self->priv->current;
877 self->priv->current = _tmp101_ + 1;
878 }
879 }
880 }
881 }
882 } else {
883 gchar* _tmp102_;
884 gchar _tmp103_;
885 vala_markup_reader_space (self);
886 _tmp102_ = self->priv->current;
887 _tmp103_ = _tmp102_[0];
888 if (_tmp103_ != '<') {
889 gchar* _tmp104_;
890 gchar* _tmp105_;
891 _tmp104_ = vala_markup_reader_text (self, '<', TRUE);
892 _tmp105_ = _tmp104_;
893 vala_markup_reader_set_content (self, _tmp105_);
894 _g_free0 (_tmp105_);
895 } else {
896 ValaSourceLocation _tmp106_ = {0};
897 ValaSourceLocation _tmp107_ = {0};
898 ValaMarkupTokenType _tmp108_;
899 _tmp108_ = vala_markup_reader_read_token (self, &_tmp106_, &_tmp107_);
900 _vala_token_begin = _tmp106_;
901 _vala_token_end = _tmp107_;
902 result = _tmp108_;
903 if (token_begin) {
904 *token_begin = _vala_token_begin;
905 }
906 if (token_end) {
907 *token_end = _vala_token_end;
908 }
909 return result;
910 }
911 type = VALA_MARKUP_TOKEN_TYPE_TEXT;
912 }
913 }
914 _tmp109_ = self->priv->current;
915 vala_source_location_init (&_vala_token_end, _tmp109_, self->priv->line, self->priv->column - 1);
916 result = type;
917 if (token_begin) {
918 *token_begin = _vala_token_begin;
919 }
920 if (token_end) {
921 *token_end = _vala_token_end;
922 }
923 return result;
924 }
925
926 static gchar*
vala_markup_reader_text(ValaMarkupReader * self,gchar end_char,gboolean rm_trailing_whitespace)927 vala_markup_reader_text (ValaMarkupReader* self,
928 gchar end_char,
929 gboolean rm_trailing_whitespace)
930 {
931 GString* content = NULL;
932 GString* _tmp0_;
933 gchar* text_begin = NULL;
934 gchar* _tmp1_;
935 gchar* last_linebreak = NULL;
936 gchar* _tmp2_;
937 gchar* _tmp77_;
938 gchar* _tmp78_;
939 gchar* _tmp85_;
940 gchar* _tmp86_;
941 GString* _tmp103_;
942 const gchar* _tmp104_;
943 gchar* _tmp105_;
944 gchar* result = NULL;
945 g_return_val_if_fail (self != NULL, NULL);
946 _tmp0_ = g_string_new ("");
947 content = _tmp0_;
948 _tmp1_ = self->priv->current;
949 text_begin = _tmp1_;
950 _tmp2_ = self->priv->current;
951 last_linebreak = _tmp2_;
952 while (TRUE) {
953 gboolean _tmp3_ = FALSE;
954 gchar* _tmp4_;
955 gchar* _tmp5_;
956 gunichar u = 0U;
957 gchar* _tmp8_;
958 gchar* _tmp9_;
959 gchar* _tmp10_;
960 _tmp4_ = self->priv->current;
961 _tmp5_ = self->priv->end;
962 if (_tmp4_ < _tmp5_) {
963 gchar* _tmp6_;
964 gchar _tmp7_;
965 _tmp6_ = self->priv->current;
966 _tmp7_ = _tmp6_[0];
967 _tmp3_ = _tmp7_ != end_char;
968 } else {
969 _tmp3_ = FALSE;
970 }
971 if (!_tmp3_) {
972 break;
973 }
974 _tmp8_ = self->priv->current;
975 _tmp9_ = self->priv->end;
976 _tmp10_ = self->priv->current;
977 u = g_utf8_get_char_validated ((const gchar*) _tmp8_, (gssize) ((glong) (_tmp9_ - _tmp10_)));
978 if (u == ((gunichar) -1)) {
979 vala_report_error (NULL, "invalid UTF-8 character");
980 } else {
981 if (u == ((gunichar) '&')) {
982 gchar* next_pos = NULL;
983 gchar* _tmp11_;
984 gchar* _tmp12_;
985 _tmp11_ = self->priv->current;
986 next_pos = _tmp11_ + g_unichar_to_utf8 (u, NULL);
987 _tmp12_ = next_pos;
988 if (g_str_has_prefix ((const gchar*) _tmp12_, "amp;")) {
989 GString* _tmp13_;
990 gchar* _tmp14_;
991 gchar* _tmp15_;
992 gchar* _tmp16_;
993 gchar* _tmp17_;
994 gchar* _tmp18_;
995 GString* _tmp19_;
996 gchar* _tmp20_;
997 gchar* _tmp21_;
998 _tmp13_ = content;
999 _tmp14_ = text_begin;
1000 _tmp15_ = self->priv->current;
1001 _tmp16_ = text_begin;
1002 _tmp17_ = string_substring ((const gchar*) _tmp14_, (glong) 0, (glong) ((gint) (_tmp15_ - _tmp16_)));
1003 _tmp18_ = _tmp17_;
1004 g_string_append (_tmp13_, _tmp18_);
1005 _g_free0 (_tmp18_);
1006 _tmp19_ = content;
1007 g_string_append_c (_tmp19_, '&');
1008 _tmp20_ = self->priv->current;
1009 self->priv->current = _tmp20_ + 5;
1010 _tmp21_ = self->priv->current;
1011 text_begin = _tmp21_;
1012 } else {
1013 gchar* _tmp22_;
1014 _tmp22_ = next_pos;
1015 if (g_str_has_prefix ((const gchar*) _tmp22_, "quot;")) {
1016 GString* _tmp23_;
1017 gchar* _tmp24_;
1018 gchar* _tmp25_;
1019 gchar* _tmp26_;
1020 gchar* _tmp27_;
1021 gchar* _tmp28_;
1022 GString* _tmp29_;
1023 gchar* _tmp30_;
1024 gchar* _tmp31_;
1025 _tmp23_ = content;
1026 _tmp24_ = text_begin;
1027 _tmp25_ = self->priv->current;
1028 _tmp26_ = text_begin;
1029 _tmp27_ = string_substring ((const gchar*) _tmp24_, (glong) 0, (glong) ((gint) (_tmp25_ - _tmp26_)));
1030 _tmp28_ = _tmp27_;
1031 g_string_append (_tmp23_, _tmp28_);
1032 _g_free0 (_tmp28_);
1033 _tmp29_ = content;
1034 g_string_append_c (_tmp29_, '"');
1035 _tmp30_ = self->priv->current;
1036 self->priv->current = _tmp30_ + 6;
1037 _tmp31_ = self->priv->current;
1038 text_begin = _tmp31_;
1039 } else {
1040 gchar* _tmp32_;
1041 _tmp32_ = next_pos;
1042 if (g_str_has_prefix ((const gchar*) _tmp32_, "apos;")) {
1043 GString* _tmp33_;
1044 gchar* _tmp34_;
1045 gchar* _tmp35_;
1046 gchar* _tmp36_;
1047 gchar* _tmp37_;
1048 gchar* _tmp38_;
1049 GString* _tmp39_;
1050 gchar* _tmp40_;
1051 gchar* _tmp41_;
1052 _tmp33_ = content;
1053 _tmp34_ = text_begin;
1054 _tmp35_ = self->priv->current;
1055 _tmp36_ = text_begin;
1056 _tmp37_ = string_substring ((const gchar*) _tmp34_, (glong) 0, (glong) ((gint) (_tmp35_ - _tmp36_)));
1057 _tmp38_ = _tmp37_;
1058 g_string_append (_tmp33_, _tmp38_);
1059 _g_free0 (_tmp38_);
1060 _tmp39_ = content;
1061 g_string_append_c (_tmp39_, '\'');
1062 _tmp40_ = self->priv->current;
1063 self->priv->current = _tmp40_ + 6;
1064 _tmp41_ = self->priv->current;
1065 text_begin = _tmp41_;
1066 } else {
1067 gchar* _tmp42_;
1068 _tmp42_ = next_pos;
1069 if (g_str_has_prefix ((const gchar*) _tmp42_, "lt;")) {
1070 GString* _tmp43_;
1071 gchar* _tmp44_;
1072 gchar* _tmp45_;
1073 gchar* _tmp46_;
1074 gchar* _tmp47_;
1075 gchar* _tmp48_;
1076 GString* _tmp49_;
1077 gchar* _tmp50_;
1078 gchar* _tmp51_;
1079 _tmp43_ = content;
1080 _tmp44_ = text_begin;
1081 _tmp45_ = self->priv->current;
1082 _tmp46_ = text_begin;
1083 _tmp47_ = string_substring ((const gchar*) _tmp44_, (glong) 0, (glong) ((gint) (_tmp45_ - _tmp46_)));
1084 _tmp48_ = _tmp47_;
1085 g_string_append (_tmp43_, _tmp48_);
1086 _g_free0 (_tmp48_);
1087 _tmp49_ = content;
1088 g_string_append_c (_tmp49_, '<');
1089 _tmp50_ = self->priv->current;
1090 self->priv->current = _tmp50_ + 4;
1091 _tmp51_ = self->priv->current;
1092 text_begin = _tmp51_;
1093 } else {
1094 gchar* _tmp52_;
1095 _tmp52_ = next_pos;
1096 if (g_str_has_prefix ((const gchar*) _tmp52_, "gt;")) {
1097 GString* _tmp53_;
1098 gchar* _tmp54_;
1099 gchar* _tmp55_;
1100 gchar* _tmp56_;
1101 gchar* _tmp57_;
1102 gchar* _tmp58_;
1103 GString* _tmp59_;
1104 gchar* _tmp60_;
1105 gchar* _tmp61_;
1106 _tmp53_ = content;
1107 _tmp54_ = text_begin;
1108 _tmp55_ = self->priv->current;
1109 _tmp56_ = text_begin;
1110 _tmp57_ = string_substring ((const gchar*) _tmp54_, (glong) 0, (glong) ((gint) (_tmp55_ - _tmp56_)));
1111 _tmp58_ = _tmp57_;
1112 g_string_append (_tmp53_, _tmp58_);
1113 _g_free0 (_tmp58_);
1114 _tmp59_ = content;
1115 g_string_append_c (_tmp59_, '>');
1116 _tmp60_ = self->priv->current;
1117 self->priv->current = _tmp60_ + 4;
1118 _tmp61_ = self->priv->current;
1119 text_begin = _tmp61_;
1120 } else {
1121 gchar* _tmp62_;
1122 _tmp62_ = next_pos;
1123 if (g_str_has_prefix ((const gchar*) _tmp62_, "percnt;")) {
1124 GString* _tmp63_;
1125 gchar* _tmp64_;
1126 gchar* _tmp65_;
1127 gchar* _tmp66_;
1128 gchar* _tmp67_;
1129 gchar* _tmp68_;
1130 GString* _tmp69_;
1131 gchar* _tmp70_;
1132 gchar* _tmp71_;
1133 _tmp63_ = content;
1134 _tmp64_ = text_begin;
1135 _tmp65_ = self->priv->current;
1136 _tmp66_ = text_begin;
1137 _tmp67_ = string_substring ((const gchar*) _tmp64_, (glong) 0, (glong) ((gint) (_tmp65_ - _tmp66_)));
1138 _tmp68_ = _tmp67_;
1139 g_string_append (_tmp63_, _tmp68_);
1140 _g_free0 (_tmp68_);
1141 _tmp69_ = content;
1142 g_string_append_c (_tmp69_, '%');
1143 _tmp70_ = self->priv->current;
1144 self->priv->current = _tmp70_ + 8;
1145 _tmp71_ = self->priv->current;
1146 text_begin = _tmp71_;
1147 } else {
1148 gchar* _tmp72_;
1149 _tmp72_ = self->priv->current;
1150 self->priv->current = _tmp72_ + g_unichar_to_utf8 (u, NULL);
1151 }
1152 }
1153 }
1154 }
1155 }
1156 }
1157 } else {
1158 gchar* _tmp75_;
1159 gint _tmp76_;
1160 if (u == ((gunichar) '\n')) {
1161 gint _tmp73_;
1162 gchar* _tmp74_;
1163 _tmp73_ = self->priv->line;
1164 self->priv->line = _tmp73_ + 1;
1165 self->priv->column = 0;
1166 _tmp74_ = self->priv->current;
1167 last_linebreak = _tmp74_;
1168 }
1169 _tmp75_ = self->priv->current;
1170 self->priv->current = _tmp75_ + g_unichar_to_utf8 (u, NULL);
1171 _tmp76_ = self->priv->column;
1172 self->priv->column = _tmp76_ + 1;
1173 }
1174 }
1175 }
1176 _tmp77_ = text_begin;
1177 _tmp78_ = self->priv->current;
1178 if (_tmp77_ != _tmp78_) {
1179 GString* _tmp79_;
1180 gchar* _tmp80_;
1181 gchar* _tmp81_;
1182 gchar* _tmp82_;
1183 gchar* _tmp83_;
1184 gchar* _tmp84_;
1185 _tmp79_ = content;
1186 _tmp80_ = text_begin;
1187 _tmp81_ = self->priv->current;
1188 _tmp82_ = text_begin;
1189 _tmp83_ = string_substring ((const gchar*) _tmp80_, (glong) 0, (glong) ((gint) (_tmp81_ - _tmp82_)));
1190 _tmp84_ = _tmp83_;
1191 g_string_append (_tmp79_, _tmp84_);
1192 _g_free0 (_tmp84_);
1193 }
1194 _tmp85_ = self->priv->current;
1195 _tmp86_ = last_linebreak;
1196 self->priv->column = self->priv->column + ((gint) (_tmp85_ - _tmp86_));
1197 if (rm_trailing_whitespace) {
1198 gchar* str_pos = NULL;
1199 GString* _tmp87_;
1200 const gchar* _tmp88_;
1201 GString* _tmp89_;
1202 GString* _tmp99_;
1203 gchar* _tmp100_;
1204 GString* _tmp101_;
1205 const gchar* _tmp102_;
1206 _tmp87_ = content;
1207 _tmp88_ = _tmp87_->str;
1208 _tmp89_ = content;
1209 str_pos = ((gchar*) _tmp88_) + _tmp89_->len;
1210 {
1211 gchar* _tmp90_;
1212 gboolean _tmp91_ = FALSE;
1213 _tmp90_ = str_pos;
1214 str_pos = _tmp90_ - 1;
1215 _tmp91_ = TRUE;
1216 while (TRUE) {
1217 gboolean _tmp93_ = FALSE;
1218 gchar* _tmp94_;
1219 GString* _tmp95_;
1220 const gchar* _tmp96_;
1221 if (!_tmp91_) {
1222 gchar* _tmp92_;
1223 _tmp92_ = str_pos;
1224 str_pos = _tmp92_ - 1;
1225 }
1226 _tmp91_ = FALSE;
1227 _tmp94_ = str_pos;
1228 _tmp95_ = content;
1229 _tmp96_ = _tmp95_->str;
1230 if (_tmp94_ > ((gchar*) _tmp96_)) {
1231 gchar* _tmp97_;
1232 gchar _tmp98_;
1233 _tmp97_ = str_pos;
1234 _tmp98_ = _tmp97_[0];
1235 _tmp93_ = g_ascii_isspace (_tmp98_);
1236 } else {
1237 _tmp93_ = FALSE;
1238 }
1239 if (!_tmp93_) {
1240 break;
1241 }
1242 }
1243 }
1244 _tmp99_ = content;
1245 _tmp100_ = str_pos;
1246 _tmp101_ = content;
1247 _tmp102_ = _tmp101_->str;
1248 g_string_erase (_tmp99_, (gssize) ((_tmp100_ - ((gchar*) _tmp102_)) + 1), (gssize) -1);
1249 }
1250 _tmp103_ = content;
1251 _tmp104_ = _tmp103_->str;
1252 _tmp105_ = g_strdup (_tmp104_);
1253 result = _tmp105_;
1254 _g_string_free0 (content);
1255 return result;
1256 }
1257
1258 static void
vala_markup_reader_space(ValaMarkupReader * self)1259 vala_markup_reader_space (ValaMarkupReader* self)
1260 {
1261 g_return_if_fail (self != NULL);
1262 while (TRUE) {
1263 gboolean _tmp0_ = FALSE;
1264 gchar* _tmp1_;
1265 gchar* _tmp2_;
1266 gchar* _tmp5_;
1267 gchar _tmp6_;
1268 gchar* _tmp8_;
1269 gint _tmp9_;
1270 _tmp1_ = self->priv->current;
1271 _tmp2_ = self->priv->end;
1272 if (_tmp1_ < _tmp2_) {
1273 gchar* _tmp3_;
1274 gchar _tmp4_;
1275 _tmp3_ = self->priv->current;
1276 _tmp4_ = _tmp3_[0];
1277 _tmp0_ = g_ascii_isspace (_tmp4_);
1278 } else {
1279 _tmp0_ = FALSE;
1280 }
1281 if (!_tmp0_) {
1282 break;
1283 }
1284 _tmp5_ = self->priv->current;
1285 _tmp6_ = _tmp5_[0];
1286 if (_tmp6_ == '\n') {
1287 gint _tmp7_;
1288 _tmp7_ = self->priv->line;
1289 self->priv->line = _tmp7_ + 1;
1290 self->priv->column = 0;
1291 }
1292 _tmp8_ = self->priv->current;
1293 self->priv->current = _tmp8_ + 1;
1294 _tmp9_ = self->priv->column;
1295 self->priv->column = _tmp9_ + 1;
1296 }
1297 }
1298
1299 static void
vala_value_markup_reader_init(GValue * value)1300 vala_value_markup_reader_init (GValue* value)
1301 {
1302 value->data[0].v_pointer = NULL;
1303 }
1304
1305 static void
vala_value_markup_reader_free_value(GValue * value)1306 vala_value_markup_reader_free_value (GValue* value)
1307 {
1308 if (value->data[0].v_pointer) {
1309 vala_markup_reader_unref (value->data[0].v_pointer);
1310 }
1311 }
1312
1313 static void
vala_value_markup_reader_copy_value(const GValue * src_value,GValue * dest_value)1314 vala_value_markup_reader_copy_value (const GValue* src_value,
1315 GValue* dest_value)
1316 {
1317 if (src_value->data[0].v_pointer) {
1318 dest_value->data[0].v_pointer = vala_markup_reader_ref (src_value->data[0].v_pointer);
1319 } else {
1320 dest_value->data[0].v_pointer = NULL;
1321 }
1322 }
1323
1324 static gpointer
vala_value_markup_reader_peek_pointer(const GValue * value)1325 vala_value_markup_reader_peek_pointer (const GValue* value)
1326 {
1327 return value->data[0].v_pointer;
1328 }
1329
1330 static gchar*
vala_value_markup_reader_collect_value(GValue * value,guint n_collect_values,GTypeCValue * collect_values,guint collect_flags)1331 vala_value_markup_reader_collect_value (GValue* value,
1332 guint n_collect_values,
1333 GTypeCValue* collect_values,
1334 guint collect_flags)
1335 {
1336 if (collect_values[0].v_pointer) {
1337 ValaMarkupReader * object;
1338 object = collect_values[0].v_pointer;
1339 if (object->parent_instance.g_class == NULL) {
1340 return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
1341 } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
1342 return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
1343 }
1344 value->data[0].v_pointer = vala_markup_reader_ref (object);
1345 } else {
1346 value->data[0].v_pointer = NULL;
1347 }
1348 return NULL;
1349 }
1350
1351 static gchar*
vala_value_markup_reader_lcopy_value(const GValue * value,guint n_collect_values,GTypeCValue * collect_values,guint collect_flags)1352 vala_value_markup_reader_lcopy_value (const GValue* value,
1353 guint n_collect_values,
1354 GTypeCValue* collect_values,
1355 guint collect_flags)
1356 {
1357 ValaMarkupReader ** object_p;
1358 object_p = collect_values[0].v_pointer;
1359 if (!object_p) {
1360 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
1361 }
1362 if (!value->data[0].v_pointer) {
1363 *object_p = NULL;
1364 } else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
1365 *object_p = value->data[0].v_pointer;
1366 } else {
1367 *object_p = vala_markup_reader_ref (value->data[0].v_pointer);
1368 }
1369 return NULL;
1370 }
1371
1372 GParamSpec*
vala_param_spec_markup_reader(const gchar * name,const gchar * nick,const gchar * blurb,GType object_type,GParamFlags flags)1373 vala_param_spec_markup_reader (const gchar* name,
1374 const gchar* nick,
1375 const gchar* blurb,
1376 GType object_type,
1377 GParamFlags flags)
1378 {
1379 ValaParamSpecMarkupReader* spec;
1380 g_return_val_if_fail (g_type_is_a (object_type, VALA_TYPE_MARKUP_READER), NULL);
1381 spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
1382 G_PARAM_SPEC (spec)->value_type = object_type;
1383 return G_PARAM_SPEC (spec);
1384 }
1385
1386 gpointer
vala_value_get_markup_reader(const GValue * value)1387 vala_value_get_markup_reader (const GValue* value)
1388 {
1389 g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALA_TYPE_MARKUP_READER), NULL);
1390 return value->data[0].v_pointer;
1391 }
1392
1393 void
vala_value_set_markup_reader(GValue * value,gpointer v_object)1394 vala_value_set_markup_reader (GValue* value,
1395 gpointer v_object)
1396 {
1397 ValaMarkupReader * old;
1398 g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALA_TYPE_MARKUP_READER));
1399 old = value->data[0].v_pointer;
1400 if (v_object) {
1401 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, VALA_TYPE_MARKUP_READER));
1402 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
1403 value->data[0].v_pointer = v_object;
1404 vala_markup_reader_ref (value->data[0].v_pointer);
1405 } else {
1406 value->data[0].v_pointer = NULL;
1407 }
1408 if (old) {
1409 vala_markup_reader_unref (old);
1410 }
1411 }
1412
1413 void
vala_value_take_markup_reader(GValue * value,gpointer v_object)1414 vala_value_take_markup_reader (GValue* value,
1415 gpointer v_object)
1416 {
1417 ValaMarkupReader * old;
1418 g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALA_TYPE_MARKUP_READER));
1419 old = value->data[0].v_pointer;
1420 if (v_object) {
1421 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, VALA_TYPE_MARKUP_READER));
1422 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
1423 value->data[0].v_pointer = v_object;
1424 } else {
1425 value->data[0].v_pointer = NULL;
1426 }
1427 if (old) {
1428 vala_markup_reader_unref (old);
1429 }
1430 }
1431
1432 static void
vala_markup_reader_class_init(ValaMarkupReaderClass * klass,gpointer klass_data)1433 vala_markup_reader_class_init (ValaMarkupReaderClass * klass,
1434 gpointer klass_data)
1435 {
1436 vala_markup_reader_parent_class = g_type_class_peek_parent (klass);
1437 ((ValaMarkupReaderClass *) klass)->finalize = vala_markup_reader_finalize;
1438 g_type_class_adjust_private_offset (klass, &ValaMarkupReader_private_offset);
1439 }
1440
1441 static void
vala_markup_reader_instance_init(ValaMarkupReader * self,gpointer klass)1442 vala_markup_reader_instance_init (ValaMarkupReader * self,
1443 gpointer klass)
1444 {
1445 GHashFunc _tmp0_;
1446 GEqualFunc _tmp1_;
1447 GEqualFunc _tmp2_;
1448 ValaHashMap* _tmp3_;
1449 self->priv = vala_markup_reader_get_instance_private (self);
1450 _tmp0_ = g_str_hash;
1451 _tmp1_ = g_str_equal;
1452 _tmp2_ = g_direct_equal;
1453 _tmp3_ = vala_hash_map_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, (GDestroyNotify) g_free, G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, (GDestroyNotify) g_free, _tmp0_, _tmp1_, _tmp2_);
1454 self->priv->attributes = (ValaMap*) _tmp3_;
1455 self->ref_count = 1;
1456 }
1457
1458 static void
vala_markup_reader_finalize(ValaMarkupReader * obj)1459 vala_markup_reader_finalize (ValaMarkupReader * obj)
1460 {
1461 ValaMarkupReader * self;
1462 self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALA_TYPE_MARKUP_READER, ValaMarkupReader);
1463 g_signal_handlers_destroy (self);
1464 _g_free0 (self->priv->_filename);
1465 _g_free0 (self->priv->_name);
1466 _g_free0 (self->priv->_content);
1467 _g_mapped_file_unref0 (self->priv->mapped_file);
1468 _vala_map_unref0 (self->priv->attributes);
1469 }
1470
1471 /**
1472 * Simple reader for a subset of XML.
1473 */
1474 static GType
vala_markup_reader_get_type_once(void)1475 vala_markup_reader_get_type_once (void)
1476 {
1477 static const GTypeValueTable g_define_type_value_table = { vala_value_markup_reader_init, vala_value_markup_reader_free_value, vala_value_markup_reader_copy_value, vala_value_markup_reader_peek_pointer, "p", vala_value_markup_reader_collect_value, "p", vala_value_markup_reader_lcopy_value };
1478 static const GTypeInfo g_define_type_info = { sizeof (ValaMarkupReaderClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_markup_reader_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaMarkupReader), 0, (GInstanceInitFunc) vala_markup_reader_instance_init, &g_define_type_value_table };
1479 static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
1480 GType vala_markup_reader_type_id;
1481 vala_markup_reader_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ValaMarkupReader", &g_define_type_info, &g_define_type_fundamental_info, 0);
1482 ValaMarkupReader_private_offset = g_type_add_instance_private (vala_markup_reader_type_id, sizeof (ValaMarkupReaderPrivate));
1483 return vala_markup_reader_type_id;
1484 }
1485
1486 GType
vala_markup_reader_get_type(void)1487 vala_markup_reader_get_type (void)
1488 {
1489 static volatile gsize vala_markup_reader_type_id__volatile = 0;
1490 if (g_once_init_enter (&vala_markup_reader_type_id__volatile)) {
1491 GType vala_markup_reader_type_id;
1492 vala_markup_reader_type_id = vala_markup_reader_get_type_once ();
1493 g_once_init_leave (&vala_markup_reader_type_id__volatile, vala_markup_reader_type_id);
1494 }
1495 return vala_markup_reader_type_id__volatile;
1496 }
1497
1498 gpointer
vala_markup_reader_ref(gpointer instance)1499 vala_markup_reader_ref (gpointer instance)
1500 {
1501 ValaMarkupReader * self;
1502 self = instance;
1503 g_atomic_int_inc (&self->ref_count);
1504 return instance;
1505 }
1506
1507 void
vala_markup_reader_unref(gpointer instance)1508 vala_markup_reader_unref (gpointer instance)
1509 {
1510 ValaMarkupReader * self;
1511 self = instance;
1512 if (g_atomic_int_dec_and_test (&self->ref_count)) {
1513 VALA_MARKUP_READER_GET_CLASS (self)->finalize (self);
1514 g_type_free_instance ((GTypeInstance *) self);
1515 }
1516 }
1517
1518 const gchar*
vala_markup_token_type_to_string(ValaMarkupTokenType self)1519 vala_markup_token_type_to_string (ValaMarkupTokenType self)
1520 {
1521 const gchar* result = NULL;
1522 switch (self) {
1523 case VALA_MARKUP_TOKEN_TYPE_START_ELEMENT:
1524 {
1525 result = "start element";
1526 return result;
1527 }
1528 case VALA_MARKUP_TOKEN_TYPE_END_ELEMENT:
1529 {
1530 result = "end element";
1531 return result;
1532 }
1533 case VALA_MARKUP_TOKEN_TYPE_TEXT:
1534 {
1535 result = "text";
1536 return result;
1537 }
1538 case VALA_MARKUP_TOKEN_TYPE_EOF:
1539 {
1540 result = "end of file";
1541 return result;
1542 }
1543 default:
1544 {
1545 result = "unknown token type";
1546 return result;
1547 }
1548 }
1549 }
1550
1551 static GType
vala_markup_token_type_get_type_once(void)1552 vala_markup_token_type_get_type_once (void)
1553 {
1554 static const GEnumValue values[] = {{VALA_MARKUP_TOKEN_TYPE_NONE, "VALA_MARKUP_TOKEN_TYPE_NONE", "none"}, {VALA_MARKUP_TOKEN_TYPE_START_ELEMENT, "VALA_MARKUP_TOKEN_TYPE_START_ELEMENT", "start-element"}, {VALA_MARKUP_TOKEN_TYPE_END_ELEMENT, "VALA_MARKUP_TOKEN_TYPE_END_ELEMENT", "end-element"}, {VALA_MARKUP_TOKEN_TYPE_TEXT, "VALA_MARKUP_TOKEN_TYPE_TEXT", "text"}, {VALA_MARKUP_TOKEN_TYPE_EOF, "VALA_MARKUP_TOKEN_TYPE_EOF", "eof"}, {0, NULL, NULL}};
1555 GType vala_markup_token_type_type_id;
1556 vala_markup_token_type_type_id = g_enum_register_static ("ValaMarkupTokenType", values);
1557 return vala_markup_token_type_type_id;
1558 }
1559
1560 GType
vala_markup_token_type_get_type(void)1561 vala_markup_token_type_get_type (void)
1562 {
1563 static volatile gsize vala_markup_token_type_type_id__volatile = 0;
1564 if (g_once_init_enter (&vala_markup_token_type_type_id__volatile)) {
1565 GType vala_markup_token_type_type_id;
1566 vala_markup_token_type_type_id = vala_markup_token_type_get_type_once ();
1567 g_once_init_leave (&vala_markup_token_type_type_id__volatile, vala_markup_token_type_type_id);
1568 }
1569 return vala_markup_token_type_type_id__volatile;
1570 }
1571
1572