1 /* valascanner.c generated by valac, the Vala compiler
2 * generated from valascanner.vala, do not modify */
3
4 /* valascanner.vala
5 *
6 * Copyright (C) 2008-2012 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 * Jukka-Pekka Iivonen <jp0409@jippii.fi>
25 */
26
27 #include "vala.h"
28 #include <glib.h>
29 #include <glib-object.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <gobject/gvaluecollector.h>
33
34 #define VALA_SCANNER_TYPE_CONDITIONAL (vala_scanner_conditional_get_type ())
35 typedef struct _ValaScannerConditional ValaScannerConditional;
36 typedef enum {
37 VALA_SCANNER_STATE_PARENS,
38 VALA_SCANNER_STATE_BRACE,
39 VALA_SCANNER_STATE_BRACKET,
40 VALA_SCANNER_STATE_TEMPLATE,
41 VALA_SCANNER_STATE_TEMPLATE_PART,
42 VALA_SCANNER_STATE_REGEX_LITERAL
43 } ValaScannerState;
44
45 #define VALA_SCANNER_TYPE_STATE (vala_scanner_state_get_type ())
46 #define _vala_source_file_unref0(var) ((var == NULL) ? NULL : (var = (vala_source_file_unref (var), NULL)))
47 #define _vala_comment_unref0(var) ((var == NULL) ? NULL : (var = (vala_comment_unref (var), NULL)))
48 #define _vala_source_reference_unref0(var) ((var == NULL) ? NULL : (var = (vala_source_reference_unref (var), NULL)))
49 #define _g_free0(var) (var = (g_free (var), NULL))
50 typedef struct _ValaParamSpecScanner ValaParamSpecScanner;
51
52 struct _ValaScannerConditional {
53 gboolean matched;
54 gboolean else_found;
55 gboolean skip_section;
56 };
57
58 struct _ValaScannerPrivate {
59 ValaSourceFile* _source_file;
60 ValaTokenType previous;
61 gchar* current;
62 gchar* end;
63 gint line;
64 gint column;
65 ValaComment* _comment;
66 ValaScannerConditional* conditional_stack;
67 gint conditional_stack_length1;
68 gint _conditional_stack_size_;
69 ValaScannerState* state_stack;
70 gint state_stack_length1;
71 gint _state_stack_size_;
72 };
73
74 struct _ValaParamSpecScanner {
75 GParamSpec parent_instance;
76 };
77
78 static gint ValaScanner_private_offset;
79 static gpointer vala_scanner_parent_class = NULL;
80
81 static GType vala_scanner_conditional_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
82 static ValaScannerConditional* vala_scanner_conditional_dup (const ValaScannerConditional* self);
83 static void vala_scanner_conditional_free (ValaScannerConditional* self);
84 static GType vala_scanner_state_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
85 static void vala_scanner_set_source_file (ValaScanner* self,
86 ValaSourceFile* value);
87 static gboolean vala_scanner_in_template (ValaScanner* self);
88 static gboolean vala_scanner_in_template_part (ValaScanner* self);
89 static gboolean vala_scanner_in_regex_literal (ValaScanner* self);
90 static gboolean vala_scanner_is_ident_char (ValaScanner* self,
91 gchar c);
92 static ValaSourceReference* vala_scanner_get_source_reference (ValaScanner* self,
93 gint offset,
94 gint length);
95 static gboolean vala_scanner_matches (gchar* begin,
96 const gchar* keyword);
97 static ValaTokenType vala_scanner_read_number (ValaScanner* self);
98 static void _vala_array_add13 (ValaScannerState* * array,
99 gint* length,
100 gint* size,
101 ValaScannerState value);
102 static void _vala_array_add14 (ValaScannerState* * array,
103 gint* length,
104 gint* size,
105 ValaScannerState value);
106 static void _vala_array_add15 (ValaScannerState* * array,
107 gint* length,
108 gint* size,
109 ValaScannerState value);
110 static void _vala_array_add16 (ValaScannerState* * array,
111 gint* length,
112 gint* size,
113 ValaScannerState value);
114 static void vala_scanner_space (ValaScanner* self);
115 static void _vala_array_add17 (ValaScannerState* * array,
116 gint* length,
117 gint* size,
118 ValaScannerState value);
119 static void _vala_array_add18 (ValaScannerState* * array,
120 gint* length,
121 gint* size,
122 ValaScannerState value);
123 static void _vala_array_add19 (ValaScannerState* * array,
124 gint* length,
125 gint* size,
126 ValaScannerState value);
127 static void _vala_array_add20 (ValaScannerState* * array,
128 gint* length,
129 gint* size,
130 ValaScannerState value);
131 static void _vala_array_add21 (ValaScannerState* * array,
132 gint* length,
133 gint* size,
134 ValaScannerState value);
135 static gboolean vala_scanner_pp_whitespace (ValaScanner* self);
136 static void vala_scanner_pp_space (ValaScanner* self);
137 static gboolean vala_scanner_comment (ValaScanner* self,
138 gboolean file_comment);
139 static void vala_scanner_pp_directive (ValaScanner* self);
140 static void vala_scanner_parse_pp_if (ValaScanner* self);
141 static void vala_scanner_parse_pp_elif (ValaScanner* self);
142 static void vala_scanner_parse_pp_else (ValaScanner* self);
143 static void vala_scanner_parse_pp_endif (ValaScanner* self);
144 static void vala_scanner_pp_eol (ValaScanner* self);
145 static gboolean vala_scanner_parse_pp_expression (ValaScanner* self);
146 static void _vala_array_add22 (ValaScannerConditional* * array,
147 gint* length,
148 gint* size,
149 const ValaScannerConditional* value);
150 static gboolean vala_scanner_parse_pp_symbol (ValaScanner* self);
151 static gboolean vala_scanner_parse_pp_primary_expression (ValaScanner* self);
152 static gboolean vala_scanner_parse_pp_unary_expression (ValaScanner* self);
153 static gboolean vala_scanner_parse_pp_equality_expression (ValaScanner* self);
154 static gboolean vala_scanner_parse_pp_and_expression (ValaScanner* self);
155 static gboolean vala_scanner_parse_pp_or_expression (ValaScanner* self);
156 static gboolean vala_scanner_whitespace (ValaScanner* self);
157 static void vala_scanner_push_comment (ValaScanner* self,
158 const gchar* comment_item,
159 ValaSourceReference* source_reference,
160 gboolean file_comment);
161 static void vala_scanner_finalize (ValaScanner * obj);
162 static GType vala_scanner_get_type_once (void);
163
164 static inline gpointer
vala_scanner_get_instance_private(ValaScanner * self)165 vala_scanner_get_instance_private (ValaScanner* self)
166 {
167 return G_STRUCT_MEMBER_P (self, ValaScanner_private_offset);
168 }
169
170 static GType
vala_scanner_state_get_type_once(void)171 vala_scanner_state_get_type_once (void)
172 {
173 static const GEnumValue values[] = {{VALA_SCANNER_STATE_PARENS, "VALA_SCANNER_STATE_PARENS", "parens"}, {VALA_SCANNER_STATE_BRACE, "VALA_SCANNER_STATE_BRACE", "brace"}, {VALA_SCANNER_STATE_BRACKET, "VALA_SCANNER_STATE_BRACKET", "bracket"}, {VALA_SCANNER_STATE_TEMPLATE, "VALA_SCANNER_STATE_TEMPLATE", "template"}, {VALA_SCANNER_STATE_TEMPLATE_PART, "VALA_SCANNER_STATE_TEMPLATE_PART", "template-part"}, {VALA_SCANNER_STATE_REGEX_LITERAL, "VALA_SCANNER_STATE_REGEX_LITERAL", "regex-literal"}, {0, NULL, NULL}};
174 GType vala_scanner_state_type_id;
175 vala_scanner_state_type_id = g_enum_register_static ("ValaScannerState", values);
176 return vala_scanner_state_type_id;
177 }
178
179 static GType
vala_scanner_state_get_type(void)180 vala_scanner_state_get_type (void)
181 {
182 static volatile gsize vala_scanner_state_type_id__volatile = 0;
183 if (g_once_init_enter (&vala_scanner_state_type_id__volatile)) {
184 GType vala_scanner_state_type_id;
185 vala_scanner_state_type_id = vala_scanner_state_get_type_once ();
186 g_once_init_leave (&vala_scanner_state_type_id__volatile, vala_scanner_state_type_id);
187 }
188 return vala_scanner_state_type_id__volatile;
189 }
190
191 ValaSourceFile*
vala_scanner_get_source_file(ValaScanner * self)192 vala_scanner_get_source_file (ValaScanner* self)
193 {
194 ValaSourceFile* result;
195 ValaSourceFile* _tmp0_;
196 g_return_val_if_fail (self != NULL, NULL);
197 _tmp0_ = self->priv->_source_file;
198 result = _tmp0_;
199 return result;
200 }
201
202 static gpointer
_vala_source_file_ref0(gpointer self)203 _vala_source_file_ref0 (gpointer self)
204 {
205 return self ? vala_source_file_ref (self) : NULL;
206 }
207
208 static void
vala_scanner_set_source_file(ValaScanner * self,ValaSourceFile * value)209 vala_scanner_set_source_file (ValaScanner* self,
210 ValaSourceFile* value)
211 {
212 ValaSourceFile* _tmp0_;
213 g_return_if_fail (self != NULL);
214 _tmp0_ = _vala_source_file_ref0 (value);
215 _vala_source_file_unref0 (self->priv->_source_file);
216 self->priv->_source_file = _tmp0_;
217 }
218
219 ValaScanner*
vala_scanner_construct(GType object_type,ValaSourceFile * source_file)220 vala_scanner_construct (GType object_type,
221 ValaSourceFile* source_file)
222 {
223 ValaScanner* self = NULL;
224 gchar* begin = NULL;
225 gchar* _tmp0_;
226 g_return_val_if_fail (source_file != NULL, NULL);
227 self = (ValaScanner*) g_type_create_instance (object_type);
228 vala_scanner_set_source_file (self, source_file);
229 _tmp0_ = vala_source_file_get_mapped_contents (source_file);
230 begin = _tmp0_;
231 self->priv->end = begin + vala_source_file_get_mapped_length (source_file);
232 self->priv->current = begin;
233 self->priv->line = 1;
234 self->priv->column = 1;
235 return self;
236 }
237
238 ValaScanner*
vala_scanner_new(ValaSourceFile * source_file)239 vala_scanner_new (ValaSourceFile* source_file)
240 {
241 return vala_scanner_construct (VALA_TYPE_SCANNER, source_file);
242 }
243
244 void
vala_scanner_seek(ValaScanner * self,ValaSourceLocation * location)245 vala_scanner_seek (ValaScanner* self,
246 ValaSourceLocation* location)
247 {
248 ValaSourceLocation _tmp0_;
249 gchar* _tmp1_;
250 ValaSourceLocation _tmp2_;
251 ValaSourceLocation _tmp3_;
252 g_return_if_fail (self != NULL);
253 g_return_if_fail (location != NULL);
254 _tmp0_ = *location;
255 _tmp1_ = _tmp0_.pos;
256 self->priv->current = _tmp1_;
257 _tmp2_ = *location;
258 self->priv->line = _tmp2_.line;
259 _tmp3_ = *location;
260 self->priv->column = _tmp3_.column;
261 self->priv->conditional_stack = (g_free (self->priv->conditional_stack), NULL);
262 self->priv->conditional_stack = NULL;
263 self->priv->conditional_stack_length1 = 0;
264 self->priv->_conditional_stack_size_ = self->priv->conditional_stack_length1;
265 self->priv->state_stack = (g_free (self->priv->state_stack), NULL);
266 self->priv->state_stack = NULL;
267 self->priv->state_stack_length1 = 0;
268 self->priv->_state_stack_size_ = self->priv->state_stack_length1;
269 }
270
271 static gboolean
vala_scanner_in_template(ValaScanner * self)272 vala_scanner_in_template (ValaScanner* self)
273 {
274 gboolean _tmp0_ = FALSE;
275 ValaScannerState* _tmp1_;
276 gint _tmp1__length1;
277 gboolean result = FALSE;
278 g_return_val_if_fail (self != NULL, FALSE);
279 _tmp1_ = self->priv->state_stack;
280 _tmp1__length1 = self->priv->state_stack_length1;
281 if (_tmp1__length1 > 0) {
282 ValaScannerState* _tmp2_;
283 gint _tmp2__length1;
284 ValaScannerState* _tmp3_;
285 gint _tmp3__length1;
286 ValaScannerState _tmp4_;
287 _tmp2_ = self->priv->state_stack;
288 _tmp2__length1 = self->priv->state_stack_length1;
289 _tmp3_ = self->priv->state_stack;
290 _tmp3__length1 = self->priv->state_stack_length1;
291 _tmp4_ = _tmp2_[_tmp3__length1 - 1];
292 _tmp0_ = _tmp4_ == VALA_SCANNER_STATE_TEMPLATE;
293 } else {
294 _tmp0_ = FALSE;
295 }
296 result = _tmp0_;
297 return result;
298 }
299
300 static gboolean
vala_scanner_in_template_part(ValaScanner * self)301 vala_scanner_in_template_part (ValaScanner* self)
302 {
303 gboolean _tmp0_ = FALSE;
304 ValaScannerState* _tmp1_;
305 gint _tmp1__length1;
306 gboolean result = FALSE;
307 g_return_val_if_fail (self != NULL, FALSE);
308 _tmp1_ = self->priv->state_stack;
309 _tmp1__length1 = self->priv->state_stack_length1;
310 if (_tmp1__length1 > 0) {
311 ValaScannerState* _tmp2_;
312 gint _tmp2__length1;
313 ValaScannerState* _tmp3_;
314 gint _tmp3__length1;
315 ValaScannerState _tmp4_;
316 _tmp2_ = self->priv->state_stack;
317 _tmp2__length1 = self->priv->state_stack_length1;
318 _tmp3_ = self->priv->state_stack;
319 _tmp3__length1 = self->priv->state_stack_length1;
320 _tmp4_ = _tmp2_[_tmp3__length1 - 1];
321 _tmp0_ = _tmp4_ == VALA_SCANNER_STATE_TEMPLATE_PART;
322 } else {
323 _tmp0_ = FALSE;
324 }
325 result = _tmp0_;
326 return result;
327 }
328
329 static gboolean
vala_scanner_in_regex_literal(ValaScanner * self)330 vala_scanner_in_regex_literal (ValaScanner* self)
331 {
332 gboolean _tmp0_ = FALSE;
333 ValaScannerState* _tmp1_;
334 gint _tmp1__length1;
335 gboolean result = FALSE;
336 g_return_val_if_fail (self != NULL, FALSE);
337 _tmp1_ = self->priv->state_stack;
338 _tmp1__length1 = self->priv->state_stack_length1;
339 if (_tmp1__length1 > 0) {
340 ValaScannerState* _tmp2_;
341 gint _tmp2__length1;
342 ValaScannerState* _tmp3_;
343 gint _tmp3__length1;
344 ValaScannerState _tmp4_;
345 _tmp2_ = self->priv->state_stack;
346 _tmp2__length1 = self->priv->state_stack_length1;
347 _tmp3_ = self->priv->state_stack;
348 _tmp3__length1 = self->priv->state_stack_length1;
349 _tmp4_ = _tmp2_[_tmp3__length1 - 1];
350 _tmp0_ = _tmp4_ == VALA_SCANNER_STATE_REGEX_LITERAL;
351 } else {
352 _tmp0_ = FALSE;
353 }
354 result = _tmp0_;
355 return result;
356 }
357
358 static gboolean
vala_scanner_is_ident_char(ValaScanner * self,gchar c)359 vala_scanner_is_ident_char (ValaScanner* self,
360 gchar c)
361 {
362 gboolean _tmp0_ = FALSE;
363 gboolean result = FALSE;
364 g_return_val_if_fail (self != NULL, FALSE);
365 if (g_ascii_isalnum (c)) {
366 _tmp0_ = TRUE;
367 } else {
368 _tmp0_ = c == '_';
369 }
370 result = _tmp0_;
371 return result;
372 }
373
374 static ValaSourceReference*
vala_scanner_get_source_reference(ValaScanner * self,gint offset,gint length)375 vala_scanner_get_source_reference (ValaScanner* self,
376 gint offset,
377 gint length)
378 {
379 ValaSourceFile* _tmp0_;
380 gchar* _tmp1_;
381 ValaSourceLocation _tmp2_ = {0};
382 gchar* _tmp3_;
383 ValaSourceLocation _tmp4_ = {0};
384 ValaSourceReference* _tmp5_;
385 ValaSourceReference* result = NULL;
386 g_return_val_if_fail (self != NULL, NULL);
387 _tmp0_ = self->priv->_source_file;
388 _tmp1_ = self->priv->current;
389 vala_source_location_init (&_tmp2_, _tmp1_, self->priv->line, self->priv->column + offset);
390 _tmp3_ = self->priv->current;
391 vala_source_location_init (&_tmp4_, _tmp3_ + length, self->priv->line, (self->priv->column + offset) + length);
392 _tmp5_ = vala_source_reference_new (_tmp0_, &_tmp2_, &_tmp4_);
393 result = _tmp5_;
394 return result;
395 }
396
397 ValaTokenType
vala_scanner_read_regex_token(ValaScanner * self,ValaSourceLocation * token_begin,ValaSourceLocation * token_end)398 vala_scanner_read_regex_token (ValaScanner* self,
399 ValaSourceLocation* token_begin,
400 ValaSourceLocation* token_end)
401 {
402 ValaSourceLocation _vala_token_begin = {0};
403 ValaSourceLocation _vala_token_end = {0};
404 ValaTokenType type = 0;
405 gchar* begin = NULL;
406 gchar* _tmp0_;
407 gchar* _tmp1_;
408 gint token_length_in_chars = 0;
409 gchar* _tmp2_;
410 gchar* _tmp3_;
411 gchar* _tmp112_;
412 ValaTokenType result = 0;
413 g_return_val_if_fail (self != NULL, 0);
414 _tmp0_ = self->priv->current;
415 begin = _tmp0_;
416 _tmp1_ = begin;
417 vala_source_location_init (&_vala_token_begin, _tmp1_, self->priv->line, self->priv->column);
418 token_length_in_chars = -1;
419 _tmp2_ = self->priv->current;
420 _tmp3_ = self->priv->end;
421 if (_tmp2_ >= _tmp3_) {
422 type = VALA_TOKEN_TYPE_EOF;
423 } else {
424 gchar* _tmp4_;
425 gchar _tmp5_;
426 _tmp4_ = self->priv->current;
427 _tmp5_ = _tmp4_[0];
428 switch (_tmp5_) {
429 case '/':
430 {
431 gchar* _tmp6_;
432 gint _tmp7_;
433 gboolean fl_i = FALSE;
434 gboolean fl_s = FALSE;
435 gboolean fl_m = FALSE;
436 gboolean fl_x = FALSE;
437 type = VALA_TOKEN_TYPE_CLOSE_REGEX_LITERAL;
438 _tmp6_ = self->priv->current;
439 self->priv->current = _tmp6_ + 1;
440 _tmp7_ = self->priv->state_stack_length1;
441 self->priv->state_stack_length1 = _tmp7_ - 1;
442 fl_i = FALSE;
443 fl_s = FALSE;
444 fl_m = FALSE;
445 fl_x = FALSE;
446 while (TRUE) {
447 gboolean _tmp8_ = FALSE;
448 gboolean _tmp9_ = FALSE;
449 gboolean _tmp10_ = FALSE;
450 gchar* _tmp11_;
451 gchar _tmp12_;
452 gchar* _tmp19_;
453 gchar _tmp20_;
454 gchar* _tmp29_;
455 gint _tmp30_;
456 _tmp11_ = self->priv->current;
457 _tmp12_ = _tmp11_[0];
458 if (_tmp12_ == 'i') {
459 _tmp10_ = TRUE;
460 } else {
461 gchar* _tmp13_;
462 gchar _tmp14_;
463 _tmp13_ = self->priv->current;
464 _tmp14_ = _tmp13_[0];
465 _tmp10_ = _tmp14_ == 's';
466 }
467 if (_tmp10_) {
468 _tmp9_ = TRUE;
469 } else {
470 gchar* _tmp15_;
471 gchar _tmp16_;
472 _tmp15_ = self->priv->current;
473 _tmp16_ = _tmp15_[0];
474 _tmp9_ = _tmp16_ == 'm';
475 }
476 if (_tmp9_) {
477 _tmp8_ = TRUE;
478 } else {
479 gchar* _tmp17_;
480 gchar _tmp18_;
481 _tmp17_ = self->priv->current;
482 _tmp18_ = _tmp17_[0];
483 _tmp8_ = _tmp18_ == 'x';
484 }
485 if (!_tmp8_) {
486 break;
487 }
488 _tmp19_ = self->priv->current;
489 _tmp20_ = _tmp19_[0];
490 switch (_tmp20_) {
491 case 'i':
492 {
493 if (fl_i) {
494 ValaSourceReference* _tmp21_;
495 ValaSourceReference* _tmp22_;
496 _tmp21_ = vala_scanner_get_source_reference (self, token_length_in_chars, 0);
497 _tmp22_ = _tmp21_;
498 vala_report_error (_tmp22_, "modifier 'i' used more than once");
499 _vala_source_reference_unref0 (_tmp22_);
500 }
501 fl_i = TRUE;
502 break;
503 }
504 case 's':
505 {
506 if (fl_s) {
507 ValaSourceReference* _tmp23_;
508 ValaSourceReference* _tmp24_;
509 _tmp23_ = vala_scanner_get_source_reference (self, token_length_in_chars, 0);
510 _tmp24_ = _tmp23_;
511 vala_report_error (_tmp24_, "modifier 's' used more than once");
512 _vala_source_reference_unref0 (_tmp24_);
513 }
514 fl_s = TRUE;
515 break;
516 }
517 case 'm':
518 {
519 if (fl_m) {
520 ValaSourceReference* _tmp25_;
521 ValaSourceReference* _tmp26_;
522 _tmp25_ = vala_scanner_get_source_reference (self, token_length_in_chars, 0);
523 _tmp26_ = _tmp25_;
524 vala_report_error (_tmp26_, "modifier 'm' used more than once");
525 _vala_source_reference_unref0 (_tmp26_);
526 }
527 fl_m = TRUE;
528 break;
529 }
530 case 'x':
531 {
532 if (fl_x) {
533 ValaSourceReference* _tmp27_;
534 ValaSourceReference* _tmp28_;
535 _tmp27_ = vala_scanner_get_source_reference (self, token_length_in_chars, 0);
536 _tmp28_ = _tmp27_;
537 vala_report_error (_tmp28_, "modifier 'x' used more than once");
538 _vala_source_reference_unref0 (_tmp28_);
539 }
540 fl_x = TRUE;
541 break;
542 }
543 default:
544 break;
545 }
546 _tmp29_ = self->priv->current;
547 self->priv->current = _tmp29_ + 1;
548 _tmp30_ = token_length_in_chars;
549 token_length_in_chars = _tmp30_ + 1;
550 }
551 break;
552 }
553 default:
554 {
555 gboolean _tmp99_ = FALSE;
556 gchar* _tmp100_;
557 gchar* _tmp101_;
558 type = VALA_TOKEN_TYPE_REGEX_LITERAL;
559 token_length_in_chars = 0;
560 while (TRUE) {
561 gboolean _tmp31_ = FALSE;
562 gchar* _tmp32_;
563 gchar* _tmp33_;
564 gchar* _tmp36_;
565 gchar _tmp37_;
566 _tmp32_ = self->priv->current;
567 _tmp33_ = self->priv->end;
568 if (_tmp32_ < _tmp33_) {
569 gchar* _tmp34_;
570 gchar _tmp35_;
571 _tmp34_ = self->priv->current;
572 _tmp35_ = _tmp34_[0];
573 _tmp31_ = _tmp35_ != '/';
574 } else {
575 _tmp31_ = FALSE;
576 }
577 if (!_tmp31_) {
578 break;
579 }
580 _tmp36_ = self->priv->current;
581 _tmp37_ = _tmp36_[0];
582 if (_tmp37_ == '\\') {
583 gchar* _tmp38_;
584 gint _tmp39_;
585 gchar* _tmp40_;
586 gchar* _tmp41_;
587 gchar* _tmp42_;
588 gchar _tmp43_;
589 _tmp38_ = self->priv->current;
590 self->priv->current = _tmp38_ + 1;
591 _tmp39_ = token_length_in_chars;
592 token_length_in_chars = _tmp39_ + 1;
593 _tmp40_ = self->priv->current;
594 _tmp41_ = self->priv->end;
595 if (_tmp40_ >= _tmp41_) {
596 break;
597 }
598 _tmp42_ = self->priv->current;
599 _tmp43_ = _tmp42_[0];
600 switch (_tmp43_) {
601 case '\'':
602 case '"':
603 case '\\':
604 case '/':
605 case '^':
606 case '$':
607 case '.':
608 case '[':
609 case ']':
610 case '{':
611 case '}':
612 case '(':
613 case ')':
614 case '?':
615 case '*':
616 case '+':
617 case '-':
618 case '#':
619 case '&':
620 case '~':
621 case ':':
622 case ';':
623 case '<':
624 case '>':
625 case '|':
626 case '%':
627 case '=':
628 case '@':
629 case '0':
630 case 'b':
631 case 'B':
632 case 'f':
633 case 'n':
634 case 'N':
635 case 'r':
636 case 'R':
637 case 't':
638 case 'v':
639 case 'a':
640 case 'A':
641 case 'p':
642 case 'P':
643 case 'e':
644 case 'd':
645 case 'D':
646 case 's':
647 case 'S':
648 case 'w':
649 case 'W':
650 case 'G':
651 case 'z':
652 case 'Z':
653 {
654 gchar* _tmp44_;
655 gint _tmp45_;
656 _tmp44_ = self->priv->current;
657 self->priv->current = _tmp44_ + 1;
658 _tmp45_ = token_length_in_chars;
659 token_length_in_chars = _tmp45_ + 1;
660 break;
661 }
662 case 'u':
663 {
664 gchar* _tmp46_;
665 gint _tmp47_;
666 gint digit_length = 0;
667 _tmp46_ = self->priv->current;
668 self->priv->current = _tmp46_ + 1;
669 _tmp47_ = token_length_in_chars;
670 token_length_in_chars = _tmp47_ + 1;
671 {
672 gboolean _tmp48_ = FALSE;
673 digit_length = 0;
674 _tmp48_ = TRUE;
675 while (TRUE) {
676 gboolean _tmp50_ = FALSE;
677 gchar* _tmp51_;
678 gchar* _tmp52_;
679 gchar* _tmp55_;
680 gint _tmp56_;
681 if (!_tmp48_) {
682 gint _tmp49_;
683 _tmp49_ = digit_length;
684 digit_length = _tmp49_ + 1;
685 }
686 _tmp48_ = FALSE;
687 _tmp51_ = self->priv->current;
688 _tmp52_ = self->priv->end;
689 if (_tmp51_ < _tmp52_) {
690 gchar* _tmp53_;
691 gchar _tmp54_;
692 _tmp53_ = self->priv->current;
693 _tmp54_ = _tmp53_[0];
694 _tmp50_ = g_ascii_isxdigit (_tmp54_);
695 } else {
696 _tmp50_ = FALSE;
697 }
698 if (!_tmp50_) {
699 break;
700 }
701 _tmp55_ = self->priv->current;
702 self->priv->current = _tmp55_ + 1;
703 _tmp56_ = token_length_in_chars;
704 token_length_in_chars = _tmp56_ + 1;
705 }
706 }
707 if (digit_length < 1) {
708 ValaSourceReference* _tmp57_;
709 ValaSourceReference* _tmp58_;
710 _tmp57_ = vala_scanner_get_source_reference (self, token_length_in_chars, 0);
711 _tmp58_ = _tmp57_;
712 vala_report_error (_tmp58_, "\\u used with no following hex digits");
713 _vala_source_reference_unref0 (_tmp58_);
714 } else {
715 if (digit_length < 4) {
716 ValaSourceReference* _tmp59_;
717 ValaSourceReference* _tmp60_;
718 _tmp59_ = vala_scanner_get_source_reference (self, token_length_in_chars, 0);
719 _tmp60_ = _tmp59_;
720 vala_report_error (_tmp60_, "incomplete universal character name");
721 _vala_source_reference_unref0 (_tmp60_);
722 }
723 }
724 break;
725 }
726 case 'x':
727 {
728 gchar* _tmp61_;
729 gint _tmp62_;
730 gint digit_length = 0;
731 gboolean empty = FALSE;
732 gboolean _tmp74_ = FALSE;
733 _tmp61_ = self->priv->current;
734 self->priv->current = _tmp61_ + 1;
735 _tmp62_ = token_length_in_chars;
736 token_length_in_chars = _tmp62_ + 1;
737 empty = TRUE;
738 {
739 gboolean _tmp63_ = FALSE;
740 digit_length = 0;
741 _tmp63_ = TRUE;
742 while (TRUE) {
743 gboolean _tmp64_ = FALSE;
744 gchar* _tmp65_;
745 gchar* _tmp66_;
746 gchar* _tmp69_;
747 gchar _tmp70_;
748 gchar* _tmp72_;
749 gint _tmp73_;
750 if (!_tmp63_) {
751 }
752 _tmp63_ = FALSE;
753 _tmp65_ = self->priv->current;
754 _tmp66_ = self->priv->end;
755 if (_tmp65_ < _tmp66_) {
756 gchar* _tmp67_;
757 gchar _tmp68_;
758 _tmp67_ = self->priv->current;
759 _tmp68_ = _tmp67_[0];
760 _tmp64_ = g_ascii_isxdigit (_tmp68_);
761 } else {
762 _tmp64_ = FALSE;
763 }
764 if (!_tmp64_) {
765 break;
766 }
767 _tmp69_ = self->priv->current;
768 _tmp70_ = _tmp69_[0];
769 if (_tmp70_ != '0') {
770 gint _tmp71_;
771 _tmp71_ = digit_length;
772 digit_length = _tmp71_ + 1;
773 } else {
774 empty = FALSE;
775 }
776 _tmp72_ = self->priv->current;
777 self->priv->current = _tmp72_ + 1;
778 _tmp73_ = token_length_in_chars;
779 token_length_in_chars = _tmp73_ + 1;
780 }
781 }
782 if (empty) {
783 _tmp74_ = digit_length < 1;
784 } else {
785 _tmp74_ = FALSE;
786 }
787 if (_tmp74_) {
788 ValaSourceReference* _tmp75_;
789 ValaSourceReference* _tmp76_;
790 _tmp75_ = vala_scanner_get_source_reference (self, token_length_in_chars, 0);
791 _tmp76_ = _tmp75_;
792 vala_report_error (_tmp76_, "\\x used with no following hex digits");
793 _vala_source_reference_unref0 (_tmp76_);
794 } else {
795 if (digit_length > 2) {
796 ValaSourceReference* _tmp77_;
797 ValaSourceReference* _tmp78_;
798 _tmp77_ = vala_scanner_get_source_reference (self, token_length_in_chars, 0);
799 _tmp78_ = _tmp77_;
800 vala_report_error (_tmp78_, "hex escape sequence out of range");
801 _vala_source_reference_unref0 (_tmp78_);
802 }
803 }
804 break;
805 }
806 default:
807 {
808 gchar* _tmp79_;
809 gchar _tmp80_;
810 _tmp79_ = self->priv->current;
811 _tmp80_ = _tmp79_[0];
812 if (g_ascii_isdigit (_tmp80_)) {
813 gchar* _tmp81_;
814 gint _tmp82_;
815 gchar* _tmp83_;
816 gchar _tmp84_;
817 _tmp81_ = self->priv->current;
818 self->priv->current = _tmp81_ + 1;
819 _tmp82_ = token_length_in_chars;
820 token_length_in_chars = _tmp82_ + 1;
821 _tmp83_ = self->priv->current;
822 _tmp84_ = _tmp83_[0];
823 if (g_ascii_isdigit (_tmp84_)) {
824 gchar* _tmp85_;
825 gint _tmp86_;
826 _tmp85_ = self->priv->current;
827 self->priv->current = _tmp85_ + 1;
828 _tmp86_ = token_length_in_chars;
829 token_length_in_chars = _tmp86_ + 1;
830 }
831 } else {
832 ValaSourceReference* _tmp87_;
833 ValaSourceReference* _tmp88_;
834 _tmp87_ = vala_scanner_get_source_reference (self, token_length_in_chars, 0);
835 _tmp88_ = _tmp87_;
836 vala_report_error (_tmp88_, "invalid escape sequence");
837 _vala_source_reference_unref0 (_tmp88_);
838 }
839 break;
840 }
841 }
842 } else {
843 gchar* _tmp89_;
844 gchar _tmp90_;
845 _tmp89_ = self->priv->current;
846 _tmp90_ = _tmp89_[0];
847 if (_tmp90_ == '\n') {
848 break;
849 } else {
850 gunichar u = 0U;
851 gchar* _tmp91_;
852 gchar* _tmp92_;
853 gchar* _tmp93_;
854 _tmp91_ = self->priv->current;
855 _tmp92_ = self->priv->end;
856 _tmp93_ = self->priv->current;
857 u = g_utf8_get_char_validated ((const gchar*) _tmp91_, (gssize) ((glong) (_tmp92_ - _tmp93_)));
858 if (u != ((gunichar) -1)) {
859 gchar* _tmp94_;
860 gint _tmp95_;
861 _tmp94_ = self->priv->current;
862 self->priv->current = _tmp94_ + g_unichar_to_utf8 (u, NULL);
863 _tmp95_ = token_length_in_chars;
864 token_length_in_chars = _tmp95_ + 1;
865 } else {
866 gchar* _tmp96_;
867 ValaSourceReference* _tmp97_;
868 ValaSourceReference* _tmp98_;
869 _tmp96_ = self->priv->current;
870 self->priv->current = _tmp96_ + 1;
871 _tmp97_ = vala_scanner_get_source_reference (self, token_length_in_chars, 0);
872 _tmp98_ = _tmp97_;
873 vala_report_error (_tmp98_, "invalid UTF-8 character");
874 _vala_source_reference_unref0 (_tmp98_);
875 }
876 }
877 }
878 }
879 _tmp100_ = self->priv->current;
880 _tmp101_ = self->priv->end;
881 if (_tmp100_ >= _tmp101_) {
882 _tmp99_ = TRUE;
883 } else {
884 gchar* _tmp102_;
885 gchar _tmp103_;
886 _tmp102_ = self->priv->current;
887 _tmp103_ = _tmp102_[0];
888 _tmp99_ = _tmp103_ == '\n';
889 }
890 if (_tmp99_) {
891 ValaSourceReference* _tmp104_;
892 ValaSourceReference* _tmp105_;
893 gint _tmp106_;
894 ValaSourceLocation _tmp107_ = {0};
895 ValaSourceLocation _tmp108_ = {0};
896 ValaTokenType _tmp109_;
897 _tmp104_ = vala_scanner_get_source_reference (self, token_length_in_chars, 0);
898 _tmp105_ = _tmp104_;
899 vala_report_error (_tmp105_, "syntax error, expected \"");
900 _vala_source_reference_unref0 (_tmp105_);
901 _tmp106_ = self->priv->state_stack_length1;
902 self->priv->state_stack_length1 = _tmp106_ - 1;
903 _tmp109_ = vala_scanner_read_token (self, &_tmp107_, &_tmp108_);
904 _vala_token_begin = _tmp107_;
905 _vala_token_end = _tmp108_;
906 result = _tmp109_;
907 if (token_begin) {
908 *token_begin = _vala_token_begin;
909 }
910 if (token_end) {
911 *token_end = _vala_token_end;
912 }
913 return result;
914 }
915 break;
916 }
917 }
918 }
919 if (token_length_in_chars < 0) {
920 gchar* _tmp110_;
921 gchar* _tmp111_;
922 _tmp110_ = self->priv->current;
923 _tmp111_ = begin;
924 self->priv->column = self->priv->column + ((gint) (_tmp110_ - _tmp111_));
925 } else {
926 self->priv->column = self->priv->column + token_length_in_chars;
927 }
928 _tmp112_ = self->priv->current;
929 vala_source_location_init (&_vala_token_end, _tmp112_, self->priv->line, self->priv->column - 1);
930 result = type;
931 if (token_begin) {
932 *token_begin = _vala_token_begin;
933 }
934 if (token_end) {
935 *token_end = _vala_token_end;
936 }
937 return result;
938 }
939
940 ValaTokenType
vala_scanner_get_identifier_or_keyword(gchar * begin,gint len)941 vala_scanner_get_identifier_or_keyword (gchar* begin,
942 gint len)
943 {
944 ValaTokenType result = 0;
945 switch (len) {
946 case 2:
947 {
948 gchar _tmp0_;
949 _tmp0_ = begin[0];
950 switch (_tmp0_) {
951 case 'a':
952 {
953 if (vala_scanner_matches (begin, "as")) {
954 result = VALA_TOKEN_TYPE_AS;
955 return result;
956 }
957 break;
958 }
959 case 'd':
960 {
961 if (vala_scanner_matches (begin, "do")) {
962 result = VALA_TOKEN_TYPE_DO;
963 return result;
964 }
965 break;
966 }
967 case 'i':
968 {
969 gchar _tmp1_;
970 _tmp1_ = begin[1];
971 switch (_tmp1_) {
972 case 'f':
973 {
974 result = VALA_TOKEN_TYPE_IF;
975 return result;
976 }
977 case 'n':
978 {
979 result = VALA_TOKEN_TYPE_IN;
980 return result;
981 }
982 case 's':
983 {
984 result = VALA_TOKEN_TYPE_IS;
985 return result;
986 }
987 default:
988 break;
989 }
990 break;
991 }
992 default:
993 break;
994 }
995 break;
996 }
997 case 3:
998 {
999 gchar _tmp2_;
1000 _tmp2_ = begin[0];
1001 switch (_tmp2_) {
1002 case 'f':
1003 {
1004 if (vala_scanner_matches (begin, "for")) {
1005 result = VALA_TOKEN_TYPE_FOR;
1006 return result;
1007 }
1008 break;
1009 }
1010 case 'g':
1011 {
1012 if (vala_scanner_matches (begin, "get")) {
1013 result = VALA_TOKEN_TYPE_GET;
1014 return result;
1015 }
1016 break;
1017 }
1018 case 'n':
1019 {
1020 if (vala_scanner_matches (begin, "new")) {
1021 result = VALA_TOKEN_TYPE_NEW;
1022 return result;
1023 }
1024 break;
1025 }
1026 case 'o':
1027 {
1028 if (vala_scanner_matches (begin, "out")) {
1029 result = VALA_TOKEN_TYPE_OUT;
1030 return result;
1031 }
1032 break;
1033 }
1034 case 'r':
1035 {
1036 if (vala_scanner_matches (begin, "ref")) {
1037 result = VALA_TOKEN_TYPE_REF;
1038 return result;
1039 }
1040 break;
1041 }
1042 case 's':
1043 {
1044 if (vala_scanner_matches (begin, "set")) {
1045 result = VALA_TOKEN_TYPE_SET;
1046 return result;
1047 }
1048 break;
1049 }
1050 case 't':
1051 {
1052 if (vala_scanner_matches (begin, "try")) {
1053 result = VALA_TOKEN_TYPE_TRY;
1054 return result;
1055 }
1056 break;
1057 }
1058 case 'v':
1059 {
1060 if (vala_scanner_matches (begin, "var")) {
1061 result = VALA_TOKEN_TYPE_VAR;
1062 return result;
1063 }
1064 break;
1065 }
1066 default:
1067 break;
1068 }
1069 break;
1070 }
1071 case 4:
1072 {
1073 gchar _tmp3_;
1074 _tmp3_ = begin[0];
1075 switch (_tmp3_) {
1076 case 'b':
1077 {
1078 if (vala_scanner_matches (begin, "base")) {
1079 result = VALA_TOKEN_TYPE_BASE;
1080 return result;
1081 }
1082 break;
1083 }
1084 case 'c':
1085 {
1086 if (vala_scanner_matches (begin, "case")) {
1087 result = VALA_TOKEN_TYPE_CASE;
1088 return result;
1089 }
1090 break;
1091 }
1092 case 'e':
1093 {
1094 gchar _tmp4_;
1095 _tmp4_ = begin[1];
1096 switch (_tmp4_) {
1097 case 'l':
1098 {
1099 if (vala_scanner_matches (begin, "else")) {
1100 result = VALA_TOKEN_TYPE_ELSE;
1101 return result;
1102 }
1103 break;
1104 }
1105 case 'n':
1106 {
1107 if (vala_scanner_matches (begin, "enum")) {
1108 result = VALA_TOKEN_TYPE_ENUM;
1109 return result;
1110 }
1111 break;
1112 }
1113 default:
1114 break;
1115 }
1116 break;
1117 }
1118 case 'l':
1119 {
1120 if (vala_scanner_matches (begin, "lock")) {
1121 result = VALA_TOKEN_TYPE_LOCK;
1122 return result;
1123 }
1124 break;
1125 }
1126 case 'n':
1127 {
1128 if (vala_scanner_matches (begin, "null")) {
1129 result = VALA_TOKEN_TYPE_NULL;
1130 return result;
1131 }
1132 break;
1133 }
1134 case 't':
1135 {
1136 gchar _tmp5_;
1137 _tmp5_ = begin[1];
1138 switch (_tmp5_) {
1139 case 'h':
1140 {
1141 if (vala_scanner_matches (begin, "this")) {
1142 result = VALA_TOKEN_TYPE_THIS;
1143 return result;
1144 }
1145 break;
1146 }
1147 case 'r':
1148 {
1149 if (vala_scanner_matches (begin, "true")) {
1150 result = VALA_TOKEN_TYPE_TRUE;
1151 return result;
1152 }
1153 break;
1154 }
1155 default:
1156 break;
1157 }
1158 break;
1159 }
1160 case 'v':
1161 {
1162 if (vala_scanner_matches (begin, "void")) {
1163 result = VALA_TOKEN_TYPE_VOID;
1164 return result;
1165 }
1166 break;
1167 }
1168 case 'w':
1169 {
1170 if (vala_scanner_matches (begin, "weak")) {
1171 result = VALA_TOKEN_TYPE_WEAK;
1172 return result;
1173 }
1174 break;
1175 }
1176 default:
1177 break;
1178 }
1179 break;
1180 }
1181 case 5:
1182 {
1183 gchar _tmp6_;
1184 _tmp6_ = begin[0];
1185 switch (_tmp6_) {
1186 case 'a':
1187 {
1188 if (vala_scanner_matches (begin, "async")) {
1189 result = VALA_TOKEN_TYPE_ASYNC;
1190 return result;
1191 }
1192 break;
1193 }
1194 case 'b':
1195 {
1196 if (vala_scanner_matches (begin, "break")) {
1197 result = VALA_TOKEN_TYPE_BREAK;
1198 return result;
1199 }
1200 break;
1201 }
1202 case 'c':
1203 {
1204 gchar _tmp7_;
1205 _tmp7_ = begin[1];
1206 switch (_tmp7_) {
1207 case 'a':
1208 {
1209 if (vala_scanner_matches (begin, "catch")) {
1210 result = VALA_TOKEN_TYPE_CATCH;
1211 return result;
1212 }
1213 break;
1214 }
1215 case 'l':
1216 {
1217 if (vala_scanner_matches (begin, "class")) {
1218 result = VALA_TOKEN_TYPE_CLASS;
1219 return result;
1220 }
1221 break;
1222 }
1223 case 'o':
1224 {
1225 if (vala_scanner_matches (begin, "const")) {
1226 result = VALA_TOKEN_TYPE_CONST;
1227 return result;
1228 }
1229 break;
1230 }
1231 default:
1232 break;
1233 }
1234 break;
1235 }
1236 case 'f':
1237 {
1238 if (vala_scanner_matches (begin, "false")) {
1239 result = VALA_TOKEN_TYPE_FALSE;
1240 return result;
1241 }
1242 break;
1243 }
1244 case 'o':
1245 {
1246 if (vala_scanner_matches (begin, "owned")) {
1247 result = VALA_TOKEN_TYPE_OWNED;
1248 return result;
1249 }
1250 break;
1251 }
1252 case 't':
1253 {
1254 if (vala_scanner_matches (begin, "throw")) {
1255 result = VALA_TOKEN_TYPE_THROW;
1256 return result;
1257 }
1258 break;
1259 }
1260 case 'u':
1261 {
1262 if (vala_scanner_matches (begin, "using")) {
1263 result = VALA_TOKEN_TYPE_USING;
1264 return result;
1265 }
1266 break;
1267 }
1268 case 'w':
1269 {
1270 if (vala_scanner_matches (begin, "while")) {
1271 result = VALA_TOKEN_TYPE_WHILE;
1272 return result;
1273 }
1274 break;
1275 }
1276 case 'y':
1277 {
1278 if (vala_scanner_matches (begin, "yield")) {
1279 result = VALA_TOKEN_TYPE_YIELD;
1280 return result;
1281 }
1282 break;
1283 }
1284 default:
1285 break;
1286 }
1287 break;
1288 }
1289 case 6:
1290 {
1291 gchar _tmp8_;
1292 _tmp8_ = begin[0];
1293 switch (_tmp8_) {
1294 case 'd':
1295 {
1296 if (vala_scanner_matches (begin, "delete")) {
1297 result = VALA_TOKEN_TYPE_DELETE;
1298 return result;
1299 }
1300 break;
1301 }
1302 case 'e':
1303 {
1304 if (vala_scanner_matches (begin, "extern")) {
1305 result = VALA_TOKEN_TYPE_EXTERN;
1306 return result;
1307 }
1308 break;
1309 }
1310 case 'i':
1311 {
1312 if (vala_scanner_matches (begin, "inline")) {
1313 result = VALA_TOKEN_TYPE_INLINE;
1314 return result;
1315 }
1316 break;
1317 }
1318 case 'p':
1319 {
1320 gchar _tmp9_;
1321 _tmp9_ = begin[1];
1322 switch (_tmp9_) {
1323 case 'a':
1324 {
1325 if (vala_scanner_matches (begin, "params")) {
1326 result = VALA_TOKEN_TYPE_PARAMS;
1327 return result;
1328 }
1329 break;
1330 }
1331 case 'u':
1332 {
1333 if (vala_scanner_matches (begin, "public")) {
1334 result = VALA_TOKEN_TYPE_PUBLIC;
1335 return result;
1336 }
1337 break;
1338 }
1339 default:
1340 break;
1341 }
1342 break;
1343 }
1344 case 'r':
1345 {
1346 if (vala_scanner_matches (begin, "return")) {
1347 result = VALA_TOKEN_TYPE_RETURN;
1348 return result;
1349 }
1350 break;
1351 }
1352 case 's':
1353 {
1354 gchar _tmp10_;
1355 _tmp10_ = begin[1];
1356 switch (_tmp10_) {
1357 case 'e':
1358 {
1359 if (vala_scanner_matches (begin, "sealed")) {
1360 result = VALA_TOKEN_TYPE_SEALED;
1361 return result;
1362 }
1363 break;
1364 }
1365 case 'i':
1366 {
1367 gchar _tmp11_;
1368 _tmp11_ = begin[2];
1369 switch (_tmp11_) {
1370 case 'g':
1371 {
1372 if (vala_scanner_matches (begin, "signal")) {
1373 result = VALA_TOKEN_TYPE_SIGNAL;
1374 return result;
1375 }
1376 break;
1377 }
1378 case 'z':
1379 {
1380 if (vala_scanner_matches (begin, "sizeof")) {
1381 result = VALA_TOKEN_TYPE_SIZEOF;
1382 return result;
1383 }
1384 break;
1385 }
1386 default:
1387 break;
1388 }
1389 break;
1390 }
1391 case 't':
1392 {
1393 gchar _tmp12_;
1394 _tmp12_ = begin[2];
1395 switch (_tmp12_) {
1396 case 'a':
1397 {
1398 if (vala_scanner_matches (begin, "static")) {
1399 result = VALA_TOKEN_TYPE_STATIC;
1400 return result;
1401 }
1402 break;
1403 }
1404 case 'r':
1405 {
1406 if (vala_scanner_matches (begin, "struct")) {
1407 result = VALA_TOKEN_TYPE_STRUCT;
1408 return result;
1409 }
1410 break;
1411 }
1412 default:
1413 break;
1414 }
1415 break;
1416 }
1417 case 'w':
1418 {
1419 if (vala_scanner_matches (begin, "switch")) {
1420 result = VALA_TOKEN_TYPE_SWITCH;
1421 return result;
1422 }
1423 break;
1424 }
1425 default:
1426 break;
1427 }
1428 break;
1429 }
1430 case 't':
1431 {
1432 gchar _tmp13_;
1433 _tmp13_ = begin[1];
1434 switch (_tmp13_) {
1435 case 'h':
1436 {
1437 if (vala_scanner_matches (begin, "throws")) {
1438 result = VALA_TOKEN_TYPE_THROWS;
1439 return result;
1440 }
1441 break;
1442 }
1443 case 'y':
1444 {
1445 if (vala_scanner_matches (begin, "typeof")) {
1446 result = VALA_TOKEN_TYPE_TYPEOF;
1447 return result;
1448 }
1449 break;
1450 }
1451 default:
1452 break;
1453 }
1454 break;
1455 }
1456 case 'u':
1457 {
1458 if (vala_scanner_matches (begin, "unlock")) {
1459 result = VALA_TOKEN_TYPE_UNLOCK;
1460 return result;
1461 }
1462 break;
1463 }
1464 default:
1465 break;
1466 }
1467 break;
1468 }
1469 case 7:
1470 {
1471 gchar _tmp14_;
1472 _tmp14_ = begin[0];
1473 switch (_tmp14_) {
1474 case 'd':
1475 {
1476 gchar _tmp15_;
1477 _tmp15_ = begin[1];
1478 switch (_tmp15_) {
1479 case 'e':
1480 {
1481 if (vala_scanner_matches (begin, "default")) {
1482 result = VALA_TOKEN_TYPE_DEFAULT;
1483 return result;
1484 }
1485 break;
1486 }
1487 case 'y':
1488 {
1489 if (vala_scanner_matches (begin, "dynamic")) {
1490 result = VALA_TOKEN_TYPE_DYNAMIC;
1491 return result;
1492 }
1493 break;
1494 }
1495 default:
1496 break;
1497 }
1498 break;
1499 }
1500 case 'e':
1501 {
1502 if (vala_scanner_matches (begin, "ensures")) {
1503 result = VALA_TOKEN_TYPE_ENSURES;
1504 return result;
1505 }
1506 break;
1507 }
1508 case 'f':
1509 {
1510 gchar _tmp16_;
1511 _tmp16_ = begin[1];
1512 switch (_tmp16_) {
1513 case 'i':
1514 {
1515 if (vala_scanner_matches (begin, "finally")) {
1516 result = VALA_TOKEN_TYPE_FINALLY;
1517 return result;
1518 }
1519 break;
1520 }
1521 case 'o':
1522 {
1523 if (vala_scanner_matches (begin, "foreach")) {
1524 result = VALA_TOKEN_TYPE_FOREACH;
1525 return result;
1526 }
1527 break;
1528 }
1529 default:
1530 break;
1531 }
1532 break;
1533 }
1534 case 'p':
1535 {
1536 if (vala_scanner_matches (begin, "private")) {
1537 result = VALA_TOKEN_TYPE_PRIVATE;
1538 return result;
1539 }
1540 break;
1541 }
1542 case 'u':
1543 {
1544 if (vala_scanner_matches (begin, "unowned")) {
1545 result = VALA_TOKEN_TYPE_UNOWNED;
1546 return result;
1547 }
1548 break;
1549 }
1550 case 'v':
1551 {
1552 if (vala_scanner_matches (begin, "virtual")) {
1553 result = VALA_TOKEN_TYPE_VIRTUAL;
1554 return result;
1555 }
1556 break;
1557 }
1558 default:
1559 break;
1560 }
1561 break;
1562 }
1563 case 8:
1564 {
1565 gchar _tmp17_;
1566 _tmp17_ = begin[0];
1567 switch (_tmp17_) {
1568 case 'a':
1569 {
1570 if (vala_scanner_matches (begin, "abstract")) {
1571 result = VALA_TOKEN_TYPE_ABSTRACT;
1572 return result;
1573 }
1574 break;
1575 }
1576 case 'c':
1577 {
1578 if (vala_scanner_matches (begin, "continue")) {
1579 result = VALA_TOKEN_TYPE_CONTINUE;
1580 return result;
1581 }
1582 break;
1583 }
1584 case 'd':
1585 {
1586 if (vala_scanner_matches (begin, "delegate")) {
1587 result = VALA_TOKEN_TYPE_DELEGATE;
1588 return result;
1589 }
1590 break;
1591 }
1592 case 'i':
1593 {
1594 if (vala_scanner_matches (begin, "internal")) {
1595 result = VALA_TOKEN_TYPE_INTERNAL;
1596 return result;
1597 }
1598 break;
1599 }
1600 case 'o':
1601 {
1602 if (vala_scanner_matches (begin, "override")) {
1603 result = VALA_TOKEN_TYPE_OVERRIDE;
1604 return result;
1605 }
1606 break;
1607 }
1608 case 'r':
1609 {
1610 if (vala_scanner_matches (begin, "requires")) {
1611 result = VALA_TOKEN_TYPE_REQUIRES;
1612 return result;
1613 }
1614 break;
1615 }
1616 case 'v':
1617 {
1618 if (vala_scanner_matches (begin, "volatile")) {
1619 result = VALA_TOKEN_TYPE_VOLATILE;
1620 return result;
1621 }
1622 break;
1623 }
1624 default:
1625 break;
1626 }
1627 break;
1628 }
1629 case 9:
1630 {
1631 gchar _tmp18_;
1632 _tmp18_ = begin[0];
1633 switch (_tmp18_) {
1634 case 'c':
1635 {
1636 if (vala_scanner_matches (begin, "construct")) {
1637 result = VALA_TOKEN_TYPE_CONSTRUCT;
1638 return result;
1639 }
1640 break;
1641 }
1642 case 'i':
1643 {
1644 if (vala_scanner_matches (begin, "interface")) {
1645 result = VALA_TOKEN_TYPE_INTERFACE;
1646 return result;
1647 }
1648 break;
1649 }
1650 case 'n':
1651 {
1652 if (vala_scanner_matches (begin, "namespace")) {
1653 result = VALA_TOKEN_TYPE_NAMESPACE;
1654 return result;
1655 }
1656 break;
1657 }
1658 case 'p':
1659 {
1660 if (vala_scanner_matches (begin, "protected")) {
1661 result = VALA_TOKEN_TYPE_PROTECTED;
1662 return result;
1663 }
1664 break;
1665 }
1666 default:
1667 break;
1668 }
1669 break;
1670 }
1671 case 11:
1672 {
1673 if (vala_scanner_matches (begin, "errordomain")) {
1674 result = VALA_TOKEN_TYPE_ERRORDOMAIN;
1675 return result;
1676 }
1677 break;
1678 }
1679 default:
1680 break;
1681 }
1682 result = VALA_TOKEN_TYPE_IDENTIFIER;
1683 return result;
1684 }
1685
1686 static ValaTokenType
vala_scanner_read_number(ValaScanner * self)1687 vala_scanner_read_number (ValaScanner* self)
1688 {
1689 ValaTokenType type = 0;
1690 gboolean _tmp0_ = FALSE;
1691 gboolean _tmp1_ = FALSE;
1692 gboolean _tmp2_ = FALSE;
1693 gchar* _tmp3_;
1694 gchar* _tmp4_;
1695 gboolean _tmp24_ = FALSE;
1696 gboolean _tmp25_ = FALSE;
1697 gchar* _tmp26_;
1698 gchar* _tmp27_;
1699 gboolean _tmp39_ = FALSE;
1700 gchar* _tmp40_;
1701 gchar* _tmp41_;
1702 gchar* _tmp60_;
1703 gchar* _tmp61_;
1704 ValaTokenType result = 0;
1705 g_return_val_if_fail (self != NULL, 0);
1706 type = VALA_TOKEN_TYPE_INTEGER_LITERAL;
1707 _tmp3_ = self->priv->current;
1708 _tmp4_ = self->priv->end;
1709 if (_tmp3_ < (_tmp4_ - 2)) {
1710 gchar* _tmp5_;
1711 gchar _tmp6_;
1712 _tmp5_ = self->priv->current;
1713 _tmp6_ = _tmp5_[0];
1714 _tmp2_ = _tmp6_ == '0';
1715 } else {
1716 _tmp2_ = FALSE;
1717 }
1718 if (_tmp2_) {
1719 gchar* _tmp7_;
1720 gchar _tmp8_;
1721 _tmp7_ = self->priv->current;
1722 _tmp8_ = _tmp7_[1];
1723 _tmp1_ = _tmp8_ == 'x';
1724 } else {
1725 _tmp1_ = FALSE;
1726 }
1727 if (_tmp1_) {
1728 gchar* _tmp9_;
1729 gchar _tmp10_;
1730 _tmp9_ = self->priv->current;
1731 _tmp10_ = _tmp9_[2];
1732 _tmp0_ = g_ascii_isxdigit (_tmp10_);
1733 } else {
1734 _tmp0_ = FALSE;
1735 }
1736 if (_tmp0_) {
1737 gchar* _tmp11_;
1738 _tmp11_ = self->priv->current;
1739 self->priv->current = _tmp11_ + 2;
1740 while (TRUE) {
1741 gboolean _tmp12_ = FALSE;
1742 gchar* _tmp13_;
1743 gchar* _tmp14_;
1744 gchar* _tmp17_;
1745 _tmp13_ = self->priv->current;
1746 _tmp14_ = self->priv->end;
1747 if (_tmp13_ < _tmp14_) {
1748 gchar* _tmp15_;
1749 gchar _tmp16_;
1750 _tmp15_ = self->priv->current;
1751 _tmp16_ = _tmp15_[0];
1752 _tmp12_ = g_ascii_isxdigit (_tmp16_);
1753 } else {
1754 _tmp12_ = FALSE;
1755 }
1756 if (!_tmp12_) {
1757 break;
1758 }
1759 _tmp17_ = self->priv->current;
1760 self->priv->current = _tmp17_ + 1;
1761 }
1762 } else {
1763 while (TRUE) {
1764 gboolean _tmp18_ = FALSE;
1765 gchar* _tmp19_;
1766 gchar* _tmp20_;
1767 gchar* _tmp23_;
1768 _tmp19_ = self->priv->current;
1769 _tmp20_ = self->priv->end;
1770 if (_tmp19_ < _tmp20_) {
1771 gchar* _tmp21_;
1772 gchar _tmp22_;
1773 _tmp21_ = self->priv->current;
1774 _tmp22_ = _tmp21_[0];
1775 _tmp18_ = g_ascii_isdigit (_tmp22_);
1776 } else {
1777 _tmp18_ = FALSE;
1778 }
1779 if (!_tmp18_) {
1780 break;
1781 }
1782 _tmp23_ = self->priv->current;
1783 self->priv->current = _tmp23_ + 1;
1784 }
1785 }
1786 _tmp26_ = self->priv->current;
1787 _tmp27_ = self->priv->end;
1788 if (_tmp26_ < (_tmp27_ - 1)) {
1789 gchar* _tmp28_;
1790 gchar _tmp29_;
1791 _tmp28_ = self->priv->current;
1792 _tmp29_ = _tmp28_[0];
1793 _tmp25_ = _tmp29_ == '.';
1794 } else {
1795 _tmp25_ = FALSE;
1796 }
1797 if (_tmp25_) {
1798 gchar* _tmp30_;
1799 gchar _tmp31_;
1800 _tmp30_ = self->priv->current;
1801 _tmp31_ = _tmp30_[1];
1802 _tmp24_ = g_ascii_isdigit (_tmp31_);
1803 } else {
1804 _tmp24_ = FALSE;
1805 }
1806 if (_tmp24_) {
1807 gchar* _tmp32_;
1808 type = VALA_TOKEN_TYPE_REAL_LITERAL;
1809 _tmp32_ = self->priv->current;
1810 self->priv->current = _tmp32_ + 1;
1811 while (TRUE) {
1812 gboolean _tmp33_ = FALSE;
1813 gchar* _tmp34_;
1814 gchar* _tmp35_;
1815 gchar* _tmp38_;
1816 _tmp34_ = self->priv->current;
1817 _tmp35_ = self->priv->end;
1818 if (_tmp34_ < _tmp35_) {
1819 gchar* _tmp36_;
1820 gchar _tmp37_;
1821 _tmp36_ = self->priv->current;
1822 _tmp37_ = _tmp36_[0];
1823 _tmp33_ = g_ascii_isdigit (_tmp37_);
1824 } else {
1825 _tmp33_ = FALSE;
1826 }
1827 if (!_tmp33_) {
1828 break;
1829 }
1830 _tmp38_ = self->priv->current;
1831 self->priv->current = _tmp38_ + 1;
1832 }
1833 }
1834 _tmp40_ = self->priv->current;
1835 _tmp41_ = self->priv->end;
1836 if (_tmp40_ < _tmp41_) {
1837 gchar* _tmp42_;
1838 gchar _tmp43_;
1839 _tmp42_ = self->priv->current;
1840 _tmp43_ = _tmp42_[0];
1841 _tmp39_ = g_ascii_tolower (_tmp43_) == 'e';
1842 } else {
1843 _tmp39_ = FALSE;
1844 }
1845 if (_tmp39_) {
1846 gchar* _tmp44_;
1847 gboolean _tmp45_ = FALSE;
1848 gchar* _tmp46_;
1849 gchar* _tmp47_;
1850 type = VALA_TOKEN_TYPE_REAL_LITERAL;
1851 _tmp44_ = self->priv->current;
1852 self->priv->current = _tmp44_ + 1;
1853 _tmp46_ = self->priv->current;
1854 _tmp47_ = self->priv->end;
1855 if (_tmp46_ < _tmp47_) {
1856 gboolean _tmp48_ = FALSE;
1857 gchar* _tmp49_;
1858 gchar _tmp50_;
1859 _tmp49_ = self->priv->current;
1860 _tmp50_ = _tmp49_[0];
1861 if (_tmp50_ == '+') {
1862 _tmp48_ = TRUE;
1863 } else {
1864 gchar* _tmp51_;
1865 gchar _tmp52_;
1866 _tmp51_ = self->priv->current;
1867 _tmp52_ = _tmp51_[0];
1868 _tmp48_ = _tmp52_ == '-';
1869 }
1870 _tmp45_ = _tmp48_;
1871 } else {
1872 _tmp45_ = FALSE;
1873 }
1874 if (_tmp45_) {
1875 gchar* _tmp53_;
1876 _tmp53_ = self->priv->current;
1877 self->priv->current = _tmp53_ + 1;
1878 }
1879 while (TRUE) {
1880 gboolean _tmp54_ = FALSE;
1881 gchar* _tmp55_;
1882 gchar* _tmp56_;
1883 gchar* _tmp59_;
1884 _tmp55_ = self->priv->current;
1885 _tmp56_ = self->priv->end;
1886 if (_tmp55_ < _tmp56_) {
1887 gchar* _tmp57_;
1888 gchar _tmp58_;
1889 _tmp57_ = self->priv->current;
1890 _tmp58_ = _tmp57_[0];
1891 _tmp54_ = g_ascii_isdigit (_tmp58_);
1892 } else {
1893 _tmp54_ = FALSE;
1894 }
1895 if (!_tmp54_) {
1896 break;
1897 }
1898 _tmp59_ = self->priv->current;
1899 self->priv->current = _tmp59_ + 1;
1900 }
1901 }
1902 _tmp60_ = self->priv->current;
1903 _tmp61_ = self->priv->end;
1904 if (_tmp60_ < _tmp61_) {
1905 gboolean real_literal = FALSE;
1906 ValaTokenType _tmp62_;
1907 gchar* _tmp63_;
1908 gchar _tmp64_;
1909 gboolean _tmp88_ = FALSE;
1910 _tmp62_ = type;
1911 real_literal = _tmp62_ == VALA_TOKEN_TYPE_REAL_LITERAL;
1912 _tmp63_ = self->priv->current;
1913 _tmp64_ = _tmp63_[0];
1914 switch (_tmp64_) {
1915 case 'l':
1916 case 'L':
1917 {
1918 ValaTokenType _tmp65_;
1919 _tmp65_ = type;
1920 if (_tmp65_ == VALA_TOKEN_TYPE_INTEGER_LITERAL) {
1921 gchar* _tmp66_;
1922 gboolean _tmp67_ = FALSE;
1923 gchar* _tmp68_;
1924 gchar* _tmp69_;
1925 _tmp66_ = self->priv->current;
1926 self->priv->current = _tmp66_ + 1;
1927 _tmp68_ = self->priv->current;
1928 _tmp69_ = self->priv->end;
1929 if (_tmp68_ < _tmp69_) {
1930 gchar* _tmp70_;
1931 gchar _tmp71_;
1932 _tmp70_ = self->priv->current;
1933 _tmp71_ = _tmp70_[0];
1934 _tmp67_ = g_ascii_tolower (_tmp71_) == 'l';
1935 } else {
1936 _tmp67_ = FALSE;
1937 }
1938 if (_tmp67_) {
1939 gchar* _tmp72_;
1940 _tmp72_ = self->priv->current;
1941 self->priv->current = _tmp72_ + 1;
1942 }
1943 }
1944 break;
1945 }
1946 case 'u':
1947 case 'U':
1948 {
1949 ValaTokenType _tmp73_;
1950 _tmp73_ = type;
1951 if (_tmp73_ == VALA_TOKEN_TYPE_INTEGER_LITERAL) {
1952 gchar* _tmp74_;
1953 gboolean _tmp75_ = FALSE;
1954 gchar* _tmp76_;
1955 gchar* _tmp77_;
1956 _tmp74_ = self->priv->current;
1957 self->priv->current = _tmp74_ + 1;
1958 _tmp76_ = self->priv->current;
1959 _tmp77_ = self->priv->end;
1960 if (_tmp76_ < _tmp77_) {
1961 gchar* _tmp78_;
1962 gchar _tmp79_;
1963 _tmp78_ = self->priv->current;
1964 _tmp79_ = _tmp78_[0];
1965 _tmp75_ = g_ascii_tolower (_tmp79_) == 'l';
1966 } else {
1967 _tmp75_ = FALSE;
1968 }
1969 if (_tmp75_) {
1970 gchar* _tmp80_;
1971 gboolean _tmp81_ = FALSE;
1972 gchar* _tmp82_;
1973 gchar* _tmp83_;
1974 _tmp80_ = self->priv->current;
1975 self->priv->current = _tmp80_ + 1;
1976 _tmp82_ = self->priv->current;
1977 _tmp83_ = self->priv->end;
1978 if (_tmp82_ < _tmp83_) {
1979 gchar* _tmp84_;
1980 gchar _tmp85_;
1981 _tmp84_ = self->priv->current;
1982 _tmp85_ = _tmp84_[0];
1983 _tmp81_ = g_ascii_tolower (_tmp85_) == 'l';
1984 } else {
1985 _tmp81_ = FALSE;
1986 }
1987 if (_tmp81_) {
1988 gchar* _tmp86_;
1989 _tmp86_ = self->priv->current;
1990 self->priv->current = _tmp86_ + 1;
1991 }
1992 }
1993 }
1994 break;
1995 }
1996 case 'f':
1997 case 'F':
1998 case 'd':
1999 case 'D':
2000 {
2001 gchar* _tmp87_;
2002 type = VALA_TOKEN_TYPE_REAL_LITERAL;
2003 _tmp87_ = self->priv->current;
2004 self->priv->current = _tmp87_ + 1;
2005 break;
2006 }
2007 default:
2008 break;
2009 }
2010 if (!real_literal) {
2011 gchar* _tmp89_;
2012 gchar _tmp90_;
2013 _tmp89_ = self->priv->current;
2014 _tmp90_ = _tmp89_[0];
2015 _tmp88_ = vala_scanner_is_ident_char (self, _tmp90_);
2016 } else {
2017 _tmp88_ = FALSE;
2018 }
2019 if (_tmp88_) {
2020 while (TRUE) {
2021 gboolean _tmp91_ = FALSE;
2022 gchar* _tmp92_;
2023 gchar* _tmp93_;
2024 gchar* _tmp96_;
2025 _tmp92_ = self->priv->current;
2026 _tmp93_ = self->priv->end;
2027 if (_tmp92_ < _tmp93_) {
2028 gchar* _tmp94_;
2029 gchar _tmp95_;
2030 _tmp94_ = self->priv->current;
2031 _tmp95_ = _tmp94_[0];
2032 _tmp91_ = vala_scanner_is_ident_char (self, _tmp95_);
2033 } else {
2034 _tmp91_ = FALSE;
2035 }
2036 if (!_tmp91_) {
2037 break;
2038 }
2039 _tmp96_ = self->priv->current;
2040 self->priv->current = _tmp96_ + 1;
2041 }
2042 type = VALA_TOKEN_TYPE_IDENTIFIER;
2043 }
2044 }
2045 result = type;
2046 return result;
2047 }
2048
2049 static void
_vala_array_add13(ValaScannerState ** array,gint * length,gint * size,ValaScannerState value)2050 _vala_array_add13 (ValaScannerState* * array,
2051 gint* length,
2052 gint* size,
2053 ValaScannerState value)
2054 {
2055 if ((*length) == (*size)) {
2056 *size = (*size) ? (2 * (*size)) : 4;
2057 *array = g_renew (ValaScannerState, *array, *size);
2058 }
2059 (*array)[(*length)++] = value;
2060 }
2061
2062 static void
_vala_array_add14(ValaScannerState ** array,gint * length,gint * size,ValaScannerState value)2063 _vala_array_add14 (ValaScannerState* * array,
2064 gint* length,
2065 gint* size,
2066 ValaScannerState value)
2067 {
2068 if ((*length) == (*size)) {
2069 *size = (*size) ? (2 * (*size)) : 4;
2070 *array = g_renew (ValaScannerState, *array, *size);
2071 }
2072 (*array)[(*length)++] = value;
2073 }
2074
2075 static void
_vala_array_add15(ValaScannerState ** array,gint * length,gint * size,ValaScannerState value)2076 _vala_array_add15 (ValaScannerState* * array,
2077 gint* length,
2078 gint* size,
2079 ValaScannerState value)
2080 {
2081 if ((*length) == (*size)) {
2082 *size = (*size) ? (2 * (*size)) : 4;
2083 *array = g_renew (ValaScannerState, *array, *size);
2084 }
2085 (*array)[(*length)++] = value;
2086 }
2087
2088 static void
_vala_array_add16(ValaScannerState ** array,gint * length,gint * size,ValaScannerState value)2089 _vala_array_add16 (ValaScannerState* * array,
2090 gint* length,
2091 gint* size,
2092 ValaScannerState value)
2093 {
2094 if ((*length) == (*size)) {
2095 *size = (*size) ? (2 * (*size)) : 4;
2096 *array = g_renew (ValaScannerState, *array, *size);
2097 }
2098 (*array)[(*length)++] = value;
2099 }
2100
2101 ValaTokenType
vala_scanner_read_template_token(ValaScanner * self,ValaSourceLocation * token_begin,ValaSourceLocation * token_end)2102 vala_scanner_read_template_token (ValaScanner* self,
2103 ValaSourceLocation* token_begin,
2104 ValaSourceLocation* token_end)
2105 {
2106 ValaSourceLocation _vala_token_begin = {0};
2107 ValaSourceLocation _vala_token_end = {0};
2108 ValaTokenType type = 0;
2109 gchar* begin = NULL;
2110 gchar* _tmp0_;
2111 gchar* _tmp1_;
2112 gint token_length_in_chars = 0;
2113 gchar* _tmp2_;
2114 gchar* _tmp3_;
2115 gchar* _tmp111_;
2116 ValaTokenType result = 0;
2117 g_return_val_if_fail (self != NULL, 0);
2118 _tmp0_ = self->priv->current;
2119 begin = _tmp0_;
2120 _tmp1_ = begin;
2121 vala_source_location_init (&_vala_token_begin, _tmp1_, self->priv->line, self->priv->column);
2122 token_length_in_chars = -1;
2123 _tmp2_ = self->priv->current;
2124 _tmp3_ = self->priv->end;
2125 if (_tmp2_ >= _tmp3_) {
2126 type = VALA_TOKEN_TYPE_EOF;
2127 } else {
2128 gchar* _tmp4_;
2129 gchar _tmp5_;
2130 _tmp4_ = self->priv->current;
2131 _tmp5_ = _tmp4_[0];
2132 switch (_tmp5_) {
2133 case '"':
2134 {
2135 gchar* _tmp6_;
2136 gint _tmp7_;
2137 type = VALA_TOKEN_TYPE_CLOSE_TEMPLATE;
2138 _tmp6_ = self->priv->current;
2139 self->priv->current = _tmp6_ + 1;
2140 _tmp7_ = self->priv->state_stack_length1;
2141 self->priv->state_stack_length1 = _tmp7_ - 1;
2142 break;
2143 }
2144 case '$':
2145 {
2146 gchar* _tmp8_;
2147 gchar* _tmp9_;
2148 gboolean _tmp10_ = FALSE;
2149 gchar* _tmp11_;
2150 gchar _tmp12_;
2151 _tmp8_ = _vala_token_begin.pos;
2152 _vala_token_begin.pos = _tmp8_ + 1;
2153 _tmp9_ = self->priv->current;
2154 self->priv->current = _tmp9_ + 1;
2155 _tmp11_ = self->priv->current;
2156 _tmp12_ = _tmp11_[0];
2157 if (g_ascii_isalpha (_tmp12_)) {
2158 _tmp10_ = TRUE;
2159 } else {
2160 gchar* _tmp13_;
2161 gchar _tmp14_;
2162 _tmp13_ = self->priv->current;
2163 _tmp14_ = _tmp13_[0];
2164 _tmp10_ = _tmp14_ == '_';
2165 }
2166 if (_tmp10_) {
2167 gint len = 0;
2168 len = 0;
2169 while (TRUE) {
2170 gboolean _tmp15_ = FALSE;
2171 gchar* _tmp16_;
2172 gchar* _tmp17_;
2173 gchar* _tmp20_;
2174 gint _tmp21_;
2175 _tmp16_ = self->priv->current;
2176 _tmp17_ = self->priv->end;
2177 if (_tmp16_ < _tmp17_) {
2178 gchar* _tmp18_;
2179 gchar _tmp19_;
2180 _tmp18_ = self->priv->current;
2181 _tmp19_ = _tmp18_[0];
2182 _tmp15_ = vala_scanner_is_ident_char (self, _tmp19_);
2183 } else {
2184 _tmp15_ = FALSE;
2185 }
2186 if (!_tmp15_) {
2187 break;
2188 }
2189 _tmp20_ = self->priv->current;
2190 self->priv->current = _tmp20_ + 1;
2191 _tmp21_ = len;
2192 len = _tmp21_ + 1;
2193 }
2194 type = VALA_TOKEN_TYPE_IDENTIFIER;
2195 _vala_array_add13 (&self->priv->state_stack, &self->priv->state_stack_length1, &self->priv->_state_stack_size_, VALA_SCANNER_STATE_TEMPLATE_PART);
2196 } else {
2197 gchar* _tmp22_;
2198 gchar _tmp23_;
2199 _tmp22_ = self->priv->current;
2200 _tmp23_ = _tmp22_[0];
2201 if (_tmp23_ == '(') {
2202 gchar* _tmp24_;
2203 ValaSourceLocation _tmp25_ = {0};
2204 ValaSourceLocation _tmp26_ = {0};
2205 ValaTokenType _tmp27_;
2206 _tmp24_ = self->priv->current;
2207 self->priv->current = _tmp24_ + 1;
2208 self->priv->column = self->priv->column + 2;
2209 _vala_array_add14 (&self->priv->state_stack, &self->priv->state_stack_length1, &self->priv->_state_stack_size_, VALA_SCANNER_STATE_PARENS);
2210 _tmp27_ = vala_scanner_read_token (self, &_tmp25_, &_tmp26_);
2211 _vala_token_begin = _tmp25_;
2212 _vala_token_end = _tmp26_;
2213 result = _tmp27_;
2214 if (token_begin) {
2215 *token_begin = _vala_token_begin;
2216 }
2217 if (token_end) {
2218 *token_end = _vala_token_end;
2219 }
2220 return result;
2221 } else {
2222 gchar* _tmp28_;
2223 gchar _tmp29_;
2224 _tmp28_ = self->priv->current;
2225 _tmp29_ = _tmp28_[0];
2226 if (_tmp29_ == '$') {
2227 gchar* _tmp30_;
2228 type = VALA_TOKEN_TYPE_TEMPLATE_STRING_LITERAL;
2229 _tmp30_ = self->priv->current;
2230 self->priv->current = _tmp30_ + 1;
2231 _vala_array_add15 (&self->priv->state_stack, &self->priv->state_stack_length1, &self->priv->_state_stack_size_, VALA_SCANNER_STATE_TEMPLATE_PART);
2232 } else {
2233 ValaSourceReference* _tmp31_;
2234 ValaSourceReference* _tmp32_;
2235 ValaSourceLocation _tmp33_ = {0};
2236 ValaSourceLocation _tmp34_ = {0};
2237 ValaTokenType _tmp35_;
2238 _tmp31_ = vala_scanner_get_source_reference (self, 1, 0);
2239 _tmp32_ = _tmp31_;
2240 vala_report_error (_tmp32_, "unexpected character");
2241 _vala_source_reference_unref0 (_tmp32_);
2242 _tmp35_ = vala_scanner_read_template_token (self, &_tmp33_, &_tmp34_);
2243 _vala_token_begin = _tmp33_;
2244 _vala_token_end = _tmp34_;
2245 result = _tmp35_;
2246 if (token_begin) {
2247 *token_begin = _vala_token_begin;
2248 }
2249 if (token_end) {
2250 *token_end = _vala_token_end;
2251 }
2252 return result;
2253 }
2254 }
2255 }
2256 break;
2257 }
2258 default:
2259 {
2260 gchar* _tmp101_;
2261 gchar* _tmp102_;
2262 type = VALA_TOKEN_TYPE_TEMPLATE_STRING_LITERAL;
2263 token_length_in_chars = 0;
2264 while (TRUE) {
2265 gboolean _tmp36_ = FALSE;
2266 gboolean _tmp37_ = FALSE;
2267 gchar* _tmp38_;
2268 gchar* _tmp39_;
2269 gchar* _tmp44_;
2270 gchar _tmp45_;
2271 _tmp38_ = self->priv->current;
2272 _tmp39_ = self->priv->end;
2273 if (_tmp38_ < _tmp39_) {
2274 gchar* _tmp40_;
2275 gchar _tmp41_;
2276 _tmp40_ = self->priv->current;
2277 _tmp41_ = _tmp40_[0];
2278 _tmp37_ = _tmp41_ != '"';
2279 } else {
2280 _tmp37_ = FALSE;
2281 }
2282 if (_tmp37_) {
2283 gchar* _tmp42_;
2284 gchar _tmp43_;
2285 _tmp42_ = self->priv->current;
2286 _tmp43_ = _tmp42_[0];
2287 _tmp36_ = _tmp43_ != '$';
2288 } else {
2289 _tmp36_ = FALSE;
2290 }
2291 if (!_tmp36_) {
2292 break;
2293 }
2294 _tmp44_ = self->priv->current;
2295 _tmp45_ = _tmp44_[0];
2296 if (_tmp45_ == '\\') {
2297 gchar* _tmp46_;
2298 gint _tmp47_;
2299 gchar* _tmp48_;
2300 gchar* _tmp49_;
2301 gchar* _tmp50_;
2302 gchar _tmp51_;
2303 _tmp46_ = self->priv->current;
2304 self->priv->current = _tmp46_ + 1;
2305 _tmp47_ = token_length_in_chars;
2306 token_length_in_chars = _tmp47_ + 1;
2307 _tmp48_ = self->priv->current;
2308 _tmp49_ = self->priv->end;
2309 if (_tmp48_ >= _tmp49_) {
2310 break;
2311 }
2312 _tmp50_ = self->priv->current;
2313 _tmp51_ = _tmp50_[0];
2314 switch (_tmp51_) {
2315 case '\'':
2316 case '"':
2317 case '\\':
2318 case '0':
2319 case 'b':
2320 case 'f':
2321 case 'n':
2322 case 'r':
2323 case 't':
2324 case 'v':
2325 {
2326 gchar* _tmp52_;
2327 gint _tmp53_;
2328 _tmp52_ = self->priv->current;
2329 self->priv->current = _tmp52_ + 1;
2330 _tmp53_ = token_length_in_chars;
2331 token_length_in_chars = _tmp53_ + 1;
2332 break;
2333 }
2334 case 'u':
2335 {
2336 gchar* _tmp54_;
2337 gint _tmp55_;
2338 gint digit_length = 0;
2339 _tmp54_ = self->priv->current;
2340 self->priv->current = _tmp54_ + 1;
2341 _tmp55_ = token_length_in_chars;
2342 token_length_in_chars = _tmp55_ + 1;
2343 {
2344 gboolean _tmp56_ = FALSE;
2345 digit_length = 0;
2346 _tmp56_ = TRUE;
2347 while (TRUE) {
2348 gboolean _tmp58_ = FALSE;
2349 gchar* _tmp59_;
2350 gchar* _tmp60_;
2351 gchar* _tmp63_;
2352 gint _tmp64_;
2353 if (!_tmp56_) {
2354 gint _tmp57_;
2355 _tmp57_ = digit_length;
2356 digit_length = _tmp57_ + 1;
2357 }
2358 _tmp56_ = FALSE;
2359 _tmp59_ = self->priv->current;
2360 _tmp60_ = self->priv->end;
2361 if (_tmp59_ < _tmp60_) {
2362 gchar* _tmp61_;
2363 gchar _tmp62_;
2364 _tmp61_ = self->priv->current;
2365 _tmp62_ = _tmp61_[0];
2366 _tmp58_ = g_ascii_isxdigit (_tmp62_);
2367 } else {
2368 _tmp58_ = FALSE;
2369 }
2370 if (!_tmp58_) {
2371 break;
2372 }
2373 _tmp63_ = self->priv->current;
2374 self->priv->current = _tmp63_ + 1;
2375 _tmp64_ = token_length_in_chars;
2376 token_length_in_chars = _tmp64_ + 1;
2377 }
2378 }
2379 if (digit_length < 1) {
2380 ValaSourceReference* _tmp65_;
2381 ValaSourceReference* _tmp66_;
2382 _tmp65_ = vala_scanner_get_source_reference (self, token_length_in_chars, 0);
2383 _tmp66_ = _tmp65_;
2384 vala_report_error (_tmp66_, "\\u used with no following hex digits");
2385 _vala_source_reference_unref0 (_tmp66_);
2386 } else {
2387 if (digit_length < 4) {
2388 ValaSourceReference* _tmp67_;
2389 ValaSourceReference* _tmp68_;
2390 _tmp67_ = vala_scanner_get_source_reference (self, token_length_in_chars, 0);
2391 _tmp68_ = _tmp67_;
2392 vala_report_error (_tmp68_, "incomplete universal character name");
2393 _vala_source_reference_unref0 (_tmp68_);
2394 }
2395 }
2396 break;
2397 }
2398 case 'x':
2399 {
2400 gchar* _tmp69_;
2401 gint _tmp70_;
2402 gint digit_length = 0;
2403 gboolean empty = FALSE;
2404 gboolean _tmp82_ = FALSE;
2405 _tmp69_ = self->priv->current;
2406 self->priv->current = _tmp69_ + 1;
2407 _tmp70_ = token_length_in_chars;
2408 token_length_in_chars = _tmp70_ + 1;
2409 empty = TRUE;
2410 {
2411 gboolean _tmp71_ = FALSE;
2412 digit_length = 0;
2413 _tmp71_ = TRUE;
2414 while (TRUE) {
2415 gboolean _tmp72_ = FALSE;
2416 gchar* _tmp73_;
2417 gchar* _tmp74_;
2418 gchar* _tmp77_;
2419 gchar _tmp78_;
2420 gchar* _tmp80_;
2421 gint _tmp81_;
2422 if (!_tmp71_) {
2423 }
2424 _tmp71_ = FALSE;
2425 _tmp73_ = self->priv->current;
2426 _tmp74_ = self->priv->end;
2427 if (_tmp73_ < _tmp74_) {
2428 gchar* _tmp75_;
2429 gchar _tmp76_;
2430 _tmp75_ = self->priv->current;
2431 _tmp76_ = _tmp75_[0];
2432 _tmp72_ = g_ascii_isxdigit (_tmp76_);
2433 } else {
2434 _tmp72_ = FALSE;
2435 }
2436 if (!_tmp72_) {
2437 break;
2438 }
2439 _tmp77_ = self->priv->current;
2440 _tmp78_ = _tmp77_[0];
2441 if (_tmp78_ != '0') {
2442 gint _tmp79_;
2443 _tmp79_ = digit_length;
2444 digit_length = _tmp79_ + 1;
2445 } else {
2446 empty = FALSE;
2447 }
2448 _tmp80_ = self->priv->current;
2449 self->priv->current = _tmp80_ + 1;
2450 _tmp81_ = token_length_in_chars;
2451 token_length_in_chars = _tmp81_ + 1;
2452 }
2453 }
2454 if (empty) {
2455 _tmp82_ = digit_length < 1;
2456 } else {
2457 _tmp82_ = FALSE;
2458 }
2459 if (_tmp82_) {
2460 ValaSourceReference* _tmp83_;
2461 ValaSourceReference* _tmp84_;
2462 _tmp83_ = vala_scanner_get_source_reference (self, token_length_in_chars, 0);
2463 _tmp84_ = _tmp83_;
2464 vala_report_error (_tmp84_, "\\x used with no following hex digits");
2465 _vala_source_reference_unref0 (_tmp84_);
2466 } else {
2467 if (digit_length > 2) {
2468 ValaSourceReference* _tmp85_;
2469 ValaSourceReference* _tmp86_;
2470 _tmp85_ = vala_scanner_get_source_reference (self, token_length_in_chars, 0);
2471 _tmp86_ = _tmp85_;
2472 vala_report_error (_tmp86_, "hex escape sequence out of range");
2473 _vala_source_reference_unref0 (_tmp86_);
2474 }
2475 }
2476 break;
2477 }
2478 default:
2479 {
2480 ValaSourceReference* _tmp87_;
2481 ValaSourceReference* _tmp88_;
2482 _tmp87_ = vala_scanner_get_source_reference (self, token_length_in_chars, 0);
2483 _tmp88_ = _tmp87_;
2484 vala_report_error (_tmp88_, "invalid escape sequence");
2485 _vala_source_reference_unref0 (_tmp88_);
2486 break;
2487 }
2488 }
2489 } else {
2490 gchar* _tmp89_;
2491 gchar _tmp90_;
2492 _tmp89_ = self->priv->current;
2493 _tmp90_ = _tmp89_[0];
2494 if (_tmp90_ == '\n') {
2495 gchar* _tmp91_;
2496 gint _tmp92_;
2497 _tmp91_ = self->priv->current;
2498 self->priv->current = _tmp91_ + 1;
2499 _tmp92_ = self->priv->line;
2500 self->priv->line = _tmp92_ + 1;
2501 self->priv->column = 1;
2502 token_length_in_chars = 1;
2503 } else {
2504 gunichar u = 0U;
2505 gchar* _tmp93_;
2506 gchar* _tmp94_;
2507 gchar* _tmp95_;
2508 _tmp93_ = self->priv->current;
2509 _tmp94_ = self->priv->end;
2510 _tmp95_ = self->priv->current;
2511 u = g_utf8_get_char_validated ((const gchar*) _tmp93_, (gssize) ((glong) (_tmp94_ - _tmp95_)));
2512 if (u != ((gunichar) -1)) {
2513 gchar* _tmp96_;
2514 gint _tmp97_;
2515 _tmp96_ = self->priv->current;
2516 self->priv->current = _tmp96_ + g_unichar_to_utf8 (u, NULL);
2517 _tmp97_ = token_length_in_chars;
2518 token_length_in_chars = _tmp97_ + 1;
2519 } else {
2520 gchar* _tmp98_;
2521 ValaSourceReference* _tmp99_;
2522 ValaSourceReference* _tmp100_;
2523 _tmp98_ = self->priv->current;
2524 self->priv->current = _tmp98_ + 1;
2525 _tmp99_ = vala_scanner_get_source_reference (self, token_length_in_chars, 0);
2526 _tmp100_ = _tmp99_;
2527 vala_report_error (_tmp100_, "invalid UTF-8 character");
2528 _vala_source_reference_unref0 (_tmp100_);
2529 }
2530 }
2531 }
2532 }
2533 _tmp101_ = self->priv->current;
2534 _tmp102_ = self->priv->end;
2535 if (_tmp101_ >= _tmp102_) {
2536 ValaSourceReference* _tmp103_;
2537 ValaSourceReference* _tmp104_;
2538 gint _tmp105_;
2539 ValaSourceLocation _tmp106_ = {0};
2540 ValaSourceLocation _tmp107_ = {0};
2541 ValaTokenType _tmp108_;
2542 _tmp103_ = vala_scanner_get_source_reference (self, token_length_in_chars, 0);
2543 _tmp104_ = _tmp103_;
2544 vala_report_error (_tmp104_, "syntax error, expected \"");
2545 _vala_source_reference_unref0 (_tmp104_);
2546 _tmp105_ = self->priv->state_stack_length1;
2547 self->priv->state_stack_length1 = _tmp105_ - 1;
2548 _tmp108_ = vala_scanner_read_token (self, &_tmp106_, &_tmp107_);
2549 _vala_token_begin = _tmp106_;
2550 _vala_token_end = _tmp107_;
2551 result = _tmp108_;
2552 if (token_begin) {
2553 *token_begin = _vala_token_begin;
2554 }
2555 if (token_end) {
2556 *token_end = _vala_token_end;
2557 }
2558 return result;
2559 }
2560 _vala_array_add16 (&self->priv->state_stack, &self->priv->state_stack_length1, &self->priv->_state_stack_size_, VALA_SCANNER_STATE_TEMPLATE_PART);
2561 break;
2562 }
2563 }
2564 }
2565 if (token_length_in_chars < 0) {
2566 gchar* _tmp109_;
2567 gchar* _tmp110_;
2568 _tmp109_ = self->priv->current;
2569 _tmp110_ = begin;
2570 self->priv->column = self->priv->column + ((gint) (_tmp109_ - _tmp110_));
2571 } else {
2572 self->priv->column = self->priv->column + token_length_in_chars;
2573 }
2574 _tmp111_ = self->priv->current;
2575 vala_source_location_init (&_vala_token_end, _tmp111_, self->priv->line, self->priv->column - 1);
2576 result = type;
2577 if (token_begin) {
2578 *token_begin = _vala_token_begin;
2579 }
2580 if (token_end) {
2581 *token_end = _vala_token_end;
2582 }
2583 return result;
2584 }
2585
2586 static void
_vala_array_add17(ValaScannerState ** array,gint * length,gint * size,ValaScannerState value)2587 _vala_array_add17 (ValaScannerState* * array,
2588 gint* length,
2589 gint* size,
2590 ValaScannerState value)
2591 {
2592 if ((*length) == (*size)) {
2593 *size = (*size) ? (2 * (*size)) : 4;
2594 *array = g_renew (ValaScannerState, *array, *size);
2595 }
2596 (*array)[(*length)++] = value;
2597 }
2598
2599 static void
_vala_array_add18(ValaScannerState ** array,gint * length,gint * size,ValaScannerState value)2600 _vala_array_add18 (ValaScannerState* * array,
2601 gint* length,
2602 gint* size,
2603 ValaScannerState value)
2604 {
2605 if ((*length) == (*size)) {
2606 *size = (*size) ? (2 * (*size)) : 4;
2607 *array = g_renew (ValaScannerState, *array, *size);
2608 }
2609 (*array)[(*length)++] = value;
2610 }
2611
2612 static void
_vala_array_add19(ValaScannerState ** array,gint * length,gint * size,ValaScannerState value)2613 _vala_array_add19 (ValaScannerState* * array,
2614 gint* length,
2615 gint* size,
2616 ValaScannerState value)
2617 {
2618 if ((*length) == (*size)) {
2619 *size = (*size) ? (2 * (*size)) : 4;
2620 *array = g_renew (ValaScannerState, *array, *size);
2621 }
2622 (*array)[(*length)++] = value;
2623 }
2624
2625 static void
_vala_array_add20(ValaScannerState ** array,gint * length,gint * size,ValaScannerState value)2626 _vala_array_add20 (ValaScannerState* * array,
2627 gint* length,
2628 gint* size,
2629 ValaScannerState value)
2630 {
2631 if ((*length) == (*size)) {
2632 *size = (*size) ? (2 * (*size)) : 4;
2633 *array = g_renew (ValaScannerState, *array, *size);
2634 }
2635 (*array)[(*length)++] = value;
2636 }
2637
2638 static void
_vala_array_add21(ValaScannerState ** array,gint * length,gint * size,ValaScannerState value)2639 _vala_array_add21 (ValaScannerState* * array,
2640 gint* length,
2641 gint* size,
2642 ValaScannerState value)
2643 {
2644 if ((*length) == (*size)) {
2645 *size = (*size) ? (2 * (*size)) : 4;
2646 *array = g_renew (ValaScannerState, *array, *size);
2647 }
2648 (*array)[(*length)++] = value;
2649 }
2650
2651 ValaTokenType
vala_scanner_read_token(ValaScanner * self,ValaSourceLocation * token_begin,ValaSourceLocation * token_end)2652 vala_scanner_read_token (ValaScanner* self,
2653 ValaSourceLocation* token_begin,
2654 ValaSourceLocation* token_end)
2655 {
2656 ValaSourceLocation _vala_token_begin = {0};
2657 ValaSourceLocation _vala_token_end = {0};
2658 ValaTokenType type = 0;
2659 gchar* begin = NULL;
2660 gchar* _tmp9_;
2661 gchar* _tmp10_;
2662 gint token_length_in_chars = 0;
2663 gchar* _tmp11_;
2664 gchar* _tmp12_;
2665 gchar* _tmp324_;
2666 ValaTokenType _tmp325_;
2667 ValaTokenType result = 0;
2668 g_return_val_if_fail (self != NULL, 0);
2669 if (vala_scanner_in_template (self)) {
2670 ValaSourceLocation _tmp0_ = {0};
2671 ValaSourceLocation _tmp1_ = {0};
2672 ValaTokenType _tmp2_;
2673 _tmp2_ = vala_scanner_read_template_token (self, &_tmp0_, &_tmp1_);
2674 _vala_token_begin = _tmp0_;
2675 _vala_token_end = _tmp1_;
2676 result = _tmp2_;
2677 if (token_begin) {
2678 *token_begin = _vala_token_begin;
2679 }
2680 if (token_end) {
2681 *token_end = _vala_token_end;
2682 }
2683 return result;
2684 } else {
2685 if (vala_scanner_in_template_part (self)) {
2686 gint _tmp3_;
2687 gchar* _tmp4_;
2688 gchar* _tmp5_;
2689 _tmp3_ = self->priv->state_stack_length1;
2690 self->priv->state_stack_length1 = _tmp3_ - 1;
2691 _tmp4_ = self->priv->current;
2692 vala_source_location_init (&_vala_token_begin, _tmp4_, self->priv->line, self->priv->column);
2693 _tmp5_ = self->priv->current;
2694 vala_source_location_init (&_vala_token_end, _tmp5_, self->priv->line, self->priv->column - 1);
2695 result = VALA_TOKEN_TYPE_COMMA;
2696 if (token_begin) {
2697 *token_begin = _vala_token_begin;
2698 }
2699 if (token_end) {
2700 *token_end = _vala_token_end;
2701 }
2702 return result;
2703 } else {
2704 if (vala_scanner_in_regex_literal (self)) {
2705 ValaSourceLocation _tmp6_ = {0};
2706 ValaSourceLocation _tmp7_ = {0};
2707 ValaTokenType _tmp8_;
2708 _tmp8_ = vala_scanner_read_regex_token (self, &_tmp6_, &_tmp7_);
2709 _vala_token_begin = _tmp6_;
2710 _vala_token_end = _tmp7_;
2711 result = _tmp8_;
2712 if (token_begin) {
2713 *token_begin = _vala_token_begin;
2714 }
2715 if (token_end) {
2716 *token_end = _vala_token_end;
2717 }
2718 return result;
2719 }
2720 }
2721 }
2722 vala_scanner_space (self);
2723 _tmp9_ = self->priv->current;
2724 begin = _tmp9_;
2725 _tmp10_ = begin;
2726 vala_source_location_init (&_vala_token_begin, _tmp10_, self->priv->line, self->priv->column);
2727 token_length_in_chars = -1;
2728 _tmp11_ = self->priv->current;
2729 _tmp12_ = self->priv->end;
2730 if (_tmp11_ >= _tmp12_) {
2731 type = VALA_TOKEN_TYPE_EOF;
2732 } else {
2733 gboolean _tmp13_ = FALSE;
2734 gchar* _tmp14_;
2735 gchar _tmp15_;
2736 _tmp14_ = self->priv->current;
2737 _tmp15_ = _tmp14_[0];
2738 if (g_ascii_isalpha (_tmp15_)) {
2739 _tmp13_ = TRUE;
2740 } else {
2741 gchar* _tmp16_;
2742 gchar _tmp17_;
2743 _tmp16_ = self->priv->current;
2744 _tmp17_ = _tmp16_[0];
2745 _tmp13_ = _tmp17_ == '_';
2746 }
2747 if (_tmp13_) {
2748 gint len = 0;
2749 gchar* _tmp25_;
2750 len = 0;
2751 while (TRUE) {
2752 gboolean _tmp18_ = FALSE;
2753 gchar* _tmp19_;
2754 gchar* _tmp20_;
2755 gchar* _tmp23_;
2756 gint _tmp24_;
2757 _tmp19_ = self->priv->current;
2758 _tmp20_ = self->priv->end;
2759 if (_tmp19_ < _tmp20_) {
2760 gchar* _tmp21_;
2761 gchar _tmp22_;
2762 _tmp21_ = self->priv->current;
2763 _tmp22_ = _tmp21_[0];
2764 _tmp18_ = vala_scanner_is_ident_char (self, _tmp22_);
2765 } else {
2766 _tmp18_ = FALSE;
2767 }
2768 if (!_tmp18_) {
2769 break;
2770 }
2771 _tmp23_ = self->priv->current;
2772 self->priv->current = _tmp23_ + 1;
2773 _tmp24_ = len;
2774 len = _tmp24_ + 1;
2775 }
2776 _tmp25_ = begin;
2777 type = vala_scanner_get_identifier_or_keyword (_tmp25_, len);
2778 } else {
2779 gchar* _tmp26_;
2780 gchar _tmp27_;
2781 _tmp26_ = self->priv->current;
2782 _tmp27_ = _tmp26_[0];
2783 if (_tmp27_ == '@') {
2784 gboolean _tmp28_ = FALSE;
2785 gchar* _tmp29_;
2786 gchar* _tmp30_;
2787 _tmp29_ = self->priv->current;
2788 _tmp30_ = self->priv->end;
2789 if (_tmp29_ < (_tmp30_ - 1)) {
2790 gchar* _tmp31_;
2791 gchar _tmp32_;
2792 _tmp31_ = self->priv->current;
2793 _tmp32_ = _tmp31_[1];
2794 _tmp28_ = _tmp32_ == '"';
2795 } else {
2796 _tmp28_ = FALSE;
2797 }
2798 if (_tmp28_) {
2799 gchar* _tmp33_;
2800 type = VALA_TOKEN_TYPE_OPEN_TEMPLATE;
2801 _tmp33_ = self->priv->current;
2802 self->priv->current = _tmp33_ + 2;
2803 _vala_array_add17 (&self->priv->state_stack, &self->priv->state_stack_length1, &self->priv->_state_stack_size_, VALA_SCANNER_STATE_TEMPLATE);
2804 } else {
2805 gchar* _tmp34_;
2806 gchar* _tmp35_;
2807 gint len = 0;
2808 _tmp34_ = _vala_token_begin.pos;
2809 _vala_token_begin.pos = _tmp34_ + 1;
2810 _tmp35_ = self->priv->current;
2811 self->priv->current = _tmp35_ + 1;
2812 len = 0;
2813 while (TRUE) {
2814 gboolean _tmp36_ = FALSE;
2815 gchar* _tmp37_;
2816 gchar* _tmp38_;
2817 gchar* _tmp41_;
2818 gint _tmp42_;
2819 _tmp37_ = self->priv->current;
2820 _tmp38_ = self->priv->end;
2821 if (_tmp37_ < _tmp38_) {
2822 gchar* _tmp39_;
2823 gchar _tmp40_;
2824 _tmp39_ = self->priv->current;
2825 _tmp40_ = _tmp39_[0];
2826 _tmp36_ = vala_scanner_is_ident_char (self, _tmp40_);
2827 } else {
2828 _tmp36_ = FALSE;
2829 }
2830 if (!_tmp36_) {
2831 break;
2832 }
2833 _tmp41_ = self->priv->current;
2834 self->priv->current = _tmp41_ + 1;
2835 _tmp42_ = len;
2836 len = _tmp42_ + 1;
2837 }
2838 type = VALA_TOKEN_TYPE_IDENTIFIER;
2839 }
2840 } else {
2841 gchar* _tmp43_;
2842 gchar _tmp44_;
2843 _tmp43_ = self->priv->current;
2844 _tmp44_ = _tmp43_[0];
2845 if (g_ascii_isdigit (_tmp44_)) {
2846 type = vala_scanner_read_number (self);
2847 } else {
2848 gchar* _tmp45_;
2849 gchar _tmp46_;
2850 _tmp45_ = self->priv->current;
2851 _tmp46_ = _tmp45_[0];
2852 switch (_tmp46_) {
2853 case '{':
2854 {
2855 gchar* _tmp47_;
2856 type = VALA_TOKEN_TYPE_OPEN_BRACE;
2857 _tmp47_ = self->priv->current;
2858 self->priv->current = _tmp47_ + 1;
2859 _vala_array_add18 (&self->priv->state_stack, &self->priv->state_stack_length1, &self->priv->_state_stack_size_, VALA_SCANNER_STATE_BRACE);
2860 break;
2861 }
2862 case '}':
2863 {
2864 gchar* _tmp48_;
2865 ValaScannerState* _tmp49_;
2866 gint _tmp49__length1;
2867 type = VALA_TOKEN_TYPE_CLOSE_BRACE;
2868 _tmp48_ = self->priv->current;
2869 self->priv->current = _tmp48_ + 1;
2870 _tmp49_ = self->priv->state_stack;
2871 _tmp49__length1 = self->priv->state_stack_length1;
2872 if (_tmp49__length1 > 0) {
2873 gint _tmp50_;
2874 _tmp50_ = self->priv->state_stack_length1;
2875 self->priv->state_stack_length1 = _tmp50_ - 1;
2876 }
2877 break;
2878 }
2879 case '(':
2880 {
2881 gchar* _tmp51_;
2882 type = VALA_TOKEN_TYPE_OPEN_PARENS;
2883 _tmp51_ = self->priv->current;
2884 self->priv->current = _tmp51_ + 1;
2885 _vala_array_add19 (&self->priv->state_stack, &self->priv->state_stack_length1, &self->priv->_state_stack_size_, VALA_SCANNER_STATE_PARENS);
2886 break;
2887 }
2888 case ')':
2889 {
2890 gchar* _tmp52_;
2891 ValaScannerState* _tmp53_;
2892 gint _tmp53__length1;
2893 type = VALA_TOKEN_TYPE_CLOSE_PARENS;
2894 _tmp52_ = self->priv->current;
2895 self->priv->current = _tmp52_ + 1;
2896 _tmp53_ = self->priv->state_stack;
2897 _tmp53__length1 = self->priv->state_stack_length1;
2898 if (_tmp53__length1 > 0) {
2899 gint _tmp54_;
2900 _tmp54_ = self->priv->state_stack_length1;
2901 self->priv->state_stack_length1 = _tmp54_ - 1;
2902 }
2903 if (vala_scanner_in_template (self)) {
2904 type = VALA_TOKEN_TYPE_COMMA;
2905 }
2906 break;
2907 }
2908 case '[':
2909 {
2910 gchar* _tmp55_;
2911 type = VALA_TOKEN_TYPE_OPEN_BRACKET;
2912 _tmp55_ = self->priv->current;
2913 self->priv->current = _tmp55_ + 1;
2914 _vala_array_add20 (&self->priv->state_stack, &self->priv->state_stack_length1, &self->priv->_state_stack_size_, VALA_SCANNER_STATE_BRACKET);
2915 break;
2916 }
2917 case ']':
2918 {
2919 gchar* _tmp56_;
2920 ValaScannerState* _tmp57_;
2921 gint _tmp57__length1;
2922 type = VALA_TOKEN_TYPE_CLOSE_BRACKET;
2923 _tmp56_ = self->priv->current;
2924 self->priv->current = _tmp56_ + 1;
2925 _tmp57_ = self->priv->state_stack;
2926 _tmp57__length1 = self->priv->state_stack_length1;
2927 if (_tmp57__length1 > 0) {
2928 gint _tmp58_;
2929 _tmp58_ = self->priv->state_stack_length1;
2930 self->priv->state_stack_length1 = _tmp58_ - 1;
2931 }
2932 break;
2933 }
2934 case '.':
2935 {
2936 gchar* _tmp59_;
2937 gchar* _tmp60_;
2938 gchar* _tmp61_;
2939 type = VALA_TOKEN_TYPE_DOT;
2940 _tmp59_ = self->priv->current;
2941 self->priv->current = _tmp59_ + 1;
2942 _tmp60_ = self->priv->current;
2943 _tmp61_ = self->priv->end;
2944 if (_tmp60_ < (_tmp61_ - 1)) {
2945 gboolean _tmp62_ = FALSE;
2946 gchar* _tmp63_;
2947 gchar _tmp64_;
2948 _tmp63_ = self->priv->current;
2949 _tmp64_ = _tmp63_[0];
2950 if (_tmp64_ == '.') {
2951 gchar* _tmp65_;
2952 gchar _tmp66_;
2953 _tmp65_ = self->priv->current;
2954 _tmp66_ = _tmp65_[1];
2955 _tmp62_ = _tmp66_ == '.';
2956 } else {
2957 _tmp62_ = FALSE;
2958 }
2959 if (_tmp62_) {
2960 gchar* _tmp67_;
2961 type = VALA_TOKEN_TYPE_ELLIPSIS;
2962 _tmp67_ = self->priv->current;
2963 self->priv->current = _tmp67_ + 2;
2964 }
2965 }
2966 break;
2967 }
2968 case ':':
2969 {
2970 gchar* _tmp68_;
2971 gboolean _tmp69_ = FALSE;
2972 gchar* _tmp70_;
2973 gchar* _tmp71_;
2974 type = VALA_TOKEN_TYPE_COLON;
2975 _tmp68_ = self->priv->current;
2976 self->priv->current = _tmp68_ + 1;
2977 _tmp70_ = self->priv->current;
2978 _tmp71_ = self->priv->end;
2979 if (_tmp70_ < _tmp71_) {
2980 gchar* _tmp72_;
2981 gchar _tmp73_;
2982 _tmp72_ = self->priv->current;
2983 _tmp73_ = _tmp72_[0];
2984 _tmp69_ = _tmp73_ == ':';
2985 } else {
2986 _tmp69_ = FALSE;
2987 }
2988 if (_tmp69_) {
2989 gchar* _tmp74_;
2990 type = VALA_TOKEN_TYPE_DOUBLE_COLON;
2991 _tmp74_ = self->priv->current;
2992 self->priv->current = _tmp74_ + 1;
2993 }
2994 break;
2995 }
2996 case ',':
2997 {
2998 gchar* _tmp75_;
2999 type = VALA_TOKEN_TYPE_COMMA;
3000 _tmp75_ = self->priv->current;
3001 self->priv->current = _tmp75_ + 1;
3002 break;
3003 }
3004 case ';':
3005 {
3006 gchar* _tmp76_;
3007 type = VALA_TOKEN_TYPE_SEMICOLON;
3008 _tmp76_ = self->priv->current;
3009 self->priv->current = _tmp76_ + 1;
3010 break;
3011 }
3012 case '#':
3013 {
3014 gchar* _tmp77_;
3015 type = VALA_TOKEN_TYPE_HASH;
3016 _tmp77_ = self->priv->current;
3017 self->priv->current = _tmp77_ + 1;
3018 break;
3019 }
3020 case '?':
3021 {
3022 gchar* _tmp78_;
3023 gboolean _tmp79_ = FALSE;
3024 gchar* _tmp80_;
3025 gchar* _tmp81_;
3026 type = VALA_TOKEN_TYPE_INTERR;
3027 _tmp78_ = self->priv->current;
3028 self->priv->current = _tmp78_ + 1;
3029 _tmp80_ = self->priv->current;
3030 _tmp81_ = self->priv->end;
3031 if (_tmp80_ < _tmp81_) {
3032 gchar* _tmp82_;
3033 gchar _tmp83_;
3034 _tmp82_ = self->priv->current;
3035 _tmp83_ = _tmp82_[0];
3036 _tmp79_ = _tmp83_ == '?';
3037 } else {
3038 _tmp79_ = FALSE;
3039 }
3040 if (_tmp79_) {
3041 gchar* _tmp84_;
3042 type = VALA_TOKEN_TYPE_OP_COALESCING;
3043 _tmp84_ = self->priv->current;
3044 self->priv->current = _tmp84_ + 1;
3045 }
3046 break;
3047 }
3048 case '|':
3049 {
3050 gchar* _tmp85_;
3051 gchar* _tmp86_;
3052 gchar* _tmp87_;
3053 type = VALA_TOKEN_TYPE_BITWISE_OR;
3054 _tmp85_ = self->priv->current;
3055 self->priv->current = _tmp85_ + 1;
3056 _tmp86_ = self->priv->current;
3057 _tmp87_ = self->priv->end;
3058 if (_tmp86_ < _tmp87_) {
3059 gchar* _tmp88_;
3060 gchar _tmp89_;
3061 _tmp88_ = self->priv->current;
3062 _tmp89_ = _tmp88_[0];
3063 switch (_tmp89_) {
3064 case '=':
3065 {
3066 gchar* _tmp90_;
3067 type = VALA_TOKEN_TYPE_ASSIGN_BITWISE_OR;
3068 _tmp90_ = self->priv->current;
3069 self->priv->current = _tmp90_ + 1;
3070 break;
3071 }
3072 case '|':
3073 {
3074 gchar* _tmp91_;
3075 type = VALA_TOKEN_TYPE_OP_OR;
3076 _tmp91_ = self->priv->current;
3077 self->priv->current = _tmp91_ + 1;
3078 break;
3079 }
3080 default:
3081 break;
3082 }
3083 }
3084 break;
3085 }
3086 case '&':
3087 {
3088 gchar* _tmp92_;
3089 gchar* _tmp93_;
3090 gchar* _tmp94_;
3091 type = VALA_TOKEN_TYPE_BITWISE_AND;
3092 _tmp92_ = self->priv->current;
3093 self->priv->current = _tmp92_ + 1;
3094 _tmp93_ = self->priv->current;
3095 _tmp94_ = self->priv->end;
3096 if (_tmp93_ < _tmp94_) {
3097 gchar* _tmp95_;
3098 gchar _tmp96_;
3099 _tmp95_ = self->priv->current;
3100 _tmp96_ = _tmp95_[0];
3101 switch (_tmp96_) {
3102 case '=':
3103 {
3104 gchar* _tmp97_;
3105 type = VALA_TOKEN_TYPE_ASSIGN_BITWISE_AND;
3106 _tmp97_ = self->priv->current;
3107 self->priv->current = _tmp97_ + 1;
3108 break;
3109 }
3110 case '&':
3111 {
3112 gchar* _tmp98_;
3113 type = VALA_TOKEN_TYPE_OP_AND;
3114 _tmp98_ = self->priv->current;
3115 self->priv->current = _tmp98_ + 1;
3116 break;
3117 }
3118 default:
3119 break;
3120 }
3121 }
3122 break;
3123 }
3124 case '^':
3125 {
3126 gchar* _tmp99_;
3127 gboolean _tmp100_ = FALSE;
3128 gchar* _tmp101_;
3129 gchar* _tmp102_;
3130 type = VALA_TOKEN_TYPE_CARRET;
3131 _tmp99_ = self->priv->current;
3132 self->priv->current = _tmp99_ + 1;
3133 _tmp101_ = self->priv->current;
3134 _tmp102_ = self->priv->end;
3135 if (_tmp101_ < _tmp102_) {
3136 gchar* _tmp103_;
3137 gchar _tmp104_;
3138 _tmp103_ = self->priv->current;
3139 _tmp104_ = _tmp103_[0];
3140 _tmp100_ = _tmp104_ == '=';
3141 } else {
3142 _tmp100_ = FALSE;
3143 }
3144 if (_tmp100_) {
3145 gchar* _tmp105_;
3146 type = VALA_TOKEN_TYPE_ASSIGN_BITWISE_XOR;
3147 _tmp105_ = self->priv->current;
3148 self->priv->current = _tmp105_ + 1;
3149 }
3150 break;
3151 }
3152 case '~':
3153 {
3154 gchar* _tmp106_;
3155 type = VALA_TOKEN_TYPE_TILDE;
3156 _tmp106_ = self->priv->current;
3157 self->priv->current = _tmp106_ + 1;
3158 break;
3159 }
3160 case '=':
3161 {
3162 gchar* _tmp107_;
3163 gchar* _tmp108_;
3164 gchar* _tmp109_;
3165 type = VALA_TOKEN_TYPE_ASSIGN;
3166 _tmp107_ = self->priv->current;
3167 self->priv->current = _tmp107_ + 1;
3168 _tmp108_ = self->priv->current;
3169 _tmp109_ = self->priv->end;
3170 if (_tmp108_ < _tmp109_) {
3171 gchar* _tmp110_;
3172 gchar _tmp111_;
3173 _tmp110_ = self->priv->current;
3174 _tmp111_ = _tmp110_[0];
3175 switch (_tmp111_) {
3176 case '=':
3177 {
3178 gchar* _tmp112_;
3179 type = VALA_TOKEN_TYPE_OP_EQ;
3180 _tmp112_ = self->priv->current;
3181 self->priv->current = _tmp112_ + 1;
3182 break;
3183 }
3184 case '>':
3185 {
3186 gchar* _tmp113_;
3187 type = VALA_TOKEN_TYPE_LAMBDA;
3188 _tmp113_ = self->priv->current;
3189 self->priv->current = _tmp113_ + 1;
3190 break;
3191 }
3192 default:
3193 break;
3194 }
3195 }
3196 break;
3197 }
3198 case '<':
3199 {
3200 gchar* _tmp114_;
3201 gchar* _tmp115_;
3202 gchar* _tmp116_;
3203 type = VALA_TOKEN_TYPE_OP_LT;
3204 _tmp114_ = self->priv->current;
3205 self->priv->current = _tmp114_ + 1;
3206 _tmp115_ = self->priv->current;
3207 _tmp116_ = self->priv->end;
3208 if (_tmp115_ < _tmp116_) {
3209 gchar* _tmp117_;
3210 gchar _tmp118_;
3211 _tmp117_ = self->priv->current;
3212 _tmp118_ = _tmp117_[0];
3213 switch (_tmp118_) {
3214 case '=':
3215 {
3216 gchar* _tmp119_;
3217 type = VALA_TOKEN_TYPE_OP_LE;
3218 _tmp119_ = self->priv->current;
3219 self->priv->current = _tmp119_ + 1;
3220 break;
3221 }
3222 case '<':
3223 {
3224 gchar* _tmp120_;
3225 gboolean _tmp121_ = FALSE;
3226 gchar* _tmp122_;
3227 gchar* _tmp123_;
3228 type = VALA_TOKEN_TYPE_OP_SHIFT_LEFT;
3229 _tmp120_ = self->priv->current;
3230 self->priv->current = _tmp120_ + 1;
3231 _tmp122_ = self->priv->current;
3232 _tmp123_ = self->priv->end;
3233 if (_tmp122_ < _tmp123_) {
3234 gchar* _tmp124_;
3235 gchar _tmp125_;
3236 _tmp124_ = self->priv->current;
3237 _tmp125_ = _tmp124_[0];
3238 _tmp121_ = _tmp125_ == '=';
3239 } else {
3240 _tmp121_ = FALSE;
3241 }
3242 if (_tmp121_) {
3243 gchar* _tmp126_;
3244 type = VALA_TOKEN_TYPE_ASSIGN_SHIFT_LEFT;
3245 _tmp126_ = self->priv->current;
3246 self->priv->current = _tmp126_ + 1;
3247 }
3248 break;
3249 }
3250 default:
3251 break;
3252 }
3253 }
3254 break;
3255 }
3256 case '>':
3257 {
3258 gchar* _tmp127_;
3259 gboolean _tmp128_ = FALSE;
3260 gchar* _tmp129_;
3261 gchar* _tmp130_;
3262 type = VALA_TOKEN_TYPE_OP_GT;
3263 _tmp127_ = self->priv->current;
3264 self->priv->current = _tmp127_ + 1;
3265 _tmp129_ = self->priv->current;
3266 _tmp130_ = self->priv->end;
3267 if (_tmp129_ < _tmp130_) {
3268 gchar* _tmp131_;
3269 gchar _tmp132_;
3270 _tmp131_ = self->priv->current;
3271 _tmp132_ = _tmp131_[0];
3272 _tmp128_ = _tmp132_ == '=';
3273 } else {
3274 _tmp128_ = FALSE;
3275 }
3276 if (_tmp128_) {
3277 gchar* _tmp133_;
3278 type = VALA_TOKEN_TYPE_OP_GE;
3279 _tmp133_ = self->priv->current;
3280 self->priv->current = _tmp133_ + 1;
3281 }
3282 break;
3283 }
3284 case '!':
3285 {
3286 gchar* _tmp134_;
3287 gboolean _tmp135_ = FALSE;
3288 gchar* _tmp136_;
3289 gchar* _tmp137_;
3290 type = VALA_TOKEN_TYPE_OP_NEG;
3291 _tmp134_ = self->priv->current;
3292 self->priv->current = _tmp134_ + 1;
3293 _tmp136_ = self->priv->current;
3294 _tmp137_ = self->priv->end;
3295 if (_tmp136_ < _tmp137_) {
3296 gchar* _tmp138_;
3297 gchar _tmp139_;
3298 _tmp138_ = self->priv->current;
3299 _tmp139_ = _tmp138_[0];
3300 _tmp135_ = _tmp139_ == '=';
3301 } else {
3302 _tmp135_ = FALSE;
3303 }
3304 if (_tmp135_) {
3305 gchar* _tmp140_;
3306 type = VALA_TOKEN_TYPE_OP_NE;
3307 _tmp140_ = self->priv->current;
3308 self->priv->current = _tmp140_ + 1;
3309 }
3310 break;
3311 }
3312 case '+':
3313 {
3314 gchar* _tmp141_;
3315 gchar* _tmp142_;
3316 gchar* _tmp143_;
3317 type = VALA_TOKEN_TYPE_PLUS;
3318 _tmp141_ = self->priv->current;
3319 self->priv->current = _tmp141_ + 1;
3320 _tmp142_ = self->priv->current;
3321 _tmp143_ = self->priv->end;
3322 if (_tmp142_ < _tmp143_) {
3323 gchar* _tmp144_;
3324 gchar _tmp145_;
3325 _tmp144_ = self->priv->current;
3326 _tmp145_ = _tmp144_[0];
3327 switch (_tmp145_) {
3328 case '=':
3329 {
3330 gchar* _tmp146_;
3331 type = VALA_TOKEN_TYPE_ASSIGN_ADD;
3332 _tmp146_ = self->priv->current;
3333 self->priv->current = _tmp146_ + 1;
3334 break;
3335 }
3336 case '+':
3337 {
3338 gchar* _tmp147_;
3339 type = VALA_TOKEN_TYPE_OP_INC;
3340 _tmp147_ = self->priv->current;
3341 self->priv->current = _tmp147_ + 1;
3342 break;
3343 }
3344 default:
3345 break;
3346 }
3347 }
3348 break;
3349 }
3350 case '-':
3351 {
3352 gchar* _tmp148_;
3353 gchar* _tmp149_;
3354 gchar* _tmp150_;
3355 type = VALA_TOKEN_TYPE_MINUS;
3356 _tmp148_ = self->priv->current;
3357 self->priv->current = _tmp148_ + 1;
3358 _tmp149_ = self->priv->current;
3359 _tmp150_ = self->priv->end;
3360 if (_tmp149_ < _tmp150_) {
3361 gchar* _tmp151_;
3362 gchar _tmp152_;
3363 _tmp151_ = self->priv->current;
3364 _tmp152_ = _tmp151_[0];
3365 switch (_tmp152_) {
3366 case '=':
3367 {
3368 gchar* _tmp153_;
3369 type = VALA_TOKEN_TYPE_ASSIGN_SUB;
3370 _tmp153_ = self->priv->current;
3371 self->priv->current = _tmp153_ + 1;
3372 break;
3373 }
3374 case '-':
3375 {
3376 gchar* _tmp154_;
3377 type = VALA_TOKEN_TYPE_OP_DEC;
3378 _tmp154_ = self->priv->current;
3379 self->priv->current = _tmp154_ + 1;
3380 break;
3381 }
3382 case '>':
3383 {
3384 gchar* _tmp155_;
3385 type = VALA_TOKEN_TYPE_OP_PTR;
3386 _tmp155_ = self->priv->current;
3387 self->priv->current = _tmp155_ + 1;
3388 break;
3389 }
3390 default:
3391 break;
3392 }
3393 }
3394 break;
3395 }
3396 case '*':
3397 {
3398 gchar* _tmp156_;
3399 gboolean _tmp157_ = FALSE;
3400 gchar* _tmp158_;
3401 gchar* _tmp159_;
3402 type = VALA_TOKEN_TYPE_STAR;
3403 _tmp156_ = self->priv->current;
3404 self->priv->current = _tmp156_ + 1;
3405 _tmp158_ = self->priv->current;
3406 _tmp159_ = self->priv->end;
3407 if (_tmp158_ < _tmp159_) {
3408 gchar* _tmp160_;
3409 gchar _tmp161_;
3410 _tmp160_ = self->priv->current;
3411 _tmp161_ = _tmp160_[0];
3412 _tmp157_ = _tmp161_ == '=';
3413 } else {
3414 _tmp157_ = FALSE;
3415 }
3416 if (_tmp157_) {
3417 gchar* _tmp162_;
3418 type = VALA_TOKEN_TYPE_ASSIGN_MUL;
3419 _tmp162_ = self->priv->current;
3420 self->priv->current = _tmp162_ + 1;
3421 }
3422 break;
3423 }
3424 case '/':
3425 {
3426 ValaTokenType _tmp163_;
3427 _tmp163_ = self->priv->previous;
3428 switch (_tmp163_) {
3429 case VALA_TOKEN_TYPE_ASSIGN:
3430 case VALA_TOKEN_TYPE_COMMA:
3431 case VALA_TOKEN_TYPE_MINUS:
3432 case VALA_TOKEN_TYPE_OP_AND:
3433 case VALA_TOKEN_TYPE_OP_COALESCING:
3434 case VALA_TOKEN_TYPE_OP_EQ:
3435 case VALA_TOKEN_TYPE_OP_GE:
3436 case VALA_TOKEN_TYPE_OP_GT:
3437 case VALA_TOKEN_TYPE_OP_LE:
3438 case VALA_TOKEN_TYPE_OP_LT:
3439 case VALA_TOKEN_TYPE_OP_NE:
3440 case VALA_TOKEN_TYPE_OP_NEG:
3441 case VALA_TOKEN_TYPE_OP_OR:
3442 case VALA_TOKEN_TYPE_OPEN_BRACE:
3443 case VALA_TOKEN_TYPE_OPEN_PARENS:
3444 case VALA_TOKEN_TYPE_PLUS:
3445 case VALA_TOKEN_TYPE_RETURN:
3446 {
3447 gchar* _tmp164_;
3448 type = VALA_TOKEN_TYPE_OPEN_REGEX_LITERAL;
3449 _vala_array_add21 (&self->priv->state_stack, &self->priv->state_stack_length1, &self->priv->_state_stack_size_, VALA_SCANNER_STATE_REGEX_LITERAL);
3450 _tmp164_ = self->priv->current;
3451 self->priv->current = _tmp164_ + 1;
3452 break;
3453 }
3454 default:
3455 {
3456 gchar* _tmp165_;
3457 gboolean _tmp166_ = FALSE;
3458 gchar* _tmp167_;
3459 gchar* _tmp168_;
3460 type = VALA_TOKEN_TYPE_DIV;
3461 _tmp165_ = self->priv->current;
3462 self->priv->current = _tmp165_ + 1;
3463 _tmp167_ = self->priv->current;
3464 _tmp168_ = self->priv->end;
3465 if (_tmp167_ < _tmp168_) {
3466 gchar* _tmp169_;
3467 gchar _tmp170_;
3468 _tmp169_ = self->priv->current;
3469 _tmp170_ = _tmp169_[0];
3470 _tmp166_ = _tmp170_ == '=';
3471 } else {
3472 _tmp166_ = FALSE;
3473 }
3474 if (_tmp166_) {
3475 gchar* _tmp171_;
3476 type = VALA_TOKEN_TYPE_ASSIGN_DIV;
3477 _tmp171_ = self->priv->current;
3478 self->priv->current = _tmp171_ + 1;
3479 }
3480 break;
3481 }
3482 }
3483 break;
3484 }
3485 case '%':
3486 {
3487 gchar* _tmp172_;
3488 gboolean _tmp173_ = FALSE;
3489 gchar* _tmp174_;
3490 gchar* _tmp175_;
3491 type = VALA_TOKEN_TYPE_PERCENT;
3492 _tmp172_ = self->priv->current;
3493 self->priv->current = _tmp172_ + 1;
3494 _tmp174_ = self->priv->current;
3495 _tmp175_ = self->priv->end;
3496 if (_tmp174_ < _tmp175_) {
3497 gchar* _tmp176_;
3498 gchar _tmp177_;
3499 _tmp176_ = self->priv->current;
3500 _tmp177_ = _tmp176_[0];
3501 _tmp173_ = _tmp177_ == '=';
3502 } else {
3503 _tmp173_ = FALSE;
3504 }
3505 if (_tmp173_) {
3506 gchar* _tmp178_;
3507 type = VALA_TOKEN_TYPE_ASSIGN_PERCENT;
3508 _tmp178_ = self->priv->current;
3509 self->priv->current = _tmp178_ + 1;
3510 }
3511 break;
3512 }
3513 case '\'':
3514 case '"':
3515 {
3516 gchar* _tmp179_;
3517 gchar _tmp180_;
3518 gchar* _tmp225_;
3519 gchar* _tmp300_;
3520 gchar* _tmp301_;
3521 _tmp179_ = begin;
3522 _tmp180_ = _tmp179_[0];
3523 if (_tmp180_ == '\'') {
3524 type = VALA_TOKEN_TYPE_CHARACTER_LITERAL;
3525 } else {
3526 gboolean _tmp181_ = FALSE;
3527 gboolean _tmp182_ = FALSE;
3528 gchar* _tmp183_;
3529 gchar* _tmp184_;
3530 _tmp183_ = self->priv->current;
3531 _tmp184_ = self->priv->end;
3532 if (_tmp183_ < (_tmp184_ - 6)) {
3533 gchar* _tmp185_;
3534 gchar _tmp186_;
3535 _tmp185_ = begin;
3536 _tmp186_ = _tmp185_[1];
3537 _tmp182_ = _tmp186_ == '"';
3538 } else {
3539 _tmp182_ = FALSE;
3540 }
3541 if (_tmp182_) {
3542 gchar* _tmp187_;
3543 gchar _tmp188_;
3544 _tmp187_ = begin;
3545 _tmp188_ = _tmp187_[2];
3546 _tmp181_ = _tmp188_ == '"';
3547 } else {
3548 _tmp181_ = FALSE;
3549 }
3550 if (_tmp181_) {
3551 gchar* _tmp189_;
3552 gboolean _tmp214_ = FALSE;
3553 gboolean _tmp215_ = FALSE;
3554 gchar* _tmp216_;
3555 gchar _tmp217_;
3556 type = VALA_TOKEN_TYPE_VERBATIM_STRING_LITERAL;
3557 token_length_in_chars = 6;
3558 _tmp189_ = self->priv->current;
3559 self->priv->current = _tmp189_ + 3;
3560 while (TRUE) {
3561 gchar* _tmp190_;
3562 gchar* _tmp191_;
3563 gboolean _tmp192_ = FALSE;
3564 gboolean _tmp193_ = FALSE;
3565 gboolean _tmp194_ = FALSE;
3566 gchar* _tmp195_;
3567 gchar _tmp196_;
3568 _tmp190_ = self->priv->current;
3569 _tmp191_ = self->priv->end;
3570 if (!(_tmp190_ < (_tmp191_ - 4))) {
3571 break;
3572 }
3573 _tmp195_ = self->priv->current;
3574 _tmp196_ = _tmp195_[0];
3575 if (_tmp196_ == '"') {
3576 gchar* _tmp197_;
3577 gchar _tmp198_;
3578 _tmp197_ = self->priv->current;
3579 _tmp198_ = _tmp197_[1];
3580 _tmp194_ = _tmp198_ == '"';
3581 } else {
3582 _tmp194_ = FALSE;
3583 }
3584 if (_tmp194_) {
3585 gchar* _tmp199_;
3586 gchar _tmp200_;
3587 _tmp199_ = self->priv->current;
3588 _tmp200_ = _tmp199_[2];
3589 _tmp193_ = _tmp200_ == '"';
3590 } else {
3591 _tmp193_ = FALSE;
3592 }
3593 if (_tmp193_) {
3594 gchar* _tmp201_;
3595 gchar _tmp202_;
3596 _tmp201_ = self->priv->current;
3597 _tmp202_ = _tmp201_[3];
3598 _tmp192_ = _tmp202_ != '"';
3599 } else {
3600 _tmp192_ = FALSE;
3601 }
3602 if (_tmp192_) {
3603 break;
3604 } else {
3605 gchar* _tmp203_;
3606 gchar _tmp204_;
3607 _tmp203_ = self->priv->current;
3608 _tmp204_ = _tmp203_[0];
3609 if (_tmp204_ == '\n') {
3610 gchar* _tmp205_;
3611 gint _tmp206_;
3612 _tmp205_ = self->priv->current;
3613 self->priv->current = _tmp205_ + 1;
3614 _tmp206_ = self->priv->line;
3615 self->priv->line = _tmp206_ + 1;
3616 self->priv->column = 1;
3617 token_length_in_chars = 3;
3618 } else {
3619 gunichar u = 0U;
3620 gchar* _tmp207_;
3621 gchar* _tmp208_;
3622 gchar* _tmp209_;
3623 _tmp207_ = self->priv->current;
3624 _tmp208_ = self->priv->end;
3625 _tmp209_ = self->priv->current;
3626 u = g_utf8_get_char_validated ((const gchar*) _tmp207_, (gssize) ((glong) (_tmp208_ - _tmp209_)));
3627 if (u != ((gunichar) -1)) {
3628 gchar* _tmp210_;
3629 gint _tmp211_;
3630 _tmp210_ = self->priv->current;
3631 self->priv->current = _tmp210_ + g_unichar_to_utf8 (u, NULL);
3632 _tmp211_ = token_length_in_chars;
3633 token_length_in_chars = _tmp211_ + 1;
3634 } else {
3635 ValaSourceReference* _tmp212_;
3636 ValaSourceReference* _tmp213_;
3637 _tmp212_ = vala_scanner_get_source_reference (self, token_length_in_chars, 0);
3638 _tmp213_ = _tmp212_;
3639 vala_report_error (_tmp213_, "invalid UTF-8 character");
3640 _vala_source_reference_unref0 (_tmp213_);
3641 }
3642 }
3643 }
3644 }
3645 _tmp216_ = self->priv->current;
3646 _tmp217_ = _tmp216_[0];
3647 if (_tmp217_ == '"') {
3648 gchar* _tmp218_;
3649 gchar _tmp219_;
3650 _tmp218_ = self->priv->current;
3651 _tmp219_ = _tmp218_[1];
3652 _tmp215_ = _tmp219_ == '"';
3653 } else {
3654 _tmp215_ = FALSE;
3655 }
3656 if (_tmp215_) {
3657 gchar* _tmp220_;
3658 gchar _tmp221_;
3659 _tmp220_ = self->priv->current;
3660 _tmp221_ = _tmp220_[2];
3661 _tmp214_ = _tmp221_ == '"';
3662 } else {
3663 _tmp214_ = FALSE;
3664 }
3665 if (_tmp214_) {
3666 gchar* _tmp222_;
3667 _tmp222_ = self->priv->current;
3668 self->priv->current = _tmp222_ + 3;
3669 } else {
3670 ValaSourceReference* _tmp223_;
3671 ValaSourceReference* _tmp224_;
3672 _tmp223_ = vala_scanner_get_source_reference (self, token_length_in_chars, 0);
3673 _tmp224_ = _tmp223_;
3674 vala_report_error (_tmp224_, "syntax error, expected \"\"\"");
3675 _vala_source_reference_unref0 (_tmp224_);
3676 }
3677 break;
3678 } else {
3679 type = VALA_TOKEN_TYPE_STRING_LITERAL;
3680 }
3681 }
3682 token_length_in_chars = 2;
3683 _tmp225_ = self->priv->current;
3684 self->priv->current = _tmp225_ + 1;
3685 while (TRUE) {
3686 gboolean _tmp226_ = FALSE;
3687 gchar* _tmp227_;
3688 gchar* _tmp228_;
3689 gchar* _tmp233_;
3690 gchar _tmp234_;
3691 gboolean _tmp290_ = FALSE;
3692 gboolean _tmp291_ = FALSE;
3693 gchar* _tmp292_;
3694 gchar* _tmp293_;
3695 _tmp227_ = self->priv->current;
3696 _tmp228_ = self->priv->end;
3697 if (_tmp227_ < _tmp228_) {
3698 gchar* _tmp229_;
3699 gchar _tmp230_;
3700 gchar* _tmp231_;
3701 gchar _tmp232_;
3702 _tmp229_ = self->priv->current;
3703 _tmp230_ = _tmp229_[0];
3704 _tmp231_ = begin;
3705 _tmp232_ = _tmp231_[0];
3706 _tmp226_ = _tmp230_ != _tmp232_;
3707 } else {
3708 _tmp226_ = FALSE;
3709 }
3710 if (!_tmp226_) {
3711 break;
3712 }
3713 _tmp233_ = self->priv->current;
3714 _tmp234_ = _tmp233_[0];
3715 if (_tmp234_ == '\\') {
3716 gchar* _tmp235_;
3717 gint _tmp236_;
3718 gchar* _tmp237_;
3719 gchar* _tmp238_;
3720 gchar* _tmp239_;
3721 gchar _tmp240_;
3722 _tmp235_ = self->priv->current;
3723 self->priv->current = _tmp235_ + 1;
3724 _tmp236_ = token_length_in_chars;
3725 token_length_in_chars = _tmp236_ + 1;
3726 _tmp237_ = self->priv->current;
3727 _tmp238_ = self->priv->end;
3728 if (_tmp237_ >= _tmp238_) {
3729 break;
3730 }
3731 _tmp239_ = self->priv->current;
3732 _tmp240_ = _tmp239_[0];
3733 switch (_tmp240_) {
3734 case '\'':
3735 case '"':
3736 case '\\':
3737 case '0':
3738 case 'b':
3739 case 'f':
3740 case 'n':
3741 case 'r':
3742 case 't':
3743 case 'v':
3744 case '$':
3745 {
3746 gchar* _tmp241_;
3747 gint _tmp242_;
3748 _tmp241_ = self->priv->current;
3749 self->priv->current = _tmp241_ + 1;
3750 _tmp242_ = token_length_in_chars;
3751 token_length_in_chars = _tmp242_ + 1;
3752 break;
3753 }
3754 case 'u':
3755 {
3756 gchar* _tmp243_;
3757 gint _tmp244_;
3758 gint digit_length = 0;
3759 _tmp243_ = self->priv->current;
3760 self->priv->current = _tmp243_ + 1;
3761 _tmp244_ = token_length_in_chars;
3762 token_length_in_chars = _tmp244_ + 1;
3763 {
3764 gboolean _tmp245_ = FALSE;
3765 digit_length = 0;
3766 _tmp245_ = TRUE;
3767 while (TRUE) {
3768 gboolean _tmp247_ = FALSE;
3769 gchar* _tmp248_;
3770 gchar* _tmp249_;
3771 gchar* _tmp252_;
3772 gint _tmp253_;
3773 if (!_tmp245_) {
3774 gint _tmp246_;
3775 _tmp246_ = digit_length;
3776 digit_length = _tmp246_ + 1;
3777 }
3778 _tmp245_ = FALSE;
3779 _tmp248_ = self->priv->current;
3780 _tmp249_ = self->priv->end;
3781 if (_tmp248_ < _tmp249_) {
3782 gchar* _tmp250_;
3783 gchar _tmp251_;
3784 _tmp250_ = self->priv->current;
3785 _tmp251_ = _tmp250_[0];
3786 _tmp247_ = g_ascii_isxdigit (_tmp251_);
3787 } else {
3788 _tmp247_ = FALSE;
3789 }
3790 if (!_tmp247_) {
3791 break;
3792 }
3793 _tmp252_ = self->priv->current;
3794 self->priv->current = _tmp252_ + 1;
3795 _tmp253_ = token_length_in_chars;
3796 token_length_in_chars = _tmp253_ + 1;
3797 }
3798 }
3799 if (digit_length < 1) {
3800 ValaSourceReference* _tmp254_;
3801 ValaSourceReference* _tmp255_;
3802 _tmp254_ = vala_scanner_get_source_reference (self, token_length_in_chars, 0);
3803 _tmp255_ = _tmp254_;
3804 vala_report_error (_tmp255_, "\\u used with no following hex digits");
3805 _vala_source_reference_unref0 (_tmp255_);
3806 } else {
3807 if (digit_length < 4) {
3808 ValaSourceReference* _tmp256_;
3809 ValaSourceReference* _tmp257_;
3810 _tmp256_ = vala_scanner_get_source_reference (self, token_length_in_chars, 0);
3811 _tmp257_ = _tmp256_;
3812 vala_report_error (_tmp257_, "incomplete universal character name");
3813 _vala_source_reference_unref0 (_tmp257_);
3814 }
3815 }
3816 break;
3817 }
3818 case 'x':
3819 {
3820 gchar* _tmp258_;
3821 gint _tmp259_;
3822 gint digit_length = 0;
3823 gboolean empty = FALSE;
3824 gboolean _tmp271_ = FALSE;
3825 _tmp258_ = self->priv->current;
3826 self->priv->current = _tmp258_ + 1;
3827 _tmp259_ = token_length_in_chars;
3828 token_length_in_chars = _tmp259_ + 1;
3829 empty = TRUE;
3830 {
3831 gboolean _tmp260_ = FALSE;
3832 digit_length = 0;
3833 _tmp260_ = TRUE;
3834 while (TRUE) {
3835 gboolean _tmp261_ = FALSE;
3836 gchar* _tmp262_;
3837 gchar* _tmp263_;
3838 gchar* _tmp266_;
3839 gchar _tmp267_;
3840 gchar* _tmp269_;
3841 gint _tmp270_;
3842 if (!_tmp260_) {
3843 }
3844 _tmp260_ = FALSE;
3845 _tmp262_ = self->priv->current;
3846 _tmp263_ = self->priv->end;
3847 if (_tmp262_ < _tmp263_) {
3848 gchar* _tmp264_;
3849 gchar _tmp265_;
3850 _tmp264_ = self->priv->current;
3851 _tmp265_ = _tmp264_[0];
3852 _tmp261_ = g_ascii_isxdigit (_tmp265_);
3853 } else {
3854 _tmp261_ = FALSE;
3855 }
3856 if (!_tmp261_) {
3857 break;
3858 }
3859 _tmp266_ = self->priv->current;
3860 _tmp267_ = _tmp266_[0];
3861 if (_tmp267_ != '0') {
3862 gint _tmp268_;
3863 _tmp268_ = digit_length;
3864 digit_length = _tmp268_ + 1;
3865 } else {
3866 empty = FALSE;
3867 }
3868 _tmp269_ = self->priv->current;
3869 self->priv->current = _tmp269_ + 1;
3870 _tmp270_ = token_length_in_chars;
3871 token_length_in_chars = _tmp270_ + 1;
3872 }
3873 }
3874 if (empty) {
3875 _tmp271_ = digit_length < 1;
3876 } else {
3877 _tmp271_ = FALSE;
3878 }
3879 if (_tmp271_) {
3880 ValaSourceReference* _tmp272_;
3881 ValaSourceReference* _tmp273_;
3882 _tmp272_ = vala_scanner_get_source_reference (self, token_length_in_chars, 0);
3883 _tmp273_ = _tmp272_;
3884 vala_report_error (_tmp273_, "\\x used with no following hex digits");
3885 _vala_source_reference_unref0 (_tmp273_);
3886 } else {
3887 if (digit_length > 2) {
3888 ValaSourceReference* _tmp274_;
3889 ValaSourceReference* _tmp275_;
3890 _tmp274_ = vala_scanner_get_source_reference (self, token_length_in_chars, 0);
3891 _tmp275_ = _tmp274_;
3892 vala_report_error (_tmp275_, "hex escape sequence out of range");
3893 _vala_source_reference_unref0 (_tmp275_);
3894 }
3895 }
3896 break;
3897 }
3898 default:
3899 {
3900 ValaSourceReference* _tmp276_;
3901 ValaSourceReference* _tmp277_;
3902 _tmp276_ = vala_scanner_get_source_reference (self, token_length_in_chars, 0);
3903 _tmp277_ = _tmp276_;
3904 vala_report_error (_tmp277_, "invalid escape sequence");
3905 _vala_source_reference_unref0 (_tmp277_);
3906 break;
3907 }
3908 }
3909 } else {
3910 gchar* _tmp278_;
3911 gchar _tmp279_;
3912 _tmp278_ = self->priv->current;
3913 _tmp279_ = _tmp278_[0];
3914 if (_tmp279_ == '\n') {
3915 gchar* _tmp280_;
3916 gint _tmp281_;
3917 _tmp280_ = self->priv->current;
3918 self->priv->current = _tmp280_ + 1;
3919 _tmp281_ = self->priv->line;
3920 self->priv->line = _tmp281_ + 1;
3921 self->priv->column = 1;
3922 token_length_in_chars = 1;
3923 } else {
3924 gunichar u = 0U;
3925 gchar* _tmp282_;
3926 gchar* _tmp283_;
3927 gchar* _tmp284_;
3928 _tmp282_ = self->priv->current;
3929 _tmp283_ = self->priv->end;
3930 _tmp284_ = self->priv->current;
3931 u = g_utf8_get_char_validated ((const gchar*) _tmp282_, (gssize) ((glong) (_tmp283_ - _tmp284_)));
3932 if (u != ((gunichar) -1)) {
3933 gchar* _tmp285_;
3934 gint _tmp286_;
3935 _tmp285_ = self->priv->current;
3936 self->priv->current = _tmp285_ + g_unichar_to_utf8 (u, NULL);
3937 _tmp286_ = token_length_in_chars;
3938 token_length_in_chars = _tmp286_ + 1;
3939 } else {
3940 gchar* _tmp287_;
3941 ValaSourceReference* _tmp288_;
3942 ValaSourceReference* _tmp289_;
3943 _tmp287_ = self->priv->current;
3944 self->priv->current = _tmp287_ + 1;
3945 _tmp288_ = vala_scanner_get_source_reference (self, token_length_in_chars, 0);
3946 _tmp289_ = _tmp288_;
3947 vala_report_error (_tmp289_, "invalid UTF-8 character");
3948 _vala_source_reference_unref0 (_tmp289_);
3949 }
3950 }
3951 }
3952 _tmp292_ = self->priv->current;
3953 _tmp293_ = self->priv->end;
3954 if (_tmp292_ < _tmp293_) {
3955 gchar* _tmp294_;
3956 gchar _tmp295_;
3957 _tmp294_ = begin;
3958 _tmp295_ = _tmp294_[0];
3959 _tmp291_ = _tmp295_ == '\'';
3960 } else {
3961 _tmp291_ = FALSE;
3962 }
3963 if (_tmp291_) {
3964 gchar* _tmp296_;
3965 gchar _tmp297_;
3966 _tmp296_ = self->priv->current;
3967 _tmp297_ = _tmp296_[0];
3968 _tmp290_ = _tmp297_ != '\'';
3969 } else {
3970 _tmp290_ = FALSE;
3971 }
3972 if (_tmp290_) {
3973 ValaSourceReference* _tmp298_;
3974 ValaSourceReference* _tmp299_;
3975 _tmp298_ = vala_scanner_get_source_reference (self, token_length_in_chars, 0);
3976 _tmp299_ = _tmp298_;
3977 vala_report_error (_tmp299_, "invalid character literal");
3978 _vala_source_reference_unref0 (_tmp299_);
3979 }
3980 }
3981 _tmp300_ = self->priv->current;
3982 _tmp301_ = self->priv->end;
3983 if (_tmp300_ < _tmp301_) {
3984 gchar* _tmp302_;
3985 _tmp302_ = self->priv->current;
3986 self->priv->current = _tmp302_ + 1;
3987 } else {
3988 ValaSourceReference* _tmp303_;
3989 ValaSourceReference* _tmp304_;
3990 gchar* _tmp305_;
3991 gchar _tmp306_;
3992 gchar* _tmp307_;
3993 gchar* _tmp308_;
3994 _tmp303_ = vala_scanner_get_source_reference (self, token_length_in_chars, 0);
3995 _tmp304_ = _tmp303_;
3996 _tmp305_ = begin;
3997 _tmp306_ = _tmp305_[0];
3998 _tmp307_ = g_strdup_printf ("syntax error, expected %c", (gint) _tmp306_);
3999 _tmp308_ = _tmp307_;
4000 vala_report_error (_tmp304_, _tmp308_);
4001 _g_free0 (_tmp308_);
4002 _vala_source_reference_unref0 (_tmp304_);
4003 }
4004 break;
4005 }
4006 default:
4007 {
4008 gunichar u = 0U;
4009 gchar* _tmp309_;
4010 gchar* _tmp310_;
4011 gchar* _tmp311_;
4012 gint _tmp318_;
4013 ValaSourceLocation _tmp319_ = {0};
4014 ValaSourceLocation _tmp320_ = {0};
4015 ValaTokenType _tmp321_;
4016 _tmp309_ = self->priv->current;
4017 _tmp310_ = self->priv->end;
4018 _tmp311_ = self->priv->current;
4019 u = g_utf8_get_char_validated ((const gchar*) _tmp309_, (gssize) ((glong) (_tmp310_ - _tmp311_)));
4020 if (u != ((gunichar) -1)) {
4021 gchar* _tmp312_;
4022 ValaSourceReference* _tmp313_;
4023 ValaSourceReference* _tmp314_;
4024 _tmp312_ = self->priv->current;
4025 self->priv->current = _tmp312_ + g_unichar_to_utf8 (u, NULL);
4026 _tmp313_ = vala_scanner_get_source_reference (self, 0, 0);
4027 _tmp314_ = _tmp313_;
4028 vala_report_error (_tmp314_, "syntax error, unexpected character");
4029 _vala_source_reference_unref0 (_tmp314_);
4030 } else {
4031 gchar* _tmp315_;
4032 ValaSourceReference* _tmp316_;
4033 ValaSourceReference* _tmp317_;
4034 _tmp315_ = self->priv->current;
4035 self->priv->current = _tmp315_ + 1;
4036 _tmp316_ = vala_scanner_get_source_reference (self, 0, 0);
4037 _tmp317_ = _tmp316_;
4038 vala_report_error (_tmp317_, "invalid UTF-8 character");
4039 _vala_source_reference_unref0 (_tmp317_);
4040 }
4041 _tmp318_ = self->priv->column;
4042 self->priv->column = _tmp318_ + 1;
4043 _tmp321_ = vala_scanner_read_token (self, &_tmp319_, &_tmp320_);
4044 _vala_token_begin = _tmp319_;
4045 _vala_token_end = _tmp320_;
4046 result = _tmp321_;
4047 if (token_begin) {
4048 *token_begin = _vala_token_begin;
4049 }
4050 if (token_end) {
4051 *token_end = _vala_token_end;
4052 }
4053 return result;
4054 }
4055 }
4056 }
4057 }
4058 }
4059 }
4060 if (token_length_in_chars < 0) {
4061 gchar* _tmp322_;
4062 gchar* _tmp323_;
4063 _tmp322_ = self->priv->current;
4064 _tmp323_ = begin;
4065 self->priv->column = self->priv->column + ((gint) (_tmp322_ - _tmp323_));
4066 } else {
4067 self->priv->column = self->priv->column + token_length_in_chars;
4068 }
4069 _tmp324_ = self->priv->current;
4070 vala_source_location_init (&_vala_token_end, _tmp324_, self->priv->line, self->priv->column - 1);
4071 _tmp325_ = type;
4072 self->priv->previous = _tmp325_;
4073 result = type;
4074 if (token_begin) {
4075 *token_begin = _vala_token_begin;
4076 }
4077 if (token_end) {
4078 *token_end = _vala_token_end;
4079 }
4080 return result;
4081 }
4082
4083 static gboolean
vala_scanner_matches(gchar * begin,const gchar * keyword)4084 vala_scanner_matches (gchar* begin,
4085 const gchar* keyword)
4086 {
4087 gchar* keyword_array = NULL;
4088 glong len = 0L;
4089 gint _tmp0_;
4090 gint _tmp1_;
4091 gboolean result = FALSE;
4092 g_return_val_if_fail (keyword != NULL, FALSE);
4093 keyword_array = (gchar*) keyword;
4094 _tmp0_ = strlen (keyword);
4095 _tmp1_ = _tmp0_;
4096 len = (glong) _tmp1_;
4097 {
4098 gint i = 0;
4099 i = 0;
4100 {
4101 gboolean _tmp2_ = FALSE;
4102 _tmp2_ = TRUE;
4103 while (TRUE) {
4104 gchar _tmp4_;
4105 gchar* _tmp5_;
4106 gchar _tmp6_;
4107 if (!_tmp2_) {
4108 gint _tmp3_;
4109 _tmp3_ = i;
4110 i = _tmp3_ + 1;
4111 }
4112 _tmp2_ = FALSE;
4113 if (!(((glong) i) < len)) {
4114 break;
4115 }
4116 _tmp4_ = begin[i];
4117 _tmp5_ = keyword_array;
4118 _tmp6_ = _tmp5_[i];
4119 if (_tmp4_ != _tmp6_) {
4120 result = FALSE;
4121 return result;
4122 }
4123 }
4124 }
4125 }
4126 result = TRUE;
4127 return result;
4128 }
4129
4130 static gboolean
vala_scanner_pp_whitespace(ValaScanner * self)4131 vala_scanner_pp_whitespace (ValaScanner* self)
4132 {
4133 gboolean found = FALSE;
4134 gboolean result = FALSE;
4135 g_return_val_if_fail (self != NULL, FALSE);
4136 found = FALSE;
4137 while (TRUE) {
4138 gboolean _tmp0_ = FALSE;
4139 gboolean _tmp1_ = FALSE;
4140 gchar* _tmp2_;
4141 gchar* _tmp3_;
4142 gchar* _tmp8_;
4143 gint _tmp9_;
4144 _tmp2_ = self->priv->current;
4145 _tmp3_ = self->priv->end;
4146 if (_tmp2_ < _tmp3_) {
4147 gchar* _tmp4_;
4148 gchar _tmp5_;
4149 _tmp4_ = self->priv->current;
4150 _tmp5_ = _tmp4_[0];
4151 _tmp1_ = g_ascii_isspace (_tmp5_);
4152 } else {
4153 _tmp1_ = FALSE;
4154 }
4155 if (_tmp1_) {
4156 gchar* _tmp6_;
4157 gchar _tmp7_;
4158 _tmp6_ = self->priv->current;
4159 _tmp7_ = _tmp6_[0];
4160 _tmp0_ = _tmp7_ != '\n';
4161 } else {
4162 _tmp0_ = FALSE;
4163 }
4164 if (!_tmp0_) {
4165 break;
4166 }
4167 found = TRUE;
4168 _tmp8_ = self->priv->current;
4169 self->priv->current = _tmp8_ + 1;
4170 _tmp9_ = self->priv->column;
4171 self->priv->column = _tmp9_ + 1;
4172 }
4173 result = found;
4174 return result;
4175 }
4176
4177 static void
vala_scanner_pp_space(ValaScanner * self)4178 vala_scanner_pp_space (ValaScanner* self)
4179 {
4180 g_return_if_fail (self != NULL);
4181 while (TRUE) {
4182 gboolean _tmp0_ = FALSE;
4183 if (vala_scanner_pp_whitespace (self)) {
4184 _tmp0_ = TRUE;
4185 } else {
4186 _tmp0_ = vala_scanner_comment (self, FALSE);
4187 }
4188 if (!_tmp0_) {
4189 break;
4190 }
4191 }
4192 }
4193
4194 static void
vala_scanner_pp_directive(ValaScanner * self)4195 vala_scanner_pp_directive (ValaScanner* self)
4196 {
4197 gchar* _tmp0_;
4198 gint _tmp1_;
4199 gboolean _tmp2_ = FALSE;
4200 gboolean _tmp3_ = FALSE;
4201 gboolean _tmp4_ = FALSE;
4202 gchar* begin = NULL;
4203 gchar* _tmp15_;
4204 gint len = 0;
4205 gboolean _tmp24_ = FALSE;
4206 gboolean _tmp34_ = FALSE;
4207 ValaScannerConditional* _tmp35_;
4208 gint _tmp35__length1;
4209 g_return_if_fail (self != NULL);
4210 _tmp0_ = self->priv->current;
4211 self->priv->current = _tmp0_ + 1;
4212 _tmp1_ = self->priv->column;
4213 self->priv->column = _tmp1_ + 1;
4214 if (self->priv->line == 1) {
4215 _tmp4_ = self->priv->column == 2;
4216 } else {
4217 _tmp4_ = FALSE;
4218 }
4219 if (_tmp4_) {
4220 gchar* _tmp5_;
4221 gchar* _tmp6_;
4222 _tmp5_ = self->priv->current;
4223 _tmp6_ = self->priv->end;
4224 _tmp3_ = _tmp5_ < _tmp6_;
4225 } else {
4226 _tmp3_ = FALSE;
4227 }
4228 if (_tmp3_) {
4229 gchar* _tmp7_;
4230 gchar _tmp8_;
4231 _tmp7_ = self->priv->current;
4232 _tmp8_ = _tmp7_[0];
4233 _tmp2_ = _tmp8_ == '!';
4234 } else {
4235 _tmp2_ = FALSE;
4236 }
4237 if (_tmp2_) {
4238 while (TRUE) {
4239 gboolean _tmp9_ = FALSE;
4240 gchar* _tmp10_;
4241 gchar* _tmp11_;
4242 gchar* _tmp14_;
4243 _tmp10_ = self->priv->current;
4244 _tmp11_ = self->priv->end;
4245 if (_tmp10_ < _tmp11_) {
4246 gchar* _tmp12_;
4247 gchar _tmp13_;
4248 _tmp12_ = self->priv->current;
4249 _tmp13_ = _tmp12_[0];
4250 _tmp9_ = _tmp13_ != '\n';
4251 } else {
4252 _tmp9_ = FALSE;
4253 }
4254 if (!_tmp9_) {
4255 break;
4256 }
4257 _tmp14_ = self->priv->current;
4258 self->priv->current = _tmp14_ + 1;
4259 }
4260 return;
4261 }
4262 vala_scanner_pp_space (self);
4263 _tmp15_ = self->priv->current;
4264 begin = _tmp15_;
4265 len = 0;
4266 while (TRUE) {
4267 gboolean _tmp16_ = FALSE;
4268 gchar* _tmp17_;
4269 gchar* _tmp18_;
4270 gchar* _tmp21_;
4271 gint _tmp22_;
4272 gint _tmp23_;
4273 _tmp17_ = self->priv->current;
4274 _tmp18_ = self->priv->end;
4275 if (_tmp17_ < _tmp18_) {
4276 gchar* _tmp19_;
4277 gchar _tmp20_;
4278 _tmp19_ = self->priv->current;
4279 _tmp20_ = _tmp19_[0];
4280 _tmp16_ = g_ascii_isalnum (_tmp20_);
4281 } else {
4282 _tmp16_ = FALSE;
4283 }
4284 if (!_tmp16_) {
4285 break;
4286 }
4287 _tmp21_ = self->priv->current;
4288 self->priv->current = _tmp21_ + 1;
4289 _tmp22_ = self->priv->column;
4290 self->priv->column = _tmp22_ + 1;
4291 _tmp23_ = len;
4292 len = _tmp23_ + 1;
4293 }
4294 if (len == 2) {
4295 gchar* _tmp25_;
4296 _tmp25_ = begin;
4297 _tmp24_ = vala_scanner_matches (_tmp25_, "if");
4298 } else {
4299 _tmp24_ = FALSE;
4300 }
4301 if (_tmp24_) {
4302 vala_scanner_parse_pp_if (self);
4303 } else {
4304 gboolean _tmp26_ = FALSE;
4305 if (len == 4) {
4306 gchar* _tmp27_;
4307 _tmp27_ = begin;
4308 _tmp26_ = vala_scanner_matches (_tmp27_, "elif");
4309 } else {
4310 _tmp26_ = FALSE;
4311 }
4312 if (_tmp26_) {
4313 vala_scanner_parse_pp_elif (self);
4314 } else {
4315 gboolean _tmp28_ = FALSE;
4316 if (len == 4) {
4317 gchar* _tmp29_;
4318 _tmp29_ = begin;
4319 _tmp28_ = vala_scanner_matches (_tmp29_, "else");
4320 } else {
4321 _tmp28_ = FALSE;
4322 }
4323 if (_tmp28_) {
4324 vala_scanner_parse_pp_else (self);
4325 } else {
4326 gboolean _tmp30_ = FALSE;
4327 if (len == 5) {
4328 gchar* _tmp31_;
4329 _tmp31_ = begin;
4330 _tmp30_ = vala_scanner_matches (_tmp31_, "endif");
4331 } else {
4332 _tmp30_ = FALSE;
4333 }
4334 if (_tmp30_) {
4335 vala_scanner_parse_pp_endif (self);
4336 } else {
4337 ValaSourceReference* _tmp32_;
4338 ValaSourceReference* _tmp33_;
4339 _tmp32_ = vala_scanner_get_source_reference (self, -len, len);
4340 _tmp33_ = _tmp32_;
4341 vala_report_error (_tmp33_, "syntax error, invalid preprocessing directive");
4342 _vala_source_reference_unref0 (_tmp33_);
4343 }
4344 }
4345 }
4346 }
4347 _tmp35_ = self->priv->conditional_stack;
4348 _tmp35__length1 = self->priv->conditional_stack_length1;
4349 if (_tmp35__length1 > 0) {
4350 ValaScannerConditional* _tmp36_;
4351 gint _tmp36__length1;
4352 ValaScannerConditional* _tmp37_;
4353 gint _tmp37__length1;
4354 ValaScannerConditional _tmp38_;
4355 _tmp36_ = self->priv->conditional_stack;
4356 _tmp36__length1 = self->priv->conditional_stack_length1;
4357 _tmp37_ = self->priv->conditional_stack;
4358 _tmp37__length1 = self->priv->conditional_stack_length1;
4359 _tmp38_ = _tmp36_[_tmp37__length1 - 1];
4360 _tmp34_ = _tmp38_.skip_section;
4361 } else {
4362 _tmp34_ = FALSE;
4363 }
4364 if (_tmp34_) {
4365 gboolean bol = FALSE;
4366 bol = FALSE;
4367 while (TRUE) {
4368 gchar* _tmp39_;
4369 gchar* _tmp40_;
4370 gboolean _tmp41_ = FALSE;
4371 gchar* _tmp45_;
4372 gchar _tmp46_;
4373 gchar* _tmp50_;
4374 gint _tmp51_;
4375 _tmp39_ = self->priv->current;
4376 _tmp40_ = self->priv->end;
4377 if (!(_tmp39_ < _tmp40_)) {
4378 break;
4379 }
4380 if (bol) {
4381 gchar* _tmp42_;
4382 gchar _tmp43_;
4383 _tmp42_ = self->priv->current;
4384 _tmp43_ = _tmp42_[0];
4385 _tmp41_ = _tmp43_ == '#';
4386 } else {
4387 _tmp41_ = FALSE;
4388 }
4389 if (_tmp41_) {
4390 gchar* _tmp44_;
4391 _tmp44_ = self->priv->current;
4392 self->priv->current = _tmp44_ - (self->priv->column - 1);
4393 self->priv->column = 1;
4394 return;
4395 }
4396 _tmp45_ = self->priv->current;
4397 _tmp46_ = _tmp45_[0];
4398 if (_tmp46_ == '\n') {
4399 gint _tmp47_;
4400 _tmp47_ = self->priv->line;
4401 self->priv->line = _tmp47_ + 1;
4402 self->priv->column = 0;
4403 bol = TRUE;
4404 } else {
4405 gchar* _tmp48_;
4406 gchar _tmp49_;
4407 _tmp48_ = self->priv->current;
4408 _tmp49_ = _tmp48_[0];
4409 if (!g_ascii_isspace (_tmp49_)) {
4410 bol = FALSE;
4411 }
4412 }
4413 _tmp50_ = self->priv->current;
4414 self->priv->current = _tmp50_ + 1;
4415 _tmp51_ = self->priv->column;
4416 self->priv->column = _tmp51_ + 1;
4417 }
4418 }
4419 }
4420
4421 static void
vala_scanner_pp_eol(ValaScanner * self)4422 vala_scanner_pp_eol (ValaScanner* self)
4423 {
4424 gboolean _tmp0_ = FALSE;
4425 gchar* _tmp1_;
4426 gchar* _tmp2_;
4427 g_return_if_fail (self != NULL);
4428 vala_scanner_pp_space (self);
4429 _tmp1_ = self->priv->current;
4430 _tmp2_ = self->priv->end;
4431 if (_tmp1_ >= _tmp2_) {
4432 _tmp0_ = TRUE;
4433 } else {
4434 gchar* _tmp3_;
4435 gchar _tmp4_;
4436 _tmp3_ = self->priv->current;
4437 _tmp4_ = _tmp3_[0];
4438 _tmp0_ = _tmp4_ != '\n';
4439 }
4440 if (_tmp0_) {
4441 ValaSourceReference* _tmp5_;
4442 ValaSourceReference* _tmp6_;
4443 _tmp5_ = vala_scanner_get_source_reference (self, 0, 0);
4444 _tmp6_ = _tmp5_;
4445 vala_report_error (_tmp6_, "syntax error, expected newline");
4446 _vala_source_reference_unref0 (_tmp6_);
4447 }
4448 }
4449
4450 static void
_vala_array_add22(ValaScannerConditional ** array,gint * length,gint * size,const ValaScannerConditional * value)4451 _vala_array_add22 (ValaScannerConditional* * array,
4452 gint* length,
4453 gint* size,
4454 const ValaScannerConditional* value)
4455 {
4456 if ((*length) == (*size)) {
4457 *size = (*size) ? (2 * (*size)) : 4;
4458 *array = g_renew (ValaScannerConditional, *array, *size);
4459 }
4460 (*array)[(*length)++] = *value;
4461 }
4462
4463 static void
vala_scanner_parse_pp_if(ValaScanner * self)4464 vala_scanner_parse_pp_if (ValaScanner* self)
4465 {
4466 gboolean condition = FALSE;
4467 ValaScannerConditional _tmp0_ = {0};
4468 gboolean _tmp1_ = FALSE;
4469 g_return_if_fail (self != NULL);
4470 vala_scanner_pp_space (self);
4471 condition = vala_scanner_parse_pp_expression (self);
4472 vala_scanner_pp_eol (self);
4473 memset (&_tmp0_, 0, sizeof (ValaScannerConditional));
4474 _vala_array_add22 (&self->priv->conditional_stack, &self->priv->conditional_stack_length1, &self->priv->_conditional_stack_size_, &_tmp0_);
4475 if (condition) {
4476 gboolean _tmp2_ = FALSE;
4477 ValaScannerConditional* _tmp3_;
4478 gint _tmp3__length1;
4479 _tmp3_ = self->priv->conditional_stack;
4480 _tmp3__length1 = self->priv->conditional_stack_length1;
4481 if (_tmp3__length1 == 1) {
4482 _tmp2_ = TRUE;
4483 } else {
4484 ValaScannerConditional* _tmp4_;
4485 gint _tmp4__length1;
4486 ValaScannerConditional* _tmp5_;
4487 gint _tmp5__length1;
4488 ValaScannerConditional _tmp6_;
4489 _tmp4_ = self->priv->conditional_stack;
4490 _tmp4__length1 = self->priv->conditional_stack_length1;
4491 _tmp5_ = self->priv->conditional_stack;
4492 _tmp5__length1 = self->priv->conditional_stack_length1;
4493 _tmp6_ = _tmp4_[_tmp5__length1 - 2];
4494 _tmp2_ = !_tmp6_.skip_section;
4495 }
4496 _tmp1_ = _tmp2_;
4497 } else {
4498 _tmp1_ = FALSE;
4499 }
4500 if (_tmp1_) {
4501 ValaScannerConditional* _tmp7_;
4502 gint _tmp7__length1;
4503 ValaScannerConditional* _tmp8_;
4504 gint _tmp8__length1;
4505 _tmp7_ = self->priv->conditional_stack;
4506 _tmp7__length1 = self->priv->conditional_stack_length1;
4507 _tmp8_ = self->priv->conditional_stack;
4508 _tmp8__length1 = self->priv->conditional_stack_length1;
4509 _tmp7_[_tmp8__length1 - 1].matched = TRUE;
4510 } else {
4511 ValaScannerConditional* _tmp9_;
4512 gint _tmp9__length1;
4513 ValaScannerConditional* _tmp10_;
4514 gint _tmp10__length1;
4515 _tmp9_ = self->priv->conditional_stack;
4516 _tmp9__length1 = self->priv->conditional_stack_length1;
4517 _tmp10_ = self->priv->conditional_stack;
4518 _tmp10__length1 = self->priv->conditional_stack_length1;
4519 _tmp9_[_tmp10__length1 - 1].skip_section = TRUE;
4520 }
4521 }
4522
4523 static void
vala_scanner_parse_pp_elif(ValaScanner * self)4524 vala_scanner_parse_pp_elif (ValaScanner* self)
4525 {
4526 gboolean condition = FALSE;
4527 gboolean _tmp0_ = FALSE;
4528 ValaScannerConditional* _tmp1_;
4529 gint _tmp1__length1;
4530 gboolean _tmp7_ = FALSE;
4531 gboolean _tmp8_ = FALSE;
4532 g_return_if_fail (self != NULL);
4533 vala_scanner_pp_space (self);
4534 condition = vala_scanner_parse_pp_expression (self);
4535 vala_scanner_pp_eol (self);
4536 _tmp1_ = self->priv->conditional_stack;
4537 _tmp1__length1 = self->priv->conditional_stack_length1;
4538 if (_tmp1__length1 == 0) {
4539 _tmp0_ = TRUE;
4540 } else {
4541 ValaScannerConditional* _tmp2_;
4542 gint _tmp2__length1;
4543 ValaScannerConditional* _tmp3_;
4544 gint _tmp3__length1;
4545 ValaScannerConditional _tmp4_;
4546 _tmp2_ = self->priv->conditional_stack;
4547 _tmp2__length1 = self->priv->conditional_stack_length1;
4548 _tmp3_ = self->priv->conditional_stack;
4549 _tmp3__length1 = self->priv->conditional_stack_length1;
4550 _tmp4_ = _tmp2_[_tmp3__length1 - 1];
4551 _tmp0_ = _tmp4_.else_found;
4552 }
4553 if (_tmp0_) {
4554 ValaSourceReference* _tmp5_;
4555 ValaSourceReference* _tmp6_;
4556 _tmp5_ = vala_scanner_get_source_reference (self, 0, 0);
4557 _tmp6_ = _tmp5_;
4558 vala_report_error (_tmp6_, "syntax error, unexpected #elif");
4559 _vala_source_reference_unref0 (_tmp6_);
4560 return;
4561 }
4562 if (condition) {
4563 ValaScannerConditional* _tmp9_;
4564 gint _tmp9__length1;
4565 ValaScannerConditional* _tmp10_;
4566 gint _tmp10__length1;
4567 ValaScannerConditional _tmp11_;
4568 _tmp9_ = self->priv->conditional_stack;
4569 _tmp9__length1 = self->priv->conditional_stack_length1;
4570 _tmp10_ = self->priv->conditional_stack;
4571 _tmp10__length1 = self->priv->conditional_stack_length1;
4572 _tmp11_ = _tmp9_[_tmp10__length1 - 1];
4573 _tmp8_ = !_tmp11_.matched;
4574 } else {
4575 _tmp8_ = FALSE;
4576 }
4577 if (_tmp8_) {
4578 gboolean _tmp12_ = FALSE;
4579 ValaScannerConditional* _tmp13_;
4580 gint _tmp13__length1;
4581 _tmp13_ = self->priv->conditional_stack;
4582 _tmp13__length1 = self->priv->conditional_stack_length1;
4583 if (_tmp13__length1 == 1) {
4584 _tmp12_ = TRUE;
4585 } else {
4586 ValaScannerConditional* _tmp14_;
4587 gint _tmp14__length1;
4588 ValaScannerConditional* _tmp15_;
4589 gint _tmp15__length1;
4590 ValaScannerConditional _tmp16_;
4591 _tmp14_ = self->priv->conditional_stack;
4592 _tmp14__length1 = self->priv->conditional_stack_length1;
4593 _tmp15_ = self->priv->conditional_stack;
4594 _tmp15__length1 = self->priv->conditional_stack_length1;
4595 _tmp16_ = _tmp14_[_tmp15__length1 - 2];
4596 _tmp12_ = !_tmp16_.skip_section;
4597 }
4598 _tmp7_ = _tmp12_;
4599 } else {
4600 _tmp7_ = FALSE;
4601 }
4602 if (_tmp7_) {
4603 ValaScannerConditional* _tmp17_;
4604 gint _tmp17__length1;
4605 ValaScannerConditional* _tmp18_;
4606 gint _tmp18__length1;
4607 ValaScannerConditional* _tmp19_;
4608 gint _tmp19__length1;
4609 ValaScannerConditional* _tmp20_;
4610 gint _tmp20__length1;
4611 _tmp17_ = self->priv->conditional_stack;
4612 _tmp17__length1 = self->priv->conditional_stack_length1;
4613 _tmp18_ = self->priv->conditional_stack;
4614 _tmp18__length1 = self->priv->conditional_stack_length1;
4615 _tmp17_[_tmp18__length1 - 1].matched = TRUE;
4616 _tmp19_ = self->priv->conditional_stack;
4617 _tmp19__length1 = self->priv->conditional_stack_length1;
4618 _tmp20_ = self->priv->conditional_stack;
4619 _tmp20__length1 = self->priv->conditional_stack_length1;
4620 _tmp19_[_tmp20__length1 - 1].skip_section = FALSE;
4621 } else {
4622 ValaScannerConditional* _tmp21_;
4623 gint _tmp21__length1;
4624 ValaScannerConditional* _tmp22_;
4625 gint _tmp22__length1;
4626 _tmp21_ = self->priv->conditional_stack;
4627 _tmp21__length1 = self->priv->conditional_stack_length1;
4628 _tmp22_ = self->priv->conditional_stack;
4629 _tmp22__length1 = self->priv->conditional_stack_length1;
4630 _tmp21_[_tmp22__length1 - 1].skip_section = TRUE;
4631 }
4632 }
4633
4634 static void
vala_scanner_parse_pp_else(ValaScanner * self)4635 vala_scanner_parse_pp_else (ValaScanner* self)
4636 {
4637 gboolean _tmp0_ = FALSE;
4638 ValaScannerConditional* _tmp1_;
4639 gint _tmp1__length1;
4640 gboolean _tmp7_ = FALSE;
4641 ValaScannerConditional* _tmp8_;
4642 gint _tmp8__length1;
4643 ValaScannerConditional* _tmp9_;
4644 gint _tmp9__length1;
4645 ValaScannerConditional _tmp10_;
4646 g_return_if_fail (self != NULL);
4647 vala_scanner_pp_eol (self);
4648 _tmp1_ = self->priv->conditional_stack;
4649 _tmp1__length1 = self->priv->conditional_stack_length1;
4650 if (_tmp1__length1 == 0) {
4651 _tmp0_ = TRUE;
4652 } else {
4653 ValaScannerConditional* _tmp2_;
4654 gint _tmp2__length1;
4655 ValaScannerConditional* _tmp3_;
4656 gint _tmp3__length1;
4657 ValaScannerConditional _tmp4_;
4658 _tmp2_ = self->priv->conditional_stack;
4659 _tmp2__length1 = self->priv->conditional_stack_length1;
4660 _tmp3_ = self->priv->conditional_stack;
4661 _tmp3__length1 = self->priv->conditional_stack_length1;
4662 _tmp4_ = _tmp2_[_tmp3__length1 - 1];
4663 _tmp0_ = _tmp4_.else_found;
4664 }
4665 if (_tmp0_) {
4666 ValaSourceReference* _tmp5_;
4667 ValaSourceReference* _tmp6_;
4668 _tmp5_ = vala_scanner_get_source_reference (self, 0, 0);
4669 _tmp6_ = _tmp5_;
4670 vala_report_error (_tmp6_, "syntax error, unexpected #else");
4671 _vala_source_reference_unref0 (_tmp6_);
4672 return;
4673 }
4674 _tmp8_ = self->priv->conditional_stack;
4675 _tmp8__length1 = self->priv->conditional_stack_length1;
4676 _tmp9_ = self->priv->conditional_stack;
4677 _tmp9__length1 = self->priv->conditional_stack_length1;
4678 _tmp10_ = _tmp8_[_tmp9__length1 - 1];
4679 if (!_tmp10_.matched) {
4680 gboolean _tmp11_ = FALSE;
4681 ValaScannerConditional* _tmp12_;
4682 gint _tmp12__length1;
4683 _tmp12_ = self->priv->conditional_stack;
4684 _tmp12__length1 = self->priv->conditional_stack_length1;
4685 if (_tmp12__length1 == 1) {
4686 _tmp11_ = TRUE;
4687 } else {
4688 ValaScannerConditional* _tmp13_;
4689 gint _tmp13__length1;
4690 ValaScannerConditional* _tmp14_;
4691 gint _tmp14__length1;
4692 ValaScannerConditional _tmp15_;
4693 _tmp13_ = self->priv->conditional_stack;
4694 _tmp13__length1 = self->priv->conditional_stack_length1;
4695 _tmp14_ = self->priv->conditional_stack;
4696 _tmp14__length1 = self->priv->conditional_stack_length1;
4697 _tmp15_ = _tmp13_[_tmp14__length1 - 2];
4698 _tmp11_ = !_tmp15_.skip_section;
4699 }
4700 _tmp7_ = _tmp11_;
4701 } else {
4702 _tmp7_ = FALSE;
4703 }
4704 if (_tmp7_) {
4705 ValaScannerConditional* _tmp16_;
4706 gint _tmp16__length1;
4707 ValaScannerConditional* _tmp17_;
4708 gint _tmp17__length1;
4709 ValaScannerConditional* _tmp18_;
4710 gint _tmp18__length1;
4711 ValaScannerConditional* _tmp19_;
4712 gint _tmp19__length1;
4713 _tmp16_ = self->priv->conditional_stack;
4714 _tmp16__length1 = self->priv->conditional_stack_length1;
4715 _tmp17_ = self->priv->conditional_stack;
4716 _tmp17__length1 = self->priv->conditional_stack_length1;
4717 _tmp16_[_tmp17__length1 - 1].matched = TRUE;
4718 _tmp18_ = self->priv->conditional_stack;
4719 _tmp18__length1 = self->priv->conditional_stack_length1;
4720 _tmp19_ = self->priv->conditional_stack;
4721 _tmp19__length1 = self->priv->conditional_stack_length1;
4722 _tmp18_[_tmp19__length1 - 1].skip_section = FALSE;
4723 } else {
4724 ValaScannerConditional* _tmp20_;
4725 gint _tmp20__length1;
4726 ValaScannerConditional* _tmp21_;
4727 gint _tmp21__length1;
4728 _tmp20_ = self->priv->conditional_stack;
4729 _tmp20__length1 = self->priv->conditional_stack_length1;
4730 _tmp21_ = self->priv->conditional_stack;
4731 _tmp21__length1 = self->priv->conditional_stack_length1;
4732 _tmp20_[_tmp21__length1 - 1].skip_section = TRUE;
4733 }
4734 }
4735
4736 static void
vala_scanner_parse_pp_endif(ValaScanner * self)4737 vala_scanner_parse_pp_endif (ValaScanner* self)
4738 {
4739 ValaScannerConditional* _tmp0_;
4740 gint _tmp0__length1;
4741 gint _tmp3_;
4742 g_return_if_fail (self != NULL);
4743 vala_scanner_pp_eol (self);
4744 _tmp0_ = self->priv->conditional_stack;
4745 _tmp0__length1 = self->priv->conditional_stack_length1;
4746 if (_tmp0__length1 == 0) {
4747 ValaSourceReference* _tmp1_;
4748 ValaSourceReference* _tmp2_;
4749 _tmp1_ = vala_scanner_get_source_reference (self, 0, 0);
4750 _tmp2_ = _tmp1_;
4751 vala_report_error (_tmp2_, "syntax error, unexpected #endif");
4752 _vala_source_reference_unref0 (_tmp2_);
4753 return;
4754 }
4755 _tmp3_ = self->priv->conditional_stack_length1;
4756 self->priv->conditional_stack_length1 = _tmp3_ - 1;
4757 }
4758
4759 static glong
string_strnlen(gchar * str,glong maxlen)4760 string_strnlen (gchar* str,
4761 glong maxlen)
4762 {
4763 gchar* end = NULL;
4764 gchar* _tmp0_;
4765 gchar* _tmp1_;
4766 glong result = 0L;
4767 _tmp0_ = memchr (str, 0, (gsize) maxlen);
4768 end = _tmp0_;
4769 _tmp1_ = end;
4770 if (_tmp1_ == NULL) {
4771 result = maxlen;
4772 return result;
4773 } else {
4774 gchar* _tmp2_;
4775 _tmp2_ = end;
4776 result = (glong) (_tmp2_ - str);
4777 return result;
4778 }
4779 }
4780
4781 static gchar*
string_substring(const gchar * self,glong offset,glong len)4782 string_substring (const gchar* self,
4783 glong offset,
4784 glong len)
4785 {
4786 glong string_length = 0L;
4787 gboolean _tmp0_ = FALSE;
4788 gchar* _tmp3_;
4789 gchar* result = NULL;
4790 g_return_val_if_fail (self != NULL, NULL);
4791 if (offset >= ((glong) 0)) {
4792 _tmp0_ = len >= ((glong) 0);
4793 } else {
4794 _tmp0_ = FALSE;
4795 }
4796 if (_tmp0_) {
4797 string_length = string_strnlen ((gchar*) self, offset + len);
4798 } else {
4799 gint _tmp1_;
4800 gint _tmp2_;
4801 _tmp1_ = strlen (self);
4802 _tmp2_ = _tmp1_;
4803 string_length = (glong) _tmp2_;
4804 }
4805 if (offset < ((glong) 0)) {
4806 offset = string_length + offset;
4807 g_return_val_if_fail (offset >= ((glong) 0), NULL);
4808 } else {
4809 g_return_val_if_fail (offset <= string_length, NULL);
4810 }
4811 if (len < ((glong) 0)) {
4812 len = string_length - offset;
4813 }
4814 g_return_val_if_fail ((offset + len) <= string_length, NULL);
4815 _tmp3_ = g_strndup (((gchar*) self) + offset, (gsize) len);
4816 result = _tmp3_;
4817 return result;
4818 }
4819
4820 static gboolean
vala_scanner_parse_pp_symbol(ValaScanner * self)4821 vala_scanner_parse_pp_symbol (ValaScanner* self)
4822 {
4823 gint len = 0;
4824 gchar* identifier = NULL;
4825 gchar* _tmp10_;
4826 gchar* _tmp11_;
4827 gboolean defined = FALSE;
4828 const gchar* _tmp12_;
4829 gboolean result = FALSE;
4830 g_return_val_if_fail (self != NULL, FALSE);
4831 len = 0;
4832 while (TRUE) {
4833 gboolean _tmp0_ = FALSE;
4834 gchar* _tmp1_;
4835 gchar* _tmp2_;
4836 gchar* _tmp5_;
4837 gint _tmp6_;
4838 gint _tmp7_;
4839 _tmp1_ = self->priv->current;
4840 _tmp2_ = self->priv->end;
4841 if (_tmp1_ < _tmp2_) {
4842 gchar* _tmp3_;
4843 gchar _tmp4_;
4844 _tmp3_ = self->priv->current;
4845 _tmp4_ = _tmp3_[0];
4846 _tmp0_ = vala_scanner_is_ident_char (self, _tmp4_);
4847 } else {
4848 _tmp0_ = FALSE;
4849 }
4850 if (!_tmp0_) {
4851 break;
4852 }
4853 _tmp5_ = self->priv->current;
4854 self->priv->current = _tmp5_ + 1;
4855 _tmp6_ = self->priv->column;
4856 self->priv->column = _tmp6_ + 1;
4857 _tmp7_ = len;
4858 len = _tmp7_ + 1;
4859 }
4860 if (len == 0) {
4861 ValaSourceReference* _tmp8_;
4862 ValaSourceReference* _tmp9_;
4863 _tmp8_ = vala_scanner_get_source_reference (self, 0, 0);
4864 _tmp9_ = _tmp8_;
4865 vala_report_error (_tmp9_, "syntax error, expected identifier");
4866 _vala_source_reference_unref0 (_tmp9_);
4867 result = FALSE;
4868 return result;
4869 }
4870 _tmp10_ = self->priv->current;
4871 _tmp11_ = string_substring ((const gchar*) (_tmp10_ - len), (glong) 0, (glong) len);
4872 identifier = _tmp11_;
4873 _tmp12_ = identifier;
4874 if (g_strcmp0 (_tmp12_, "true") == 0) {
4875 defined = TRUE;
4876 } else {
4877 const gchar* _tmp13_;
4878 _tmp13_ = identifier;
4879 if (g_strcmp0 (_tmp13_, "false") == 0) {
4880 defined = FALSE;
4881 } else {
4882 ValaSourceFile* _tmp14_;
4883 ValaCodeContext* _tmp15_;
4884 ValaCodeContext* _tmp16_;
4885 const gchar* _tmp17_;
4886 _tmp14_ = self->priv->_source_file;
4887 _tmp15_ = vala_source_file_get_context (_tmp14_);
4888 _tmp16_ = _tmp15_;
4889 _tmp17_ = identifier;
4890 defined = vala_code_context_is_defined (_tmp16_, _tmp17_);
4891 }
4892 }
4893 result = defined;
4894 _g_free0 (identifier);
4895 return result;
4896 }
4897
4898 static gboolean
vala_scanner_parse_pp_primary_expression(ValaScanner * self)4899 vala_scanner_parse_pp_primary_expression (ValaScanner* self)
4900 {
4901 gchar* _tmp0_;
4902 gchar* _tmp1_;
4903 gboolean result = FALSE;
4904 g_return_val_if_fail (self != NULL, FALSE);
4905 _tmp0_ = self->priv->current;
4906 _tmp1_ = self->priv->end;
4907 if (_tmp0_ >= _tmp1_) {
4908 ValaSourceReference* _tmp2_;
4909 ValaSourceReference* _tmp3_;
4910 _tmp2_ = vala_scanner_get_source_reference (self, 0, 0);
4911 _tmp3_ = _tmp2_;
4912 vala_report_error (_tmp3_, "syntax error, expected identifier");
4913 _vala_source_reference_unref0 (_tmp3_);
4914 } else {
4915 gchar* _tmp4_;
4916 gchar _tmp5_;
4917 _tmp4_ = self->priv->current;
4918 _tmp5_ = _tmp4_[0];
4919 if (vala_scanner_is_ident_char (self, _tmp5_)) {
4920 result = vala_scanner_parse_pp_symbol (self);
4921 return result;
4922 } else {
4923 gchar* _tmp6_;
4924 gchar _tmp7_;
4925 _tmp6_ = self->priv->current;
4926 _tmp7_ = _tmp6_[0];
4927 if (_tmp7_ == '(') {
4928 gchar* _tmp8_;
4929 gint _tmp9_;
4930 gboolean _result_ = FALSE;
4931 gboolean _tmp10_ = FALSE;
4932 gchar* _tmp11_;
4933 gchar* _tmp12_;
4934 _tmp8_ = self->priv->current;
4935 self->priv->current = _tmp8_ + 1;
4936 _tmp9_ = self->priv->column;
4937 self->priv->column = _tmp9_ + 1;
4938 vala_scanner_pp_space (self);
4939 _result_ = vala_scanner_parse_pp_expression (self);
4940 vala_scanner_pp_space (self);
4941 _tmp11_ = self->priv->current;
4942 _tmp12_ = self->priv->end;
4943 if (_tmp11_ < _tmp12_) {
4944 gchar* _tmp13_;
4945 gchar _tmp14_;
4946 _tmp13_ = self->priv->current;
4947 _tmp14_ = _tmp13_[0];
4948 _tmp10_ = _tmp14_ == ')';
4949 } else {
4950 _tmp10_ = FALSE;
4951 }
4952 if (_tmp10_) {
4953 gchar* _tmp15_;
4954 gint _tmp16_;
4955 _tmp15_ = self->priv->current;
4956 self->priv->current = _tmp15_ + 1;
4957 _tmp16_ = self->priv->column;
4958 self->priv->column = _tmp16_ + 1;
4959 } else {
4960 ValaSourceReference* _tmp17_;
4961 ValaSourceReference* _tmp18_;
4962 _tmp17_ = vala_scanner_get_source_reference (self, 0, 0);
4963 _tmp18_ = _tmp17_;
4964 vala_report_error (_tmp18_, "syntax error, expected `)'");
4965 _vala_source_reference_unref0 (_tmp18_);
4966 }
4967 result = _result_;
4968 return result;
4969 } else {
4970 ValaSourceReference* _tmp19_;
4971 ValaSourceReference* _tmp20_;
4972 _tmp19_ = vala_scanner_get_source_reference (self, 0, 0);
4973 _tmp20_ = _tmp19_;
4974 vala_report_error (_tmp20_, "syntax error, expected identifier");
4975 _vala_source_reference_unref0 (_tmp20_);
4976 }
4977 }
4978 }
4979 result = FALSE;
4980 return result;
4981 }
4982
4983 static gboolean
vala_scanner_parse_pp_unary_expression(ValaScanner * self)4984 vala_scanner_parse_pp_unary_expression (ValaScanner* self)
4985 {
4986 gboolean _tmp0_ = FALSE;
4987 gchar* _tmp1_;
4988 gchar* _tmp2_;
4989 gboolean result = FALSE;
4990 g_return_val_if_fail (self != NULL, FALSE);
4991 _tmp1_ = self->priv->current;
4992 _tmp2_ = self->priv->end;
4993 if (_tmp1_ < _tmp2_) {
4994 gchar* _tmp3_;
4995 gchar _tmp4_;
4996 _tmp3_ = self->priv->current;
4997 _tmp4_ = _tmp3_[0];
4998 _tmp0_ = _tmp4_ == '!';
4999 } else {
5000 _tmp0_ = FALSE;
5001 }
5002 if (_tmp0_) {
5003 gchar* _tmp5_;
5004 gint _tmp6_;
5005 _tmp5_ = self->priv->current;
5006 self->priv->current = _tmp5_ + 1;
5007 _tmp6_ = self->priv->column;
5008 self->priv->column = _tmp6_ + 1;
5009 vala_scanner_pp_space (self);
5010 result = !vala_scanner_parse_pp_unary_expression (self);
5011 return result;
5012 }
5013 result = vala_scanner_parse_pp_primary_expression (self);
5014 return result;
5015 }
5016
5017 static gboolean
vala_scanner_parse_pp_equality_expression(ValaScanner * self)5018 vala_scanner_parse_pp_equality_expression (ValaScanner* self)
5019 {
5020 gboolean left = FALSE;
5021 gboolean result = FALSE;
5022 g_return_val_if_fail (self != NULL, FALSE);
5023 left = vala_scanner_parse_pp_unary_expression (self);
5024 vala_scanner_pp_space (self);
5025 while (TRUE) {
5026 gboolean _tmp0_ = FALSE;
5027 gboolean _tmp1_ = FALSE;
5028 gchar* _tmp2_;
5029 gchar* _tmp3_;
5030 _tmp2_ = self->priv->current;
5031 _tmp3_ = self->priv->end;
5032 if (_tmp2_ < (_tmp3_ - 1)) {
5033 gchar* _tmp4_;
5034 gchar _tmp5_;
5035 _tmp4_ = self->priv->current;
5036 _tmp5_ = _tmp4_[0];
5037 _tmp1_ = _tmp5_ == '=';
5038 } else {
5039 _tmp1_ = FALSE;
5040 }
5041 if (_tmp1_) {
5042 gchar* _tmp6_;
5043 gchar _tmp7_;
5044 _tmp6_ = self->priv->current;
5045 _tmp7_ = _tmp6_[1];
5046 _tmp0_ = _tmp7_ == '=';
5047 } else {
5048 _tmp0_ = FALSE;
5049 }
5050 if (_tmp0_) {
5051 gchar* _tmp8_;
5052 gboolean right = FALSE;
5053 _tmp8_ = self->priv->current;
5054 self->priv->current = _tmp8_ + 2;
5055 self->priv->column = self->priv->column + 2;
5056 vala_scanner_pp_space (self);
5057 right = vala_scanner_parse_pp_unary_expression (self);
5058 left = left == right;
5059 } else {
5060 gboolean _tmp9_ = FALSE;
5061 gboolean _tmp10_ = FALSE;
5062 gchar* _tmp11_;
5063 gchar* _tmp12_;
5064 _tmp11_ = self->priv->current;
5065 _tmp12_ = self->priv->end;
5066 if (_tmp11_ < (_tmp12_ - 1)) {
5067 gchar* _tmp13_;
5068 gchar _tmp14_;
5069 _tmp13_ = self->priv->current;
5070 _tmp14_ = _tmp13_[0];
5071 _tmp10_ = _tmp14_ == '!';
5072 } else {
5073 _tmp10_ = FALSE;
5074 }
5075 if (_tmp10_) {
5076 gchar* _tmp15_;
5077 gchar _tmp16_;
5078 _tmp15_ = self->priv->current;
5079 _tmp16_ = _tmp15_[1];
5080 _tmp9_ = _tmp16_ == '=';
5081 } else {
5082 _tmp9_ = FALSE;
5083 }
5084 if (_tmp9_) {
5085 gchar* _tmp17_;
5086 gboolean right = FALSE;
5087 _tmp17_ = self->priv->current;
5088 self->priv->current = _tmp17_ + 2;
5089 self->priv->column = self->priv->column + 2;
5090 vala_scanner_pp_space (self);
5091 right = vala_scanner_parse_pp_unary_expression (self);
5092 left = left != right;
5093 } else {
5094 break;
5095 }
5096 }
5097 }
5098 result = left;
5099 return result;
5100 }
5101
5102 static gboolean
vala_scanner_parse_pp_and_expression(ValaScanner * self)5103 vala_scanner_parse_pp_and_expression (ValaScanner* self)
5104 {
5105 gboolean left = FALSE;
5106 gboolean result = FALSE;
5107 g_return_val_if_fail (self != NULL, FALSE);
5108 left = vala_scanner_parse_pp_equality_expression (self);
5109 vala_scanner_pp_space (self);
5110 while (TRUE) {
5111 gboolean _tmp0_ = FALSE;
5112 gboolean _tmp1_ = FALSE;
5113 gchar* _tmp2_;
5114 gchar* _tmp3_;
5115 gchar* _tmp8_;
5116 gboolean right = FALSE;
5117 gboolean _tmp9_ = FALSE;
5118 _tmp2_ = self->priv->current;
5119 _tmp3_ = self->priv->end;
5120 if (_tmp2_ < (_tmp3_ - 1)) {
5121 gchar* _tmp4_;
5122 gchar _tmp5_;
5123 _tmp4_ = self->priv->current;
5124 _tmp5_ = _tmp4_[0];
5125 _tmp1_ = _tmp5_ == '&';
5126 } else {
5127 _tmp1_ = FALSE;
5128 }
5129 if (_tmp1_) {
5130 gchar* _tmp6_;
5131 gchar _tmp7_;
5132 _tmp6_ = self->priv->current;
5133 _tmp7_ = _tmp6_[1];
5134 _tmp0_ = _tmp7_ == '&';
5135 } else {
5136 _tmp0_ = FALSE;
5137 }
5138 if (!_tmp0_) {
5139 break;
5140 }
5141 _tmp8_ = self->priv->current;
5142 self->priv->current = _tmp8_ + 2;
5143 self->priv->column = self->priv->column + 2;
5144 vala_scanner_pp_space (self);
5145 right = vala_scanner_parse_pp_equality_expression (self);
5146 if (left) {
5147 _tmp9_ = right;
5148 } else {
5149 _tmp9_ = FALSE;
5150 }
5151 left = _tmp9_;
5152 }
5153 result = left;
5154 return result;
5155 }
5156
5157 static gboolean
vala_scanner_parse_pp_or_expression(ValaScanner * self)5158 vala_scanner_parse_pp_or_expression (ValaScanner* self)
5159 {
5160 gboolean left = FALSE;
5161 gboolean result = FALSE;
5162 g_return_val_if_fail (self != NULL, FALSE);
5163 left = vala_scanner_parse_pp_and_expression (self);
5164 vala_scanner_pp_space (self);
5165 while (TRUE) {
5166 gboolean _tmp0_ = FALSE;
5167 gboolean _tmp1_ = FALSE;
5168 gchar* _tmp2_;
5169 gchar* _tmp3_;
5170 gchar* _tmp8_;
5171 gboolean right = FALSE;
5172 gboolean _tmp9_ = FALSE;
5173 _tmp2_ = self->priv->current;
5174 _tmp3_ = self->priv->end;
5175 if (_tmp2_ < (_tmp3_ - 1)) {
5176 gchar* _tmp4_;
5177 gchar _tmp5_;
5178 _tmp4_ = self->priv->current;
5179 _tmp5_ = _tmp4_[0];
5180 _tmp1_ = _tmp5_ == '|';
5181 } else {
5182 _tmp1_ = FALSE;
5183 }
5184 if (_tmp1_) {
5185 gchar* _tmp6_;
5186 gchar _tmp7_;
5187 _tmp6_ = self->priv->current;
5188 _tmp7_ = _tmp6_[1];
5189 _tmp0_ = _tmp7_ == '|';
5190 } else {
5191 _tmp0_ = FALSE;
5192 }
5193 if (!_tmp0_) {
5194 break;
5195 }
5196 _tmp8_ = self->priv->current;
5197 self->priv->current = _tmp8_ + 2;
5198 self->priv->column = self->priv->column + 2;
5199 vala_scanner_pp_space (self);
5200 right = vala_scanner_parse_pp_and_expression (self);
5201 if (left) {
5202 _tmp9_ = TRUE;
5203 } else {
5204 _tmp9_ = right;
5205 }
5206 left = _tmp9_;
5207 }
5208 result = left;
5209 return result;
5210 }
5211
5212 static gboolean
vala_scanner_parse_pp_expression(ValaScanner * self)5213 vala_scanner_parse_pp_expression (ValaScanner* self)
5214 {
5215 gboolean result = FALSE;
5216 g_return_val_if_fail (self != NULL, FALSE);
5217 result = vala_scanner_parse_pp_or_expression (self);
5218 return result;
5219 }
5220
5221 static gboolean
vala_scanner_whitespace(ValaScanner * self)5222 vala_scanner_whitespace (ValaScanner* self)
5223 {
5224 gboolean found = FALSE;
5225 gboolean bol = FALSE;
5226 gboolean _tmp10_ = FALSE;
5227 gboolean _tmp11_ = FALSE;
5228 gboolean result = FALSE;
5229 g_return_val_if_fail (self != NULL, FALSE);
5230 found = FALSE;
5231 bol = self->priv->column == 1;
5232 while (TRUE) {
5233 gboolean _tmp0_ = FALSE;
5234 gchar* _tmp1_;
5235 gchar* _tmp2_;
5236 gchar* _tmp5_;
5237 gchar _tmp6_;
5238 gchar* _tmp8_;
5239 gint _tmp9_;
5240 _tmp1_ = self->priv->current;
5241 _tmp2_ = self->priv->end;
5242 if (_tmp1_ < _tmp2_) {
5243 gchar* _tmp3_;
5244 gchar _tmp4_;
5245 _tmp3_ = self->priv->current;
5246 _tmp4_ = _tmp3_[0];
5247 _tmp0_ = g_ascii_isspace (_tmp4_);
5248 } else {
5249 _tmp0_ = FALSE;
5250 }
5251 if (!_tmp0_) {
5252 break;
5253 }
5254 _tmp5_ = self->priv->current;
5255 _tmp6_ = _tmp5_[0];
5256 if (_tmp6_ == '\n') {
5257 gint _tmp7_;
5258 _tmp7_ = self->priv->line;
5259 self->priv->line = _tmp7_ + 1;
5260 self->priv->column = 0;
5261 bol = TRUE;
5262 }
5263 found = TRUE;
5264 _tmp8_ = self->priv->current;
5265 self->priv->current = _tmp8_ + 1;
5266 _tmp9_ = self->priv->column;
5267 self->priv->column = _tmp9_ + 1;
5268 }
5269 if (bol) {
5270 gchar* _tmp12_;
5271 gchar* _tmp13_;
5272 _tmp12_ = self->priv->current;
5273 _tmp13_ = self->priv->end;
5274 _tmp11_ = _tmp12_ < _tmp13_;
5275 } else {
5276 _tmp11_ = FALSE;
5277 }
5278 if (_tmp11_) {
5279 gchar* _tmp14_;
5280 gchar _tmp15_;
5281 _tmp14_ = self->priv->current;
5282 _tmp15_ = _tmp14_[0];
5283 _tmp10_ = _tmp15_ == '#';
5284 } else {
5285 _tmp10_ = FALSE;
5286 }
5287 if (_tmp10_) {
5288 vala_scanner_pp_directive (self);
5289 result = TRUE;
5290 return result;
5291 }
5292 result = found;
5293 return result;
5294 }
5295
5296 static gboolean
vala_scanner_comment(ValaScanner * self,gboolean file_comment)5297 vala_scanner_comment (ValaScanner* self,
5298 gboolean file_comment)
5299 {
5300 gboolean _tmp0_ = FALSE;
5301 gboolean _tmp1_ = FALSE;
5302 gboolean _tmp2_ = FALSE;
5303 gchar* _tmp3_;
5304 gchar* _tmp13_;
5305 gchar _tmp14_;
5306 gboolean result = FALSE;
5307 g_return_val_if_fail (self != NULL, FALSE);
5308 _tmp3_ = self->priv->current;
5309 if (_tmp3_ == NULL) {
5310 _tmp2_ = TRUE;
5311 } else {
5312 gchar* _tmp4_;
5313 gchar* _tmp5_;
5314 _tmp4_ = self->priv->current;
5315 _tmp5_ = self->priv->end;
5316 _tmp2_ = _tmp4_ > (_tmp5_ - 2);
5317 }
5318 if (_tmp2_) {
5319 _tmp1_ = TRUE;
5320 } else {
5321 gchar* _tmp6_;
5322 gchar _tmp7_;
5323 _tmp6_ = self->priv->current;
5324 _tmp7_ = _tmp6_[0];
5325 _tmp1_ = _tmp7_ != '/';
5326 }
5327 if (_tmp1_) {
5328 _tmp0_ = TRUE;
5329 } else {
5330 gboolean _tmp8_ = FALSE;
5331 gchar* _tmp9_;
5332 gchar _tmp10_;
5333 _tmp9_ = self->priv->current;
5334 _tmp10_ = _tmp9_[1];
5335 if (_tmp10_ != '/') {
5336 gchar* _tmp11_;
5337 gchar _tmp12_;
5338 _tmp11_ = self->priv->current;
5339 _tmp12_ = _tmp11_[1];
5340 _tmp8_ = _tmp12_ != '*';
5341 } else {
5342 _tmp8_ = FALSE;
5343 }
5344 _tmp0_ = _tmp8_;
5345 }
5346 if (_tmp0_) {
5347 result = FALSE;
5348 return result;
5349 }
5350 _tmp13_ = self->priv->current;
5351 _tmp14_ = _tmp13_[1];
5352 if (_tmp14_ == '/') {
5353 ValaSourceReference* source_reference = NULL;
5354 gchar* _tmp16_;
5355 gchar* begin = NULL;
5356 gchar* _tmp17_;
5357 ValaSourceReference* _tmp24_;
5358 source_reference = NULL;
5359 if (file_comment) {
5360 ValaSourceReference* _tmp15_;
5361 _tmp15_ = vala_scanner_get_source_reference (self, 0, 0);
5362 _vala_source_reference_unref0 (source_reference);
5363 source_reference = _tmp15_;
5364 }
5365 _tmp16_ = self->priv->current;
5366 self->priv->current = _tmp16_ + 2;
5367 _tmp17_ = self->priv->current;
5368 begin = _tmp17_;
5369 while (TRUE) {
5370 gboolean _tmp18_ = FALSE;
5371 gchar* _tmp19_;
5372 gchar* _tmp20_;
5373 gchar* _tmp23_;
5374 _tmp19_ = self->priv->current;
5375 _tmp20_ = self->priv->end;
5376 if (_tmp19_ < _tmp20_) {
5377 gchar* _tmp21_;
5378 gchar _tmp22_;
5379 _tmp21_ = self->priv->current;
5380 _tmp22_ = _tmp21_[0];
5381 _tmp18_ = _tmp22_ != '\n';
5382 } else {
5383 _tmp18_ = FALSE;
5384 }
5385 if (!_tmp18_) {
5386 break;
5387 }
5388 _tmp23_ = self->priv->current;
5389 self->priv->current = _tmp23_ + 1;
5390 }
5391 _tmp24_ = source_reference;
5392 if (_tmp24_ != NULL) {
5393 gchar* _tmp25_;
5394 gchar* _tmp26_;
5395 gchar* _tmp27_;
5396 gchar* _tmp28_;
5397 gchar* _tmp29_;
5398 ValaSourceReference* _tmp30_;
5399 _tmp25_ = begin;
5400 _tmp26_ = self->priv->current;
5401 _tmp27_ = begin;
5402 _tmp28_ = string_substring ((const gchar*) _tmp25_, (glong) 0, (glong) (_tmp26_ - _tmp27_));
5403 _tmp29_ = _tmp28_;
5404 _tmp30_ = source_reference;
5405 vala_scanner_push_comment (self, _tmp29_, _tmp30_, file_comment);
5406 _g_free0 (_tmp29_);
5407 }
5408 _vala_source_reference_unref0 (source_reference);
5409 } else {
5410 ValaSourceReference* source_reference = NULL;
5411 gboolean _tmp31_ = FALSE;
5412 gboolean _tmp34_ = FALSE;
5413 gchar* _tmp35_;
5414 gchar _tmp36_;
5415 gchar* _tmp38_;
5416 gchar* begin = NULL;
5417 gchar* _tmp39_;
5418 gchar* _tmp53_;
5419 gchar* _tmp54_;
5420 ValaSourceReference* _tmp57_;
5421 gchar* _tmp64_;
5422 source_reference = NULL;
5423 if (file_comment) {
5424 gchar* _tmp32_;
5425 gchar _tmp33_;
5426 _tmp32_ = self->priv->current;
5427 _tmp33_ = _tmp32_[2];
5428 _tmp31_ = _tmp33_ == '*';
5429 } else {
5430 _tmp31_ = FALSE;
5431 }
5432 if (_tmp31_) {
5433 result = FALSE;
5434 _vala_source_reference_unref0 (source_reference);
5435 return result;
5436 }
5437 _tmp35_ = self->priv->current;
5438 _tmp36_ = _tmp35_[2];
5439 if (_tmp36_ == '*') {
5440 _tmp34_ = TRUE;
5441 } else {
5442 _tmp34_ = file_comment;
5443 }
5444 if (_tmp34_) {
5445 ValaSourceReference* _tmp37_;
5446 _tmp37_ = vala_scanner_get_source_reference (self, 0, 0);
5447 _vala_source_reference_unref0 (source_reference);
5448 source_reference = _tmp37_;
5449 }
5450 _tmp38_ = self->priv->current;
5451 self->priv->current = _tmp38_ + 2;
5452 self->priv->column = self->priv->column + 2;
5453 _tmp39_ = self->priv->current;
5454 begin = _tmp39_;
5455 while (TRUE) {
5456 gboolean _tmp40_ = FALSE;
5457 gchar* _tmp41_;
5458 gchar* _tmp42_;
5459 gchar* _tmp48_;
5460 gchar _tmp49_;
5461 gchar* _tmp51_;
5462 gint _tmp52_;
5463 _tmp41_ = self->priv->current;
5464 _tmp42_ = self->priv->end;
5465 if (_tmp41_ < (_tmp42_ - 1)) {
5466 gboolean _tmp43_ = FALSE;
5467 gchar* _tmp44_;
5468 gchar _tmp45_;
5469 _tmp44_ = self->priv->current;
5470 _tmp45_ = _tmp44_[0];
5471 if (_tmp45_ != '*') {
5472 _tmp43_ = TRUE;
5473 } else {
5474 gchar* _tmp46_;
5475 gchar _tmp47_;
5476 _tmp46_ = self->priv->current;
5477 _tmp47_ = _tmp46_[1];
5478 _tmp43_ = _tmp47_ != '/';
5479 }
5480 _tmp40_ = _tmp43_;
5481 } else {
5482 _tmp40_ = FALSE;
5483 }
5484 if (!_tmp40_) {
5485 break;
5486 }
5487 _tmp48_ = self->priv->current;
5488 _tmp49_ = _tmp48_[0];
5489 if (_tmp49_ == '\n') {
5490 gint _tmp50_;
5491 _tmp50_ = self->priv->line;
5492 self->priv->line = _tmp50_ + 1;
5493 self->priv->column = 0;
5494 }
5495 _tmp51_ = self->priv->current;
5496 self->priv->current = _tmp51_ + 1;
5497 _tmp52_ = self->priv->column;
5498 self->priv->column = _tmp52_ + 1;
5499 }
5500 _tmp53_ = self->priv->current;
5501 _tmp54_ = self->priv->end;
5502 if (_tmp53_ == (_tmp54_ - 1)) {
5503 ValaSourceReference* _tmp55_;
5504 ValaSourceReference* _tmp56_;
5505 _tmp55_ = vala_scanner_get_source_reference (self, 0, 0);
5506 _tmp56_ = _tmp55_;
5507 vala_report_error (_tmp56_, "syntax error, expected */");
5508 _vala_source_reference_unref0 (_tmp56_);
5509 result = TRUE;
5510 _vala_source_reference_unref0 (source_reference);
5511 return result;
5512 }
5513 _tmp57_ = source_reference;
5514 if (_tmp57_ != NULL) {
5515 gchar* _tmp58_;
5516 gchar* _tmp59_;
5517 gchar* _tmp60_;
5518 gchar* _tmp61_;
5519 gchar* _tmp62_;
5520 ValaSourceReference* _tmp63_;
5521 _tmp58_ = begin;
5522 _tmp59_ = self->priv->current;
5523 _tmp60_ = begin;
5524 _tmp61_ = string_substring ((const gchar*) _tmp58_, (glong) 0, (glong) (_tmp59_ - _tmp60_));
5525 _tmp62_ = _tmp61_;
5526 _tmp63_ = source_reference;
5527 vala_scanner_push_comment (self, _tmp62_, _tmp63_, file_comment);
5528 _g_free0 (_tmp62_);
5529 }
5530 _tmp64_ = self->priv->current;
5531 self->priv->current = _tmp64_ + 2;
5532 self->priv->column = self->priv->column + 2;
5533 _vala_source_reference_unref0 (source_reference);
5534 }
5535 result = TRUE;
5536 return result;
5537 }
5538
5539 static void
vala_scanner_space(ValaScanner * self)5540 vala_scanner_space (ValaScanner* self)
5541 {
5542 g_return_if_fail (self != NULL);
5543 while (TRUE) {
5544 gboolean _tmp0_ = FALSE;
5545 if (vala_scanner_whitespace (self)) {
5546 _tmp0_ = TRUE;
5547 } else {
5548 _tmp0_ = vala_scanner_comment (self, FALSE);
5549 }
5550 if (!_tmp0_) {
5551 break;
5552 }
5553 }
5554 }
5555
5556 void
vala_scanner_parse_file_comments(ValaScanner * self)5557 vala_scanner_parse_file_comments (ValaScanner* self)
5558 {
5559 g_return_if_fail (self != NULL);
5560 while (TRUE) {
5561 gboolean _tmp0_ = FALSE;
5562 if (vala_scanner_whitespace (self)) {
5563 _tmp0_ = TRUE;
5564 } else {
5565 _tmp0_ = vala_scanner_comment (self, TRUE);
5566 }
5567 if (!_tmp0_) {
5568 break;
5569 }
5570 }
5571 }
5572
5573 static gchar
string_get(const gchar * self,glong index)5574 string_get (const gchar* self,
5575 glong index)
5576 {
5577 gchar _tmp0_;
5578 gchar result = '\0';
5579 g_return_val_if_fail (self != NULL, '\0');
5580 _tmp0_ = ((gchar*) self)[index];
5581 result = _tmp0_;
5582 return result;
5583 }
5584
5585 static void
vala_scanner_push_comment(ValaScanner * self,const gchar * comment_item,ValaSourceReference * source_reference,gboolean file_comment)5586 vala_scanner_push_comment (ValaScanner* self,
5587 const gchar* comment_item,
5588 ValaSourceReference* source_reference,
5589 gboolean file_comment)
5590 {
5591 g_return_if_fail (self != NULL);
5592 g_return_if_fail (comment_item != NULL);
5593 g_return_if_fail (source_reference != NULL);
5594 if (string_get (comment_item, (glong) 0) == '*') {
5595 ValaComment* _tmp0_;
5596 ValaComment* _tmp3_;
5597 _tmp0_ = self->priv->_comment;
5598 if (_tmp0_ != NULL) {
5599 ValaSourceFile* _tmp1_;
5600 ValaComment* _tmp2_;
5601 _tmp1_ = self->priv->_source_file;
5602 _tmp2_ = self->priv->_comment;
5603 vala_source_file_add_comment (_tmp1_, _tmp2_);
5604 }
5605 _tmp3_ = vala_comment_new (comment_item, source_reference);
5606 _vala_comment_unref0 (self->priv->_comment);
5607 self->priv->_comment = _tmp3_;
5608 }
5609 if (file_comment) {
5610 ValaSourceFile* _tmp4_;
5611 ValaComment* _tmp5_;
5612 ValaComment* _tmp6_;
5613 _tmp4_ = self->priv->_source_file;
5614 _tmp5_ = vala_comment_new (comment_item, source_reference);
5615 _tmp6_ = _tmp5_;
5616 vala_source_file_add_comment (_tmp4_, _tmp6_);
5617 _vala_comment_unref0 (_tmp6_);
5618 _vala_comment_unref0 (self->priv->_comment);
5619 self->priv->_comment = NULL;
5620 }
5621 }
5622
5623 /**
5624 * Clears and returns the content of the comment stack.
5625 *
5626 * @return saved comment
5627 */
5628 static gpointer
_vala_comment_ref0(gpointer self)5629 _vala_comment_ref0 (gpointer self)
5630 {
5631 return self ? vala_comment_ref (self) : NULL;
5632 }
5633
5634 ValaComment*
vala_scanner_pop_comment(ValaScanner * self)5635 vala_scanner_pop_comment (ValaScanner* self)
5636 {
5637 ValaComment* _tmp0_;
5638 ValaComment* comment = NULL;
5639 ValaComment* _tmp1_;
5640 ValaComment* _tmp2_;
5641 ValaComment* result = NULL;
5642 g_return_val_if_fail (self != NULL, NULL);
5643 _tmp0_ = self->priv->_comment;
5644 if (_tmp0_ == NULL) {
5645 result = NULL;
5646 return result;
5647 }
5648 _tmp1_ = self->priv->_comment;
5649 _tmp2_ = _vala_comment_ref0 (_tmp1_);
5650 comment = _tmp2_;
5651 _vala_comment_unref0 (self->priv->_comment);
5652 self->priv->_comment = NULL;
5653 result = comment;
5654 return result;
5655 }
5656
5657 static ValaScannerConditional*
vala_scanner_conditional_dup(const ValaScannerConditional * self)5658 vala_scanner_conditional_dup (const ValaScannerConditional* self)
5659 {
5660 ValaScannerConditional* dup;
5661 dup = g_new0 (ValaScannerConditional, 1);
5662 memcpy (dup, self, sizeof (ValaScannerConditional));
5663 return dup;
5664 }
5665
5666 static void
vala_scanner_conditional_free(ValaScannerConditional * self)5667 vala_scanner_conditional_free (ValaScannerConditional* self)
5668 {
5669 g_free (self);
5670 }
5671
5672 static GType
vala_scanner_conditional_get_type_once(void)5673 vala_scanner_conditional_get_type_once (void)
5674 {
5675 GType vala_scanner_conditional_type_id;
5676 vala_scanner_conditional_type_id = g_boxed_type_register_static ("ValaScannerConditional", (GBoxedCopyFunc) vala_scanner_conditional_dup, (GBoxedFreeFunc) vala_scanner_conditional_free);
5677 return vala_scanner_conditional_type_id;
5678 }
5679
5680 static GType
vala_scanner_conditional_get_type(void)5681 vala_scanner_conditional_get_type (void)
5682 {
5683 static volatile gsize vala_scanner_conditional_type_id__volatile = 0;
5684 if (g_once_init_enter (&vala_scanner_conditional_type_id__volatile)) {
5685 GType vala_scanner_conditional_type_id;
5686 vala_scanner_conditional_type_id = vala_scanner_conditional_get_type_once ();
5687 g_once_init_leave (&vala_scanner_conditional_type_id__volatile, vala_scanner_conditional_type_id);
5688 }
5689 return vala_scanner_conditional_type_id__volatile;
5690 }
5691
5692 static void
vala_value_scanner_init(GValue * value)5693 vala_value_scanner_init (GValue* value)
5694 {
5695 value->data[0].v_pointer = NULL;
5696 }
5697
5698 static void
vala_value_scanner_free_value(GValue * value)5699 vala_value_scanner_free_value (GValue* value)
5700 {
5701 if (value->data[0].v_pointer) {
5702 vala_scanner_unref (value->data[0].v_pointer);
5703 }
5704 }
5705
5706 static void
vala_value_scanner_copy_value(const GValue * src_value,GValue * dest_value)5707 vala_value_scanner_copy_value (const GValue* src_value,
5708 GValue* dest_value)
5709 {
5710 if (src_value->data[0].v_pointer) {
5711 dest_value->data[0].v_pointer = vala_scanner_ref (src_value->data[0].v_pointer);
5712 } else {
5713 dest_value->data[0].v_pointer = NULL;
5714 }
5715 }
5716
5717 static gpointer
vala_value_scanner_peek_pointer(const GValue * value)5718 vala_value_scanner_peek_pointer (const GValue* value)
5719 {
5720 return value->data[0].v_pointer;
5721 }
5722
5723 static gchar*
vala_value_scanner_collect_value(GValue * value,guint n_collect_values,GTypeCValue * collect_values,guint collect_flags)5724 vala_value_scanner_collect_value (GValue* value,
5725 guint n_collect_values,
5726 GTypeCValue* collect_values,
5727 guint collect_flags)
5728 {
5729 if (collect_values[0].v_pointer) {
5730 ValaScanner * object;
5731 object = collect_values[0].v_pointer;
5732 if (object->parent_instance.g_class == NULL) {
5733 return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
5734 } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
5735 return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
5736 }
5737 value->data[0].v_pointer = vala_scanner_ref (object);
5738 } else {
5739 value->data[0].v_pointer = NULL;
5740 }
5741 return NULL;
5742 }
5743
5744 static gchar*
vala_value_scanner_lcopy_value(const GValue * value,guint n_collect_values,GTypeCValue * collect_values,guint collect_flags)5745 vala_value_scanner_lcopy_value (const GValue* value,
5746 guint n_collect_values,
5747 GTypeCValue* collect_values,
5748 guint collect_flags)
5749 {
5750 ValaScanner ** object_p;
5751 object_p = collect_values[0].v_pointer;
5752 if (!object_p) {
5753 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
5754 }
5755 if (!value->data[0].v_pointer) {
5756 *object_p = NULL;
5757 } else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
5758 *object_p = value->data[0].v_pointer;
5759 } else {
5760 *object_p = vala_scanner_ref (value->data[0].v_pointer);
5761 }
5762 return NULL;
5763 }
5764
5765 GParamSpec*
vala_param_spec_scanner(const gchar * name,const gchar * nick,const gchar * blurb,GType object_type,GParamFlags flags)5766 vala_param_spec_scanner (const gchar* name,
5767 const gchar* nick,
5768 const gchar* blurb,
5769 GType object_type,
5770 GParamFlags flags)
5771 {
5772 ValaParamSpecScanner* spec;
5773 g_return_val_if_fail (g_type_is_a (object_type, VALA_TYPE_SCANNER), NULL);
5774 spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
5775 G_PARAM_SPEC (spec)->value_type = object_type;
5776 return G_PARAM_SPEC (spec);
5777 }
5778
5779 gpointer
vala_value_get_scanner(const GValue * value)5780 vala_value_get_scanner (const GValue* value)
5781 {
5782 g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALA_TYPE_SCANNER), NULL);
5783 return value->data[0].v_pointer;
5784 }
5785
5786 void
vala_value_set_scanner(GValue * value,gpointer v_object)5787 vala_value_set_scanner (GValue* value,
5788 gpointer v_object)
5789 {
5790 ValaScanner * old;
5791 g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALA_TYPE_SCANNER));
5792 old = value->data[0].v_pointer;
5793 if (v_object) {
5794 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, VALA_TYPE_SCANNER));
5795 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
5796 value->data[0].v_pointer = v_object;
5797 vala_scanner_ref (value->data[0].v_pointer);
5798 } else {
5799 value->data[0].v_pointer = NULL;
5800 }
5801 if (old) {
5802 vala_scanner_unref (old);
5803 }
5804 }
5805
5806 void
vala_value_take_scanner(GValue * value,gpointer v_object)5807 vala_value_take_scanner (GValue* value,
5808 gpointer v_object)
5809 {
5810 ValaScanner * old;
5811 g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALA_TYPE_SCANNER));
5812 old = value->data[0].v_pointer;
5813 if (v_object) {
5814 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, VALA_TYPE_SCANNER));
5815 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
5816 value->data[0].v_pointer = v_object;
5817 } else {
5818 value->data[0].v_pointer = NULL;
5819 }
5820 if (old) {
5821 vala_scanner_unref (old);
5822 }
5823 }
5824
5825 static void
vala_scanner_class_init(ValaScannerClass * klass,gpointer klass_data)5826 vala_scanner_class_init (ValaScannerClass * klass,
5827 gpointer klass_data)
5828 {
5829 vala_scanner_parent_class = g_type_class_peek_parent (klass);
5830 ((ValaScannerClass *) klass)->finalize = vala_scanner_finalize;
5831 g_type_class_adjust_private_offset (klass, &ValaScanner_private_offset);
5832 }
5833
5834 static void
vala_scanner_instance_init(ValaScanner * self,gpointer klass)5835 vala_scanner_instance_init (ValaScanner * self,
5836 gpointer klass)
5837 {
5838 self->priv = vala_scanner_get_instance_private (self);
5839 self->ref_count = 1;
5840 }
5841
5842 static void
vala_scanner_finalize(ValaScanner * obj)5843 vala_scanner_finalize (ValaScanner * obj)
5844 {
5845 ValaScanner * self;
5846 self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALA_TYPE_SCANNER, ValaScanner);
5847 g_signal_handlers_destroy (self);
5848 _vala_source_file_unref0 (self->priv->_source_file);
5849 _vala_comment_unref0 (self->priv->_comment);
5850 self->priv->conditional_stack = (g_free (self->priv->conditional_stack), NULL);
5851 self->priv->state_stack = (g_free (self->priv->state_stack), NULL);
5852 }
5853
5854 /**
5855 * Lexical scanner for Vala source files.
5856 */
5857 static GType
vala_scanner_get_type_once(void)5858 vala_scanner_get_type_once (void)
5859 {
5860 static const GTypeValueTable g_define_type_value_table = { vala_value_scanner_init, vala_value_scanner_free_value, vala_value_scanner_copy_value, vala_value_scanner_peek_pointer, "p", vala_value_scanner_collect_value, "p", vala_value_scanner_lcopy_value };
5861 static const GTypeInfo g_define_type_info = { sizeof (ValaScannerClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_scanner_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaScanner), 0, (GInstanceInitFunc) vala_scanner_instance_init, &g_define_type_value_table };
5862 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) };
5863 GType vala_scanner_type_id;
5864 vala_scanner_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ValaScanner", &g_define_type_info, &g_define_type_fundamental_info, 0);
5865 ValaScanner_private_offset = g_type_add_instance_private (vala_scanner_type_id, sizeof (ValaScannerPrivate));
5866 return vala_scanner_type_id;
5867 }
5868
5869 GType
vala_scanner_get_type(void)5870 vala_scanner_get_type (void)
5871 {
5872 static volatile gsize vala_scanner_type_id__volatile = 0;
5873 if (g_once_init_enter (&vala_scanner_type_id__volatile)) {
5874 GType vala_scanner_type_id;
5875 vala_scanner_type_id = vala_scanner_get_type_once ();
5876 g_once_init_leave (&vala_scanner_type_id__volatile, vala_scanner_type_id);
5877 }
5878 return vala_scanner_type_id__volatile;
5879 }
5880
5881 gpointer
vala_scanner_ref(gpointer instance)5882 vala_scanner_ref (gpointer instance)
5883 {
5884 ValaScanner * self;
5885 self = instance;
5886 g_atomic_int_inc (&self->ref_count);
5887 return instance;
5888 }
5889
5890 void
vala_scanner_unref(gpointer instance)5891 vala_scanner_unref (gpointer instance)
5892 {
5893 ValaScanner * self;
5894 self = instance;
5895 if (g_atomic_int_dec_and_test (&self->ref_count)) {
5896 VALA_SCANNER_GET_CLASS (self)->finalize (self);
5897 g_type_free_instance ((GTypeInstance *) self);
5898 }
5899 }
5900
5901