1 /* valabinaryexpression.c generated by valac, the Vala compiler
2 * generated from valabinaryexpression.vala, do not modify */
3
4 /* valabinaryexpression.vala
5 *
6 * Copyright (C) 2006-2010 Jürg Billeter
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 *
22 * Author:
23 * Jürg Billeter <j@bitron.ch>
24 */
25
26 #include "vala.h"
27 #include <glib.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <valagee.h>
31 #include <glib-object.h>
32
33 #define _vala_code_node_unref0(var) ((var == NULL) ? NULL : (var = (vala_code_node_unref (var), NULL)))
34 #define _g_free0(var) (var = (g_free (var), NULL))
35
36 struct _ValaBinaryExpressionPrivate {
37 ValaBinaryOperator _operator;
38 gboolean _is_chained;
39 ValaExpression* _left;
40 ValaExpression* _right;
41 };
42
43 static gint ValaBinaryExpression_private_offset;
44 static gpointer vala_binary_expression_parent_class = NULL;
45
46 static void vala_binary_expression_set_is_chained (ValaBinaryExpression* self,
47 gboolean value);
48 static void vala_binary_expression_real_accept (ValaCodeNode* base,
49 ValaCodeVisitor* visitor);
50 static void vala_binary_expression_real_accept_children (ValaCodeNode* base,
51 ValaCodeVisitor* visitor);
52 static void vala_binary_expression_real_replace_expression (ValaCodeNode* base,
53 ValaExpression* old_node,
54 ValaExpression* new_node);
55 static gchar* vala_binary_expression_real_to_string (ValaCodeNode* base);
56 static gboolean vala_binary_expression_real_is_constant (ValaExpression* base);
57 static gboolean vala_binary_expression_real_is_pure (ValaExpression* base);
58 static gboolean vala_binary_expression_real_is_non_null (ValaExpression* base);
59 static gboolean vala_binary_expression_real_is_accessible (ValaExpression* base,
60 ValaSymbol* sym);
61 static void vala_binary_expression_real_get_error_types (ValaCodeNode* base,
62 ValaCollection* collection,
63 ValaSourceReference* source_reference);
64 static gboolean vala_binary_expression_real_check (ValaCodeNode* base,
65 ValaCodeContext* context);
66 static void vala_binary_expression_real_emit (ValaCodeNode* base,
67 ValaCodeGenerator* codegen);
68 static void vala_binary_expression_real_get_defined_variables (ValaCodeNode* base,
69 ValaCollection* collection);
70 static void vala_binary_expression_real_get_used_variables (ValaCodeNode* base,
71 ValaCollection* collection);
72 static void vala_binary_expression_finalize (ValaCodeNode * obj);
73 static GType vala_binary_expression_get_type_once (void);
74
75 static inline gpointer
vala_binary_expression_get_instance_private(ValaBinaryExpression * self)76 vala_binary_expression_get_instance_private (ValaBinaryExpression* self)
77 {
78 return G_STRUCT_MEMBER_P (self, ValaBinaryExpression_private_offset);
79 }
80
81 ValaBinaryOperator
vala_binary_expression_get_operator(ValaBinaryExpression * self)82 vala_binary_expression_get_operator (ValaBinaryExpression* self)
83 {
84 ValaBinaryOperator result;
85 ValaBinaryOperator _tmp0_;
86 g_return_val_if_fail (self != NULL, 0);
87 _tmp0_ = self->priv->_operator;
88 result = _tmp0_;
89 return result;
90 }
91
92 void
vala_binary_expression_set_operator(ValaBinaryExpression * self,ValaBinaryOperator value)93 vala_binary_expression_set_operator (ValaBinaryExpression* self,
94 ValaBinaryOperator value)
95 {
96 g_return_if_fail (self != NULL);
97 self->priv->_operator = value;
98 }
99
100 ValaExpression*
vala_binary_expression_get_left(ValaBinaryExpression * self)101 vala_binary_expression_get_left (ValaBinaryExpression* self)
102 {
103 ValaExpression* result;
104 ValaExpression* _tmp0_;
105 g_return_val_if_fail (self != NULL, NULL);
106 _tmp0_ = self->priv->_left;
107 result = _tmp0_;
108 return result;
109 }
110
111 static gpointer
_vala_code_node_ref0(gpointer self)112 _vala_code_node_ref0 (gpointer self)
113 {
114 return self ? vala_code_node_ref (self) : NULL;
115 }
116
117 void
vala_binary_expression_set_left(ValaBinaryExpression * self,ValaExpression * value)118 vala_binary_expression_set_left (ValaBinaryExpression* self,
119 ValaExpression* value)
120 {
121 ValaExpression* _tmp0_;
122 ValaExpression* _tmp1_;
123 g_return_if_fail (self != NULL);
124 _tmp0_ = _vala_code_node_ref0 (value);
125 _vala_code_node_unref0 (self->priv->_left);
126 self->priv->_left = _tmp0_;
127 _tmp1_ = self->priv->_left;
128 vala_code_node_set_parent_node ((ValaCodeNode*) _tmp1_, (ValaCodeNode*) self);
129 }
130
131 ValaExpression*
vala_binary_expression_get_right(ValaBinaryExpression * self)132 vala_binary_expression_get_right (ValaBinaryExpression* self)
133 {
134 ValaExpression* result;
135 ValaExpression* _tmp0_;
136 g_return_val_if_fail (self != NULL, NULL);
137 _tmp0_ = self->priv->_right;
138 result = _tmp0_;
139 return result;
140 }
141
142 void
vala_binary_expression_set_right(ValaBinaryExpression * self,ValaExpression * value)143 vala_binary_expression_set_right (ValaBinaryExpression* self,
144 ValaExpression* value)
145 {
146 ValaExpression* _tmp0_;
147 ValaExpression* _tmp1_;
148 g_return_if_fail (self != NULL);
149 _tmp0_ = _vala_code_node_ref0 (value);
150 _vala_code_node_unref0 (self->priv->_right);
151 self->priv->_right = _tmp0_;
152 _tmp1_ = self->priv->_right;
153 vala_code_node_set_parent_node ((ValaCodeNode*) _tmp1_, (ValaCodeNode*) self);
154 }
155
156 gboolean
vala_binary_expression_get_is_chained(ValaBinaryExpression * self)157 vala_binary_expression_get_is_chained (ValaBinaryExpression* self)
158 {
159 gboolean result;
160 g_return_val_if_fail (self != NULL, FALSE);
161 result = self->priv->_is_chained;
162 return result;
163 }
164
165 static void
vala_binary_expression_set_is_chained(ValaBinaryExpression * self,gboolean value)166 vala_binary_expression_set_is_chained (ValaBinaryExpression* self,
167 gboolean value)
168 {
169 g_return_if_fail (self != NULL);
170 self->priv->_is_chained = value;
171 }
172
173 /**
174 * Creates a new binary expression.
175 *
176 * @param op binary operator
177 * @param _left left operand
178 * @param _right right operand
179 * @param source reference to source code
180 * @return newly created binary expression
181 */
182 ValaBinaryExpression*
vala_binary_expression_construct(GType object_type,ValaBinaryOperator op,ValaExpression * _left,ValaExpression * _right,ValaSourceReference * source)183 vala_binary_expression_construct (GType object_type,
184 ValaBinaryOperator op,
185 ValaExpression* _left,
186 ValaExpression* _right,
187 ValaSourceReference* source)
188 {
189 ValaBinaryExpression* self = NULL;
190 g_return_val_if_fail (_left != NULL, NULL);
191 g_return_val_if_fail (_right != NULL, NULL);
192 self = (ValaBinaryExpression*) vala_expression_construct (object_type);
193 vala_binary_expression_set_operator (self, op);
194 vala_binary_expression_set_left (self, _left);
195 vala_binary_expression_set_right (self, _right);
196 vala_binary_expression_set_is_chained (self, FALSE);
197 vala_code_node_set_source_reference ((ValaCodeNode*) self, source);
198 return self;
199 }
200
201 ValaBinaryExpression*
vala_binary_expression_new(ValaBinaryOperator op,ValaExpression * _left,ValaExpression * _right,ValaSourceReference * source)202 vala_binary_expression_new (ValaBinaryOperator op,
203 ValaExpression* _left,
204 ValaExpression* _right,
205 ValaSourceReference* source)
206 {
207 return vala_binary_expression_construct (VALA_TYPE_BINARY_EXPRESSION, op, _left, _right, source);
208 }
209
210 ValaBinaryExpression*
vala_binary_expression_construct_chained(GType object_type,ValaBinaryOperator op,ValaExpression * _left,ValaExpression * _right,ValaSourceReference * source)211 vala_binary_expression_construct_chained (GType object_type,
212 ValaBinaryOperator op,
213 ValaExpression* _left,
214 ValaExpression* _right,
215 ValaSourceReference* source)
216 {
217 ValaBinaryExpression* self = NULL;
218 g_return_val_if_fail (_left != NULL, NULL);
219 g_return_val_if_fail (_right != NULL, NULL);
220 self = (ValaBinaryExpression*) vala_expression_construct (object_type);
221 vala_binary_expression_set_operator (self, op);
222 vala_binary_expression_set_left (self, _left);
223 vala_binary_expression_set_right (self, _right);
224 vala_binary_expression_set_is_chained (self, TRUE);
225 vala_code_node_set_source_reference ((ValaCodeNode*) self, source);
226 return self;
227 }
228
229 ValaBinaryExpression*
vala_binary_expression_new_chained(ValaBinaryOperator op,ValaExpression * _left,ValaExpression * _right,ValaSourceReference * source)230 vala_binary_expression_new_chained (ValaBinaryOperator op,
231 ValaExpression* _left,
232 ValaExpression* _right,
233 ValaSourceReference* source)
234 {
235 return vala_binary_expression_construct_chained (VALA_TYPE_BINARY_EXPRESSION, op, _left, _right, source);
236 }
237
238 static void
vala_binary_expression_real_accept(ValaCodeNode * base,ValaCodeVisitor * visitor)239 vala_binary_expression_real_accept (ValaCodeNode* base,
240 ValaCodeVisitor* visitor)
241 {
242 ValaBinaryExpression * self;
243 self = (ValaBinaryExpression*) base;
244 g_return_if_fail (visitor != NULL);
245 vala_code_visitor_visit_binary_expression (visitor, self);
246 vala_code_visitor_visit_expression (visitor, (ValaExpression*) self);
247 }
248
249 static void
vala_binary_expression_real_accept_children(ValaCodeNode * base,ValaCodeVisitor * visitor)250 vala_binary_expression_real_accept_children (ValaCodeNode* base,
251 ValaCodeVisitor* visitor)
252 {
253 ValaBinaryExpression * self;
254 ValaExpression* _tmp0_;
255 ValaExpression* _tmp1_;
256 ValaExpression* _tmp2_;
257 ValaExpression* _tmp3_;
258 self = (ValaBinaryExpression*) base;
259 g_return_if_fail (visitor != NULL);
260 _tmp0_ = vala_binary_expression_get_left (self);
261 _tmp1_ = _tmp0_;
262 vala_code_node_accept ((ValaCodeNode*) _tmp1_, visitor);
263 _tmp2_ = vala_binary_expression_get_right (self);
264 _tmp3_ = _tmp2_;
265 vala_code_node_accept ((ValaCodeNode*) _tmp3_, visitor);
266 }
267
268 static void
vala_binary_expression_real_replace_expression(ValaCodeNode * base,ValaExpression * old_node,ValaExpression * new_node)269 vala_binary_expression_real_replace_expression (ValaCodeNode* base,
270 ValaExpression* old_node,
271 ValaExpression* new_node)
272 {
273 ValaBinaryExpression * self;
274 ValaExpression* _tmp0_;
275 ValaExpression* _tmp1_;
276 ValaExpression* _tmp2_;
277 ValaExpression* _tmp3_;
278 self = (ValaBinaryExpression*) base;
279 g_return_if_fail (old_node != NULL);
280 g_return_if_fail (new_node != NULL);
281 _tmp0_ = vala_binary_expression_get_left (self);
282 _tmp1_ = _tmp0_;
283 if (_tmp1_ == old_node) {
284 vala_binary_expression_set_left (self, new_node);
285 }
286 _tmp2_ = vala_binary_expression_get_right (self);
287 _tmp3_ = _tmp2_;
288 if (_tmp3_ == old_node) {
289 vala_binary_expression_set_right (self, new_node);
290 }
291 }
292
293 static gchar*
vala_binary_expression_real_to_string(ValaCodeNode * base)294 vala_binary_expression_real_to_string (ValaCodeNode* base)
295 {
296 ValaBinaryExpression * self;
297 ValaExpression* _tmp0_;
298 gchar* _tmp1_;
299 gchar* _tmp2_;
300 ValaBinaryOperator _tmp3_;
301 const gchar* _tmp4_;
302 ValaExpression* _tmp5_;
303 gchar* _tmp6_;
304 gchar* _tmp7_;
305 gchar* _tmp8_;
306 gchar* _tmp9_;
307 gchar* result = NULL;
308 self = (ValaBinaryExpression*) base;
309 _tmp0_ = self->priv->_left;
310 _tmp1_ = vala_code_node_to_string ((ValaCodeNode*) _tmp0_);
311 _tmp2_ = _tmp1_;
312 _tmp3_ = self->priv->_operator;
313 _tmp4_ = vala_binary_operator_to_string (_tmp3_);
314 _tmp5_ = self->priv->_right;
315 _tmp6_ = vala_code_node_to_string ((ValaCodeNode*) _tmp5_);
316 _tmp7_ = _tmp6_;
317 _tmp8_ = g_strdup_printf ("(%s %s %s)", _tmp2_, _tmp4_, _tmp7_);
318 _tmp9_ = _tmp8_;
319 _g_free0 (_tmp7_);
320 _g_free0 (_tmp2_);
321 result = _tmp9_;
322 return result;
323 }
324
325 static gboolean
vala_binary_expression_real_is_constant(ValaExpression * base)326 vala_binary_expression_real_is_constant (ValaExpression* base)
327 {
328 ValaBinaryExpression * self;
329 gboolean _tmp0_ = FALSE;
330 ValaExpression* _tmp1_;
331 ValaExpression* _tmp2_;
332 gboolean result = FALSE;
333 self = (ValaBinaryExpression*) base;
334 _tmp1_ = vala_binary_expression_get_left (self);
335 _tmp2_ = _tmp1_;
336 if (vala_expression_is_constant (_tmp2_)) {
337 ValaExpression* _tmp3_;
338 ValaExpression* _tmp4_;
339 _tmp3_ = vala_binary_expression_get_right (self);
340 _tmp4_ = _tmp3_;
341 _tmp0_ = vala_expression_is_constant (_tmp4_);
342 } else {
343 _tmp0_ = FALSE;
344 }
345 result = _tmp0_;
346 return result;
347 }
348
349 static gboolean
vala_binary_expression_real_is_pure(ValaExpression * base)350 vala_binary_expression_real_is_pure (ValaExpression* base)
351 {
352 ValaBinaryExpression * self;
353 gboolean _tmp0_ = FALSE;
354 ValaExpression* _tmp1_;
355 ValaExpression* _tmp2_;
356 gboolean result = FALSE;
357 self = (ValaBinaryExpression*) base;
358 _tmp1_ = vala_binary_expression_get_left (self);
359 _tmp2_ = _tmp1_;
360 if (vala_expression_is_pure (_tmp2_)) {
361 ValaExpression* _tmp3_;
362 ValaExpression* _tmp4_;
363 _tmp3_ = vala_binary_expression_get_right (self);
364 _tmp4_ = _tmp3_;
365 _tmp0_ = vala_expression_is_pure (_tmp4_);
366 } else {
367 _tmp0_ = FALSE;
368 }
369 result = _tmp0_;
370 return result;
371 }
372
373 static gboolean
vala_binary_expression_real_is_non_null(ValaExpression * base)374 vala_binary_expression_real_is_non_null (ValaExpression* base)
375 {
376 ValaBinaryExpression * self;
377 gboolean _tmp0_ = FALSE;
378 ValaExpression* _tmp1_;
379 ValaExpression* _tmp2_;
380 gboolean result = FALSE;
381 self = (ValaBinaryExpression*) base;
382 _tmp1_ = vala_binary_expression_get_left (self);
383 _tmp2_ = _tmp1_;
384 if (vala_expression_is_non_null (_tmp2_)) {
385 ValaExpression* _tmp3_;
386 ValaExpression* _tmp4_;
387 _tmp3_ = vala_binary_expression_get_right (self);
388 _tmp4_ = _tmp3_;
389 _tmp0_ = vala_expression_is_non_null (_tmp4_);
390 } else {
391 _tmp0_ = FALSE;
392 }
393 result = _tmp0_;
394 return result;
395 }
396
397 static gboolean
vala_binary_expression_real_is_accessible(ValaExpression * base,ValaSymbol * sym)398 vala_binary_expression_real_is_accessible (ValaExpression* base,
399 ValaSymbol* sym)
400 {
401 ValaBinaryExpression * self;
402 gboolean _tmp0_ = FALSE;
403 ValaExpression* _tmp1_;
404 ValaExpression* _tmp2_;
405 gboolean result = FALSE;
406 self = (ValaBinaryExpression*) base;
407 g_return_val_if_fail (sym != NULL, FALSE);
408 _tmp1_ = vala_binary_expression_get_left (self);
409 _tmp2_ = _tmp1_;
410 if (vala_expression_is_accessible (_tmp2_, sym)) {
411 ValaExpression* _tmp3_;
412 ValaExpression* _tmp4_;
413 _tmp3_ = vala_binary_expression_get_right (self);
414 _tmp4_ = _tmp3_;
415 _tmp0_ = vala_expression_is_accessible (_tmp4_, sym);
416 } else {
417 _tmp0_ = FALSE;
418 }
419 result = _tmp0_;
420 return result;
421 }
422
423 static void
vala_binary_expression_real_get_error_types(ValaCodeNode * base,ValaCollection * collection,ValaSourceReference * source_reference)424 vala_binary_expression_real_get_error_types (ValaCodeNode* base,
425 ValaCollection* collection,
426 ValaSourceReference* source_reference)
427 {
428 ValaBinaryExpression * self;
429 ValaExpression* _tmp0_;
430 ValaExpression* _tmp1_;
431 ValaExpression* _tmp2_;
432 ValaExpression* _tmp3_;
433 self = (ValaBinaryExpression*) base;
434 g_return_if_fail (collection != NULL);
435 _tmp0_ = vala_binary_expression_get_left (self);
436 _tmp1_ = _tmp0_;
437 vala_code_node_get_error_types ((ValaCodeNode*) _tmp1_, collection, source_reference);
438 _tmp2_ = vala_binary_expression_get_right (self);
439 _tmp3_ = _tmp2_;
440 vala_code_node_get_error_types ((ValaCodeNode*) _tmp3_, collection, source_reference);
441 }
442
443 static gboolean
vala_binary_expression_real_check(ValaCodeNode * base,ValaCodeContext * context)444 vala_binary_expression_real_check (ValaCodeNode* base,
445 ValaCodeContext* context)
446 {
447 ValaBinaryExpression * self;
448 gboolean _tmp0_;
449 gboolean _tmp1_;
450 gboolean _tmp4_ = FALSE;
451 ValaSemanticAnalyzer* _tmp5_;
452 ValaSemanticAnalyzer* _tmp6_;
453 ValaSymbol* _tmp7_;
454 ValaSymbol* _tmp8_;
455 ValaBinaryOperator _tmp126_;
456 gboolean _tmp367_ = FALSE;
457 gboolean _tmp368_ = FALSE;
458 ValaDataType* _tmp369_;
459 ValaDataType* _tmp370_;
460 ValaExpression* _tmp407_;
461 ValaExpression* _tmp408_;
462 gboolean _tmp409_ = FALSE;
463 gboolean _tmp410_ = FALSE;
464 ValaExpression* _tmp411_;
465 ValaExpression* _tmp412_;
466 ValaDataType* _tmp413_;
467 ValaDataType* _tmp414_;
468 ValaExpression* _tmp432_;
469 ValaExpression* _tmp433_;
470 gboolean _tmp434_ = FALSE;
471 gboolean _tmp435_ = FALSE;
472 ValaExpression* _tmp436_;
473 ValaExpression* _tmp437_;
474 ValaDataType* _tmp438_;
475 ValaDataType* _tmp439_;
476 gboolean _tmp457_ = FALSE;
477 ValaExpression* _tmp458_;
478 ValaExpression* _tmp459_;
479 ValaExpression* _tmp462_;
480 ValaExpression* _tmp463_;
481 ValaDataType* _tmp464_;
482 ValaDataType* _tmp465_;
483 gboolean _tmp470_ = FALSE;
484 ValaBinaryOperator _tmp471_;
485 gboolean _tmp480_ = FALSE;
486 ValaExpression* _tmp481_;
487 ValaExpression* _tmp482_;
488 ValaDataType* _tmp483_;
489 ValaDataType* _tmp484_;
490 gboolean _tmp501_ = FALSE;
491 ValaExpression* _tmp502_;
492 ValaExpression* _tmp503_;
493 ValaDataType* _tmp504_;
494 ValaDataType* _tmp505_;
495 ValaExpression* _tmp522_;
496 ValaExpression* _tmp523_;
497 ValaExpression* _tmp524_;
498 ValaExpression* _tmp525_;
499 ValaDataType* _tmp526_;
500 ValaDataType* _tmp527_;
501 ValaDataType* _tmp528_;
502 ValaDataType* _tmp529_;
503 ValaExpression* _tmp530_;
504 ValaExpression* _tmp531_;
505 ValaDataType* _tmp532_;
506 ValaDataType* _tmp533_;
507 ValaExpression* _tmp534_;
508 ValaExpression* _tmp535_;
509 ValaExpression* _tmp536_;
510 ValaExpression* _tmp537_;
511 ValaDataType* _tmp538_;
512 ValaDataType* _tmp539_;
513 ValaDataType* _tmp540_;
514 ValaDataType* _tmp541_;
515 ValaExpression* _tmp542_;
516 ValaExpression* _tmp543_;
517 ValaDataType* _tmp544_;
518 ValaDataType* _tmp545_;
519 gboolean _tmp546_ = FALSE;
520 gboolean _tmp547_ = FALSE;
521 ValaBinaryOperator _tmp548_;
522 ValaBinaryOperator _tmp637_;
523 ValaDataType* _tmp1180_;
524 ValaDataType* _tmp1181_;
525 gboolean _tmp1182_;
526 gboolean _tmp1183_;
527 gboolean result = FALSE;
528 self = (ValaBinaryExpression*) base;
529 g_return_val_if_fail (context != NULL, FALSE);
530 _tmp0_ = vala_code_node_get_checked ((ValaCodeNode*) self);
531 _tmp1_ = _tmp0_;
532 if (_tmp1_) {
533 gboolean _tmp2_;
534 gboolean _tmp3_;
535 _tmp2_ = vala_code_node_get_error ((ValaCodeNode*) self);
536 _tmp3_ = _tmp2_;
537 result = !_tmp3_;
538 return result;
539 }
540 vala_code_node_set_checked ((ValaCodeNode*) self, TRUE);
541 _tmp5_ = vala_code_context_get_analyzer (context);
542 _tmp6_ = _tmp5_;
543 _tmp7_ = vala_semantic_analyzer_get_current_symbol (_tmp6_);
544 _tmp8_ = _tmp7_;
545 if (VALA_IS_BLOCK (_tmp8_)) {
546 gboolean _tmp9_ = FALSE;
547 ValaBinaryOperator _tmp10_;
548 _tmp10_ = self->priv->_operator;
549 if (_tmp10_ == VALA_BINARY_OPERATOR_AND) {
550 _tmp9_ = TRUE;
551 } else {
552 ValaBinaryOperator _tmp11_;
553 _tmp11_ = self->priv->_operator;
554 _tmp9_ = _tmp11_ == VALA_BINARY_OPERATOR_OR;
555 }
556 _tmp4_ = _tmp9_;
557 } else {
558 _tmp4_ = FALSE;
559 }
560 if (_tmp4_) {
561 ValaLocalVariable* local = NULL;
562 ValaSemanticAnalyzer* _tmp12_;
563 ValaSemanticAnalyzer* _tmp13_;
564 ValaDataType* _tmp14_;
565 ValaDataType* _tmp15_;
566 ValaDataType* _tmp16_;
567 gchar* _tmp17_;
568 gchar* _tmp18_;
569 ValaSourceReference* _tmp19_;
570 ValaSourceReference* _tmp20_;
571 ValaLocalVariable* _tmp21_;
572 ValaLocalVariable* _tmp22_;
573 ValaDeclarationStatement* decl = NULL;
574 ValaLocalVariable* _tmp23_;
575 ValaSourceReference* _tmp24_;
576 ValaSourceReference* _tmp25_;
577 ValaDeclarationStatement* _tmp26_;
578 ValaExpressionStatement* right_stmt = NULL;
579 ValaLocalVariable* _tmp27_;
580 const gchar* _tmp28_;
581 const gchar* _tmp29_;
582 ValaExpression* _tmp30_;
583 ValaExpression* _tmp31_;
584 ValaSourceReference* _tmp32_;
585 ValaSourceReference* _tmp33_;
586 ValaMemberAccess* _tmp34_;
587 ValaMemberAccess* _tmp35_;
588 ValaExpression* _tmp36_;
589 ValaExpression* _tmp37_;
590 ValaExpression* _tmp38_;
591 ValaExpression* _tmp39_;
592 ValaSourceReference* _tmp40_;
593 ValaSourceReference* _tmp41_;
594 ValaAssignment* _tmp42_;
595 ValaAssignment* _tmp43_;
596 ValaExpression* _tmp44_;
597 ValaExpression* _tmp45_;
598 ValaSourceReference* _tmp46_;
599 ValaSourceReference* _tmp47_;
600 ValaExpressionStatement* _tmp48_;
601 ValaExpressionStatement* _tmp49_;
602 ValaExpressionStatement* stmt = NULL;
603 ValaLocalVariable* _tmp50_;
604 const gchar* _tmp51_;
605 const gchar* _tmp52_;
606 ValaExpression* _tmp53_;
607 ValaExpression* _tmp54_;
608 ValaSourceReference* _tmp55_;
609 ValaSourceReference* _tmp56_;
610 ValaMemberAccess* _tmp57_;
611 ValaMemberAccess* _tmp58_;
612 ValaBinaryOperator _tmp59_;
613 ValaExpression* _tmp60_;
614 ValaExpression* _tmp61_;
615 ValaSourceReference* _tmp62_;
616 ValaSourceReference* _tmp63_;
617 ValaBooleanLiteral* _tmp64_;
618 ValaBooleanLiteral* _tmp65_;
619 ValaExpression* _tmp66_;
620 ValaExpression* _tmp67_;
621 ValaSourceReference* _tmp68_;
622 ValaSourceReference* _tmp69_;
623 ValaAssignment* _tmp70_;
624 ValaAssignment* _tmp71_;
625 ValaExpression* _tmp72_;
626 ValaExpression* _tmp73_;
627 ValaSourceReference* _tmp74_;
628 ValaSourceReference* _tmp75_;
629 ValaExpressionStatement* _tmp76_;
630 ValaExpressionStatement* _tmp77_;
631 ValaBlock* true_block = NULL;
632 ValaSourceReference* _tmp78_;
633 ValaSourceReference* _tmp79_;
634 ValaBlock* _tmp80_;
635 ValaBlock* false_block = NULL;
636 ValaSourceReference* _tmp81_;
637 ValaSourceReference* _tmp82_;
638 ValaBlock* _tmp83_;
639 ValaBinaryOperator _tmp84_;
640 ValaIfStatement* if_stmt = NULL;
641 ValaExpression* _tmp93_;
642 ValaExpression* _tmp94_;
643 ValaBlock* _tmp95_;
644 ValaBlock* _tmp96_;
645 ValaSourceReference* _tmp97_;
646 ValaSourceReference* _tmp98_;
647 ValaIfStatement* _tmp99_;
648 ValaSemanticAnalyzer* _tmp100_;
649 ValaSemanticAnalyzer* _tmp101_;
650 ValaBlock* _tmp102_;
651 ValaDeclarationStatement* _tmp103_;
652 ValaSemanticAnalyzer* _tmp104_;
653 ValaSemanticAnalyzer* _tmp105_;
654 ValaBlock* _tmp106_;
655 ValaIfStatement* _tmp107_;
656 ValaDeclarationStatement* _tmp108_;
657 ValaIfStatement* _tmp109_;
658 ValaMemberAccess* ma = NULL;
659 ValaLocalVariable* _tmp110_;
660 const gchar* _tmp111_;
661 const gchar* _tmp112_;
662 ValaSourceReference* _tmp113_;
663 ValaSourceReference* _tmp114_;
664 ValaMemberAccess* _tmp115_;
665 ValaMemberAccess* _tmp116_;
666 ValaDataType* _tmp117_;
667 ValaDataType* _tmp118_;
668 ValaMemberAccess* _tmp119_;
669 ValaDataType* _tmp120_;
670 ValaDataType* _tmp121_;
671 ValaCodeNode* _tmp122_;
672 ValaCodeNode* _tmp123_;
673 ValaMemberAccess* _tmp124_;
674 ValaMemberAccess* _tmp125_;
675 _tmp12_ = vala_code_context_get_analyzer (context);
676 _tmp13_ = _tmp12_;
677 _tmp14_ = _tmp13_->bool_type;
678 _tmp15_ = vala_data_type_copy (_tmp14_);
679 _tmp16_ = _tmp15_;
680 _tmp17_ = vala_code_node_get_temp_name ();
681 _tmp18_ = _tmp17_;
682 _tmp19_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
683 _tmp20_ = _tmp19_;
684 _tmp21_ = vala_local_variable_new (_tmp16_, _tmp18_, NULL, _tmp20_);
685 _tmp22_ = _tmp21_;
686 _g_free0 (_tmp18_);
687 _vala_code_node_unref0 (_tmp16_);
688 local = _tmp22_;
689 _tmp23_ = local;
690 _tmp24_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
691 _tmp25_ = _tmp24_;
692 _tmp26_ = vala_declaration_statement_new ((ValaSymbol*) _tmp23_, _tmp25_);
693 decl = _tmp26_;
694 _tmp27_ = local;
695 _tmp28_ = vala_symbol_get_name ((ValaSymbol*) _tmp27_);
696 _tmp29_ = _tmp28_;
697 _tmp30_ = vala_binary_expression_get_right (self);
698 _tmp31_ = _tmp30_;
699 _tmp32_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp31_);
700 _tmp33_ = _tmp32_;
701 _tmp34_ = vala_member_access_new_simple (_tmp29_, _tmp33_);
702 _tmp35_ = _tmp34_;
703 _tmp36_ = vala_binary_expression_get_right (self);
704 _tmp37_ = _tmp36_;
705 _tmp38_ = vala_binary_expression_get_right (self);
706 _tmp39_ = _tmp38_;
707 _tmp40_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp39_);
708 _tmp41_ = _tmp40_;
709 _tmp42_ = vala_assignment_new ((ValaExpression*) _tmp35_, _tmp37_, VALA_ASSIGNMENT_OPERATOR_SIMPLE, _tmp41_);
710 _tmp43_ = _tmp42_;
711 _tmp44_ = vala_binary_expression_get_right (self);
712 _tmp45_ = _tmp44_;
713 _tmp46_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp45_);
714 _tmp47_ = _tmp46_;
715 _tmp48_ = vala_expression_statement_new ((ValaExpression*) _tmp43_, _tmp47_);
716 _tmp49_ = _tmp48_;
717 _vala_code_node_unref0 (_tmp43_);
718 _vala_code_node_unref0 (_tmp35_);
719 right_stmt = _tmp49_;
720 _tmp50_ = local;
721 _tmp51_ = vala_symbol_get_name ((ValaSymbol*) _tmp50_);
722 _tmp52_ = _tmp51_;
723 _tmp53_ = vala_binary_expression_get_left (self);
724 _tmp54_ = _tmp53_;
725 _tmp55_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp54_);
726 _tmp56_ = _tmp55_;
727 _tmp57_ = vala_member_access_new_simple (_tmp52_, _tmp56_);
728 _tmp58_ = _tmp57_;
729 _tmp59_ = self->priv->_operator;
730 _tmp60_ = vala_binary_expression_get_left (self);
731 _tmp61_ = _tmp60_;
732 _tmp62_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp61_);
733 _tmp63_ = _tmp62_;
734 _tmp64_ = vala_boolean_literal_new (_tmp59_ == VALA_BINARY_OPERATOR_OR, _tmp63_);
735 _tmp65_ = _tmp64_;
736 _tmp66_ = vala_binary_expression_get_left (self);
737 _tmp67_ = _tmp66_;
738 _tmp68_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp67_);
739 _tmp69_ = _tmp68_;
740 _tmp70_ = vala_assignment_new ((ValaExpression*) _tmp58_, (ValaExpression*) _tmp65_, VALA_ASSIGNMENT_OPERATOR_SIMPLE, _tmp69_);
741 _tmp71_ = _tmp70_;
742 _tmp72_ = vala_binary_expression_get_left (self);
743 _tmp73_ = _tmp72_;
744 _tmp74_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp73_);
745 _tmp75_ = _tmp74_;
746 _tmp76_ = vala_expression_statement_new ((ValaExpression*) _tmp71_, _tmp75_);
747 _tmp77_ = _tmp76_;
748 _vala_code_node_unref0 (_tmp71_);
749 _vala_code_node_unref0 (_tmp65_);
750 _vala_code_node_unref0 (_tmp58_);
751 stmt = _tmp77_;
752 _tmp78_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
753 _tmp79_ = _tmp78_;
754 _tmp80_ = vala_block_new (_tmp79_);
755 true_block = _tmp80_;
756 _tmp81_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
757 _tmp82_ = _tmp81_;
758 _tmp83_ = vala_block_new (_tmp82_);
759 false_block = _tmp83_;
760 _tmp84_ = self->priv->_operator;
761 if (_tmp84_ == VALA_BINARY_OPERATOR_AND) {
762 ValaBlock* _tmp85_;
763 ValaExpressionStatement* _tmp86_;
764 ValaBlock* _tmp87_;
765 ValaExpressionStatement* _tmp88_;
766 _tmp85_ = true_block;
767 _tmp86_ = right_stmt;
768 vala_block_add_statement (_tmp85_, (ValaStatement*) _tmp86_);
769 _tmp87_ = false_block;
770 _tmp88_ = stmt;
771 vala_block_add_statement (_tmp87_, (ValaStatement*) _tmp88_);
772 } else {
773 ValaBlock* _tmp89_;
774 ValaExpressionStatement* _tmp90_;
775 ValaBlock* _tmp91_;
776 ValaExpressionStatement* _tmp92_;
777 _tmp89_ = true_block;
778 _tmp90_ = stmt;
779 vala_block_add_statement (_tmp89_, (ValaStatement*) _tmp90_);
780 _tmp91_ = false_block;
781 _tmp92_ = right_stmt;
782 vala_block_add_statement (_tmp91_, (ValaStatement*) _tmp92_);
783 }
784 _tmp93_ = vala_binary_expression_get_left (self);
785 _tmp94_ = _tmp93_;
786 _tmp95_ = true_block;
787 _tmp96_ = false_block;
788 _tmp97_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
789 _tmp98_ = _tmp97_;
790 _tmp99_ = vala_if_statement_new (_tmp94_, _tmp95_, _tmp96_, _tmp98_);
791 if_stmt = _tmp99_;
792 _tmp100_ = vala_code_context_get_analyzer (context);
793 _tmp101_ = _tmp100_;
794 _tmp102_ = _tmp101_->insert_block;
795 _tmp103_ = decl;
796 vala_expression_insert_statement ((ValaExpression*) self, _tmp102_, (ValaStatement*) _tmp103_);
797 _tmp104_ = vala_code_context_get_analyzer (context);
798 _tmp105_ = _tmp104_;
799 _tmp106_ = _tmp105_->insert_block;
800 _tmp107_ = if_stmt;
801 vala_expression_insert_statement ((ValaExpression*) self, _tmp106_, (ValaStatement*) _tmp107_);
802 _tmp108_ = decl;
803 vala_code_node_check ((ValaCodeNode*) _tmp108_, context);
804 _tmp109_ = if_stmt;
805 if (!vala_code_node_check ((ValaCodeNode*) _tmp109_, context)) {
806 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
807 result = FALSE;
808 _vala_code_node_unref0 (if_stmt);
809 _vala_code_node_unref0 (false_block);
810 _vala_code_node_unref0 (true_block);
811 _vala_code_node_unref0 (stmt);
812 _vala_code_node_unref0 (right_stmt);
813 _vala_code_node_unref0 (decl);
814 _vala_code_node_unref0 (local);
815 return result;
816 }
817 _tmp110_ = local;
818 _tmp111_ = vala_symbol_get_name ((ValaSymbol*) _tmp110_);
819 _tmp112_ = _tmp111_;
820 _tmp113_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
821 _tmp114_ = _tmp113_;
822 _tmp115_ = vala_member_access_new_simple (_tmp112_, _tmp114_);
823 ma = _tmp115_;
824 _tmp116_ = ma;
825 _tmp117_ = vala_expression_get_target_type ((ValaExpression*) self);
826 _tmp118_ = _tmp117_;
827 vala_expression_set_target_type ((ValaExpression*) _tmp116_, _tmp118_);
828 _tmp119_ = ma;
829 _tmp120_ = vala_expression_get_formal_target_type ((ValaExpression*) self);
830 _tmp121_ = _tmp120_;
831 vala_expression_set_formal_target_type ((ValaExpression*) _tmp119_, _tmp121_);
832 _tmp122_ = vala_code_node_get_parent_node ((ValaCodeNode*) self);
833 _tmp123_ = _tmp122_;
834 _tmp124_ = ma;
835 vala_code_node_replace_expression (_tmp123_, (ValaExpression*) self, (ValaExpression*) _tmp124_);
836 _tmp125_ = ma;
837 vala_code_node_check ((ValaCodeNode*) _tmp125_, context);
838 result = TRUE;
839 _vala_code_node_unref0 (ma);
840 _vala_code_node_unref0 (if_stmt);
841 _vala_code_node_unref0 (false_block);
842 _vala_code_node_unref0 (true_block);
843 _vala_code_node_unref0 (stmt);
844 _vala_code_node_unref0 (right_stmt);
845 _vala_code_node_unref0 (decl);
846 _vala_code_node_unref0 (local);
847 return result;
848 }
849 _tmp126_ = self->priv->_operator;
850 if (_tmp126_ == VALA_BINARY_OPERATOR_COALESCE) {
851 ValaDataType* _tmp127_;
852 ValaDataType* _tmp128_;
853 ValaExpression* _tmp141_;
854 ValaExpression* _tmp142_;
855 gchar* temp_name = NULL;
856 gchar* _tmp143_;
857 ValaLocalVariable* right_local = NULL;
858 const gchar* _tmp144_;
859 ValaExpression* _tmp145_;
860 ValaExpression* _tmp146_;
861 ValaExpression* _tmp147_;
862 ValaExpression* _tmp148_;
863 ValaSourceReference* _tmp149_;
864 ValaSourceReference* _tmp150_;
865 ValaLocalVariable* _tmp151_;
866 ValaDeclarationStatement* right_decl = NULL;
867 ValaLocalVariable* _tmp152_;
868 ValaExpression* _tmp153_;
869 ValaExpression* _tmp154_;
870 ValaSourceReference* _tmp155_;
871 ValaSourceReference* _tmp156_;
872 ValaDeclarationStatement* _tmp157_;
873 ValaBlock* true_block = NULL;
874 ValaSourceReference* _tmp158_;
875 ValaSourceReference* _tmp159_;
876 ValaBlock* _tmp160_;
877 ValaBlock* _tmp161_;
878 ValaDeclarationStatement* _tmp162_;
879 ValaBlock* _tmp163_;
880 ValaLocalVariable* _tmp164_;
881 ValaExpression* _tmp165_;
882 ValaExpression* _tmp166_;
883 ValaDataType* local_type = NULL;
884 gboolean cast_non_null = FALSE;
885 gboolean _tmp167_ = FALSE;
886 ValaExpression* _tmp168_;
887 ValaExpression* _tmp169_;
888 ValaDataType* _tmp170_;
889 ValaDataType* _tmp171_;
890 gboolean _tmp254_ = FALSE;
891 gboolean _tmp255_ = FALSE;
892 ValaDataType* _tmp256_;
893 ValaLocalVariable* local = NULL;
894 ValaDataType* _tmp268_;
895 const gchar* _tmp269_;
896 ValaExpression* _tmp270_;
897 ValaExpression* _tmp271_;
898 ValaSourceReference* _tmp272_;
899 ValaSourceReference* _tmp273_;
900 ValaLocalVariable* _tmp274_;
901 ValaDeclarationStatement* decl = NULL;
902 ValaLocalVariable* _tmp275_;
903 ValaSourceReference* _tmp276_;
904 ValaSourceReference* _tmp277_;
905 ValaDeclarationStatement* _tmp278_;
906 ValaSemanticAnalyzer* _tmp279_;
907 ValaSemanticAnalyzer* _tmp280_;
908 ValaBlock* _tmp281_;
909 ValaDeclarationStatement* _tmp282_;
910 ValaDeclarationStatement* _tmp283_;
911 ValaExpressionStatement* right_stmt = NULL;
912 ValaLocalVariable* _tmp284_;
913 const gchar* _tmp285_;
914 const gchar* _tmp286_;
915 ValaExpression* _tmp287_;
916 ValaExpression* _tmp288_;
917 ValaSourceReference* _tmp289_;
918 ValaSourceReference* _tmp290_;
919 ValaMemberAccess* _tmp291_;
920 ValaMemberAccess* _tmp292_;
921 ValaExpression* _tmp293_;
922 ValaExpression* _tmp294_;
923 ValaExpression* _tmp295_;
924 ValaExpression* _tmp296_;
925 ValaSourceReference* _tmp297_;
926 ValaSourceReference* _tmp298_;
927 ValaAssignment* _tmp299_;
928 ValaAssignment* _tmp300_;
929 ValaExpression* _tmp301_;
930 ValaExpression* _tmp302_;
931 ValaSourceReference* _tmp303_;
932 ValaSourceReference* _tmp304_;
933 ValaExpressionStatement* _tmp305_;
934 ValaExpressionStatement* _tmp306_;
935 ValaBlock* _tmp307_;
936 ValaLocalVariable* _tmp308_;
937 ValaBlock* _tmp309_;
938 ValaDeclarationStatement* _tmp310_;
939 ValaExpressionStatement* _tmp311_;
940 ValaExpressionStatement* _tmp312_;
941 ValaBinaryExpression* cond = NULL;
942 ValaLocalVariable* _tmp313_;
943 const gchar* _tmp314_;
944 const gchar* _tmp315_;
945 ValaExpression* _tmp316_;
946 ValaExpression* _tmp317_;
947 ValaSourceReference* _tmp318_;
948 ValaSourceReference* _tmp319_;
949 ValaMemberAccess* _tmp320_;
950 ValaMemberAccess* _tmp321_;
951 ValaSourceReference* _tmp322_;
952 ValaSourceReference* _tmp323_;
953 ValaNullLiteral* _tmp324_;
954 ValaNullLiteral* _tmp325_;
955 ValaSourceReference* _tmp326_;
956 ValaSourceReference* _tmp327_;
957 ValaBinaryExpression* _tmp328_;
958 ValaBinaryExpression* _tmp329_;
959 ValaIfStatement* if_stmt = NULL;
960 ValaBinaryExpression* _tmp330_;
961 ValaBlock* _tmp331_;
962 ValaSourceReference* _tmp332_;
963 ValaSourceReference* _tmp333_;
964 ValaIfStatement* _tmp334_;
965 ValaSemanticAnalyzer* _tmp335_;
966 ValaSemanticAnalyzer* _tmp336_;
967 ValaBlock* _tmp337_;
968 ValaIfStatement* _tmp338_;
969 ValaIfStatement* _tmp339_;
970 ValaExpression* replace_expr = NULL;
971 ValaLocalVariable* _tmp340_;
972 ValaDataType* _tmp341_;
973 ValaDataType* _tmp342_;
974 ValaExpression* _tmp343_;
975 gboolean _tmp344_ = FALSE;
976 ValaCodeNode* _tmp363_;
977 ValaCodeNode* _tmp364_;
978 ValaExpression* _tmp365_;
979 ValaExpression* _tmp366_;
980 _tmp127_ = vala_expression_get_target_type ((ValaExpression*) self);
981 _tmp128_ = _tmp127_;
982 if (_tmp128_ != NULL) {
983 ValaExpression* _tmp129_;
984 ValaExpression* _tmp130_;
985 ValaDataType* _tmp131_;
986 ValaDataType* _tmp132_;
987 ValaDataType* _tmp133_;
988 ValaDataType* _tmp134_;
989 ValaExpression* _tmp135_;
990 ValaExpression* _tmp136_;
991 ValaDataType* _tmp137_;
992 ValaDataType* _tmp138_;
993 ValaDataType* _tmp139_;
994 ValaDataType* _tmp140_;
995 _tmp129_ = vala_binary_expression_get_left (self);
996 _tmp130_ = _tmp129_;
997 _tmp131_ = vala_expression_get_target_type ((ValaExpression*) self);
998 _tmp132_ = _tmp131_;
999 _tmp133_ = vala_data_type_copy (_tmp132_);
1000 _tmp134_ = _tmp133_;
1001 vala_expression_set_target_type (_tmp130_, _tmp134_);
1002 _vala_code_node_unref0 (_tmp134_);
1003 _tmp135_ = vala_binary_expression_get_right (self);
1004 _tmp136_ = _tmp135_;
1005 _tmp137_ = vala_expression_get_target_type ((ValaExpression*) self);
1006 _tmp138_ = _tmp137_;
1007 _tmp139_ = vala_data_type_copy (_tmp138_);
1008 _tmp140_ = _tmp139_;
1009 vala_expression_set_target_type (_tmp136_, _tmp140_);
1010 _vala_code_node_unref0 (_tmp140_);
1011 }
1012 _tmp141_ = vala_binary_expression_get_left (self);
1013 _tmp142_ = _tmp141_;
1014 if (!vala_code_node_check ((ValaCodeNode*) _tmp142_, context)) {
1015 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
1016 result = FALSE;
1017 return result;
1018 }
1019 _tmp143_ = vala_code_node_get_temp_name ();
1020 temp_name = _tmp143_;
1021 _tmp144_ = temp_name;
1022 _tmp145_ = vala_binary_expression_get_right (self);
1023 _tmp146_ = _tmp145_;
1024 _tmp147_ = vala_binary_expression_get_right (self);
1025 _tmp148_ = _tmp147_;
1026 _tmp149_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp148_);
1027 _tmp150_ = _tmp149_;
1028 _tmp151_ = vala_local_variable_new (NULL, _tmp144_, _tmp146_, _tmp150_);
1029 right_local = _tmp151_;
1030 _tmp152_ = right_local;
1031 _tmp153_ = vala_binary_expression_get_right (self);
1032 _tmp154_ = _tmp153_;
1033 _tmp155_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp154_);
1034 _tmp156_ = _tmp155_;
1035 _tmp157_ = vala_declaration_statement_new ((ValaSymbol*) _tmp152_, _tmp156_);
1036 right_decl = _tmp157_;
1037 _tmp158_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1038 _tmp159_ = _tmp158_;
1039 _tmp160_ = vala_block_new (_tmp159_);
1040 true_block = _tmp160_;
1041 _tmp161_ = true_block;
1042 _tmp162_ = right_decl;
1043 vala_block_add_statement (_tmp161_, (ValaStatement*) _tmp162_);
1044 _tmp163_ = true_block;
1045 if (!vala_code_node_check ((ValaCodeNode*) _tmp163_, context)) {
1046 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
1047 result = FALSE;
1048 _vala_code_node_unref0 (true_block);
1049 _vala_code_node_unref0 (right_decl);
1050 _vala_code_node_unref0 (right_local);
1051 _g_free0 (temp_name);
1052 return result;
1053 }
1054 _tmp164_ = right_local;
1055 _tmp165_ = vala_variable_get_initializer ((ValaVariable*) _tmp164_);
1056 _tmp166_ = _tmp165_;
1057 vala_binary_expression_set_right (self, _tmp166_);
1058 local_type = NULL;
1059 cast_non_null = FALSE;
1060 _tmp168_ = vala_binary_expression_get_left (self);
1061 _tmp169_ = _tmp168_;
1062 _tmp170_ = vala_expression_get_value_type (_tmp169_);
1063 _tmp171_ = _tmp170_;
1064 if (VALA_IS_NULL_TYPE (_tmp171_)) {
1065 ValaExpression* _tmp172_;
1066 ValaExpression* _tmp173_;
1067 ValaDataType* _tmp174_;
1068 ValaDataType* _tmp175_;
1069 _tmp172_ = vala_binary_expression_get_right (self);
1070 _tmp173_ = _tmp172_;
1071 _tmp174_ = vala_expression_get_value_type (_tmp173_);
1072 _tmp175_ = _tmp174_;
1073 _tmp167_ = _tmp175_ != NULL;
1074 } else {
1075 _tmp167_ = FALSE;
1076 }
1077 if (_tmp167_) {
1078 ValaExpression* _tmp176_;
1079 ValaExpression* _tmp177_;
1080 ValaSourceReference* _tmp178_;
1081 ValaSourceReference* _tmp179_;
1082 ValaExpression* _tmp180_;
1083 ValaExpression* _tmp181_;
1084 ValaDataType* _tmp182_;
1085 ValaDataType* _tmp183_;
1086 ValaDataType* _tmp184_;
1087 ValaDataType* _tmp185_;
1088 ValaExpression* _tmp186_;
1089 ValaExpression* _tmp187_;
1090 ValaDataType* _tmp188_;
1091 ValaDataType* _tmp189_;
1092 gboolean _tmp190_;
1093 gboolean _tmp191_;
1094 _tmp176_ = vala_binary_expression_get_left (self);
1095 _tmp177_ = _tmp176_;
1096 _tmp178_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp177_);
1097 _tmp179_ = _tmp178_;
1098 vala_report_warning (_tmp179_, "left operand is always null");
1099 _tmp180_ = vala_binary_expression_get_right (self);
1100 _tmp181_ = _tmp180_;
1101 _tmp182_ = vala_expression_get_value_type (_tmp181_);
1102 _tmp183_ = _tmp182_;
1103 _tmp184_ = vala_data_type_copy (_tmp183_);
1104 _vala_code_node_unref0 (local_type);
1105 local_type = _tmp184_;
1106 _tmp185_ = local_type;
1107 vala_data_type_set_nullable (_tmp185_, TRUE);
1108 _tmp186_ = vala_binary_expression_get_right (self);
1109 _tmp187_ = _tmp186_;
1110 _tmp188_ = vala_expression_get_value_type (_tmp187_);
1111 _tmp189_ = _tmp188_;
1112 _tmp190_ = vala_data_type_get_nullable (_tmp189_);
1113 _tmp191_ = _tmp190_;
1114 if (!_tmp191_) {
1115 cast_non_null = TRUE;
1116 }
1117 } else {
1118 ValaExpression* _tmp192_;
1119 ValaExpression* _tmp193_;
1120 ValaDataType* _tmp194_;
1121 ValaDataType* _tmp195_;
1122 _tmp192_ = vala_binary_expression_get_left (self);
1123 _tmp193_ = _tmp192_;
1124 _tmp194_ = vala_expression_get_value_type (_tmp193_);
1125 _tmp195_ = _tmp194_;
1126 if (_tmp195_ != NULL) {
1127 ValaExpression* _tmp196_;
1128 ValaExpression* _tmp197_;
1129 ValaDataType* _tmp198_;
1130 ValaDataType* _tmp199_;
1131 ValaDataType* _tmp200_;
1132 gboolean _tmp201_ = FALSE;
1133 ValaExpression* _tmp202_;
1134 ValaExpression* _tmp203_;
1135 ValaDataType* _tmp204_;
1136 ValaDataType* _tmp205_;
1137 gboolean _tmp213_;
1138 gboolean _tmp214_;
1139 _tmp196_ = vala_binary_expression_get_left (self);
1140 _tmp197_ = _tmp196_;
1141 _tmp198_ = vala_expression_get_value_type (_tmp197_);
1142 _tmp199_ = _tmp198_;
1143 _tmp200_ = vala_data_type_copy (_tmp199_);
1144 _vala_code_node_unref0 (local_type);
1145 local_type = _tmp200_;
1146 _tmp202_ = vala_binary_expression_get_right (self);
1147 _tmp203_ = _tmp202_;
1148 _tmp204_ = vala_expression_get_value_type (_tmp203_);
1149 _tmp205_ = _tmp204_;
1150 if (_tmp205_ != NULL) {
1151 ValaExpression* _tmp206_;
1152 ValaExpression* _tmp207_;
1153 ValaDataType* _tmp208_;
1154 ValaDataType* _tmp209_;
1155 gboolean _tmp210_;
1156 gboolean _tmp211_;
1157 _tmp206_ = vala_binary_expression_get_right (self);
1158 _tmp207_ = _tmp206_;
1159 _tmp208_ = vala_expression_get_value_type (_tmp207_);
1160 _tmp209_ = _tmp208_;
1161 _tmp210_ = vala_data_type_get_value_owned (_tmp209_);
1162 _tmp211_ = _tmp210_;
1163 _tmp201_ = _tmp211_;
1164 } else {
1165 _tmp201_ = FALSE;
1166 }
1167 if (_tmp201_) {
1168 ValaDataType* _tmp212_;
1169 _tmp212_ = local_type;
1170 vala_data_type_set_value_owned (_tmp212_, TRUE);
1171 }
1172 _tmp213_ = vala_code_context_get_experimental_non_null (context);
1173 _tmp214_ = _tmp213_;
1174 if (_tmp214_) {
1175 ValaDataType* _tmp215_;
1176 gboolean _tmp216_;
1177 gboolean _tmp217_;
1178 _tmp215_ = local_type;
1179 _tmp216_ = vala_data_type_get_nullable (_tmp215_);
1180 _tmp217_ = _tmp216_;
1181 if (!_tmp217_) {
1182 ValaExpression* _tmp218_;
1183 ValaExpression* _tmp219_;
1184 ValaSourceReference* _tmp220_;
1185 ValaSourceReference* _tmp221_;
1186 gboolean _tmp222_ = FALSE;
1187 ValaExpression* _tmp223_;
1188 ValaExpression* _tmp224_;
1189 ValaDataType* _tmp225_;
1190 ValaDataType* _tmp226_;
1191 _tmp218_ = vala_binary_expression_get_left (self);
1192 _tmp219_ = _tmp218_;
1193 _tmp220_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp219_);
1194 _tmp221_ = _tmp220_;
1195 vala_report_warning (_tmp221_, "left operand is never null");
1196 _tmp223_ = vala_binary_expression_get_right (self);
1197 _tmp224_ = _tmp223_;
1198 _tmp225_ = vala_expression_get_value_type (_tmp224_);
1199 _tmp226_ = _tmp225_;
1200 if (_tmp226_ != NULL) {
1201 ValaExpression* _tmp227_;
1202 ValaExpression* _tmp228_;
1203 ValaDataType* _tmp229_;
1204 ValaDataType* _tmp230_;
1205 gboolean _tmp231_;
1206 gboolean _tmp232_;
1207 _tmp227_ = vala_binary_expression_get_right (self);
1208 _tmp228_ = _tmp227_;
1209 _tmp229_ = vala_expression_get_value_type (_tmp228_);
1210 _tmp230_ = _tmp229_;
1211 _tmp231_ = vala_data_type_get_nullable (_tmp230_);
1212 _tmp232_ = _tmp231_;
1213 _tmp222_ = _tmp232_;
1214 } else {
1215 _tmp222_ = FALSE;
1216 }
1217 if (_tmp222_) {
1218 ValaDataType* _tmp233_;
1219 _tmp233_ = local_type;
1220 vala_data_type_set_nullable (_tmp233_, TRUE);
1221 cast_non_null = TRUE;
1222 }
1223 } else {
1224 gboolean _tmp234_ = FALSE;
1225 ValaExpression* _tmp235_;
1226 ValaExpression* _tmp236_;
1227 ValaDataType* _tmp237_;
1228 ValaDataType* _tmp238_;
1229 _tmp235_ = vala_binary_expression_get_right (self);
1230 _tmp236_ = _tmp235_;
1231 _tmp237_ = vala_expression_get_value_type (_tmp236_);
1232 _tmp238_ = _tmp237_;
1233 if (_tmp238_ != NULL) {
1234 ValaExpression* _tmp239_;
1235 ValaExpression* _tmp240_;
1236 ValaDataType* _tmp241_;
1237 ValaDataType* _tmp242_;
1238 gboolean _tmp243_;
1239 gboolean _tmp244_;
1240 _tmp239_ = vala_binary_expression_get_right (self);
1241 _tmp240_ = _tmp239_;
1242 _tmp241_ = vala_expression_get_value_type (_tmp240_);
1243 _tmp242_ = _tmp241_;
1244 _tmp243_ = vala_data_type_get_nullable (_tmp242_);
1245 _tmp244_ = _tmp243_;
1246 _tmp234_ = !_tmp244_;
1247 } else {
1248 _tmp234_ = FALSE;
1249 }
1250 if (_tmp234_) {
1251 cast_non_null = TRUE;
1252 }
1253 }
1254 }
1255 } else {
1256 ValaExpression* _tmp245_;
1257 ValaExpression* _tmp246_;
1258 ValaDataType* _tmp247_;
1259 ValaDataType* _tmp248_;
1260 _tmp245_ = vala_binary_expression_get_right (self);
1261 _tmp246_ = _tmp245_;
1262 _tmp247_ = vala_expression_get_value_type (_tmp246_);
1263 _tmp248_ = _tmp247_;
1264 if (_tmp248_ != NULL) {
1265 ValaExpression* _tmp249_;
1266 ValaExpression* _tmp250_;
1267 ValaDataType* _tmp251_;
1268 ValaDataType* _tmp252_;
1269 ValaDataType* _tmp253_;
1270 _tmp249_ = vala_binary_expression_get_right (self);
1271 _tmp250_ = _tmp249_;
1272 _tmp251_ = vala_expression_get_value_type (_tmp250_);
1273 _tmp252_ = _tmp251_;
1274 _tmp253_ = vala_data_type_copy (_tmp252_);
1275 _vala_code_node_unref0 (local_type);
1276 local_type = _tmp253_;
1277 }
1278 }
1279 }
1280 _tmp256_ = local_type;
1281 if (_tmp256_ != NULL) {
1282 ValaExpression* _tmp257_;
1283 ValaExpression* _tmp258_;
1284 ValaDataType* _tmp259_;
1285 ValaDataType* _tmp260_;
1286 _tmp257_ = vala_binary_expression_get_right (self);
1287 _tmp258_ = _tmp257_;
1288 _tmp259_ = vala_expression_get_value_type (_tmp258_);
1289 _tmp260_ = _tmp259_;
1290 _tmp255_ = VALA_IS_VALUE_TYPE (_tmp260_);
1291 } else {
1292 _tmp255_ = FALSE;
1293 }
1294 if (_tmp255_) {
1295 ValaExpression* _tmp261_;
1296 ValaExpression* _tmp262_;
1297 ValaDataType* _tmp263_;
1298 ValaDataType* _tmp264_;
1299 gboolean _tmp265_;
1300 gboolean _tmp266_;
1301 _tmp261_ = vala_binary_expression_get_right (self);
1302 _tmp262_ = _tmp261_;
1303 _tmp263_ = vala_expression_get_value_type (_tmp262_);
1304 _tmp264_ = _tmp263_;
1305 _tmp265_ = vala_data_type_get_nullable (_tmp264_);
1306 _tmp266_ = _tmp265_;
1307 _tmp254_ = !_tmp266_;
1308 } else {
1309 _tmp254_ = FALSE;
1310 }
1311 if (_tmp254_) {
1312 ValaDataType* _tmp267_;
1313 _tmp267_ = local_type;
1314 vala_data_type_set_value_owned (_tmp267_, TRUE);
1315 }
1316 _tmp268_ = local_type;
1317 _tmp269_ = temp_name;
1318 _tmp270_ = vala_binary_expression_get_left (self);
1319 _tmp271_ = _tmp270_;
1320 _tmp272_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1321 _tmp273_ = _tmp272_;
1322 _tmp274_ = vala_local_variable_new (_tmp268_, _tmp269_, _tmp271_, _tmp273_);
1323 local = _tmp274_;
1324 _tmp275_ = local;
1325 _tmp276_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1326 _tmp277_ = _tmp276_;
1327 _tmp278_ = vala_declaration_statement_new ((ValaSymbol*) _tmp275_, _tmp277_);
1328 decl = _tmp278_;
1329 _tmp279_ = vala_code_context_get_analyzer (context);
1330 _tmp280_ = _tmp279_;
1331 _tmp281_ = _tmp280_->insert_block;
1332 _tmp282_ = decl;
1333 vala_expression_insert_statement ((ValaExpression*) self, _tmp281_, (ValaStatement*) _tmp282_);
1334 _tmp283_ = decl;
1335 if (!vala_code_node_check ((ValaCodeNode*) _tmp283_, context)) {
1336 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
1337 result = FALSE;
1338 _vala_code_node_unref0 (decl);
1339 _vala_code_node_unref0 (local);
1340 _vala_code_node_unref0 (local_type);
1341 _vala_code_node_unref0 (true_block);
1342 _vala_code_node_unref0 (right_decl);
1343 _vala_code_node_unref0 (right_local);
1344 _g_free0 (temp_name);
1345 return result;
1346 }
1347 _tmp284_ = local;
1348 _tmp285_ = vala_symbol_get_name ((ValaSymbol*) _tmp284_);
1349 _tmp286_ = _tmp285_;
1350 _tmp287_ = vala_binary_expression_get_right (self);
1351 _tmp288_ = _tmp287_;
1352 _tmp289_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp288_);
1353 _tmp290_ = _tmp289_;
1354 _tmp291_ = vala_member_access_new_simple (_tmp286_, _tmp290_);
1355 _tmp292_ = _tmp291_;
1356 _tmp293_ = vala_binary_expression_get_right (self);
1357 _tmp294_ = _tmp293_;
1358 _tmp295_ = vala_binary_expression_get_right (self);
1359 _tmp296_ = _tmp295_;
1360 _tmp297_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp296_);
1361 _tmp298_ = _tmp297_;
1362 _tmp299_ = vala_assignment_new ((ValaExpression*) _tmp292_, _tmp294_, VALA_ASSIGNMENT_OPERATOR_SIMPLE, _tmp298_);
1363 _tmp300_ = _tmp299_;
1364 _tmp301_ = vala_binary_expression_get_right (self);
1365 _tmp302_ = _tmp301_;
1366 _tmp303_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp302_);
1367 _tmp304_ = _tmp303_;
1368 _tmp305_ = vala_expression_statement_new ((ValaExpression*) _tmp300_, _tmp304_);
1369 _tmp306_ = _tmp305_;
1370 _vala_code_node_unref0 (_tmp300_);
1371 _vala_code_node_unref0 (_tmp292_);
1372 right_stmt = _tmp306_;
1373 _tmp307_ = true_block;
1374 _tmp308_ = right_local;
1375 vala_block_remove_local_variable (_tmp307_, _tmp308_);
1376 _tmp309_ = true_block;
1377 _tmp310_ = right_decl;
1378 _tmp311_ = right_stmt;
1379 vala_block_replace_statement (_tmp309_, (ValaStatement*) _tmp310_, (ValaStatement*) _tmp311_);
1380 _tmp312_ = right_stmt;
1381 if (!vala_code_node_check ((ValaCodeNode*) _tmp312_, context)) {
1382 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
1383 result = FALSE;
1384 _vala_code_node_unref0 (right_stmt);
1385 _vala_code_node_unref0 (decl);
1386 _vala_code_node_unref0 (local);
1387 _vala_code_node_unref0 (local_type);
1388 _vala_code_node_unref0 (true_block);
1389 _vala_code_node_unref0 (right_decl);
1390 _vala_code_node_unref0 (right_local);
1391 _g_free0 (temp_name);
1392 return result;
1393 }
1394 _tmp313_ = local;
1395 _tmp314_ = vala_symbol_get_name ((ValaSymbol*) _tmp313_);
1396 _tmp315_ = _tmp314_;
1397 _tmp316_ = vala_binary_expression_get_left (self);
1398 _tmp317_ = _tmp316_;
1399 _tmp318_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp317_);
1400 _tmp319_ = _tmp318_;
1401 _tmp320_ = vala_member_access_new_simple (_tmp315_, _tmp319_);
1402 _tmp321_ = _tmp320_;
1403 _tmp322_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1404 _tmp323_ = _tmp322_;
1405 _tmp324_ = vala_null_literal_new (_tmp323_);
1406 _tmp325_ = _tmp324_;
1407 _tmp326_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1408 _tmp327_ = _tmp326_;
1409 _tmp328_ = vala_binary_expression_new (VALA_BINARY_OPERATOR_EQUALITY, (ValaExpression*) _tmp321_, (ValaExpression*) _tmp325_, _tmp327_);
1410 _tmp329_ = _tmp328_;
1411 _vala_code_node_unref0 (_tmp325_);
1412 _vala_code_node_unref0 (_tmp321_);
1413 cond = _tmp329_;
1414 _tmp330_ = cond;
1415 _tmp331_ = true_block;
1416 _tmp332_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1417 _tmp333_ = _tmp332_;
1418 _tmp334_ = vala_if_statement_new ((ValaExpression*) _tmp330_, _tmp331_, NULL, _tmp333_);
1419 if_stmt = _tmp334_;
1420 _tmp335_ = vala_code_context_get_analyzer (context);
1421 _tmp336_ = _tmp335_;
1422 _tmp337_ = _tmp336_->insert_block;
1423 _tmp338_ = if_stmt;
1424 vala_expression_insert_statement ((ValaExpression*) self, _tmp337_, (ValaStatement*) _tmp338_);
1425 _tmp339_ = if_stmt;
1426 if (!vala_code_node_check ((ValaCodeNode*) _tmp339_, context)) {
1427 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
1428 result = FALSE;
1429 _vala_code_node_unref0 (if_stmt);
1430 _vala_code_node_unref0 (cond);
1431 _vala_code_node_unref0 (right_stmt);
1432 _vala_code_node_unref0 (decl);
1433 _vala_code_node_unref0 (local);
1434 _vala_code_node_unref0 (local_type);
1435 _vala_code_node_unref0 (true_block);
1436 _vala_code_node_unref0 (right_decl);
1437 _vala_code_node_unref0 (right_local);
1438 _g_free0 (temp_name);
1439 return result;
1440 }
1441 _tmp340_ = local;
1442 _tmp341_ = vala_expression_get_target_type ((ValaExpression*) self);
1443 _tmp342_ = _tmp341_;
1444 _tmp343_ = vala_semantic_analyzer_create_temp_access (_tmp340_, _tmp342_);
1445 replace_expr = _tmp343_;
1446 if (cast_non_null) {
1447 ValaExpression* _tmp345_;
1448 ValaDataType* _tmp346_;
1449 ValaDataType* _tmp347_;
1450 _tmp345_ = replace_expr;
1451 _tmp346_ = vala_expression_get_target_type (_tmp345_);
1452 _tmp347_ = _tmp346_;
1453 _tmp344_ = _tmp347_ != NULL;
1454 } else {
1455 _tmp344_ = FALSE;
1456 }
1457 if (_tmp344_) {
1458 ValaCastExpression* cast = NULL;
1459 ValaExpression* _tmp348_;
1460 ValaSourceReference* _tmp349_;
1461 ValaSourceReference* _tmp350_;
1462 ValaCastExpression* _tmp351_;
1463 ValaCastExpression* _tmp352_;
1464 ValaExpression* _tmp353_;
1465 ValaDataType* _tmp354_;
1466 ValaDataType* _tmp355_;
1467 ValaDataType* _tmp356_;
1468 ValaDataType* _tmp357_;
1469 ValaCastExpression* _tmp358_;
1470 ValaDataType* _tmp359_;
1471 ValaDataType* _tmp360_;
1472 ValaCastExpression* _tmp361_;
1473 ValaExpression* _tmp362_;
1474 _tmp348_ = replace_expr;
1475 _tmp349_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
1476 _tmp350_ = _tmp349_;
1477 _tmp351_ = vala_cast_expression_new_non_null (_tmp348_, _tmp350_);
1478 cast = _tmp351_;
1479 _tmp352_ = cast;
1480 _tmp353_ = replace_expr;
1481 _tmp354_ = vala_expression_get_target_type (_tmp353_);
1482 _tmp355_ = _tmp354_;
1483 _tmp356_ = vala_data_type_copy (_tmp355_);
1484 _tmp357_ = _tmp356_;
1485 vala_expression_set_target_type ((ValaExpression*) _tmp352_, _tmp357_);
1486 _vala_code_node_unref0 (_tmp357_);
1487 _tmp358_ = cast;
1488 _tmp359_ = vala_expression_get_target_type ((ValaExpression*) _tmp358_);
1489 _tmp360_ = _tmp359_;
1490 vala_data_type_set_nullable (_tmp360_, FALSE);
1491 _tmp361_ = cast;
1492 _tmp362_ = _vala_code_node_ref0 ((ValaExpression*) _tmp361_);
1493 _vala_code_node_unref0 (replace_expr);
1494 replace_expr = _tmp362_;
1495 _vala_code_node_unref0 (cast);
1496 }
1497 _tmp363_ = vala_code_node_get_parent_node ((ValaCodeNode*) self);
1498 _tmp364_ = _tmp363_;
1499 _tmp365_ = replace_expr;
1500 vala_code_node_replace_expression (_tmp364_, (ValaExpression*) self, _tmp365_);
1501 _tmp366_ = replace_expr;
1502 vala_code_node_check ((ValaCodeNode*) _tmp366_, context);
1503 result = TRUE;
1504 _vala_code_node_unref0 (replace_expr);
1505 _vala_code_node_unref0 (if_stmt);
1506 _vala_code_node_unref0 (cond);
1507 _vala_code_node_unref0 (right_stmt);
1508 _vala_code_node_unref0 (decl);
1509 _vala_code_node_unref0 (local);
1510 _vala_code_node_unref0 (local_type);
1511 _vala_code_node_unref0 (true_block);
1512 _vala_code_node_unref0 (right_decl);
1513 _vala_code_node_unref0 (right_local);
1514 _g_free0 (temp_name);
1515 return result;
1516 }
1517 _tmp369_ = vala_expression_get_target_type ((ValaExpression*) self);
1518 _tmp370_ = _tmp369_;
1519 if (_tmp370_ != NULL) {
1520 ValaDataType* _tmp371_;
1521 ValaDataType* _tmp372_;
1522 ValaTypeSymbol* _tmp373_;
1523 ValaTypeSymbol* _tmp374_;
1524 _tmp371_ = vala_expression_get_target_type ((ValaExpression*) self);
1525 _tmp372_ = _tmp371_;
1526 _tmp373_ = vala_data_type_get_type_symbol (_tmp372_);
1527 _tmp374_ = _tmp373_;
1528 _tmp368_ = VALA_IS_ENUM (_tmp374_);
1529 } else {
1530 _tmp368_ = FALSE;
1531 }
1532 if (_tmp368_) {
1533 gboolean _tmp375_ = FALSE;
1534 ValaBinaryOperator _tmp376_;
1535 _tmp376_ = self->priv->_operator;
1536 if (_tmp376_ == VALA_BINARY_OPERATOR_BITWISE_AND) {
1537 _tmp375_ = TRUE;
1538 } else {
1539 ValaBinaryOperator _tmp377_;
1540 _tmp377_ = self->priv->_operator;
1541 _tmp375_ = _tmp377_ == VALA_BINARY_OPERATOR_BITWISE_OR;
1542 }
1543 _tmp367_ = _tmp375_;
1544 } else {
1545 _tmp367_ = FALSE;
1546 }
1547 if (_tmp367_) {
1548 ValaExpression* _tmp378_;
1549 ValaExpression* _tmp379_;
1550 ValaDataType* _tmp380_;
1551 ValaDataType* _tmp381_;
1552 ValaDataType* _tmp382_;
1553 ValaDataType* _tmp383_;
1554 ValaExpression* _tmp384_;
1555 ValaExpression* _tmp385_;
1556 ValaDataType* _tmp386_;
1557 ValaDataType* _tmp387_;
1558 ValaDataType* _tmp388_;
1559 ValaDataType* _tmp389_;
1560 _tmp378_ = vala_binary_expression_get_left (self);
1561 _tmp379_ = _tmp378_;
1562 _tmp380_ = vala_expression_get_target_type ((ValaExpression*) self);
1563 _tmp381_ = _tmp380_;
1564 _tmp382_ = vala_data_type_copy (_tmp381_);
1565 _tmp383_ = _tmp382_;
1566 vala_expression_set_target_type (_tmp379_, _tmp383_);
1567 _vala_code_node_unref0 (_tmp383_);
1568 _tmp384_ = vala_binary_expression_get_right (self);
1569 _tmp385_ = _tmp384_;
1570 _tmp386_ = vala_expression_get_target_type ((ValaExpression*) self);
1571 _tmp387_ = _tmp386_;
1572 _tmp388_ = vala_data_type_copy (_tmp387_);
1573 _tmp389_ = _tmp388_;
1574 vala_expression_set_target_type (_tmp385_, _tmp389_);
1575 _vala_code_node_unref0 (_tmp389_);
1576 } else {
1577 ValaBinaryOperator _tmp390_;
1578 _tmp390_ = self->priv->_operator;
1579 if (_tmp390_ == VALA_BINARY_OPERATOR_IN) {
1580 ValaExpression* _tmp391_;
1581 ValaExpression* _tmp392_;
1582 ValaExpression* _tmp393_;
1583 ValaExpression* _tmp394_;
1584 ValaDataType* _tmp395_;
1585 ValaDataType* _tmp396_;
1586 ValaTypeSymbol* _tmp397_;
1587 ValaTypeSymbol* _tmp398_;
1588 _tmp391_ = vala_binary_expression_get_right (self);
1589 _tmp392_ = _tmp391_;
1590 vala_code_node_check ((ValaCodeNode*) _tmp392_, context);
1591 _tmp393_ = vala_binary_expression_get_right (self);
1592 _tmp394_ = _tmp393_;
1593 _tmp395_ = vala_expression_get_value_type (_tmp394_);
1594 _tmp396_ = _tmp395_;
1595 _tmp397_ = vala_data_type_get_type_symbol (_tmp396_);
1596 _tmp398_ = _tmp397_;
1597 if (VALA_IS_ENUM (_tmp398_)) {
1598 ValaExpression* _tmp399_;
1599 ValaExpression* _tmp400_;
1600 ValaExpression* _tmp401_;
1601 ValaExpression* _tmp402_;
1602 ValaDataType* _tmp403_;
1603 ValaDataType* _tmp404_;
1604 ValaDataType* _tmp405_;
1605 ValaDataType* _tmp406_;
1606 _tmp399_ = vala_binary_expression_get_left (self);
1607 _tmp400_ = _tmp399_;
1608 _tmp401_ = vala_binary_expression_get_right (self);
1609 _tmp402_ = _tmp401_;
1610 _tmp403_ = vala_expression_get_value_type (_tmp402_);
1611 _tmp404_ = _tmp403_;
1612 _tmp405_ = vala_data_type_copy (_tmp404_);
1613 _tmp406_ = _tmp405_;
1614 vala_expression_set_target_type (_tmp400_, _tmp406_);
1615 _vala_code_node_unref0 (_tmp406_);
1616 }
1617 }
1618 }
1619 _tmp407_ = vala_binary_expression_get_left (self);
1620 _tmp408_ = _tmp407_;
1621 vala_code_node_check ((ValaCodeNode*) _tmp408_, context);
1622 _tmp411_ = vala_binary_expression_get_left (self);
1623 _tmp412_ = _tmp411_;
1624 _tmp413_ = vala_expression_get_value_type (_tmp412_);
1625 _tmp414_ = _tmp413_;
1626 if (_tmp414_ != NULL) {
1627 ValaExpression* _tmp415_;
1628 ValaExpression* _tmp416_;
1629 ValaDataType* _tmp417_;
1630 ValaDataType* _tmp418_;
1631 ValaTypeSymbol* _tmp419_;
1632 ValaTypeSymbol* _tmp420_;
1633 _tmp415_ = vala_binary_expression_get_left (self);
1634 _tmp416_ = _tmp415_;
1635 _tmp417_ = vala_expression_get_value_type (_tmp416_);
1636 _tmp418_ = _tmp417_;
1637 _tmp419_ = vala_data_type_get_type_symbol (_tmp418_);
1638 _tmp420_ = _tmp419_;
1639 _tmp410_ = VALA_IS_ENUM (_tmp420_);
1640 } else {
1641 _tmp410_ = FALSE;
1642 }
1643 if (_tmp410_) {
1644 gboolean _tmp421_ = FALSE;
1645 ValaBinaryOperator _tmp422_;
1646 _tmp422_ = self->priv->_operator;
1647 if (_tmp422_ == VALA_BINARY_OPERATOR_EQUALITY) {
1648 _tmp421_ = TRUE;
1649 } else {
1650 ValaBinaryOperator _tmp423_;
1651 _tmp423_ = self->priv->_operator;
1652 _tmp421_ = _tmp423_ == VALA_BINARY_OPERATOR_INEQUALITY;
1653 }
1654 _tmp409_ = _tmp421_;
1655 } else {
1656 _tmp409_ = FALSE;
1657 }
1658 if (_tmp409_) {
1659 ValaExpression* _tmp424_;
1660 ValaExpression* _tmp425_;
1661 ValaExpression* _tmp426_;
1662 ValaExpression* _tmp427_;
1663 ValaDataType* _tmp428_;
1664 ValaDataType* _tmp429_;
1665 ValaDataType* _tmp430_;
1666 ValaDataType* _tmp431_;
1667 _tmp424_ = vala_binary_expression_get_right (self);
1668 _tmp425_ = _tmp424_;
1669 _tmp426_ = vala_binary_expression_get_left (self);
1670 _tmp427_ = _tmp426_;
1671 _tmp428_ = vala_expression_get_value_type (_tmp427_);
1672 _tmp429_ = _tmp428_;
1673 _tmp430_ = vala_data_type_copy (_tmp429_);
1674 _tmp431_ = _tmp430_;
1675 vala_expression_set_target_type (_tmp425_, _tmp431_);
1676 _vala_code_node_unref0 (_tmp431_);
1677 }
1678 _tmp432_ = vala_binary_expression_get_right (self);
1679 _tmp433_ = _tmp432_;
1680 vala_code_node_check ((ValaCodeNode*) _tmp433_, context);
1681 _tmp436_ = vala_binary_expression_get_right (self);
1682 _tmp437_ = _tmp436_;
1683 _tmp438_ = vala_expression_get_value_type (_tmp437_);
1684 _tmp439_ = _tmp438_;
1685 if (_tmp439_ != NULL) {
1686 ValaExpression* _tmp440_;
1687 ValaExpression* _tmp441_;
1688 ValaDataType* _tmp442_;
1689 ValaDataType* _tmp443_;
1690 ValaTypeSymbol* _tmp444_;
1691 ValaTypeSymbol* _tmp445_;
1692 _tmp440_ = vala_binary_expression_get_right (self);
1693 _tmp441_ = _tmp440_;
1694 _tmp442_ = vala_expression_get_value_type (_tmp441_);
1695 _tmp443_ = _tmp442_;
1696 _tmp444_ = vala_data_type_get_type_symbol (_tmp443_);
1697 _tmp445_ = _tmp444_;
1698 _tmp435_ = VALA_IS_ENUM (_tmp445_);
1699 } else {
1700 _tmp435_ = FALSE;
1701 }
1702 if (_tmp435_) {
1703 gboolean _tmp446_ = FALSE;
1704 ValaBinaryOperator _tmp447_;
1705 _tmp447_ = self->priv->_operator;
1706 if (_tmp447_ == VALA_BINARY_OPERATOR_EQUALITY) {
1707 _tmp446_ = TRUE;
1708 } else {
1709 ValaBinaryOperator _tmp448_;
1710 _tmp448_ = self->priv->_operator;
1711 _tmp446_ = _tmp448_ == VALA_BINARY_OPERATOR_INEQUALITY;
1712 }
1713 _tmp434_ = _tmp446_;
1714 } else {
1715 _tmp434_ = FALSE;
1716 }
1717 if (_tmp434_) {
1718 ValaExpression* _tmp449_;
1719 ValaExpression* _tmp450_;
1720 ValaExpression* _tmp451_;
1721 ValaExpression* _tmp452_;
1722 ValaDataType* _tmp453_;
1723 ValaDataType* _tmp454_;
1724 ValaDataType* _tmp455_;
1725 ValaDataType* _tmp456_;
1726 _tmp449_ = vala_binary_expression_get_left (self);
1727 _tmp450_ = _tmp449_;
1728 _tmp451_ = vala_binary_expression_get_right (self);
1729 _tmp452_ = _tmp451_;
1730 _tmp453_ = vala_expression_get_value_type (_tmp452_);
1731 _tmp454_ = _tmp453_;
1732 _tmp455_ = vala_data_type_copy (_tmp454_);
1733 _tmp456_ = _tmp455_;
1734 vala_expression_set_target_type (_tmp450_, _tmp456_);
1735 _vala_code_node_unref0 (_tmp456_);
1736 }
1737 _tmp458_ = vala_binary_expression_get_left (self);
1738 _tmp459_ = _tmp458_;
1739 if (!vala_code_node_check ((ValaCodeNode*) _tmp459_, context)) {
1740 _tmp457_ = TRUE;
1741 } else {
1742 ValaExpression* _tmp460_;
1743 ValaExpression* _tmp461_;
1744 _tmp460_ = vala_binary_expression_get_right (self);
1745 _tmp461_ = _tmp460_;
1746 _tmp457_ = !vala_code_node_check ((ValaCodeNode*) _tmp461_, context);
1747 }
1748 if (_tmp457_) {
1749 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
1750 result = FALSE;
1751 return result;
1752 }
1753 _tmp462_ = vala_binary_expression_get_left (self);
1754 _tmp463_ = _tmp462_;
1755 _tmp464_ = vala_expression_get_value_type (_tmp463_);
1756 _tmp465_ = _tmp464_;
1757 if (_tmp465_ == NULL) {
1758 ValaExpression* _tmp466_;
1759 ValaExpression* _tmp467_;
1760 ValaSourceReference* _tmp468_;
1761 ValaSourceReference* _tmp469_;
1762 _tmp466_ = vala_binary_expression_get_left (self);
1763 _tmp467_ = _tmp466_;
1764 _tmp468_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp467_);
1765 _tmp469_ = _tmp468_;
1766 vala_report_error (_tmp469_, "invalid left operand");
1767 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
1768 result = FALSE;
1769 return result;
1770 }
1771 _tmp471_ = self->priv->_operator;
1772 if (_tmp471_ != VALA_BINARY_OPERATOR_IN) {
1773 ValaExpression* _tmp472_;
1774 ValaExpression* _tmp473_;
1775 ValaDataType* _tmp474_;
1776 ValaDataType* _tmp475_;
1777 _tmp472_ = vala_binary_expression_get_right (self);
1778 _tmp473_ = _tmp472_;
1779 _tmp474_ = vala_expression_get_value_type (_tmp473_);
1780 _tmp475_ = _tmp474_;
1781 _tmp470_ = _tmp475_ == NULL;
1782 } else {
1783 _tmp470_ = FALSE;
1784 }
1785 if (_tmp470_) {
1786 ValaExpression* _tmp476_;
1787 ValaExpression* _tmp477_;
1788 ValaSourceReference* _tmp478_;
1789 ValaSourceReference* _tmp479_;
1790 _tmp476_ = vala_binary_expression_get_right (self);
1791 _tmp477_ = _tmp476_;
1792 _tmp478_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp477_);
1793 _tmp479_ = _tmp478_;
1794 vala_report_error (_tmp479_, "invalid right operand");
1795 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
1796 result = FALSE;
1797 return result;
1798 }
1799 _tmp481_ = vala_binary_expression_get_left (self);
1800 _tmp482_ = _tmp481_;
1801 _tmp483_ = vala_expression_get_value_type (_tmp482_);
1802 _tmp484_ = _tmp483_;
1803 if (VALA_IS_FIELD_PROTOTYPE (_tmp484_)) {
1804 _tmp480_ = TRUE;
1805 } else {
1806 ValaExpression* _tmp485_;
1807 ValaExpression* _tmp486_;
1808 ValaDataType* _tmp487_;
1809 ValaDataType* _tmp488_;
1810 _tmp485_ = vala_binary_expression_get_left (self);
1811 _tmp486_ = _tmp485_;
1812 _tmp487_ = vala_expression_get_value_type (_tmp486_);
1813 _tmp488_ = _tmp487_;
1814 _tmp480_ = VALA_IS_PROPERTY_PROTOTYPE (_tmp488_);
1815 }
1816 if (_tmp480_) {
1817 ValaExpression* _tmp489_;
1818 ValaExpression* _tmp490_;
1819 ValaSourceReference* _tmp491_;
1820 ValaSourceReference* _tmp492_;
1821 ValaExpression* _tmp493_;
1822 ValaExpression* _tmp494_;
1823 ValaSymbol* _tmp495_;
1824 ValaSymbol* _tmp496_;
1825 gchar* _tmp497_;
1826 gchar* _tmp498_;
1827 gchar* _tmp499_;
1828 gchar* _tmp500_;
1829 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
1830 _tmp489_ = vala_binary_expression_get_left (self);
1831 _tmp490_ = _tmp489_;
1832 _tmp491_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp490_);
1833 _tmp492_ = _tmp491_;
1834 _tmp493_ = vala_binary_expression_get_left (self);
1835 _tmp494_ = _tmp493_;
1836 _tmp495_ = vala_expression_get_symbol_reference (_tmp494_);
1837 _tmp496_ = _tmp495_;
1838 _tmp497_ = vala_symbol_get_full_name (_tmp496_);
1839 _tmp498_ = _tmp497_;
1840 _tmp499_ = g_strdup_printf ("Access to instance member `%s' denied", _tmp498_);
1841 _tmp500_ = _tmp499_;
1842 vala_report_error (_tmp492_, _tmp500_);
1843 _g_free0 (_tmp500_);
1844 _g_free0 (_tmp498_);
1845 result = FALSE;
1846 return result;
1847 }
1848 _tmp502_ = vala_binary_expression_get_right (self);
1849 _tmp503_ = _tmp502_;
1850 _tmp504_ = vala_expression_get_value_type (_tmp503_);
1851 _tmp505_ = _tmp504_;
1852 if (VALA_IS_FIELD_PROTOTYPE (_tmp505_)) {
1853 _tmp501_ = TRUE;
1854 } else {
1855 ValaExpression* _tmp506_;
1856 ValaExpression* _tmp507_;
1857 ValaDataType* _tmp508_;
1858 ValaDataType* _tmp509_;
1859 _tmp506_ = vala_binary_expression_get_right (self);
1860 _tmp507_ = _tmp506_;
1861 _tmp508_ = vala_expression_get_value_type (_tmp507_);
1862 _tmp509_ = _tmp508_;
1863 _tmp501_ = VALA_IS_PROPERTY_PROTOTYPE (_tmp509_);
1864 }
1865 if (_tmp501_) {
1866 ValaExpression* _tmp510_;
1867 ValaExpression* _tmp511_;
1868 ValaSourceReference* _tmp512_;
1869 ValaSourceReference* _tmp513_;
1870 ValaExpression* _tmp514_;
1871 ValaExpression* _tmp515_;
1872 ValaSymbol* _tmp516_;
1873 ValaSymbol* _tmp517_;
1874 gchar* _tmp518_;
1875 gchar* _tmp519_;
1876 gchar* _tmp520_;
1877 gchar* _tmp521_;
1878 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
1879 _tmp510_ = vala_binary_expression_get_right (self);
1880 _tmp511_ = _tmp510_;
1881 _tmp512_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp511_);
1882 _tmp513_ = _tmp512_;
1883 _tmp514_ = vala_binary_expression_get_right (self);
1884 _tmp515_ = _tmp514_;
1885 _tmp516_ = vala_expression_get_symbol_reference (_tmp515_);
1886 _tmp517_ = _tmp516_;
1887 _tmp518_ = vala_symbol_get_full_name (_tmp517_);
1888 _tmp519_ = _tmp518_;
1889 _tmp520_ = g_strdup_printf ("Access to instance member `%s' denied", _tmp519_);
1890 _tmp521_ = _tmp520_;
1891 vala_report_error (_tmp513_, _tmp521_);
1892 _g_free0 (_tmp521_);
1893 _g_free0 (_tmp519_);
1894 result = FALSE;
1895 return result;
1896 }
1897 _tmp522_ = vala_binary_expression_get_left (self);
1898 _tmp523_ = _tmp522_;
1899 _tmp524_ = vala_binary_expression_get_left (self);
1900 _tmp525_ = _tmp524_;
1901 _tmp526_ = vala_expression_get_value_type (_tmp525_);
1902 _tmp527_ = _tmp526_;
1903 _tmp528_ = vala_data_type_copy (_tmp527_);
1904 _tmp529_ = _tmp528_;
1905 vala_expression_set_target_type (_tmp523_, _tmp529_);
1906 _vala_code_node_unref0 (_tmp529_);
1907 _tmp530_ = vala_binary_expression_get_left (self);
1908 _tmp531_ = _tmp530_;
1909 _tmp532_ = vala_expression_get_target_type (_tmp531_);
1910 _tmp533_ = _tmp532_;
1911 vala_data_type_set_value_owned (_tmp533_, FALSE);
1912 _tmp534_ = vala_binary_expression_get_right (self);
1913 _tmp535_ = _tmp534_;
1914 _tmp536_ = vala_binary_expression_get_right (self);
1915 _tmp537_ = _tmp536_;
1916 _tmp538_ = vala_expression_get_value_type (_tmp537_);
1917 _tmp539_ = _tmp538_;
1918 _tmp540_ = vala_data_type_copy (_tmp539_);
1919 _tmp541_ = _tmp540_;
1920 vala_expression_set_target_type (_tmp535_, _tmp541_);
1921 _vala_code_node_unref0 (_tmp541_);
1922 _tmp542_ = vala_binary_expression_get_right (self);
1923 _tmp543_ = _tmp542_;
1924 _tmp544_ = vala_expression_get_target_type (_tmp543_);
1925 _tmp545_ = _tmp544_;
1926 vala_data_type_set_value_owned (_tmp545_, FALSE);
1927 _tmp548_ = self->priv->_operator;
1928 if (_tmp548_ == VALA_BINARY_OPERATOR_PLUS) {
1929 ValaExpression* _tmp549_;
1930 ValaExpression* _tmp550_;
1931 ValaDataType* _tmp551_;
1932 ValaDataType* _tmp552_;
1933 _tmp549_ = vala_binary_expression_get_left (self);
1934 _tmp550_ = _tmp549_;
1935 _tmp551_ = vala_expression_get_value_type (_tmp550_);
1936 _tmp552_ = _tmp551_;
1937 _tmp547_ = !VALA_IS_POINTER_TYPE (_tmp552_);
1938 } else {
1939 _tmp547_ = FALSE;
1940 }
1941 if (_tmp547_) {
1942 ValaExpression* _tmp553_;
1943 ValaExpression* _tmp554_;
1944 ValaDataType* _tmp555_;
1945 ValaDataType* _tmp556_;
1946 ValaSemanticAnalyzer* _tmp557_;
1947 ValaSemanticAnalyzer* _tmp558_;
1948 ValaDataType* _tmp559_;
1949 _tmp553_ = vala_binary_expression_get_left (self);
1950 _tmp554_ = _tmp553_;
1951 _tmp555_ = vala_expression_get_value_type (_tmp554_);
1952 _tmp556_ = _tmp555_;
1953 _tmp557_ = vala_code_context_get_analyzer (context);
1954 _tmp558_ = _tmp557_;
1955 _tmp559_ = _tmp558_->string_type;
1956 _tmp546_ = vala_data_type_compatible (_tmp556_, _tmp559_);
1957 } else {
1958 _tmp546_ = FALSE;
1959 }
1960 if (_tmp546_) {
1961 gboolean _tmp560_ = FALSE;
1962 ValaExpression* _tmp561_;
1963 ValaExpression* _tmp562_;
1964 ValaDataType* _tmp563_;
1965 ValaDataType* _tmp564_;
1966 ValaSemanticAnalyzer* _tmp574_;
1967 ValaSemanticAnalyzer* _tmp575_;
1968 ValaDataType* _tmp576_;
1969 ValaDataType* _tmp577_;
1970 ValaDataType* _tmp578_;
1971 gboolean _tmp579_ = FALSE;
1972 ValaExpression* _tmp580_;
1973 ValaExpression* _tmp581_;
1974 ValaDataType* _tmp588_;
1975 ValaDataType* _tmp589_;
1976 gboolean _tmp590_;
1977 gboolean _tmp591_;
1978 _tmp561_ = vala_binary_expression_get_right (self);
1979 _tmp562_ = _tmp561_;
1980 _tmp563_ = vala_expression_get_value_type (_tmp562_);
1981 _tmp564_ = _tmp563_;
1982 if (_tmp564_ == NULL) {
1983 _tmp560_ = TRUE;
1984 } else {
1985 ValaExpression* _tmp565_;
1986 ValaExpression* _tmp566_;
1987 ValaDataType* _tmp567_;
1988 ValaDataType* _tmp568_;
1989 ValaSemanticAnalyzer* _tmp569_;
1990 ValaSemanticAnalyzer* _tmp570_;
1991 ValaDataType* _tmp571_;
1992 _tmp565_ = vala_binary_expression_get_right (self);
1993 _tmp566_ = _tmp565_;
1994 _tmp567_ = vala_expression_get_value_type (_tmp566_);
1995 _tmp568_ = _tmp567_;
1996 _tmp569_ = vala_code_context_get_analyzer (context);
1997 _tmp570_ = _tmp569_;
1998 _tmp571_ = _tmp570_->string_type;
1999 _tmp560_ = !vala_data_type_compatible (_tmp568_, _tmp571_);
2000 }
2001 if (_tmp560_) {
2002 ValaSourceReference* _tmp572_;
2003 ValaSourceReference* _tmp573_;
2004 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
2005 _tmp572_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
2006 _tmp573_ = _tmp572_;
2007 vala_report_error (_tmp573_, "Operands must be strings");
2008 result = FALSE;
2009 return result;
2010 }
2011 _tmp574_ = vala_code_context_get_analyzer (context);
2012 _tmp575_ = _tmp574_;
2013 _tmp576_ = _tmp575_->string_type;
2014 _tmp577_ = vala_data_type_copy (_tmp576_);
2015 _tmp578_ = _tmp577_;
2016 vala_expression_set_value_type ((ValaExpression*) self, _tmp578_);
2017 _vala_code_node_unref0 (_tmp578_);
2018 _tmp580_ = vala_binary_expression_get_left (self);
2019 _tmp581_ = _tmp580_;
2020 if (vala_expression_is_constant (_tmp581_)) {
2021 ValaExpression* _tmp582_;
2022 ValaExpression* _tmp583_;
2023 _tmp582_ = vala_binary_expression_get_right (self);
2024 _tmp583_ = _tmp582_;
2025 _tmp579_ = vala_expression_is_constant (_tmp583_);
2026 } else {
2027 _tmp579_ = FALSE;
2028 }
2029 if (_tmp579_) {
2030 ValaDataType* _tmp584_;
2031 ValaDataType* _tmp585_;
2032 _tmp584_ = vala_expression_get_value_type ((ValaExpression*) self);
2033 _tmp585_ = _tmp584_;
2034 vala_data_type_set_value_owned (_tmp585_, FALSE);
2035 } else {
2036 ValaDataType* _tmp586_;
2037 ValaDataType* _tmp587_;
2038 _tmp586_ = vala_expression_get_value_type ((ValaExpression*) self);
2039 _tmp587_ = _tmp586_;
2040 vala_data_type_set_value_owned (_tmp587_, TRUE);
2041 }
2042 _tmp588_ = vala_expression_get_value_type ((ValaExpression*) self);
2043 _tmp589_ = _tmp588_;
2044 vala_code_node_check ((ValaCodeNode*) _tmp589_, context);
2045 _tmp590_ = vala_code_node_get_error ((ValaCodeNode*) self);
2046 _tmp591_ = _tmp590_;
2047 result = !_tmp591_;
2048 return result;
2049 } else {
2050 gboolean _tmp592_ = FALSE;
2051 ValaBinaryOperator _tmp593_;
2052 _tmp593_ = self->priv->_operator;
2053 if (_tmp593_ == VALA_BINARY_OPERATOR_PLUS) {
2054 ValaExpression* _tmp594_;
2055 ValaExpression* _tmp595_;
2056 ValaDataType* _tmp596_;
2057 ValaDataType* _tmp597_;
2058 _tmp594_ = vala_binary_expression_get_left (self);
2059 _tmp595_ = _tmp594_;
2060 _tmp596_ = vala_expression_get_value_type (_tmp595_);
2061 _tmp597_ = _tmp596_;
2062 _tmp592_ = VALA_IS_ARRAY_TYPE (_tmp597_);
2063 } else {
2064 _tmp592_ = FALSE;
2065 }
2066 if (_tmp592_) {
2067 ValaArrayType* array_type = NULL;
2068 ValaExpression* _tmp598_;
2069 ValaExpression* _tmp599_;
2070 ValaDataType* _tmp600_;
2071 ValaDataType* _tmp601_;
2072 ValaArrayType* _tmp602_;
2073 gboolean _tmp603_;
2074 gboolean _tmp604_;
2075 gboolean _tmp607_ = FALSE;
2076 ValaExpression* _tmp608_;
2077 ValaExpression* _tmp609_;
2078 ValaDataType* _tmp610_;
2079 ValaDataType* _tmp611_;
2080 ValaExpression* _tmp621_;
2081 ValaExpression* _tmp622_;
2082 ValaArrayType* _tmp623_;
2083 ValaDataType* _tmp624_;
2084 ValaDataType* _tmp625_;
2085 ValaDataType* _tmp626_;
2086 ValaDataType* _tmp627_;
2087 ValaArrayType* _tmp628_;
2088 ValaDataType* _tmp629_;
2089 ValaDataType* _tmp630_;
2090 ValaDataType* _tmp631_;
2091 ValaDataType* _tmp632_;
2092 ValaDataType* _tmp633_;
2093 ValaDataType* _tmp634_;
2094 gboolean _tmp635_;
2095 gboolean _tmp636_;
2096 _tmp598_ = vala_binary_expression_get_left (self);
2097 _tmp599_ = _tmp598_;
2098 _tmp600_ = vala_expression_get_value_type (_tmp599_);
2099 _tmp601_ = _tmp600_;
2100 array_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp601_, VALA_TYPE_ARRAY_TYPE, ValaArrayType);
2101 _tmp602_ = array_type;
2102 _tmp603_ = vala_array_type_get_inline_allocated (_tmp602_);
2103 _tmp604_ = _tmp603_;
2104 if (_tmp604_) {
2105 ValaSourceReference* _tmp605_;
2106 ValaSourceReference* _tmp606_;
2107 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
2108 _tmp605_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
2109 _tmp606_ = _tmp605_;
2110 vala_report_error (_tmp606_, "Array concatenation not supported for fixed length arrays");
2111 }
2112 _tmp608_ = vala_binary_expression_get_right (self);
2113 _tmp609_ = _tmp608_;
2114 _tmp610_ = vala_expression_get_value_type (_tmp609_);
2115 _tmp611_ = _tmp610_;
2116 if (_tmp611_ == NULL) {
2117 _tmp607_ = TRUE;
2118 } else {
2119 ValaExpression* _tmp612_;
2120 ValaExpression* _tmp613_;
2121 ValaDataType* _tmp614_;
2122 ValaDataType* _tmp615_;
2123 ValaArrayType* _tmp616_;
2124 ValaDataType* _tmp617_;
2125 ValaDataType* _tmp618_;
2126 _tmp612_ = vala_binary_expression_get_right (self);
2127 _tmp613_ = _tmp612_;
2128 _tmp614_ = vala_expression_get_value_type (_tmp613_);
2129 _tmp615_ = _tmp614_;
2130 _tmp616_ = array_type;
2131 _tmp617_ = vala_array_type_get_element_type (_tmp616_);
2132 _tmp618_ = _tmp617_;
2133 _tmp607_ = !vala_data_type_compatible (_tmp615_, _tmp618_);
2134 }
2135 if (_tmp607_) {
2136 ValaSourceReference* _tmp619_;
2137 ValaSourceReference* _tmp620_;
2138 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
2139 _tmp619_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
2140 _tmp620_ = _tmp619_;
2141 vala_report_error (_tmp620_, "Incompatible operand");
2142 result = FALSE;
2143 return result;
2144 }
2145 _tmp621_ = vala_binary_expression_get_right (self);
2146 _tmp622_ = _tmp621_;
2147 _tmp623_ = array_type;
2148 _tmp624_ = vala_array_type_get_element_type (_tmp623_);
2149 _tmp625_ = _tmp624_;
2150 _tmp626_ = vala_data_type_copy (_tmp625_);
2151 _tmp627_ = _tmp626_;
2152 vala_expression_set_target_type (_tmp622_, _tmp627_);
2153 _vala_code_node_unref0 (_tmp627_);
2154 _tmp628_ = array_type;
2155 _tmp629_ = vala_data_type_copy ((ValaDataType*) _tmp628_);
2156 _tmp630_ = _tmp629_;
2157 vala_expression_set_value_type ((ValaExpression*) self, _tmp630_);
2158 _vala_code_node_unref0 (_tmp630_);
2159 _tmp631_ = vala_expression_get_value_type ((ValaExpression*) self);
2160 _tmp632_ = _tmp631_;
2161 vala_data_type_set_value_owned (_tmp632_, TRUE);
2162 _tmp633_ = vala_expression_get_value_type ((ValaExpression*) self);
2163 _tmp634_ = _tmp633_;
2164 vala_code_node_check ((ValaCodeNode*) _tmp634_, context);
2165 _tmp635_ = vala_code_node_get_error ((ValaCodeNode*) self);
2166 _tmp636_ = _tmp635_;
2167 result = !_tmp636_;
2168 return result;
2169 }
2170 }
2171 _tmp637_ = self->priv->_operator;
2172 switch (_tmp637_) {
2173 case VALA_BINARY_OPERATOR_PLUS:
2174 case VALA_BINARY_OPERATOR_MINUS:
2175 case VALA_BINARY_OPERATOR_MUL:
2176 case VALA_BINARY_OPERATOR_DIV:
2177 {
2178 ValaExpression* _tmp638_;
2179 ValaExpression* _tmp639_;
2180 ValaDataType* _tmp640_;
2181 ValaDataType* _tmp641_;
2182 ValaDataType* _tmp684_;
2183 ValaDataType* _tmp685_;
2184 ValaDataType* _tmp697_;
2185 ValaDataType* _tmp698_;
2186 _tmp638_ = vala_binary_expression_get_left (self);
2187 _tmp639_ = _tmp638_;
2188 _tmp640_ = vala_expression_get_value_type (_tmp639_);
2189 _tmp641_ = _tmp640_;
2190 if (VALA_IS_POINTER_TYPE (_tmp641_)) {
2191 ValaPointerType* pointer_type = NULL;
2192 ValaExpression* _tmp642_;
2193 ValaExpression* _tmp643_;
2194 ValaDataType* _tmp644_;
2195 ValaDataType* _tmp645_;
2196 ValaPointerType* _tmp646_;
2197 ValaDataType* _tmp647_;
2198 ValaDataType* _tmp648_;
2199 ValaStruct* offset_type = NULL;
2200 ValaExpression* _tmp651_;
2201 ValaExpression* _tmp652_;
2202 ValaDataType* _tmp653_;
2203 ValaDataType* _tmp654_;
2204 ValaTypeSymbol* _tmp655_;
2205 ValaTypeSymbol* _tmp656_;
2206 gboolean _tmp657_ = FALSE;
2207 ValaStruct* _tmp658_;
2208 _tmp642_ = vala_binary_expression_get_left (self);
2209 _tmp643_ = _tmp642_;
2210 _tmp644_ = vala_expression_get_value_type (_tmp643_);
2211 _tmp645_ = _tmp644_;
2212 pointer_type = G_TYPE_CHECK_INSTANCE_CAST (_tmp645_, VALA_TYPE_POINTER_TYPE, ValaPointerType);
2213 _tmp646_ = pointer_type;
2214 _tmp647_ = vala_pointer_type_get_base_type (_tmp646_);
2215 _tmp648_ = _tmp647_;
2216 if (VALA_IS_VOID_TYPE (_tmp648_)) {
2217 ValaSourceReference* _tmp649_;
2218 ValaSourceReference* _tmp650_;
2219 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
2220 _tmp649_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
2221 _tmp650_ = _tmp649_;
2222 vala_report_error (_tmp650_, "Pointer arithmetic not supported for `void*'");
2223 result = FALSE;
2224 return result;
2225 }
2226 _tmp651_ = vala_binary_expression_get_right (self);
2227 _tmp652_ = _tmp651_;
2228 _tmp653_ = vala_expression_get_value_type (_tmp652_);
2229 _tmp654_ = _tmp653_;
2230 _tmp655_ = vala_data_type_get_type_symbol (_tmp654_);
2231 _tmp656_ = _tmp655_;
2232 offset_type = VALA_IS_STRUCT (_tmp656_) ? ((ValaStruct*) _tmp656_) : NULL;
2233 _tmp658_ = offset_type;
2234 if (_tmp658_ != NULL) {
2235 ValaStruct* _tmp659_;
2236 _tmp659_ = offset_type;
2237 _tmp657_ = vala_struct_is_integer_type (_tmp659_);
2238 } else {
2239 _tmp657_ = FALSE;
2240 }
2241 if (_tmp657_) {
2242 gboolean _tmp660_ = FALSE;
2243 ValaBinaryOperator _tmp661_;
2244 _tmp661_ = self->priv->_operator;
2245 if (_tmp661_ == VALA_BINARY_OPERATOR_PLUS) {
2246 _tmp660_ = TRUE;
2247 } else {
2248 ValaBinaryOperator _tmp662_;
2249 _tmp662_ = self->priv->_operator;
2250 _tmp660_ = _tmp662_ == VALA_BINARY_OPERATOR_MINUS;
2251 }
2252 if (_tmp660_) {
2253 ValaExpression* _tmp663_;
2254 ValaExpression* _tmp664_;
2255 ValaDataType* _tmp665_;
2256 ValaDataType* _tmp666_;
2257 ValaDataType* _tmp667_;
2258 ValaDataType* _tmp668_;
2259 _tmp663_ = vala_binary_expression_get_left (self);
2260 _tmp664_ = _tmp663_;
2261 _tmp665_ = vala_expression_get_value_type (_tmp664_);
2262 _tmp666_ = _tmp665_;
2263 _tmp667_ = vala_data_type_copy (_tmp666_);
2264 _tmp668_ = _tmp667_;
2265 vala_expression_set_value_type ((ValaExpression*) self, _tmp668_);
2266 _vala_code_node_unref0 (_tmp668_);
2267 }
2268 } else {
2269 ValaExpression* _tmp669_;
2270 ValaExpression* _tmp670_;
2271 ValaDataType* _tmp671_;
2272 ValaDataType* _tmp672_;
2273 _tmp669_ = vala_binary_expression_get_right (self);
2274 _tmp670_ = _tmp669_;
2275 _tmp671_ = vala_expression_get_value_type (_tmp670_);
2276 _tmp672_ = _tmp671_;
2277 if (VALA_IS_POINTER_TYPE (_tmp672_)) {
2278 ValaSemanticAnalyzer* _tmp673_;
2279 ValaSemanticAnalyzer* _tmp674_;
2280 ValaDataType* _tmp675_;
2281 _tmp673_ = vala_code_context_get_analyzer (context);
2282 _tmp674_ = _tmp673_;
2283 _tmp675_ = _tmp674_->size_t_type;
2284 vala_expression_set_value_type ((ValaExpression*) self, _tmp675_);
2285 }
2286 }
2287 } else {
2288 ValaExpression* _tmp676_;
2289 ValaExpression* _tmp677_;
2290 ValaDataType* _tmp678_;
2291 ValaDataType* _tmp679_;
2292 ValaExpression* _tmp680_;
2293 ValaExpression* _tmp681_;
2294 ValaDataType* _tmp682_;
2295 ValaDataType* _tmp683_;
2296 _tmp676_ = vala_binary_expression_get_left (self);
2297 _tmp677_ = _tmp676_;
2298 _tmp678_ = vala_expression_get_target_type (_tmp677_);
2299 _tmp679_ = _tmp678_;
2300 vala_data_type_set_nullable (_tmp679_, FALSE);
2301 _tmp680_ = vala_binary_expression_get_right (self);
2302 _tmp681_ = _tmp680_;
2303 _tmp682_ = vala_expression_get_target_type (_tmp681_);
2304 _tmp683_ = _tmp682_;
2305 vala_data_type_set_nullable (_tmp683_, FALSE);
2306 }
2307 _tmp684_ = vala_expression_get_value_type ((ValaExpression*) self);
2308 _tmp685_ = _tmp684_;
2309 if (_tmp685_ == NULL) {
2310 ValaSemanticAnalyzer* _tmp686_;
2311 ValaSemanticAnalyzer* _tmp687_;
2312 ValaExpression* _tmp688_;
2313 ValaExpression* _tmp689_;
2314 ValaDataType* _tmp690_;
2315 ValaDataType* _tmp691_;
2316 ValaExpression* _tmp692_;
2317 ValaExpression* _tmp693_;
2318 ValaDataType* _tmp694_;
2319 ValaDataType* _tmp695_;
2320 ValaDataType* _tmp696_;
2321 _tmp686_ = vala_code_context_get_analyzer (context);
2322 _tmp687_ = _tmp686_;
2323 _tmp688_ = vala_binary_expression_get_left (self);
2324 _tmp689_ = _tmp688_;
2325 _tmp690_ = vala_expression_get_target_type (_tmp689_);
2326 _tmp691_ = _tmp690_;
2327 _tmp692_ = vala_binary_expression_get_right (self);
2328 _tmp693_ = _tmp692_;
2329 _tmp694_ = vala_expression_get_target_type (_tmp693_);
2330 _tmp695_ = _tmp694_;
2331 _tmp696_ = vala_semantic_analyzer_get_arithmetic_result_type (_tmp687_, _tmp691_, _tmp695_);
2332 vala_expression_set_value_type ((ValaExpression*) self, _tmp696_);
2333 }
2334 _tmp697_ = vala_expression_get_value_type ((ValaExpression*) self);
2335 _tmp698_ = _tmp697_;
2336 if (_tmp698_ == NULL) {
2337 ValaSourceReference* _tmp699_;
2338 ValaSourceReference* _tmp700_;
2339 ValaExpression* _tmp701_;
2340 ValaExpression* _tmp702_;
2341 ValaDataType* _tmp703_;
2342 ValaDataType* _tmp704_;
2343 gchar* _tmp705_;
2344 gchar* _tmp706_;
2345 ValaExpression* _tmp707_;
2346 ValaExpression* _tmp708_;
2347 ValaDataType* _tmp709_;
2348 ValaDataType* _tmp710_;
2349 gchar* _tmp711_;
2350 gchar* _tmp712_;
2351 gchar* _tmp713_;
2352 gchar* _tmp714_;
2353 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
2354 _tmp699_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
2355 _tmp700_ = _tmp699_;
2356 _tmp701_ = vala_binary_expression_get_left (self);
2357 _tmp702_ = _tmp701_;
2358 _tmp703_ = vala_expression_get_value_type (_tmp702_);
2359 _tmp704_ = _tmp703_;
2360 _tmp705_ = vala_code_node_to_string ((ValaCodeNode*) _tmp704_);
2361 _tmp706_ = _tmp705_;
2362 _tmp707_ = vala_binary_expression_get_right (self);
2363 _tmp708_ = _tmp707_;
2364 _tmp709_ = vala_expression_get_value_type (_tmp708_);
2365 _tmp710_ = _tmp709_;
2366 _tmp711_ = vala_code_node_to_string ((ValaCodeNode*) _tmp710_);
2367 _tmp712_ = _tmp711_;
2368 _tmp713_ = g_strdup_printf ("Arithmetic operation not supported for types `%s' and `%s'", _tmp706_, _tmp712_);
2369 _tmp714_ = _tmp713_;
2370 vala_report_error (_tmp700_, _tmp714_);
2371 _g_free0 (_tmp714_);
2372 _g_free0 (_tmp712_);
2373 _g_free0 (_tmp706_);
2374 result = FALSE;
2375 return result;
2376 }
2377 break;
2378 }
2379 case VALA_BINARY_OPERATOR_MOD:
2380 case VALA_BINARY_OPERATOR_SHIFT_LEFT:
2381 case VALA_BINARY_OPERATOR_SHIFT_RIGHT:
2382 {
2383 ValaExpression* _tmp715_;
2384 ValaExpression* _tmp716_;
2385 ValaDataType* _tmp717_;
2386 ValaDataType* _tmp718_;
2387 ValaExpression* _tmp719_;
2388 ValaExpression* _tmp720_;
2389 ValaDataType* _tmp721_;
2390 ValaDataType* _tmp722_;
2391 ValaSemanticAnalyzer* _tmp723_;
2392 ValaSemanticAnalyzer* _tmp724_;
2393 ValaExpression* _tmp725_;
2394 ValaExpression* _tmp726_;
2395 ValaDataType* _tmp727_;
2396 ValaDataType* _tmp728_;
2397 ValaExpression* _tmp729_;
2398 ValaExpression* _tmp730_;
2399 ValaDataType* _tmp731_;
2400 ValaDataType* _tmp732_;
2401 ValaDataType* _tmp733_;
2402 ValaDataType* _tmp734_;
2403 ValaDataType* _tmp735_;
2404 _tmp715_ = vala_binary_expression_get_left (self);
2405 _tmp716_ = _tmp715_;
2406 _tmp717_ = vala_expression_get_target_type (_tmp716_);
2407 _tmp718_ = _tmp717_;
2408 vala_data_type_set_nullable (_tmp718_, FALSE);
2409 _tmp719_ = vala_binary_expression_get_right (self);
2410 _tmp720_ = _tmp719_;
2411 _tmp721_ = vala_expression_get_target_type (_tmp720_);
2412 _tmp722_ = _tmp721_;
2413 vala_data_type_set_nullable (_tmp722_, FALSE);
2414 _tmp723_ = vala_code_context_get_analyzer (context);
2415 _tmp724_ = _tmp723_;
2416 _tmp725_ = vala_binary_expression_get_left (self);
2417 _tmp726_ = _tmp725_;
2418 _tmp727_ = vala_expression_get_target_type (_tmp726_);
2419 _tmp728_ = _tmp727_;
2420 _tmp729_ = vala_binary_expression_get_right (self);
2421 _tmp730_ = _tmp729_;
2422 _tmp731_ = vala_expression_get_target_type (_tmp730_);
2423 _tmp732_ = _tmp731_;
2424 _tmp733_ = vala_semantic_analyzer_get_arithmetic_result_type (_tmp724_, _tmp728_, _tmp732_);
2425 vala_expression_set_value_type ((ValaExpression*) self, _tmp733_);
2426 _tmp734_ = vala_expression_get_value_type ((ValaExpression*) self);
2427 _tmp735_ = _tmp734_;
2428 if (_tmp735_ == NULL) {
2429 ValaSourceReference* _tmp736_;
2430 ValaSourceReference* _tmp737_;
2431 ValaExpression* _tmp738_;
2432 ValaExpression* _tmp739_;
2433 ValaDataType* _tmp740_;
2434 ValaDataType* _tmp741_;
2435 gchar* _tmp742_;
2436 gchar* _tmp743_;
2437 ValaExpression* _tmp744_;
2438 ValaExpression* _tmp745_;
2439 ValaDataType* _tmp746_;
2440 ValaDataType* _tmp747_;
2441 gchar* _tmp748_;
2442 gchar* _tmp749_;
2443 gchar* _tmp750_;
2444 gchar* _tmp751_;
2445 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
2446 _tmp736_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
2447 _tmp737_ = _tmp736_;
2448 _tmp738_ = vala_binary_expression_get_left (self);
2449 _tmp739_ = _tmp738_;
2450 _tmp740_ = vala_expression_get_value_type (_tmp739_);
2451 _tmp741_ = _tmp740_;
2452 _tmp742_ = vala_code_node_to_string ((ValaCodeNode*) _tmp741_);
2453 _tmp743_ = _tmp742_;
2454 _tmp744_ = vala_binary_expression_get_right (self);
2455 _tmp745_ = _tmp744_;
2456 _tmp746_ = vala_expression_get_value_type (_tmp745_);
2457 _tmp747_ = _tmp746_;
2458 _tmp748_ = vala_code_node_to_string ((ValaCodeNode*) _tmp747_);
2459 _tmp749_ = _tmp748_;
2460 _tmp750_ = g_strdup_printf ("Arithmetic operation not supported for types `%s' and `%s'", _tmp743_, _tmp749_);
2461 _tmp751_ = _tmp750_;
2462 vala_report_error (_tmp737_, _tmp751_);
2463 _g_free0 (_tmp751_);
2464 _g_free0 (_tmp749_);
2465 _g_free0 (_tmp743_);
2466 result = FALSE;
2467 return result;
2468 }
2469 break;
2470 }
2471 case VALA_BINARY_OPERATOR_LESS_THAN:
2472 case VALA_BINARY_OPERATOR_GREATER_THAN:
2473 case VALA_BINARY_OPERATOR_LESS_THAN_OR_EQUAL:
2474 case VALA_BINARY_OPERATOR_GREATER_THAN_OR_EQUAL:
2475 {
2476 gboolean _tmp752_ = FALSE;
2477 ValaExpression* _tmp753_;
2478 ValaExpression* _tmp754_;
2479 ValaDataType* _tmp755_;
2480 ValaDataType* _tmp756_;
2481 ValaSemanticAnalyzer* _tmp757_;
2482 ValaSemanticAnalyzer* _tmp758_;
2483 ValaDataType* _tmp759_;
2484 ValaSemanticAnalyzer* _tmp841_;
2485 ValaSemanticAnalyzer* _tmp842_;
2486 ValaDataType* _tmp843_;
2487 _tmp753_ = vala_binary_expression_get_left (self);
2488 _tmp754_ = _tmp753_;
2489 _tmp755_ = vala_expression_get_value_type (_tmp754_);
2490 _tmp756_ = _tmp755_;
2491 _tmp757_ = vala_code_context_get_analyzer (context);
2492 _tmp758_ = _tmp757_;
2493 _tmp759_ = _tmp758_->string_type;
2494 if (vala_data_type_compatible (_tmp756_, _tmp759_)) {
2495 ValaExpression* _tmp760_;
2496 ValaExpression* _tmp761_;
2497 ValaDataType* _tmp762_;
2498 ValaDataType* _tmp763_;
2499 ValaSemanticAnalyzer* _tmp764_;
2500 ValaSemanticAnalyzer* _tmp765_;
2501 ValaDataType* _tmp766_;
2502 _tmp760_ = vala_binary_expression_get_right (self);
2503 _tmp761_ = _tmp760_;
2504 _tmp762_ = vala_expression_get_value_type (_tmp761_);
2505 _tmp763_ = _tmp762_;
2506 _tmp764_ = vala_code_context_get_analyzer (context);
2507 _tmp765_ = _tmp764_;
2508 _tmp766_ = _tmp765_->string_type;
2509 _tmp752_ = vala_data_type_compatible (_tmp763_, _tmp766_);
2510 } else {
2511 _tmp752_ = FALSE;
2512 }
2513 if (_tmp752_) {
2514 } else {
2515 gboolean _tmp767_ = FALSE;
2516 ValaExpression* _tmp768_;
2517 ValaExpression* _tmp769_;
2518 ValaDataType* _tmp770_;
2519 ValaDataType* _tmp771_;
2520 _tmp768_ = vala_binary_expression_get_left (self);
2521 _tmp769_ = _tmp768_;
2522 _tmp770_ = vala_expression_get_value_type (_tmp769_);
2523 _tmp771_ = _tmp770_;
2524 if (VALA_IS_POINTER_TYPE (_tmp771_)) {
2525 ValaExpression* _tmp772_;
2526 ValaExpression* _tmp773_;
2527 ValaDataType* _tmp774_;
2528 ValaDataType* _tmp775_;
2529 _tmp772_ = vala_binary_expression_get_right (self);
2530 _tmp773_ = _tmp772_;
2531 _tmp774_ = vala_expression_get_value_type (_tmp773_);
2532 _tmp775_ = _tmp774_;
2533 _tmp767_ = VALA_IS_POINTER_TYPE (_tmp775_);
2534 } else {
2535 _tmp767_ = FALSE;
2536 }
2537 if (_tmp767_) {
2538 } else {
2539 ValaDataType* resulting_type = NULL;
2540 gboolean _tmp776_;
2541 ValaDataType* _tmp805_;
2542 gboolean _tmp822_;
2543 ValaExpression* _tmp828_;
2544 ValaExpression* _tmp829_;
2545 ValaDataType* _tmp830_;
2546 ValaDataType* _tmp831_;
2547 ValaDataType* _tmp832_;
2548 ValaExpression* _tmp833_;
2549 ValaExpression* _tmp834_;
2550 ValaDataType* _tmp835_;
2551 ValaDataType* _tmp836_;
2552 ValaExpression* _tmp837_;
2553 ValaExpression* _tmp838_;
2554 ValaDataType* _tmp839_;
2555 ValaDataType* _tmp840_;
2556 _tmp776_ = self->priv->_is_chained;
2557 if (_tmp776_) {
2558 ValaBinaryExpression* lbe = NULL;
2559 ValaExpression* _tmp777_;
2560 ValaExpression* _tmp778_;
2561 ValaBinaryExpression* _tmp779_;
2562 ValaSemanticAnalyzer* _tmp780_;
2563 ValaSemanticAnalyzer* _tmp781_;
2564 ValaBinaryExpression* _tmp782_;
2565 ValaExpression* _tmp783_;
2566 ValaExpression* _tmp784_;
2567 ValaDataType* _tmp785_;
2568 ValaDataType* _tmp786_;
2569 ValaExpression* _tmp787_;
2570 ValaExpression* _tmp788_;
2571 ValaDataType* _tmp789_;
2572 ValaDataType* _tmp790_;
2573 ValaDataType* _tmp791_;
2574 ValaDataType* _tmp792_;
2575 _tmp777_ = vala_binary_expression_get_left (self);
2576 _tmp778_ = _tmp777_;
2577 _tmp779_ = _vala_code_node_ref0 (G_TYPE_CHECK_INSTANCE_CAST (_tmp778_, VALA_TYPE_BINARY_EXPRESSION, ValaBinaryExpression));
2578 lbe = _tmp779_;
2579 _tmp780_ = vala_code_context_get_analyzer (context);
2580 _tmp781_ = _tmp780_;
2581 _tmp782_ = lbe;
2582 _tmp783_ = vala_binary_expression_get_right (_tmp782_);
2583 _tmp784_ = _tmp783_;
2584 _tmp785_ = vala_expression_get_target_type (_tmp784_);
2585 _tmp786_ = _tmp785_;
2586 _tmp787_ = vala_binary_expression_get_right (self);
2587 _tmp788_ = _tmp787_;
2588 _tmp789_ = vala_expression_get_target_type (_tmp788_);
2589 _tmp790_ = _tmp789_;
2590 _tmp791_ = vala_semantic_analyzer_get_arithmetic_result_type (_tmp781_, _tmp786_, _tmp790_);
2591 _tmp792_ = _vala_code_node_ref0 (_tmp791_);
2592 _vala_code_node_unref0 (resulting_type);
2593 resulting_type = _tmp792_;
2594 _vala_code_node_unref0 (lbe);
2595 } else {
2596 ValaSemanticAnalyzer* _tmp793_;
2597 ValaSemanticAnalyzer* _tmp794_;
2598 ValaExpression* _tmp795_;
2599 ValaExpression* _tmp796_;
2600 ValaDataType* _tmp797_;
2601 ValaDataType* _tmp798_;
2602 ValaExpression* _tmp799_;
2603 ValaExpression* _tmp800_;
2604 ValaDataType* _tmp801_;
2605 ValaDataType* _tmp802_;
2606 ValaDataType* _tmp803_;
2607 ValaDataType* _tmp804_;
2608 _tmp793_ = vala_code_context_get_analyzer (context);
2609 _tmp794_ = _tmp793_;
2610 _tmp795_ = vala_binary_expression_get_left (self);
2611 _tmp796_ = _tmp795_;
2612 _tmp797_ = vala_expression_get_target_type (_tmp796_);
2613 _tmp798_ = _tmp797_;
2614 _tmp799_ = vala_binary_expression_get_right (self);
2615 _tmp800_ = _tmp799_;
2616 _tmp801_ = vala_expression_get_target_type (_tmp800_);
2617 _tmp802_ = _tmp801_;
2618 _tmp803_ = vala_semantic_analyzer_get_arithmetic_result_type (_tmp794_, _tmp798_, _tmp802_);
2619 _tmp804_ = _vala_code_node_ref0 (_tmp803_);
2620 _vala_code_node_unref0 (resulting_type);
2621 resulting_type = _tmp804_;
2622 }
2623 _tmp805_ = resulting_type;
2624 if (_tmp805_ == NULL) {
2625 ValaSourceReference* _tmp806_;
2626 ValaSourceReference* _tmp807_;
2627 ValaExpression* _tmp808_;
2628 ValaExpression* _tmp809_;
2629 ValaDataType* _tmp810_;
2630 ValaDataType* _tmp811_;
2631 gchar* _tmp812_;
2632 gchar* _tmp813_;
2633 ValaExpression* _tmp814_;
2634 ValaExpression* _tmp815_;
2635 ValaDataType* _tmp816_;
2636 ValaDataType* _tmp817_;
2637 gchar* _tmp818_;
2638 gchar* _tmp819_;
2639 gchar* _tmp820_;
2640 gchar* _tmp821_;
2641 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
2642 _tmp806_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
2643 _tmp807_ = _tmp806_;
2644 _tmp808_ = vala_binary_expression_get_left (self);
2645 _tmp809_ = _tmp808_;
2646 _tmp810_ = vala_expression_get_value_type (_tmp809_);
2647 _tmp811_ = _tmp810_;
2648 _tmp812_ = vala_code_node_to_string ((ValaCodeNode*) _tmp811_);
2649 _tmp813_ = _tmp812_;
2650 _tmp814_ = vala_binary_expression_get_right (self);
2651 _tmp815_ = _tmp814_;
2652 _tmp816_ = vala_expression_get_value_type (_tmp815_);
2653 _tmp817_ = _tmp816_;
2654 _tmp818_ = vala_code_node_to_string ((ValaCodeNode*) _tmp817_);
2655 _tmp819_ = _tmp818_;
2656 _tmp820_ = g_strdup_printf ("Relational operation not supported for types `%s' and `%s'", _tmp813_, _tmp819_);
2657 _tmp821_ = _tmp820_;
2658 vala_report_error (_tmp807_, _tmp821_);
2659 _g_free0 (_tmp821_);
2660 _g_free0 (_tmp819_);
2661 _g_free0 (_tmp813_);
2662 result = FALSE;
2663 _vala_code_node_unref0 (resulting_type);
2664 return result;
2665 }
2666 _tmp822_ = self->priv->_is_chained;
2667 if (!_tmp822_) {
2668 ValaExpression* _tmp823_;
2669 ValaExpression* _tmp824_;
2670 ValaDataType* _tmp825_;
2671 ValaDataType* _tmp826_;
2672 ValaDataType* _tmp827_;
2673 _tmp823_ = vala_binary_expression_get_left (self);
2674 _tmp824_ = _tmp823_;
2675 _tmp825_ = resulting_type;
2676 _tmp826_ = vala_data_type_copy (_tmp825_);
2677 _tmp827_ = _tmp826_;
2678 vala_expression_set_target_type (_tmp824_, _tmp827_);
2679 _vala_code_node_unref0 (_tmp827_);
2680 }
2681 _tmp828_ = vala_binary_expression_get_right (self);
2682 _tmp829_ = _tmp828_;
2683 _tmp830_ = resulting_type;
2684 _tmp831_ = vala_data_type_copy (_tmp830_);
2685 _tmp832_ = _tmp831_;
2686 vala_expression_set_target_type (_tmp829_, _tmp832_);
2687 _vala_code_node_unref0 (_tmp832_);
2688 _tmp833_ = vala_binary_expression_get_left (self);
2689 _tmp834_ = _tmp833_;
2690 _tmp835_ = vala_expression_get_target_type (_tmp834_);
2691 _tmp836_ = _tmp835_;
2692 vala_data_type_set_nullable (_tmp836_, FALSE);
2693 _tmp837_ = vala_binary_expression_get_right (self);
2694 _tmp838_ = _tmp837_;
2695 _tmp839_ = vala_expression_get_target_type (_tmp838_);
2696 _tmp840_ = _tmp839_;
2697 vala_data_type_set_nullable (_tmp840_, FALSE);
2698 _vala_code_node_unref0 (resulting_type);
2699 }
2700 }
2701 _tmp841_ = vala_code_context_get_analyzer (context);
2702 _tmp842_ = _tmp841_;
2703 _tmp843_ = _tmp842_->bool_type;
2704 vala_expression_set_value_type ((ValaExpression*) self, _tmp843_);
2705 break;
2706 }
2707 case VALA_BINARY_OPERATOR_EQUALITY:
2708 case VALA_BINARY_OPERATOR_INEQUALITY:
2709 {
2710 ValaProfile _tmp844_;
2711 ValaProfile _tmp845_;
2712 gboolean _tmp914_ = FALSE;
2713 ValaExpression* _tmp915_;
2714 ValaExpression* _tmp916_;
2715 ValaDataType* _tmp917_;
2716 ValaDataType* _tmp918_;
2717 ValaExpression* _tmp919_;
2718 ValaExpression* _tmp920_;
2719 ValaDataType* _tmp921_;
2720 ValaDataType* _tmp922_;
2721 ValaDataType* resulting_type = NULL;
2722 ValaSemanticAnalyzer* _tmp947_;
2723 ValaSemanticAnalyzer* _tmp948_;
2724 ValaExpression* _tmp949_;
2725 ValaExpression* _tmp950_;
2726 ValaDataType* _tmp951_;
2727 ValaDataType* _tmp952_;
2728 ValaExpression* _tmp953_;
2729 ValaExpression* _tmp954_;
2730 ValaDataType* _tmp955_;
2731 ValaDataType* _tmp956_;
2732 ValaDataType* _tmp957_;
2733 ValaDataType* _tmp958_;
2734 ValaDataType* _tmp959_;
2735 ValaExpression* _tmp970_;
2736 ValaExpression* _tmp971_;
2737 ValaDataType* _tmp972_;
2738 ValaDataType* _tmp973_;
2739 ValaExpression* _tmp974_;
2740 ValaExpression* _tmp975_;
2741 ValaDataType* _tmp976_;
2742 ValaDataType* _tmp977_;
2743 ValaExpression* _tmp978_;
2744 ValaExpression* _tmp979_;
2745 ValaDataType* _tmp980_;
2746 ValaDataType* _tmp981_;
2747 gboolean _tmp982_;
2748 gboolean _tmp983_;
2749 ValaExpression* _tmp984_;
2750 ValaExpression* _tmp985_;
2751 ValaDataType* _tmp986_;
2752 ValaDataType* _tmp987_;
2753 gboolean _tmp988_;
2754 gboolean _tmp989_;
2755 ValaSemanticAnalyzer* _tmp998_;
2756 ValaSemanticAnalyzer* _tmp999_;
2757 ValaDataType* _tmp1000_;
2758 _tmp844_ = vala_code_context_get_profile (context);
2759 _tmp845_ = _tmp844_;
2760 if (_tmp845_ == VALA_PROFILE_GOBJECT) {
2761 ValaTypeSymbol* gvalue_type = NULL;
2762 ValaSemanticAnalyzer* _tmp846_;
2763 ValaSemanticAnalyzer* _tmp847_;
2764 ValaStructValueType* _tmp848_;
2765 ValaTypeSymbol* _tmp849_;
2766 ValaTypeSymbol* _tmp850_;
2767 ValaTypeSymbol* _tmp851_;
2768 gboolean _tmp852_ = FALSE;
2769 gboolean _tmp853_ = FALSE;
2770 ValaExpression* _tmp854_;
2771 ValaExpression* _tmp855_;
2772 ValaDataType* _tmp856_;
2773 ValaDataType* _tmp857_;
2774 ValaTypeSymbol* _tmp858_;
2775 ValaTypeSymbol* _tmp859_;
2776 ValaTypeSymbol* _tmp860_;
2777 _tmp846_ = vala_code_context_get_analyzer (context);
2778 _tmp847_ = _tmp846_;
2779 _tmp848_ = _tmp847_->gvalue_type;
2780 _tmp849_ = vala_data_type_get_type_symbol ((ValaDataType*) _tmp848_);
2781 _tmp850_ = _tmp849_;
2782 _tmp851_ = _vala_code_node_ref0 (_tmp850_);
2783 gvalue_type = _tmp851_;
2784 _tmp854_ = vala_binary_expression_get_left (self);
2785 _tmp855_ = _tmp854_;
2786 _tmp856_ = vala_expression_get_target_type (_tmp855_);
2787 _tmp857_ = _tmp856_;
2788 _tmp858_ = vala_data_type_get_type_symbol (_tmp857_);
2789 _tmp859_ = _tmp858_;
2790 _tmp860_ = gvalue_type;
2791 if (_tmp859_ == _tmp860_) {
2792 ValaExpression* _tmp861_;
2793 ValaExpression* _tmp862_;
2794 ValaDataType* _tmp863_;
2795 ValaDataType* _tmp864_;
2796 ValaTypeSymbol* _tmp865_;
2797 ValaTypeSymbol* _tmp866_;
2798 ValaTypeSymbol* _tmp867_;
2799 _tmp861_ = vala_binary_expression_get_right (self);
2800 _tmp862_ = _tmp861_;
2801 _tmp863_ = vala_expression_get_target_type (_tmp862_);
2802 _tmp864_ = _tmp863_;
2803 _tmp865_ = vala_data_type_get_type_symbol (_tmp864_);
2804 _tmp866_ = _tmp865_;
2805 _tmp867_ = gvalue_type;
2806 _tmp853_ = _tmp866_ != _tmp867_;
2807 } else {
2808 _tmp853_ = FALSE;
2809 }
2810 if (_tmp853_) {
2811 _tmp852_ = TRUE;
2812 } else {
2813 gboolean _tmp868_ = FALSE;
2814 ValaExpression* _tmp869_;
2815 ValaExpression* _tmp870_;
2816 ValaDataType* _tmp871_;
2817 ValaDataType* _tmp872_;
2818 ValaTypeSymbol* _tmp873_;
2819 ValaTypeSymbol* _tmp874_;
2820 ValaTypeSymbol* _tmp875_;
2821 _tmp869_ = vala_binary_expression_get_left (self);
2822 _tmp870_ = _tmp869_;
2823 _tmp871_ = vala_expression_get_target_type (_tmp870_);
2824 _tmp872_ = _tmp871_;
2825 _tmp873_ = vala_data_type_get_type_symbol (_tmp872_);
2826 _tmp874_ = _tmp873_;
2827 _tmp875_ = gvalue_type;
2828 if (_tmp874_ != _tmp875_) {
2829 ValaExpression* _tmp876_;
2830 ValaExpression* _tmp877_;
2831 ValaDataType* _tmp878_;
2832 ValaDataType* _tmp879_;
2833 ValaTypeSymbol* _tmp880_;
2834 ValaTypeSymbol* _tmp881_;
2835 ValaTypeSymbol* _tmp882_;
2836 _tmp876_ = vala_binary_expression_get_right (self);
2837 _tmp877_ = _tmp876_;
2838 _tmp878_ = vala_expression_get_target_type (_tmp877_);
2839 _tmp879_ = _tmp878_;
2840 _tmp880_ = vala_data_type_get_type_symbol (_tmp879_);
2841 _tmp881_ = _tmp880_;
2842 _tmp882_ = gvalue_type;
2843 _tmp868_ = _tmp881_ == _tmp882_;
2844 } else {
2845 _tmp868_ = FALSE;
2846 }
2847 _tmp852_ = _tmp868_;
2848 }
2849 if (_tmp852_) {
2850 ValaExpression* gvalue_expr = NULL;
2851 ValaDataType* target_type = NULL;
2852 ValaExpression* _tmp883_;
2853 ValaExpression* _tmp884_;
2854 ValaDataType* _tmp885_;
2855 ValaDataType* _tmp886_;
2856 ValaTypeSymbol* _tmp887_;
2857 ValaTypeSymbol* _tmp888_;
2858 ValaTypeSymbol* _tmp889_;
2859 ValaCastExpression* cast_expr = NULL;
2860 ValaExpression* _tmp906_;
2861 ValaDataType* _tmp907_;
2862 ValaExpression* _tmp908_;
2863 ValaSourceReference* _tmp909_;
2864 ValaSourceReference* _tmp910_;
2865 ValaCastExpression* _tmp911_;
2866 ValaExpression* _tmp912_;
2867 ValaCastExpression* _tmp913_;
2868 _tmp883_ = vala_binary_expression_get_left (self);
2869 _tmp884_ = _tmp883_;
2870 _tmp885_ = vala_expression_get_target_type (_tmp884_);
2871 _tmp886_ = _tmp885_;
2872 _tmp887_ = vala_data_type_get_type_symbol (_tmp886_);
2873 _tmp888_ = _tmp887_;
2874 _tmp889_ = gvalue_type;
2875 if (_tmp888_ == _tmp889_) {
2876 ValaExpression* _tmp890_;
2877 ValaExpression* _tmp891_;
2878 ValaExpression* _tmp892_;
2879 ValaExpression* _tmp893_;
2880 ValaExpression* _tmp894_;
2881 ValaDataType* _tmp895_;
2882 ValaDataType* _tmp896_;
2883 ValaDataType* _tmp897_;
2884 _tmp890_ = vala_binary_expression_get_left (self);
2885 _tmp891_ = _tmp890_;
2886 _tmp892_ = _vala_code_node_ref0 (_tmp891_);
2887 _vala_code_node_unref0 (gvalue_expr);
2888 gvalue_expr = _tmp892_;
2889 _tmp893_ = vala_binary_expression_get_right (self);
2890 _tmp894_ = _tmp893_;
2891 _tmp895_ = vala_expression_get_target_type (_tmp894_);
2892 _tmp896_ = _tmp895_;
2893 _tmp897_ = _vala_code_node_ref0 (_tmp896_);
2894 _vala_code_node_unref0 (target_type);
2895 target_type = _tmp897_;
2896 } else {
2897 ValaExpression* _tmp898_;
2898 ValaExpression* _tmp899_;
2899 ValaExpression* _tmp900_;
2900 ValaExpression* _tmp901_;
2901 ValaExpression* _tmp902_;
2902 ValaDataType* _tmp903_;
2903 ValaDataType* _tmp904_;
2904 ValaDataType* _tmp905_;
2905 _tmp898_ = vala_binary_expression_get_right (self);
2906 _tmp899_ = _tmp898_;
2907 _tmp900_ = _vala_code_node_ref0 (_tmp899_);
2908 _vala_code_node_unref0 (gvalue_expr);
2909 gvalue_expr = _tmp900_;
2910 _tmp901_ = vala_binary_expression_get_left (self);
2911 _tmp902_ = _tmp901_;
2912 _tmp903_ = vala_expression_get_target_type (_tmp902_);
2913 _tmp904_ = _tmp903_;
2914 _tmp905_ = _vala_code_node_ref0 (_tmp904_);
2915 _vala_code_node_unref0 (target_type);
2916 target_type = _tmp905_;
2917 }
2918 _tmp906_ = gvalue_expr;
2919 _tmp907_ = target_type;
2920 _tmp908_ = gvalue_expr;
2921 _tmp909_ = vala_code_node_get_source_reference ((ValaCodeNode*) _tmp908_);
2922 _tmp910_ = _tmp909_;
2923 _tmp911_ = vala_cast_expression_new (_tmp906_, _tmp907_, _tmp910_);
2924 cast_expr = _tmp911_;
2925 _tmp912_ = gvalue_expr;
2926 _tmp913_ = cast_expr;
2927 vala_code_node_replace_expression ((ValaCodeNode*) self, _tmp912_, (ValaExpression*) _tmp913_);
2928 vala_code_node_set_checked ((ValaCodeNode*) self, FALSE);
2929 result = vala_code_node_check ((ValaCodeNode*) self, context);
2930 _vala_code_node_unref0 (cast_expr);
2931 _vala_code_node_unref0 (target_type);
2932 _vala_code_node_unref0 (gvalue_expr);
2933 _vala_code_node_unref0 (gvalue_type);
2934 return result;
2935 }
2936 _vala_code_node_unref0 (gvalue_type);
2937 }
2938 _tmp915_ = vala_binary_expression_get_right (self);
2939 _tmp916_ = _tmp915_;
2940 _tmp917_ = vala_expression_get_value_type (_tmp916_);
2941 _tmp918_ = _tmp917_;
2942 _tmp919_ = vala_binary_expression_get_left (self);
2943 _tmp920_ = _tmp919_;
2944 _tmp921_ = vala_expression_get_value_type (_tmp920_);
2945 _tmp922_ = _tmp921_;
2946 if (!vala_data_type_compatible (_tmp918_, _tmp922_)) {
2947 ValaExpression* _tmp923_;
2948 ValaExpression* _tmp924_;
2949 ValaDataType* _tmp925_;
2950 ValaDataType* _tmp926_;
2951 ValaExpression* _tmp927_;
2952 ValaExpression* _tmp928_;
2953 ValaDataType* _tmp929_;
2954 ValaDataType* _tmp930_;
2955 _tmp923_ = vala_binary_expression_get_left (self);
2956 _tmp924_ = _tmp923_;
2957 _tmp925_ = vala_expression_get_value_type (_tmp924_);
2958 _tmp926_ = _tmp925_;
2959 _tmp927_ = vala_binary_expression_get_right (self);
2960 _tmp928_ = _tmp927_;
2961 _tmp929_ = vala_expression_get_value_type (_tmp928_);
2962 _tmp930_ = _tmp929_;
2963 _tmp914_ = !vala_data_type_compatible (_tmp926_, _tmp930_);
2964 } else {
2965 _tmp914_ = FALSE;
2966 }
2967 if (_tmp914_) {
2968 ValaSourceReference* _tmp931_;
2969 ValaSourceReference* _tmp932_;
2970 ValaExpression* _tmp933_;
2971 ValaExpression* _tmp934_;
2972 ValaDataType* _tmp935_;
2973 ValaDataType* _tmp936_;
2974 gchar* _tmp937_;
2975 gchar* _tmp938_;
2976 ValaExpression* _tmp939_;
2977 ValaExpression* _tmp940_;
2978 ValaDataType* _tmp941_;
2979 ValaDataType* _tmp942_;
2980 gchar* _tmp943_;
2981 gchar* _tmp944_;
2982 gchar* _tmp945_;
2983 gchar* _tmp946_;
2984 _tmp931_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
2985 _tmp932_ = _tmp931_;
2986 _tmp933_ = vala_binary_expression_get_right (self);
2987 _tmp934_ = _tmp933_;
2988 _tmp935_ = vala_expression_get_value_type (_tmp934_);
2989 _tmp936_ = _tmp935_;
2990 _tmp937_ = vala_code_node_to_string ((ValaCodeNode*) _tmp936_);
2991 _tmp938_ = _tmp937_;
2992 _tmp939_ = vala_binary_expression_get_left (self);
2993 _tmp940_ = _tmp939_;
2994 _tmp941_ = vala_expression_get_value_type (_tmp940_);
2995 _tmp942_ = _tmp941_;
2996 _tmp943_ = vala_code_node_to_string ((ValaCodeNode*) _tmp942_);
2997 _tmp944_ = _tmp943_;
2998 _tmp945_ = g_strdup_printf ("Equality operation: `%s' and `%s' are incompatible", _tmp938_, _tmp944_);
2999 _tmp946_ = _tmp945_;
3000 vala_report_error (_tmp932_, _tmp946_);
3001 _g_free0 (_tmp946_);
3002 _g_free0 (_tmp944_);
3003 _g_free0 (_tmp938_);
3004 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
3005 result = FALSE;
3006 return result;
3007 }
3008 _tmp947_ = vala_code_context_get_analyzer (context);
3009 _tmp948_ = _tmp947_;
3010 _tmp949_ = vala_binary_expression_get_left (self);
3011 _tmp950_ = _tmp949_;
3012 _tmp951_ = vala_expression_get_target_type (_tmp950_);
3013 _tmp952_ = _tmp951_;
3014 _tmp953_ = vala_binary_expression_get_right (self);
3015 _tmp954_ = _tmp953_;
3016 _tmp955_ = vala_expression_get_target_type (_tmp954_);
3017 _tmp956_ = _tmp955_;
3018 _tmp957_ = vala_semantic_analyzer_get_arithmetic_result_type (_tmp948_, _tmp952_, _tmp956_);
3019 _tmp958_ = _vala_code_node_ref0 (_tmp957_);
3020 resulting_type = _tmp958_;
3021 _tmp959_ = resulting_type;
3022 if (_tmp959_ != NULL) {
3023 ValaExpression* _tmp960_;
3024 ValaExpression* _tmp961_;
3025 ValaDataType* _tmp962_;
3026 ValaDataType* _tmp963_;
3027 ValaDataType* _tmp964_;
3028 ValaExpression* _tmp965_;
3029 ValaExpression* _tmp966_;
3030 ValaDataType* _tmp967_;
3031 ValaDataType* _tmp968_;
3032 ValaDataType* _tmp969_;
3033 _tmp960_ = vala_binary_expression_get_left (self);
3034 _tmp961_ = _tmp960_;
3035 _tmp962_ = resulting_type;
3036 _tmp963_ = vala_data_type_copy (_tmp962_);
3037 _tmp964_ = _tmp963_;
3038 vala_expression_set_target_type (_tmp961_, _tmp964_);
3039 _vala_code_node_unref0 (_tmp964_);
3040 _tmp965_ = vala_binary_expression_get_right (self);
3041 _tmp966_ = _tmp965_;
3042 _tmp967_ = resulting_type;
3043 _tmp968_ = vala_data_type_copy (_tmp967_);
3044 _tmp969_ = _tmp968_;
3045 vala_expression_set_target_type (_tmp966_, _tmp969_);
3046 _vala_code_node_unref0 (_tmp969_);
3047 }
3048 _tmp970_ = vala_binary_expression_get_left (self);
3049 _tmp971_ = _tmp970_;
3050 _tmp972_ = vala_expression_get_target_type (_tmp971_);
3051 _tmp973_ = _tmp972_;
3052 vala_data_type_set_value_owned (_tmp973_, FALSE);
3053 _tmp974_ = vala_binary_expression_get_right (self);
3054 _tmp975_ = _tmp974_;
3055 _tmp976_ = vala_expression_get_target_type (_tmp975_);
3056 _tmp977_ = _tmp976_;
3057 vala_data_type_set_value_owned (_tmp977_, FALSE);
3058 _tmp978_ = vala_binary_expression_get_left (self);
3059 _tmp979_ = _tmp978_;
3060 _tmp980_ = vala_expression_get_value_type (_tmp979_);
3061 _tmp981_ = _tmp980_;
3062 _tmp982_ = vala_data_type_get_nullable (_tmp981_);
3063 _tmp983_ = _tmp982_;
3064 _tmp984_ = vala_binary_expression_get_right (self);
3065 _tmp985_ = _tmp984_;
3066 _tmp986_ = vala_expression_get_value_type (_tmp985_);
3067 _tmp987_ = _tmp986_;
3068 _tmp988_ = vala_data_type_get_nullable (_tmp987_);
3069 _tmp989_ = _tmp988_;
3070 if (_tmp983_ != _tmp989_) {
3071 ValaExpression* _tmp990_;
3072 ValaExpression* _tmp991_;
3073 ValaDataType* _tmp992_;
3074 ValaDataType* _tmp993_;
3075 ValaExpression* _tmp994_;
3076 ValaExpression* _tmp995_;
3077 ValaDataType* _tmp996_;
3078 ValaDataType* _tmp997_;
3079 _tmp990_ = vala_binary_expression_get_left (self);
3080 _tmp991_ = _tmp990_;
3081 _tmp992_ = vala_expression_get_target_type (_tmp991_);
3082 _tmp993_ = _tmp992_;
3083 vala_data_type_set_nullable (_tmp993_, TRUE);
3084 _tmp994_ = vala_binary_expression_get_right (self);
3085 _tmp995_ = _tmp994_;
3086 _tmp996_ = vala_expression_get_target_type (_tmp995_);
3087 _tmp997_ = _tmp996_;
3088 vala_data_type_set_nullable (_tmp997_, TRUE);
3089 }
3090 _tmp998_ = vala_code_context_get_analyzer (context);
3091 _tmp999_ = _tmp998_;
3092 _tmp1000_ = _tmp999_->bool_type;
3093 vala_expression_set_value_type ((ValaExpression*) self, _tmp1000_);
3094 _vala_code_node_unref0 (resulting_type);
3095 break;
3096 }
3097 case VALA_BINARY_OPERATOR_BITWISE_AND:
3098 case VALA_BINARY_OPERATOR_BITWISE_OR:
3099 case VALA_BINARY_OPERATOR_BITWISE_XOR:
3100 {
3101 ValaExpression* _tmp1001_;
3102 ValaExpression* _tmp1002_;
3103 ValaDataType* _tmp1003_;
3104 ValaDataType* _tmp1004_;
3105 ValaExpression* _tmp1005_;
3106 ValaExpression* _tmp1006_;
3107 ValaDataType* _tmp1007_;
3108 ValaDataType* _tmp1008_;
3109 gboolean _tmp1009_ = FALSE;
3110 ValaExpression* _tmp1010_;
3111 ValaExpression* _tmp1011_;
3112 ValaDataType* _tmp1012_;
3113 ValaDataType* _tmp1013_;
3114 ValaSemanticAnalyzer* _tmp1014_;
3115 ValaSemanticAnalyzer* _tmp1015_;
3116 ValaDataType* _tmp1016_;
3117 _tmp1001_ = vala_binary_expression_get_left (self);
3118 _tmp1002_ = _tmp1001_;
3119 _tmp1003_ = vala_expression_get_target_type (_tmp1002_);
3120 _tmp1004_ = _tmp1003_;
3121 vala_data_type_set_nullable (_tmp1004_, FALSE);
3122 _tmp1005_ = vala_binary_expression_get_right (self);
3123 _tmp1006_ = _tmp1005_;
3124 _tmp1007_ = vala_expression_get_target_type (_tmp1006_);
3125 _tmp1008_ = _tmp1007_;
3126 vala_data_type_set_nullable (_tmp1008_, FALSE);
3127 _tmp1010_ = vala_binary_expression_get_left (self);
3128 _tmp1011_ = _tmp1010_;
3129 _tmp1012_ = vala_expression_get_value_type (_tmp1011_);
3130 _tmp1013_ = _tmp1012_;
3131 _tmp1014_ = vala_code_context_get_analyzer (context);
3132 _tmp1015_ = _tmp1014_;
3133 _tmp1016_ = _tmp1015_->bool_type;
3134 if (vala_data_type_compatible (_tmp1013_, _tmp1016_)) {
3135 ValaExpression* _tmp1017_;
3136 ValaExpression* _tmp1018_;
3137 ValaDataType* _tmp1019_;
3138 ValaDataType* _tmp1020_;
3139 ValaSemanticAnalyzer* _tmp1021_;
3140 ValaSemanticAnalyzer* _tmp1022_;
3141 ValaDataType* _tmp1023_;
3142 _tmp1017_ = vala_binary_expression_get_right (self);
3143 _tmp1018_ = _tmp1017_;
3144 _tmp1019_ = vala_expression_get_value_type (_tmp1018_);
3145 _tmp1020_ = _tmp1019_;
3146 _tmp1021_ = vala_code_context_get_analyzer (context);
3147 _tmp1022_ = _tmp1021_;
3148 _tmp1023_ = _tmp1022_->bool_type;
3149 _tmp1009_ = !vala_data_type_compatible (_tmp1020_, _tmp1023_);
3150 } else {
3151 _tmp1009_ = FALSE;
3152 }
3153 if (_tmp1009_) {
3154 ValaExpression* _tmp1024_;
3155 ValaExpression* _tmp1025_;
3156 ValaDataType* _tmp1026_;
3157 ValaDataType* _tmp1027_;
3158 ValaDataType* _tmp1028_;
3159 ValaDataType* _tmp1029_;
3160 _tmp1024_ = vala_binary_expression_get_right (self);
3161 _tmp1025_ = _tmp1024_;
3162 _tmp1026_ = vala_expression_get_target_type (_tmp1025_);
3163 _tmp1027_ = _tmp1026_;
3164 _tmp1028_ = vala_data_type_copy (_tmp1027_);
3165 _tmp1029_ = _tmp1028_;
3166 vala_expression_set_value_type ((ValaExpression*) self, _tmp1029_);
3167 _vala_code_node_unref0 (_tmp1029_);
3168 } else {
3169 ValaExpression* _tmp1030_;
3170 ValaExpression* _tmp1031_;
3171 ValaDataType* _tmp1032_;
3172 ValaDataType* _tmp1033_;
3173 ValaDataType* _tmp1034_;
3174 ValaDataType* _tmp1035_;
3175 _tmp1030_ = vala_binary_expression_get_left (self);
3176 _tmp1031_ = _tmp1030_;
3177 _tmp1032_ = vala_expression_get_target_type (_tmp1031_);
3178 _tmp1033_ = _tmp1032_;
3179 _tmp1034_ = vala_data_type_copy (_tmp1033_);
3180 _tmp1035_ = _tmp1034_;
3181 vala_expression_set_value_type ((ValaExpression*) self, _tmp1035_);
3182 _vala_code_node_unref0 (_tmp1035_);
3183 }
3184 break;
3185 }
3186 case VALA_BINARY_OPERATOR_AND:
3187 case VALA_BINARY_OPERATOR_OR:
3188 {
3189 gboolean _tmp1036_ = FALSE;
3190 ValaExpression* _tmp1037_;
3191 ValaExpression* _tmp1038_;
3192 ValaDataType* _tmp1039_;
3193 ValaDataType* _tmp1040_;
3194 ValaSemanticAnalyzer* _tmp1041_;
3195 ValaSemanticAnalyzer* _tmp1042_;
3196 ValaDataType* _tmp1043_;
3197 ValaExpression* _tmp1053_;
3198 ValaExpression* _tmp1054_;
3199 ValaDataType* _tmp1055_;
3200 ValaDataType* _tmp1056_;
3201 ValaExpression* _tmp1057_;
3202 ValaExpression* _tmp1058_;
3203 ValaDataType* _tmp1059_;
3204 ValaDataType* _tmp1060_;
3205 ValaSemanticAnalyzer* _tmp1061_;
3206 ValaSemanticAnalyzer* _tmp1062_;
3207 ValaDataType* _tmp1063_;
3208 _tmp1037_ = vala_binary_expression_get_left (self);
3209 _tmp1038_ = _tmp1037_;
3210 _tmp1039_ = vala_expression_get_value_type (_tmp1038_);
3211 _tmp1040_ = _tmp1039_;
3212 _tmp1041_ = vala_code_context_get_analyzer (context);
3213 _tmp1042_ = _tmp1041_;
3214 _tmp1043_ = _tmp1042_->bool_type;
3215 if (!vala_data_type_compatible (_tmp1040_, _tmp1043_)) {
3216 _tmp1036_ = TRUE;
3217 } else {
3218 ValaExpression* _tmp1044_;
3219 ValaExpression* _tmp1045_;
3220 ValaDataType* _tmp1046_;
3221 ValaDataType* _tmp1047_;
3222 ValaSemanticAnalyzer* _tmp1048_;
3223 ValaSemanticAnalyzer* _tmp1049_;
3224 ValaDataType* _tmp1050_;
3225 _tmp1044_ = vala_binary_expression_get_right (self);
3226 _tmp1045_ = _tmp1044_;
3227 _tmp1046_ = vala_expression_get_value_type (_tmp1045_);
3228 _tmp1047_ = _tmp1046_;
3229 _tmp1048_ = vala_code_context_get_analyzer (context);
3230 _tmp1049_ = _tmp1048_;
3231 _tmp1050_ = _tmp1049_->bool_type;
3232 _tmp1036_ = !vala_data_type_compatible (_tmp1047_, _tmp1050_);
3233 }
3234 if (_tmp1036_) {
3235 ValaSourceReference* _tmp1051_;
3236 ValaSourceReference* _tmp1052_;
3237 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
3238 _tmp1051_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
3239 _tmp1052_ = _tmp1051_;
3240 vala_report_error (_tmp1052_, "Operands must be boolean");
3241 }
3242 _tmp1053_ = vala_binary_expression_get_left (self);
3243 _tmp1054_ = _tmp1053_;
3244 _tmp1055_ = vala_expression_get_target_type (_tmp1054_);
3245 _tmp1056_ = _tmp1055_;
3246 vala_data_type_set_nullable (_tmp1056_, FALSE);
3247 _tmp1057_ = vala_binary_expression_get_right (self);
3248 _tmp1058_ = _tmp1057_;
3249 _tmp1059_ = vala_expression_get_target_type (_tmp1058_);
3250 _tmp1060_ = _tmp1059_;
3251 vala_data_type_set_nullable (_tmp1060_, FALSE);
3252 _tmp1061_ = vala_code_context_get_analyzer (context);
3253 _tmp1062_ = _tmp1061_;
3254 _tmp1063_ = _tmp1062_->bool_type;
3255 vala_expression_set_value_type ((ValaExpression*) self, _tmp1063_);
3256 break;
3257 }
3258 case VALA_BINARY_OPERATOR_IN:
3259 {
3260 gboolean _tmp1064_ = FALSE;
3261 ValaExpression* _tmp1065_;
3262 ValaExpression* _tmp1066_;
3263 ValaDataType* _tmp1067_;
3264 ValaDataType* _tmp1068_;
3265 ValaSemanticAnalyzer* _tmp1069_;
3266 ValaSemanticAnalyzer* _tmp1070_;
3267 ValaDataType* _tmp1071_;
3268 ValaSemanticAnalyzer* _tmp1175_;
3269 ValaSemanticAnalyzer* _tmp1176_;
3270 ValaDataType* _tmp1177_;
3271 _tmp1065_ = vala_binary_expression_get_left (self);
3272 _tmp1066_ = _tmp1065_;
3273 _tmp1067_ = vala_expression_get_value_type (_tmp1066_);
3274 _tmp1068_ = _tmp1067_;
3275 _tmp1069_ = vala_code_context_get_analyzer (context);
3276 _tmp1070_ = _tmp1069_;
3277 _tmp1071_ = _tmp1070_->int_type;
3278 if (vala_data_type_compatible (_tmp1068_, _tmp1071_)) {
3279 ValaExpression* _tmp1072_;
3280 ValaExpression* _tmp1073_;
3281 ValaDataType* _tmp1074_;
3282 ValaDataType* _tmp1075_;
3283 ValaSemanticAnalyzer* _tmp1076_;
3284 ValaSemanticAnalyzer* _tmp1077_;
3285 ValaDataType* _tmp1078_;
3286 _tmp1072_ = vala_binary_expression_get_right (self);
3287 _tmp1073_ = _tmp1072_;
3288 _tmp1074_ = vala_expression_get_value_type (_tmp1073_);
3289 _tmp1075_ = _tmp1074_;
3290 _tmp1076_ = vala_code_context_get_analyzer (context);
3291 _tmp1077_ = _tmp1076_;
3292 _tmp1078_ = _tmp1077_->int_type;
3293 _tmp1064_ = vala_data_type_compatible (_tmp1075_, _tmp1078_);
3294 } else {
3295 _tmp1064_ = FALSE;
3296 }
3297 if (_tmp1064_) {
3298 ValaExpression* _tmp1079_;
3299 ValaExpression* _tmp1080_;
3300 ValaDataType* _tmp1081_;
3301 ValaDataType* _tmp1082_;
3302 ValaExpression* _tmp1083_;
3303 ValaExpression* _tmp1084_;
3304 ValaDataType* _tmp1085_;
3305 ValaDataType* _tmp1086_;
3306 _tmp1079_ = vala_binary_expression_get_left (self);
3307 _tmp1080_ = _tmp1079_;
3308 _tmp1081_ = vala_expression_get_target_type (_tmp1080_);
3309 _tmp1082_ = _tmp1081_;
3310 vala_data_type_set_nullable (_tmp1082_, FALSE);
3311 _tmp1083_ = vala_binary_expression_get_right (self);
3312 _tmp1084_ = _tmp1083_;
3313 _tmp1085_ = vala_expression_get_target_type (_tmp1084_);
3314 _tmp1086_ = _tmp1085_;
3315 vala_data_type_set_nullable (_tmp1086_, FALSE);
3316 } else {
3317 ValaExpression* _tmp1087_;
3318 ValaExpression* _tmp1088_;
3319 ValaDataType* _tmp1089_;
3320 ValaDataType* _tmp1090_;
3321 _tmp1087_ = vala_binary_expression_get_right (self);
3322 _tmp1088_ = _tmp1087_;
3323 _tmp1089_ = vala_expression_get_value_type (_tmp1088_);
3324 _tmp1090_ = _tmp1089_;
3325 if (VALA_IS_ARRAY_TYPE (_tmp1090_)) {
3326 ValaExpression* _tmp1091_;
3327 ValaExpression* _tmp1092_;
3328 ValaDataType* _tmp1093_;
3329 ValaDataType* _tmp1094_;
3330 ValaExpression* _tmp1095_;
3331 ValaExpression* _tmp1096_;
3332 ValaDataType* _tmp1097_;
3333 ValaDataType* _tmp1098_;
3334 ValaDataType* _tmp1099_;
3335 ValaDataType* _tmp1100_;
3336 _tmp1091_ = vala_binary_expression_get_left (self);
3337 _tmp1092_ = _tmp1091_;
3338 _tmp1093_ = vala_expression_get_value_type (_tmp1092_);
3339 _tmp1094_ = _tmp1093_;
3340 _tmp1095_ = vala_binary_expression_get_right (self);
3341 _tmp1096_ = _tmp1095_;
3342 _tmp1097_ = vala_expression_get_value_type (_tmp1096_);
3343 _tmp1098_ = _tmp1097_;
3344 _tmp1099_ = vala_array_type_get_element_type (G_TYPE_CHECK_INSTANCE_CAST (_tmp1098_, VALA_TYPE_ARRAY_TYPE, ValaArrayType));
3345 _tmp1100_ = _tmp1099_;
3346 if (!vala_data_type_compatible (_tmp1094_, _tmp1100_)) {
3347 ValaSourceReference* _tmp1101_;
3348 ValaSourceReference* _tmp1102_;
3349 ValaExpression* _tmp1103_;
3350 ValaExpression* _tmp1104_;
3351 ValaDataType* _tmp1105_;
3352 ValaDataType* _tmp1106_;
3353 gchar* _tmp1107_;
3354 gchar* _tmp1108_;
3355 ValaExpression* _tmp1109_;
3356 ValaExpression* _tmp1110_;
3357 ValaDataType* _tmp1111_;
3358 ValaDataType* _tmp1112_;
3359 gchar* _tmp1113_;
3360 gchar* _tmp1114_;
3361 gchar* _tmp1115_;
3362 gchar* _tmp1116_;
3363 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
3364 _tmp1101_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
3365 _tmp1102_ = _tmp1101_;
3366 _tmp1103_ = vala_binary_expression_get_left (self);
3367 _tmp1104_ = _tmp1103_;
3368 _tmp1105_ = vala_expression_get_value_type (_tmp1104_);
3369 _tmp1106_ = _tmp1105_;
3370 _tmp1107_ = vala_code_node_to_string ((ValaCodeNode*) _tmp1106_);
3371 _tmp1108_ = _tmp1107_;
3372 _tmp1109_ = vala_binary_expression_get_right (self);
3373 _tmp1110_ = _tmp1109_;
3374 _tmp1111_ = vala_expression_get_value_type (_tmp1110_);
3375 _tmp1112_ = _tmp1111_;
3376 _tmp1113_ = vala_code_node_to_string ((ValaCodeNode*) _tmp1112_);
3377 _tmp1114_ = _tmp1113_;
3378 _tmp1115_ = g_strdup_printf ("Cannot look for `%s' in `%s'", _tmp1108_, _tmp1114_);
3379 _tmp1116_ = _tmp1115_;
3380 vala_report_error (_tmp1102_, _tmp1116_);
3381 _g_free0 (_tmp1116_);
3382 _g_free0 (_tmp1114_);
3383 _g_free0 (_tmp1108_);
3384 }
3385 } else {
3386 ValaMethod* contains_method = NULL;
3387 ValaExpression* _tmp1117_;
3388 ValaExpression* _tmp1118_;
3389 ValaDataType* _tmp1119_;
3390 ValaDataType* _tmp1120_;
3391 ValaSymbol* _tmp1121_;
3392 ValaMethod* _tmp1122_;
3393 ValaMethod* _tmp1123_;
3394 ValaMethod* _tmp1134_;
3395 ValaList* _tmp1135_;
3396 gint _tmp1136_;
3397 gint _tmp1137_;
3398 ValaMethod* _tmp1145_;
3399 ValaDataType* _tmp1146_;
3400 ValaDataType* _tmp1147_;
3401 ValaSemanticAnalyzer* _tmp1148_;
3402 ValaSemanticAnalyzer* _tmp1149_;
3403 ValaDataType* _tmp1150_;
3404 ValaMethodCall* contains_call = NULL;
3405 ValaExpression* _tmp1158_;
3406 ValaExpression* _tmp1159_;
3407 ValaSourceReference* _tmp1160_;
3408 ValaSourceReference* _tmp1161_;
3409 ValaMemberAccess* _tmp1162_;
3410 ValaMemberAccess* _tmp1163_;
3411 ValaSourceReference* _tmp1164_;
3412 ValaSourceReference* _tmp1165_;
3413 ValaMethodCall* _tmp1166_;
3414 ValaMethodCall* _tmp1167_;
3415 ValaMethodCall* _tmp1168_;
3416 ValaExpression* _tmp1169_;
3417 ValaExpression* _tmp1170_;
3418 ValaCodeNode* _tmp1171_;
3419 ValaCodeNode* _tmp1172_;
3420 ValaMethodCall* _tmp1173_;
3421 ValaMethodCall* _tmp1174_;
3422 _tmp1117_ = vala_binary_expression_get_right (self);
3423 _tmp1118_ = _tmp1117_;
3424 _tmp1119_ = vala_expression_get_value_type (_tmp1118_);
3425 _tmp1120_ = _tmp1119_;
3426 _tmp1121_ = vala_data_type_get_member (_tmp1120_, "contains");
3427 _tmp1122_ = VALA_IS_METHOD (_tmp1121_) ? ((ValaMethod*) _tmp1121_) : NULL;
3428 if (_tmp1122_ == NULL) {
3429 _vala_code_node_unref0 (_tmp1121_);
3430 }
3431 contains_method = _tmp1122_;
3432 _tmp1123_ = contains_method;
3433 if (_tmp1123_ == NULL) {
3434 ValaSourceReference* _tmp1124_;
3435 ValaSourceReference* _tmp1125_;
3436 ValaExpression* _tmp1126_;
3437 ValaExpression* _tmp1127_;
3438 ValaDataType* _tmp1128_;
3439 ValaDataType* _tmp1129_;
3440 gchar* _tmp1130_;
3441 gchar* _tmp1131_;
3442 gchar* _tmp1132_;
3443 gchar* _tmp1133_;
3444 _tmp1124_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
3445 _tmp1125_ = _tmp1124_;
3446 _tmp1126_ = vala_binary_expression_get_right (self);
3447 _tmp1127_ = _tmp1126_;
3448 _tmp1128_ = vala_expression_get_value_type (_tmp1127_);
3449 _tmp1129_ = _tmp1128_;
3450 _tmp1130_ = vala_code_node_to_string ((ValaCodeNode*) _tmp1129_);
3451 _tmp1131_ = _tmp1130_;
3452 _tmp1132_ = g_strdup_printf ("`%s' does not have a `contains' method", _tmp1131_);
3453 _tmp1133_ = _tmp1132_;
3454 vala_report_error (_tmp1125_, _tmp1133_);
3455 _g_free0 (_tmp1133_);
3456 _g_free0 (_tmp1131_);
3457 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
3458 result = FALSE;
3459 _vala_code_node_unref0 (contains_method);
3460 return result;
3461 }
3462 _tmp1134_ = contains_method;
3463 _tmp1135_ = vala_callable_get_parameters ((ValaCallable*) _tmp1134_);
3464 _tmp1136_ = vala_collection_get_size ((ValaCollection*) _tmp1135_);
3465 _tmp1137_ = _tmp1136_;
3466 if (_tmp1137_ != 1) {
3467 ValaSourceReference* _tmp1138_;
3468 ValaSourceReference* _tmp1139_;
3469 ValaMethod* _tmp1140_;
3470 gchar* _tmp1141_;
3471 gchar* _tmp1142_;
3472 gchar* _tmp1143_;
3473 gchar* _tmp1144_;
3474 _tmp1138_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
3475 _tmp1139_ = _tmp1138_;
3476 _tmp1140_ = contains_method;
3477 _tmp1141_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp1140_);
3478 _tmp1142_ = _tmp1141_;
3479 _tmp1143_ = g_strdup_printf ("`%s' must have one parameter", _tmp1142_);
3480 _tmp1144_ = _tmp1143_;
3481 vala_report_error (_tmp1139_, _tmp1144_);
3482 _g_free0 (_tmp1144_);
3483 _g_free0 (_tmp1142_);
3484 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
3485 result = FALSE;
3486 _vala_code_node_unref0 (contains_method);
3487 return result;
3488 }
3489 _tmp1145_ = contains_method;
3490 _tmp1146_ = vala_callable_get_return_type ((ValaCallable*) _tmp1145_);
3491 _tmp1147_ = _tmp1146_;
3492 _tmp1148_ = vala_code_context_get_analyzer (context);
3493 _tmp1149_ = _tmp1148_;
3494 _tmp1150_ = _tmp1149_->bool_type;
3495 if (!vala_data_type_compatible (_tmp1147_, _tmp1150_)) {
3496 ValaSourceReference* _tmp1151_;
3497 ValaSourceReference* _tmp1152_;
3498 ValaMethod* _tmp1153_;
3499 gchar* _tmp1154_;
3500 gchar* _tmp1155_;
3501 gchar* _tmp1156_;
3502 gchar* _tmp1157_;
3503 _tmp1151_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
3504 _tmp1152_ = _tmp1151_;
3505 _tmp1153_ = contains_method;
3506 _tmp1154_ = vala_symbol_get_full_name ((ValaSymbol*) _tmp1153_);
3507 _tmp1155_ = _tmp1154_;
3508 _tmp1156_ = g_strdup_printf ("`%s' must return a boolean value", _tmp1155_);
3509 _tmp1157_ = _tmp1156_;
3510 vala_report_error (_tmp1152_, _tmp1157_);
3511 _g_free0 (_tmp1157_);
3512 _g_free0 (_tmp1155_);
3513 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
3514 result = FALSE;
3515 _vala_code_node_unref0 (contains_method);
3516 return result;
3517 }
3518 _tmp1158_ = vala_binary_expression_get_right (self);
3519 _tmp1159_ = _tmp1158_;
3520 _tmp1160_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
3521 _tmp1161_ = _tmp1160_;
3522 _tmp1162_ = vala_member_access_new (_tmp1159_, "contains", _tmp1161_);
3523 _tmp1163_ = _tmp1162_;
3524 _tmp1164_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
3525 _tmp1165_ = _tmp1164_;
3526 _tmp1166_ = vala_method_call_new ((ValaExpression*) _tmp1163_, _tmp1165_);
3527 _tmp1167_ = _tmp1166_;
3528 _vala_code_node_unref0 (_tmp1163_);
3529 contains_call = _tmp1167_;
3530 _tmp1168_ = contains_call;
3531 _tmp1169_ = vala_binary_expression_get_left (self);
3532 _tmp1170_ = _tmp1169_;
3533 vala_method_call_add_argument (_tmp1168_, _tmp1170_);
3534 _tmp1171_ = vala_code_node_get_parent_node ((ValaCodeNode*) self);
3535 _tmp1172_ = _tmp1171_;
3536 _tmp1173_ = contains_call;
3537 vala_code_node_replace_expression (_tmp1172_, (ValaExpression*) self, (ValaExpression*) _tmp1173_);
3538 _tmp1174_ = contains_call;
3539 result = vala_code_node_check ((ValaCodeNode*) _tmp1174_, context);
3540 _vala_code_node_unref0 (contains_call);
3541 _vala_code_node_unref0 (contains_method);
3542 return result;
3543 }
3544 }
3545 _tmp1175_ = vala_code_context_get_analyzer (context);
3546 _tmp1176_ = _tmp1175_;
3547 _tmp1177_ = _tmp1176_->bool_type;
3548 vala_expression_set_value_type ((ValaExpression*) self, _tmp1177_);
3549 break;
3550 }
3551 default:
3552 {
3553 ValaSourceReference* _tmp1178_;
3554 ValaSourceReference* _tmp1179_;
3555 vala_code_node_set_error ((ValaCodeNode*) self, TRUE);
3556 _tmp1178_ = vala_code_node_get_source_reference ((ValaCodeNode*) self);
3557 _tmp1179_ = _tmp1178_;
3558 vala_report_error (_tmp1179_, "internal error: unsupported binary operator");
3559 result = FALSE;
3560 return result;
3561 }
3562 }
3563 _tmp1180_ = vala_expression_get_value_type ((ValaExpression*) self);
3564 _tmp1181_ = _tmp1180_;
3565 vala_code_node_check ((ValaCodeNode*) _tmp1181_, context);
3566 _tmp1182_ = vala_code_node_get_error ((ValaCodeNode*) self);
3567 _tmp1183_ = _tmp1182_;
3568 result = !_tmp1183_;
3569 return result;
3570 }
3571
3572 static void
vala_binary_expression_real_emit(ValaCodeNode * base,ValaCodeGenerator * codegen)3573 vala_binary_expression_real_emit (ValaCodeNode* base,
3574 ValaCodeGenerator* codegen)
3575 {
3576 ValaBinaryExpression * self;
3577 ValaExpression* _tmp0_;
3578 ValaExpression* _tmp1_;
3579 ValaExpression* _tmp2_;
3580 ValaExpression* _tmp3_;
3581 self = (ValaBinaryExpression*) base;
3582 g_return_if_fail (codegen != NULL);
3583 _tmp0_ = vala_binary_expression_get_left (self);
3584 _tmp1_ = _tmp0_;
3585 vala_code_node_emit ((ValaCodeNode*) _tmp1_, codegen);
3586 _tmp2_ = vala_binary_expression_get_right (self);
3587 _tmp3_ = _tmp2_;
3588 vala_code_node_emit ((ValaCodeNode*) _tmp3_, codegen);
3589 vala_code_visitor_visit_binary_expression ((ValaCodeVisitor*) codegen, self);
3590 vala_code_visitor_visit_expression ((ValaCodeVisitor*) codegen, (ValaExpression*) self);
3591 }
3592
3593 static void
vala_binary_expression_real_get_defined_variables(ValaCodeNode * base,ValaCollection * collection)3594 vala_binary_expression_real_get_defined_variables (ValaCodeNode* base,
3595 ValaCollection* collection)
3596 {
3597 ValaBinaryExpression * self;
3598 ValaExpression* _tmp0_;
3599 ValaExpression* _tmp1_;
3600 ValaExpression* _tmp2_;
3601 ValaExpression* _tmp3_;
3602 self = (ValaBinaryExpression*) base;
3603 g_return_if_fail (collection != NULL);
3604 _tmp0_ = vala_binary_expression_get_left (self);
3605 _tmp1_ = _tmp0_;
3606 vala_code_node_get_defined_variables ((ValaCodeNode*) _tmp1_, collection);
3607 _tmp2_ = vala_binary_expression_get_right (self);
3608 _tmp3_ = _tmp2_;
3609 vala_code_node_get_defined_variables ((ValaCodeNode*) _tmp3_, collection);
3610 }
3611
3612 static void
vala_binary_expression_real_get_used_variables(ValaCodeNode * base,ValaCollection * collection)3613 vala_binary_expression_real_get_used_variables (ValaCodeNode* base,
3614 ValaCollection* collection)
3615 {
3616 ValaBinaryExpression * self;
3617 ValaExpression* _tmp0_;
3618 ValaExpression* _tmp1_;
3619 ValaExpression* _tmp2_;
3620 ValaExpression* _tmp3_;
3621 self = (ValaBinaryExpression*) base;
3622 g_return_if_fail (collection != NULL);
3623 _tmp0_ = vala_binary_expression_get_left (self);
3624 _tmp1_ = _tmp0_;
3625 vala_code_node_get_used_variables ((ValaCodeNode*) _tmp1_, collection);
3626 _tmp2_ = vala_binary_expression_get_right (self);
3627 _tmp3_ = _tmp2_;
3628 vala_code_node_get_used_variables ((ValaCodeNode*) _tmp3_, collection);
3629 }
3630
3631 static void
vala_binary_expression_class_init(ValaBinaryExpressionClass * klass,gpointer klass_data)3632 vala_binary_expression_class_init (ValaBinaryExpressionClass * klass,
3633 gpointer klass_data)
3634 {
3635 vala_binary_expression_parent_class = g_type_class_peek_parent (klass);
3636 ((ValaCodeNodeClass *) klass)->finalize = vala_binary_expression_finalize;
3637 g_type_class_adjust_private_offset (klass, &ValaBinaryExpression_private_offset);
3638 ((ValaCodeNodeClass *) klass)->accept = (void (*) (ValaCodeNode*, ValaCodeVisitor*)) vala_binary_expression_real_accept;
3639 ((ValaCodeNodeClass *) klass)->accept_children = (void (*) (ValaCodeNode*, ValaCodeVisitor*)) vala_binary_expression_real_accept_children;
3640 ((ValaCodeNodeClass *) klass)->replace_expression = (void (*) (ValaCodeNode*, ValaExpression*, ValaExpression*)) vala_binary_expression_real_replace_expression;
3641 ((ValaCodeNodeClass *) klass)->to_string = (gchar* (*) (ValaCodeNode*)) vala_binary_expression_real_to_string;
3642 ((ValaExpressionClass *) klass)->is_constant = (gboolean (*) (ValaExpression*)) vala_binary_expression_real_is_constant;
3643 ((ValaExpressionClass *) klass)->is_pure = (gboolean (*) (ValaExpression*)) vala_binary_expression_real_is_pure;
3644 ((ValaExpressionClass *) klass)->is_non_null = (gboolean (*) (ValaExpression*)) vala_binary_expression_real_is_non_null;
3645 ((ValaExpressionClass *) klass)->is_accessible = (gboolean (*) (ValaExpression*, ValaSymbol*)) vala_binary_expression_real_is_accessible;
3646 ((ValaCodeNodeClass *) klass)->get_error_types = (void (*) (ValaCodeNode*, ValaCollection*, ValaSourceReference*)) vala_binary_expression_real_get_error_types;
3647 ((ValaCodeNodeClass *) klass)->check = (gboolean (*) (ValaCodeNode*, ValaCodeContext*)) vala_binary_expression_real_check;
3648 ((ValaCodeNodeClass *) klass)->emit = (void (*) (ValaCodeNode*, ValaCodeGenerator*)) vala_binary_expression_real_emit;
3649 ((ValaCodeNodeClass *) klass)->get_defined_variables = (void (*) (ValaCodeNode*, ValaCollection*)) vala_binary_expression_real_get_defined_variables;
3650 ((ValaCodeNodeClass *) klass)->get_used_variables = (void (*) (ValaCodeNode*, ValaCollection*)) vala_binary_expression_real_get_used_variables;
3651 }
3652
3653 static void
vala_binary_expression_instance_init(ValaBinaryExpression * self,gpointer klass)3654 vala_binary_expression_instance_init (ValaBinaryExpression * self,
3655 gpointer klass)
3656 {
3657 self->priv = vala_binary_expression_get_instance_private (self);
3658 }
3659
3660 static void
vala_binary_expression_finalize(ValaCodeNode * obj)3661 vala_binary_expression_finalize (ValaCodeNode * obj)
3662 {
3663 ValaBinaryExpression * self;
3664 self = G_TYPE_CHECK_INSTANCE_CAST (obj, VALA_TYPE_BINARY_EXPRESSION, ValaBinaryExpression);
3665 _vala_code_node_unref0 (self->priv->_left);
3666 _vala_code_node_unref0 (self->priv->_right);
3667 VALA_CODE_NODE_CLASS (vala_binary_expression_parent_class)->finalize (obj);
3668 }
3669
3670 /**
3671 * Represents an expression with two operands in the source code.
3672 *
3673 * Supports +, -, *, /, %, <<, >>, <, >, <=, >=, ==, !=, &, |, ^, &&, ||, ??.
3674 */
3675 static GType
vala_binary_expression_get_type_once(void)3676 vala_binary_expression_get_type_once (void)
3677 {
3678 static const GTypeInfo g_define_type_info = { sizeof (ValaBinaryExpressionClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_binary_expression_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaBinaryExpression), 0, (GInstanceInitFunc) vala_binary_expression_instance_init, NULL };
3679 GType vala_binary_expression_type_id;
3680 vala_binary_expression_type_id = g_type_register_static (VALA_TYPE_EXPRESSION, "ValaBinaryExpression", &g_define_type_info, 0);
3681 ValaBinaryExpression_private_offset = g_type_add_instance_private (vala_binary_expression_type_id, sizeof (ValaBinaryExpressionPrivate));
3682 return vala_binary_expression_type_id;
3683 }
3684
3685 GType
vala_binary_expression_get_type(void)3686 vala_binary_expression_get_type (void)
3687 {
3688 static volatile gsize vala_binary_expression_type_id__volatile = 0;
3689 if (g_once_init_enter (&vala_binary_expression_type_id__volatile)) {
3690 GType vala_binary_expression_type_id;
3691 vala_binary_expression_type_id = vala_binary_expression_get_type_once ();
3692 g_once_init_leave (&vala_binary_expression_type_id__volatile, vala_binary_expression_type_id);
3693 }
3694 return vala_binary_expression_type_id__volatile;
3695 }
3696
3697 const gchar*
vala_binary_operator_to_string(ValaBinaryOperator self)3698 vala_binary_operator_to_string (ValaBinaryOperator self)
3699 {
3700 const gchar* result = NULL;
3701 switch (self) {
3702 case VALA_BINARY_OPERATOR_PLUS:
3703 {
3704 result = "+";
3705 return result;
3706 }
3707 case VALA_BINARY_OPERATOR_MINUS:
3708 {
3709 result = "-";
3710 return result;
3711 }
3712 case VALA_BINARY_OPERATOR_MUL:
3713 {
3714 result = "*";
3715 return result;
3716 }
3717 case VALA_BINARY_OPERATOR_DIV:
3718 {
3719 result = "/";
3720 return result;
3721 }
3722 case VALA_BINARY_OPERATOR_MOD:
3723 {
3724 result = "%";
3725 return result;
3726 }
3727 case VALA_BINARY_OPERATOR_SHIFT_LEFT:
3728 {
3729 result = "<<";
3730 return result;
3731 }
3732 case VALA_BINARY_OPERATOR_SHIFT_RIGHT:
3733 {
3734 result = ">>";
3735 return result;
3736 }
3737 case VALA_BINARY_OPERATOR_LESS_THAN:
3738 {
3739 result = "<";
3740 return result;
3741 }
3742 case VALA_BINARY_OPERATOR_GREATER_THAN:
3743 {
3744 result = ">";
3745 return result;
3746 }
3747 case VALA_BINARY_OPERATOR_LESS_THAN_OR_EQUAL:
3748 {
3749 result = "<=";
3750 return result;
3751 }
3752 case VALA_BINARY_OPERATOR_GREATER_THAN_OR_EQUAL:
3753 {
3754 result = ">=";
3755 return result;
3756 }
3757 case VALA_BINARY_OPERATOR_EQUALITY:
3758 {
3759 result = "==";
3760 return result;
3761 }
3762 case VALA_BINARY_OPERATOR_INEQUALITY:
3763 {
3764 result = "!=";
3765 return result;
3766 }
3767 case VALA_BINARY_OPERATOR_BITWISE_AND:
3768 {
3769 result = "&";
3770 return result;
3771 }
3772 case VALA_BINARY_OPERATOR_BITWISE_OR:
3773 {
3774 result = "|";
3775 return result;
3776 }
3777 case VALA_BINARY_OPERATOR_BITWISE_XOR:
3778 {
3779 result = "^";
3780 return result;
3781 }
3782 case VALA_BINARY_OPERATOR_AND:
3783 {
3784 result = "&&";
3785 return result;
3786 }
3787 case VALA_BINARY_OPERATOR_OR:
3788 {
3789 result = "||";
3790 return result;
3791 }
3792 case VALA_BINARY_OPERATOR_IN:
3793 {
3794 result = "in";
3795 return result;
3796 }
3797 case VALA_BINARY_OPERATOR_COALESCE:
3798 {
3799 result = "??";
3800 return result;
3801 }
3802 default:
3803 {
3804 g_assert_not_reached ();
3805 }
3806 }
3807 }
3808
3809 static GType
vala_binary_operator_get_type_once(void)3810 vala_binary_operator_get_type_once (void)
3811 {
3812 static const GEnumValue values[] = {{VALA_BINARY_OPERATOR_NONE, "VALA_BINARY_OPERATOR_NONE", "none"}, {VALA_BINARY_OPERATOR_PLUS, "VALA_BINARY_OPERATOR_PLUS", "plus"}, {VALA_BINARY_OPERATOR_MINUS, "VALA_BINARY_OPERATOR_MINUS", "minus"}, {VALA_BINARY_OPERATOR_MUL, "VALA_BINARY_OPERATOR_MUL", "mul"}, {VALA_BINARY_OPERATOR_DIV, "VALA_BINARY_OPERATOR_DIV", "div"}, {VALA_BINARY_OPERATOR_MOD, "VALA_BINARY_OPERATOR_MOD", "mod"}, {VALA_BINARY_OPERATOR_SHIFT_LEFT, "VALA_BINARY_OPERATOR_SHIFT_LEFT", "shift-left"}, {VALA_BINARY_OPERATOR_SHIFT_RIGHT, "VALA_BINARY_OPERATOR_SHIFT_RIGHT", "shift-right"}, {VALA_BINARY_OPERATOR_LESS_THAN, "VALA_BINARY_OPERATOR_LESS_THAN", "less-than"}, {VALA_BINARY_OPERATOR_GREATER_THAN, "VALA_BINARY_OPERATOR_GREATER_THAN", "greater-than"}, {VALA_BINARY_OPERATOR_LESS_THAN_OR_EQUAL, "VALA_BINARY_OPERATOR_LESS_THAN_OR_EQUAL", "less-than-or-equal"}, {VALA_BINARY_OPERATOR_GREATER_THAN_OR_EQUAL, "VALA_BINARY_OPERATOR_GREATER_THAN_OR_EQUAL", "greater-than-or-equal"}, {VALA_BINARY_OPERATOR_EQUALITY, "VALA_BINARY_OPERATOR_EQUALITY", "equality"}, {VALA_BINARY_OPERATOR_INEQUALITY, "VALA_BINARY_OPERATOR_INEQUALITY", "inequality"}, {VALA_BINARY_OPERATOR_BITWISE_AND, "VALA_BINARY_OPERATOR_BITWISE_AND", "bitwise-and"}, {VALA_BINARY_OPERATOR_BITWISE_OR, "VALA_BINARY_OPERATOR_BITWISE_OR", "bitwise-or"}, {VALA_BINARY_OPERATOR_BITWISE_XOR, "VALA_BINARY_OPERATOR_BITWISE_XOR", "bitwise-xor"}, {VALA_BINARY_OPERATOR_AND, "VALA_BINARY_OPERATOR_AND", "and"}, {VALA_BINARY_OPERATOR_OR, "VALA_BINARY_OPERATOR_OR", "or"}, {VALA_BINARY_OPERATOR_IN, "VALA_BINARY_OPERATOR_IN", "in"}, {VALA_BINARY_OPERATOR_COALESCE, "VALA_BINARY_OPERATOR_COALESCE", "coalesce"}, {0, NULL, NULL}};
3813 GType vala_binary_operator_type_id;
3814 vala_binary_operator_type_id = g_enum_register_static ("ValaBinaryOperator", values);
3815 return vala_binary_operator_type_id;
3816 }
3817
3818 GType
vala_binary_operator_get_type(void)3819 vala_binary_operator_get_type (void)
3820 {
3821 static volatile gsize vala_binary_operator_type_id__volatile = 0;
3822 if (g_once_init_enter (&vala_binary_operator_type_id__volatile)) {
3823 GType vala_binary_operator_type_id;
3824 vala_binary_operator_type_id = vala_binary_operator_get_type_once ();
3825 g_once_init_leave (&vala_binary_operator_type_id__volatile, vala_binary_operator_type_id);
3826 }
3827 return vala_binary_operator_type_id__volatile;
3828 }
3829
3830