vala/valaconditionalexpression.vala

   1 /* valaconditionalexpression.vala
   2  *
   3  * Copyright (C) 2006-2011  Jürg Billeter
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  18  *
  19  * Author:
  20  *      Jürg Billeter <j@bitron.ch>
  21  */
  22
  23 using GLib;
  24
  25 /**
  26  * Represents a conditional expression in the source code.
  27  */
  28 public class Vala.ConditionalExpression : Expression {
  29         /**
  30          * The condition.
  31          */
  32         public Expression condition {
  33                 get {
  34                         return _condition;
  35                 }
  36                 set {
  37                         _condition = value;
  38                         _condition.parent_node = this;
  39                 }
  40         }
  41
  42         /**
  43          * The expression to be evaluated if the condition holds.
  44          */
  45         public Expression true_expression {
  46                 get {
  47                         return _true_expression;
  48                 }
  49                 set {
  50                         _true_expression = value;
  51                         _true_expression.parent_node = this;
  52                 }
  53         }
  54
  55         /**
  56          * The expression to be evaluated if the condition doesn't hold.
  57          */
  58         public Expression false_expression {
  59                 get {
  60                         return _false_expression;
  61                 }
  62                 set {
  63                         _false_expression = value;
  64                         _false_expression.parent_node = this;
  65                 }
  66         }
  67
  68         Expression _condition;
  69         Expression _true_expression;
  70         Expression _false_expression;
  71
  72         /**
  73          * Creates a new conditional expression.
  74          *
  75          * @param cond       a condition
  76          * @param true_expr  expression to be evaluated if condition is true
  77          * @param false_expr expression to be evaluated if condition is false
  78          * @return           newly created conditional expression
  79          */
  80         public ConditionalExpression (Expression cond, Expression true_expr, Expression false_expr, SourceReference source) {
  81                 condition = cond;
  82                 true_expression = true_expr;
  83                 false_expression = false_expr;
  84                 source_reference = source;
  85         }
  86
  87         public override void accept (CodeVisitor visitor) {
  88                 visitor.visit_conditional_expression (this);
  89
  90                 visitor.visit_expression (this);
  91         }
  92
  93         public override void accept_children (CodeVisitor visitor) {
  94                 condition.accept (visitor);
  95                 true_expression.accept (visitor);
  96                 false_expression.accept (visitor);
  97         }
  98
  99         public override bool is_pure () {
 100                 return condition.is_pure () && true_expression.is_pure () && false_expression.is_pure ();
 101         }
 102
 103         public override bool is_accessible (Symbol sym) {
 104                 return condition.is_accessible (sym) && true_expression.is_accessible (sym) && false_expression.is_accessible (sym);
 105         }
 106
 107         public override bool check (CodeContext context) {
 108                 if (checked) {
 109                         return !error;
 110                 }
 111
 112                 checked = true;
 113
 114                 if (!(context.analyzer.current_symbol is Block)) {
 115                         Report.error (source_reference, "Conditional expressions may only be used in blocks");
 116                         error = true;
 117                         return false;
 118                 }
 119
 120                 // convert ternary expression into if statement
 121                 // required for flow analysis and exception handling
 122
 123                 string temp_name = get_temp_name ();
 124
 125                 true_expression.target_type = target_type;
 126                 false_expression.target_type = target_type;
 127
 128                 var local = new LocalVariable (null, temp_name, null, source_reference);
 129                 var decl = new DeclarationStatement (local, source_reference);
 130
 131                 var true_local = new LocalVariable (null, temp_name, true_expression, true_expression.source_reference);
 132                 var true_block = new Block (true_expression.source_reference);
 133                 var true_decl = new DeclarationStatement (true_local, true_expression.source_reference);
 134                 true_block.add_statement (true_decl);
 135
 136                 var false_local = new LocalVariable (null, temp_name, false_expression, false_expression.source_reference);
 137                 var false_block = new Block (false_expression.source_reference);
 138                 var false_decl = new DeclarationStatement (false_local, false_expression.source_reference);
 139                 false_block.add_statement (false_decl);
 140
 141                 var if_stmt = new IfStatement (condition, true_block, false_block, source_reference);
 142
 143                 insert_statement (context.analyzer.insert_block, decl);
 144                 insert_statement (context.analyzer.insert_block, if_stmt);
 145
 146                 if (!if_stmt.check (context) || true_expression.error || false_expression.error) {
 147                         error = true;
 148                         return false;
 149                 }
 150
 151                 true_expression = true_local.initializer;
 152                 false_expression = false_local.initializer;
 153
 154                 true_block.remove_local_variable (true_local);
 155                 false_block.remove_local_variable (false_local);
 156
 157                 if (false_expression.value_type.compatible (true_expression.value_type)) {
 158                         value_type = true_expression.value_type.copy ();
 159                 } else if (true_expression.value_type.compatible (false_expression.value_type)) {
 160                         value_type = false_expression.value_type.copy ();
 161                 } else {
 162                         error = true;
 163                         Report.error (condition.source_reference, "Incompatible expressions");
 164                         return false;
 165                 }
 166
 167                 value_type.value_owned = (true_expression.value_type.value_owned || false_expression.value_type.value_owned);
 168
 169                 local.variable_type = value_type;
 170                 decl.check (context);
 171
 172                 true_expression.target_type = value_type;
 173                 false_expression.target_type = value_type;
 174
 175                 var true_stmt = new ExpressionStatement (new Assignment (new MemberAccess.simple (local.name, true_expression.source_reference), true_expression, AssignmentOperator.SIMPLE, true_expression.source_reference), true_expression.source_reference);
 176                 true_stmt.check (context);
 177
 178                 var false_stmt = new ExpressionStatement (new Assignment (new MemberAccess.simple (local.name, false_expression.source_reference), false_expression, AssignmentOperator.SIMPLE, false_expression.source_reference), false_expression.source_reference);
 179                 false_stmt.check (context);
 180
 181                 true_block.replace_statement (true_decl, true_stmt);
 182                 false_block.replace_statement (false_decl, false_stmt);
 183
 184                 var ma = new MemberAccess.simple (local.name, source_reference);
 185                 ma.formal_target_type = formal_target_type;
 186                 ma.target_type = target_type;
 187                 ma.check (context);
 188
 189                 parent_node.replace_expression (this, ma);
 190
 191                 return true;
 192         }
 193 }