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